From 1756f1c47bfa2d1c06ef0de8875d2587dd5f3ab4 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Fri, 28 Jul 2017 14:35:28 +0300
Subject: [PATCH 01/18] Less dependencies

no Filter::signatures;
no feature 'signatures';
no Text::CleanFragment required (replacement into HTTP::Upload::FlowJs::Utils
MIME::Detect is optional
---
 lib/HTTP/Upload/FlowJs.pm                 | 102 ++-
 lib/HTTP/Upload/FlowJs/Utils.pm           |  83 +++
 t/002_http_upload_disallowedContentType.t |  12 +-
 t/003_http_upload_flowjs.t                | 716 +++++++++++-----------
 4 files changed, 534 insertions(+), 379 deletions(-)
 create mode 100644 lib/HTTP/Upload/FlowJs/Utils.pm

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 8f85b2a..b689787 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -1,12 +1,9 @@
 package HTTP::Upload::FlowJs;
 use strict;
 use Carp qw(croak);
-use Filter::signatures;
-no warnings 'experimental::signatures';
-use feature 'signatures';
-use Text::CleanFragment 'clean_fragment';
+
+use HTTP::Upload::FlowJs::Utils qw(clean_fragment mime_detect);
 use Data::Dumper;
-use MIME::Detect;
 
 use vars '$VERSION';
 $VERSION = '0.01';
@@ -200,7 +197,8 @@ fairly disk-intensive on some systems.
 
 =cut
 
-sub new( $class, %options ) {
+sub new {
+    my ( $class, %options ) = @_;
     croak "Need a directory name for the temporary upload parts"
         unless $options{ incomingDirectory };
 
@@ -210,17 +208,21 @@ sub new( $class, %options ) {
     $options{ minChunkSize } ||= 1024;
     $options{ simultaneousUploads } ||= 3;
     $options{ maxPendingUploads } ||= 1000;
-    $options{ mime } ||= MIME::Detect->new();
+    $options{ mime } ||= mime_detect();
     $options{ allowedContentType } ||= sub { 1 };
 
     bless \%options => $class;
 };
 
-sub incomingDirectory( $self ) {
+sub incomingDirectory {
+    my ($self) = @_;
+
     $self->{incomingDirectory};
 };
 
-sub mime($self) {
+sub mime {
+    my ($self) = @_;
+
     $self->{mime}
 };
 
@@ -235,7 +237,9 @@ object for inclusion with the JS side of the world
 
 =cut
 
-sub jsConfig( $self, %override ) {
+sub jsConfig {
+    my ( $self, %override ) = @_;
+
     {
         map { $_ => $self->{$_} } (qw(
             chunkSize
@@ -249,7 +253,9 @@ sub jsConfig( $self, %override ) {
     }
 }
 
-sub jsConfigStr( $self, %override ) {
+sub jsConfigStr {
+    my ( $self, %override ) = @_;
+
     encode_json($self->js_Config(%override))
 }
 
@@ -269,7 +275,9 @@ check previously stored information.
 
 =cut
 
-sub validateRequest( $self, $method, $info, $sessionId=undef ) {
+sub validateRequest {
+    my ( $self, $method, $info, $sessionId ) = @_;
+
     # Validate the input somewhat
     local $Data::Dumper::Useqq = 1;
 
@@ -424,7 +432,11 @@ chunk as indicated by C<$info>.
 
 =cut
 
-sub expectedChunkSize( $self, $info, $index=0 ) {
+sub expectedChunkSize {
+    my ( $self, $info, $index ) = @_;
+
+    $index //= 0;
+
     # If we are not the last chunk, we need to be what the information says:
     $index ||= $info->{flowChunkNumber};
     if( ! $info->{flowTotalChunks}) {
@@ -460,7 +472,9 @@ is passed, it will remove all partial files from the directory.
 
 =cut
 
-sub resetUploadDirectories( $self, $wipe=undef ) {
+sub resetUploadDirectories {
+    my ( $self, $wipe ) = @_;
+
     my $dir = $self->{incomingDirectory};
     if( ! -d $dir ) {
         mkdir $dir
@@ -486,7 +500,11 @@ the current chunk.
 
 =cut
 
-sub chunkName( $self, $info, $sessionPrefix=undef, $index=0 ) {
+sub chunkName {
+    my ( $self, $info, $sessionPrefix, $index ) = @_;
+
+    $index //= 0;
+
     my $dir = $self->{incomingDirectory};
     $sessionPrefix = '' unless defined $sessionPrefix;
     my $chunkname = sprintf "%s/%s%s.part%03d",
@@ -516,7 +534,11 @@ sub chunkName( $self, $info, $sessionPrefix=undef, $index=0 ) {
 
 =cut
 
-sub chunkOK($self, $info, $sessionPrefix=undef, $index=0) {
+sub chunkOK {
+    my ( $self, $info, $sessionPrefix, $index ) = @_;
+
+    $index //= 0;
+
     my @messages = $self->validateRequest( 'GET', $info, $sessionPrefix );
     if( @messages ) {
         return 500, @messages
@@ -539,7 +561,9 @@ sub chunkOK($self, $info, $sessionPrefix=undef, $index=0) {
 
 =cut
 
-sub uploadComplete( $self, $info, $sessionPrefix=undef ) {
+sub uploadComplete {
+    my ( $self, $info, $sessionPrefix) = @_;
+
     my $complete = 1;
     for( 1.. $info->{ flowTotalChunks }) {
         my( $status, @messages ) = $self->chunkOK( $info, $sessionPrefix, $_ ) ;
@@ -561,7 +585,11 @@ and the index are optional.
 
 =cut
 
-sub chunkFh( $self, $info, $sessionPrefix=undef, $index=0 ) {
+sub chunkFh {
+    my ( $self, $info, $sessionPrefix, $index ) = @_;
+
+    $index //= 0;
+
     my %info = %$info;
     $info{ chunkNumber } = $index if $index;
     my $chunkname = $self->chunkName( \%info, $sessionPrefix, $index );
@@ -580,7 +608,11 @@ and the index are optional.
 
 =cut
 
-sub chunkContent( $self, $info, $sessionPrefix=undef, $index=0 ) {
+sub chunkContent {
+    my ( $self, $info, $sessionPrefix, $index ) = @_;
+
+    $index //= 0;
+
     my $chunk = $self->chunkFh( $info, $sessionPrefix, $index );
     local $/;
     <$chunk>
@@ -597,7 +629,9 @@ this MIME type. Unrecognized files will be blocked.
 
 =cut
 
-sub disallowedContentType( $self, $info, $session=undef ) {
+sub disallowedContentType {
+    my ( $self, $info, $session) = @_;
+
     my( $content_type, $image_ext ) = $self->sniffContentType($info,$session);
     if( !defined $content_type ) {
         # we need more chunks uploaded to check the content type
@@ -639,13 +673,15 @@ check the upload type.
 
 =cut
 
-sub sniffContentType( $self, $info, $sessionPrefix=undef ) {
+sub sniffContentType {
+    my ( $self, $info, $sessionPrefix ) = @_;
+
     my( $content_type, $image_ext );
 
     my( $status, @messages ) = $self->chunkOK( $info, $sessionPrefix, 1 );
     if( 200 == $status ) {
         my $fh = $self->chunkFh( $info, $sessionPrefix, 1 );
-        my $t = $self->mime->mime_type($fh);
+        my $t = $self->mime->mime_type($fh) if $self->mime;
         if( $t ) {
             $content_type = $t->mime_type;
             $image_ext    = $t->extension;
@@ -686,7 +722,9 @@ sub sniffContentType( $self, $info, $sessionPrefix=undef ) {
 
 =cut
 
-sub combineChunks( $self, $info, $sessionPrefix, $target_fh, $digest=undef ) {
+sub combineChunks {
+    my ( $self, $info, $sessionPrefix, $target_fh, $digest ) = @_;
+
     my @unlink_chunks;
     my $ok = 1;
     for( 1.. $info->{ flowTotalChunks }) {
@@ -712,7 +750,9 @@ than one chunk.
 
 =cut
 
-sub pendingUploads( $self ) {
+sub pendingUploads {
+    my ($self) = @_;
+
     my @files;
     my %uploads;
 
@@ -752,7 +792,12 @@ It defaults to C<time>.
 
 =cut
 
-sub staleUploads( $self, $timeout = 3600, $now = time() ) {
+sub staleUploads {
+    my ( $self, $timeout, $now ) = @_;
+
+    $timeout //= 3600;
+    $now     //= time;
+
     my $cutoff = $now - $timeout;
     my %mtime;
     my @files = reverse sort $self->pendingUploads();
@@ -796,7 +841,12 @@ will delete files from another instance.
 
 =cut
 
-sub purgeStaleOrInvalid($self, $timeout = 3600, $now = time() ) {
+sub purgeStaleOrInvalid {
+    my ($self, $timeout, $now ) = @_;
+
+    $timeout //= 3600;
+    $now     //= time;
+
     # First, kill off all stale files
     my @errors;
     for my $f ($self->staleUploads( $timeout, $now )) {
diff --git a/lib/HTTP/Upload/FlowJs/Utils.pm b/lib/HTTP/Upload/FlowJs/Utils.pm
new file mode 100644
index 0000000..4fd72b7
--- /dev/null
+++ b/lib/HTTP/Upload/FlowJs/Utils.pm
@@ -0,0 +1,83 @@
+package HTTP::Upload::FlowJs::Util;
+
+use strict;
+use warnings;
+
+use vars qw(@ISA @EXPORT_OK);
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(clean_fragment mime_detect);
+
+use feature "fc";
+use Unicode::Normalize;
+
+#
+# mime detect
+#
+
+my $mime_detect_fallback;
+sub mime_detect {
+    if ( not defined $mime_detect_fallback ) {
+        eval {
+            require MIME::Detect;
+            $mime_detect_fallback = 0;
+            1;
+        } or do {
+            $mime_detect_fallback = 1;
+        }
+    }
+
+    if ( $mime_detect_fallback ) {
+        return undef
+    }
+    elsif ( defined $mime_detect_fallback ) {
+        return MIME::Detect->new(@_);
+    }
+}
+
+
+#
+# clean_fragment
+#
+
+my $clean_fragment_fallback;
+sub clean_fragment {
+    if ( not defined $clean_fragment_fallback ) {
+        eval {
+            require Text::CleanFragment;
+            $clean_fragment_fallback = 0;
+            1;
+        } or do {
+            $clean_fragment_fallback = 1;
+        }
+    }
+
+    if ( $clean_fragment_fallback ) {
+        return clean_fragment_fallback(@_);
+    }
+    elsif ( defined $clean_fragment_fallback ) {
+        return Text::CleanFragment::clean_fragment(@_);
+    }
+}
+
+sub clean_fragment_fallback {
+    my @strings = @_;
+
+    for( @strings ) {
+        $_ = NFKD($_);
+        s/([\x{80}-\x{300}])/fc($1)/eg;
+
+        tr/['"\x{2019}]//d;     # Eliminate apostrophes
+        tr/\x{300}-\x{36f}//d;
+        s/[^a-zA-Z0-9.-]+/_/g;  # Replace all non-ascii by underscores, including whitespace
+        s/-+/-/g;               # Squash dashes
+        s/_(?:-_)+/-/g;         # Squash _-_ and _-_-_ to -
+        s/^[-_]+//;             # Eliminate leading underscores
+        s/[-_]+$//;             # Eliminate trailing underscores
+        s/_(\W)/$1/;            # No underscore before - or .
+     };
+    wantarray ? @strings : $strings[0];
+};
+
+1;
diff --git a/t/002_http_upload_disallowedContentType.t b/t/002_http_upload_disallowedContentType.t
index 712493b..898b571 100644
--- a/t/002_http_upload_disallowedContentType.t
+++ b/t/002_http_upload_disallowedContentType.t
@@ -1,13 +1,23 @@
 #!perl -w
 use strict;
 use warnings;
-use Test::More tests => 3;
+use Test::More;
 use Data::Dumper;
 use File::Temp 'tempdir';
 use File::Copy 'cp';
 
 use HTTP::Upload::FlowJs;
 
+BEGIN {
+    eval 'use MIME::Detect';
+    if( $@ ) {
+        plan skip_all => 'No MIME::Detect installed';
+    }
+    else {
+        plan tests => 3;
+    }
+}
+
 my $tempdir = tempdir();
 
 my $called = 0;
diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index 0715b51..1e628dd 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -1,353 +1,365 @@
-#!perl -w
-use strict;
-use warnings;
-use Test::More tests => 86;
-use Data::Dumper;
-
-use HTTP::Upload::FlowJs;
-use File::Temp qw(tempdir);
-use ExtUtils::Command();
-
-my $tempdir = tempdir();
-END {
-    if( defined $tempdir ) {
-        diag "Cleaning up $tempdir";
-        @ARGV = $tempdir;
-        ExtUtils::Command::rm_rf $tempdir;
-    };
-};
-
-my $flowjs = HTTP::Upload::FlowJs->new(
-    incomingDirectory => $tempdir,
-);
-
-is $flowjs->pendingUploads, 0, "At start we have no pending uploads";
-is_deeply [$flowjs->pendingUploads], [], "At start we have no pending uploads (list)";
-is $flowjs->staleUploads, 0, "At start we have no stale uploads";
-
-# Check that we can ask for the presence of a file
-my( $status, @errors ) = $flowjs->chunkOK(
-    {
-        flowChunkNumber => 3,
-        flowChunkSize => 1048576,
-        flowFilename => 'IMG_7363.JPG',
-        flowIdentifier => '2226376-IMG_7363JPG',
-        flowRelativePath => 'IMG_7363.JPG',
-        flowTotalChunks => 3,
-        flowTotalSize => 2226376
-    }
-);
-is $status, 416, "A non-existing directory+file is no error";
-is_deeply \@errors, [], "The request is not obviously invalid";
-
-# Check that different sessions get different names
-   $flowjs = HTTP::Upload::FlowJs->new(
-    incomingDirectory => $tempdir,
-);
-
-my %chunkName;
-for my $session_id (1..3) {
-    $chunkName{ $session_id } = $flowjs->chunkName(
-    {
-        flowChunkNumber => 3,
-        flowChunkSize => 1048576,
-        flowFilename => 'IMG_7363.JPG',
-        flowIdentifier => '2226376-IMG_7363JPG',
-        flowRelativePath => 'IMG_7363.JPG',
-        flowTotalChunks => 3,
-        flowTotalSize => 2226376
-    }, $session_id);
-};
-isn't $chunkName{1}, $chunkName{2}, "Different sessions get different filenames";
-
-   $flowjs = HTTP::Upload::FlowJs->new(
-    incomingDirectory => $tempdir,
-);
-# Now try to "upload" a chunk much larger than what is allowed:
-# Check that we can ask for the presence of a file
-my %info = (
-        flowChunkNumber => 1,
-        flowChunkSize => 1048576,
-        flowFilename => 'IMG_7363.JPG',
-        flowIdentifier => '2226376-IMG_7363JPG',
-        flowRelativePath => 'IMG_7363.JPG',
-        flowTotalChunks => 1,
-        flowTotalSize => -s $0,
-        localChunkSize => 10_000_000,
-        file => $0,
-);
-@errors = $flowjs->validateRequest(
-    'POST',
-    \%info,
-);
-is_deeply [ sort @errors ], [
-    'Uploaded chunk [1] of [IMG_7363.JPG] is larger than it should be ([10000000], expect [1048576])',
-], "We reject a chunk that is larger than the proposed size"
-    or do { diag $_ for @errors };
-
-# Now try to "upload" a set of too many chunks
-%info = (
-        flowChunkNumber => 1,
-        flowChunkSize => 1048576,
-        flowFilename => 'IMG_7363.JPG',
-        flowIdentifier => '2226376-IMG_7363JPG',
-        flowRelativePath => 'IMG_7363.JPG',
-        flowTotalChunks => 1100,
-        flowTotalSize => -s $0,
-        localChunkSize => 1,
-        file => $0,
-);
-@errors = $flowjs->validateRequest(
-    'POST',
-    \%info,
-);
-is_deeply [ sort @errors ], [
-  'Parameter [flowTotalChunks] should be less than 1000, but is [1100]',
-], "We reject a set of chunks that is larger than the proposed count";
-
-
-# Now try to "upload" this chunk:
-# Check that we can ask for the presence of a file
-# XXX we need to create the appropriate tempfile here!
-open my $testfile, '<', $0 or die "Couldn't read testfile '$0': $!";
-binmode $testfile;
-%info = (
-        flowChunkNumber => 1,
-        flowChunkSize => 1048576,
-        flowFilename => 'IMG_7363.JPG',
-        flowIdentifier => '2226376-IMG_7363JPG',
-        flowRelativePath => 'IMG_7363.JPG',
-        flowTotalChunks => 1,
-        flowTotalSize => -s $0,
-        localChunkSize => -s $0,
-        file => $0,
-);
-@errors = $flowjs->validateRequest(
-    'POST',
-    \%info,
-);
-# Save the data
-my $tempname = $flowjs->chunkName(\%info);
-ok $tempname, 'We get a temporary filename for the chunk';
-open my $fh, '>', $flowjs->chunkName(\%info)
-    or die "Couldn't create '$tempname': $!";
-binmode $fh;
-print $fh $_ for <$testfile>;
-close $fh;
-is_deeply \@errors, [], "The request is not obviously invalid";
-ok $flowjs->uploadComplete(\%info), "The upload is considered complete";
-is $flowjs->pendingUploads, 1, "We have one pending upload (even if it's complete)";
-is_deeply [$flowjs->pendingUploads], [$tempname], "We have one pending upload (even if it's complete)";
-
-
-my $payload = join '',
-              "\x89",
-              'PNG',
-              "\x0d\x0a",
-              "\x1a",
-              "\x0a",
-              (map { chr($_) x (1024 * 1024) } 1..3)
-              ;
-
-sub chunkSize { 1_000_000 };
-sub parts { int( length( $payload )/ chunkSize )+1 }
-sub part {
-    my( $index ) = @_;
-    substr $payload, ($index-1)*chunkSize, chunkSize
-}
-sub part_fh {
-    my $content = part(@_);
-    open my $fh, '<', \$content
-        or die "Couldn't open in-memory filehandle: $!";
-    binmode $fh;
-    
-    $fh;
-}
-
-# Upload a file in three chunks, first->last->middle
-# check that it's considered "complete"
-# We create a fake PNG that's basically just the PNG header and then nulls
-   $flowjs = HTTP::Upload::FlowJs->new(
-    incomingDirectory => $tempdir,
-    flowChunkSize => chunkSize,
-);
-
-my @parts = 1..parts;
-my %seen;
-unshift @parts, pop @parts; # favour first and last chunks
-diag "Uploading sequence: @parts";
- %info = (
-    flowChunkSize => chunkSize,
-    flowChunkNumber => 0,
-    flowTotalChunks => parts,
-    flowTotalSize => length($payload),
-    flowFilename => 'test.png',
-    flowIdentifier => 'test.png',
-    file => undef,
-    localChunkSize => undef,
-);
-
-my @uploaded_parts = ($tempname); # from above
-for my $chunk (@parts) {
-    %info = (
-        flowChunkSize => chunkSize,
-        flowChunkNumber => $chunk,
-        flowTotalChunks => parts,
-        flowTotalSize => length($payload),
-        flowFilename => 'test.png',
-        flowIdentifier => 'test.png',
-        file => part_fh($chunk),
-        localChunkSize => length part($chunk),
-    );
-    $seen{ $chunk } = $info{ localChunkSize };
-    @errors = $flowjs->validateRequest(
-        'POST',
-        \%info,
-    );
-    diag "Uploaded chunk $chunk";
-    is_deeply [ sort @errors ], [], "No errors for chunk $chunk";
-    
-    # save the upload
-    my $tempname = $flowjs->chunkName(\%info);
-    ok $tempname, 'We get a temporary filename for the chunk';
-    open my $fh, '>', $flowjs->chunkName(\%info)
-        or die "Couldn't create '$tempname': $!";
-    binmode $fh;
-    print $fh part($chunk);
-    close $fh;
-    push @uploaded_parts, $tempname;
-    
-    my( $content_type, $ext ) = $flowjs->sniffContentType(\%info);
-    if( exists $seen{1}) {
-        is $content_type, 'image/png', "Once we see the first chunk, we find the correct content type";
-        is $ext, 'png', "Once we see the first chunk, we find the correct extension";
-    } else {
-        is $content_type, undef, "Until we see the first chunk, we don't know the content type";
-        is $ext, undef, "Until we see the first chunk, we don't know the extension";
-    };
-
-    is $flowjs->pendingUploads, 2, "We have twp pending uploads";
-    is_deeply [sort $flowjs->pendingUploads], [ sort @uploaded_parts ],
-        "We get the list of uploaded partial files";
-
-    if( $chunk != $parts[-1]) {
-        ok !$flowjs->uploadComplete( \%info ), "An incomplete upload is not complete";
-    } else {
-        ok $flowjs->uploadComplete( \%info ), "A complete upload is complete";
-    };
-};
-
-# Check that we receive the complete file in the chunks:
-if( $flowjs->uploadComplete( \%info, undef )) {
-    pass "The upload is considered complete";
-    
-    # Combine all chunks to final name
-
-    my $result = '';
-    open my $fh, '>', \$result
-        or die $!;
-    binmode $fh;
-
-    my( $ok, @unlink_chunks ) = $flowjs->combineChunks( \%info, undef, $fh );
-    unlink @unlink_chunks;
-    
-    close $fh;
-    
-    ok $result eq $payload, "We can read the identical file from the parts again";
-    is $flowjs->pendingUploads, 1, "After combining the chunks, the upload count decreases";
-    is_deeply [$flowjs->pendingUploads], [$tempname], "Only one file remains";
-
-} else {
-    fail "The upload is considered complete";
-    SKIP: {
-        skip 2, "Upload was not completed, no sense in checking the files";
-    }
-}
-
-# Upload a file in three chunks, first->last->middle
-# check that starting with chunk 2 the chunks are rejected because we don't
-# allow this MIME type here
-   $flowjs = HTTP::Upload::FlowJs->new(
-    incomingDirectory => $tempdir,
-    allowedContentType => sub { $_[0] =~ m!^text/plain$! },
-);
-
-@parts = 1..parts;
-%seen = ();
-unshift @parts, pop @parts; # favour first and last chunks
-
-is_deeply [$flowjs->pendingUploads], [$tempname], "Only one file remains";
-my %uploaded_parts = ($tempname => 1);
-for my $chunk (@parts, 2..parts) {
-    %info = (
-        flowChunkSize => chunkSize,
-        flowChunkNumber => $chunk,
-        flowTotalChunks => parts,
-        flowTotalSize => length($payload),
-        flowFilename => 'test.png',
-        flowIdentifier => 'test.png',
-        file => part_fh($chunk),
-        localChunkSize => length part($chunk),
-    );
-    $seen{ $chunk } = $info{ localChunkSize };
-    @errors = $flowjs->validateRequest(
-        'POST',
-        \%info,
-    );
-    is_deeply [ sort @errors ], [], "No errors for chunk $chunk";
-    
-    # save the upload
-    my $tempname = $flowjs->chunkName(\%info);
-    open my $fh, '>', $flowjs->chunkName(\%info)
-        or die "Couldn't create '$tempname': $!";
-    binmode $fh;
-    print $fh part($chunk);
-    close $fh;
-    $uploaded_parts{ $tempname } = 1;
-
-    my $res = $flowjs->disallowedContentType(\%info);
-    if( exists $seen{1}) {
-        is $res, 'image/png', "Once we see the first chunk, we find the file is disallowed";
-    } else {
-        is $res, undef, "Until we see the first chunk, we don't know if the file is disallowed";
-    };
-
-    is $flowjs->pendingUploads, 2,
-        "Even invalid uploads get counted";
-    is_deeply [$flowjs->pendingUploads], [ sort keys %uploaded_parts ],
-        "Invalid upload parts also get listed"
-        or diag Dumper { got => [$flowjs->pendingUploads], expected => [ sort keys %uploaded_parts ] };
-};
-
-# Hopefully the test suite runs below 3600 seconds
-is $flowjs->staleUploads, 0, "At end we have no stale uploads";
-is_deeply [ sort $flowjs->staleUploads], [], "At end we have no stale uploads"
-    or diag Dumper [ sort $flowjs->staleUploads];
-
-# Now try aging some uploads:
-utime 0,0, $tempname;
-is $flowjs->staleUploads, 1, "We created a stale (single-file) upload";
-is_deeply [$flowjs->staleUploads], [$tempname], "We created a stale (single-file) upload";
-
-# We can make up to three parts of the other upload old before it gets
-# considered stale:
-my $items;
-delete $uploaded_parts{ $tempname };
-for my $partname (sort keys %uploaded_parts) {
-    utime 0,0, $partname;
-    if( $items++ < 3 ) {
-        is $flowjs->staleUploads, 1, "We still only have one stale upload (part $items)";
-        is_deeply [$flowjs->staleUploads], [$tempname], "We still only have one stale file";
-    } else {
-        is $flowjs->staleUploads, 2, "After all parts are stale, an upload is stale";
-        is_deeply [sort $flowjs->staleUploads], [sort $tempname, keys %uploaded_parts], "We now have more stale files"
-            or diag Dumper {
-                got => [$flowjs->staleUploads],
-                expected => [sort $tempname, keys %uploaded_parts],
-            };
-    };
-};
-
-
-
+#!perl -w
+use strict;
+use warnings;
+use Test::More tests => 86;
+use Data::Dumper;
+
+use HTTP::Upload::FlowJs;
+use File::Temp qw(tempdir);
+use ExtUtils::Command();
+
+my $tempdir = tempdir( );
+END {
+    if( defined $tempdir ) {
+        diag "Cleaning up $tempdir";
+        @ARGV = $tempdir;
+        ExtUtils::Command::rm_rf $tempdir;
+    };
+};
+
+my $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+);
+
+is $flowjs->pendingUploads, 0, "At start we have no pending uploads";
+is_deeply [$flowjs->pendingUploads], [], "At start we have no pending uploads (list)";
+is $flowjs->staleUploads, 0, "At start we have no stale uploads";
+
+# Check that we can ask for the presence of a file
+my( $status, @errors ) = $flowjs->chunkOK(
+    {
+        flowChunkNumber => 3,
+        flowChunkSize => 1048576,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 3,
+        flowTotalSize => 2226376
+    }
+);
+is $status, 416, "A non-existing directory+file is no error";
+is_deeply \@errors, [], "The request is not obviously invalid";
+
+# Check that different sessions get different names
+   $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+);
+
+my %chunkName;
+for my $session_id (1..3) {
+    $chunkName{ $session_id } = $flowjs->chunkName(
+    {
+        flowChunkNumber => 3,
+        flowChunkSize => 1048576,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 3,
+        flowTotalSize => 2226376
+    }, $session_id);
+};
+isn't $chunkName{1}, $chunkName{2}, "Different sessions get different filenames";
+
+   $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+);
+# Now try to "upload" a chunk much larger than what is allowed:
+# Check that we can ask for the presence of a file
+my %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1048576,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => -s $0,
+        localChunkSize => 10_000_000,
+        file => $0,
+);
+@errors = $flowjs->validateRequest(
+    'POST',
+    \%info,
+);
+is_deeply [ sort @errors ], [
+    'Uploaded chunk [1] of [IMG_7363.JPG] is larger than it should be ([10000000], expect [1048576])',
+], "We reject a chunk that is larger than the proposed size"
+    or do { diag $_ for @errors };
+
+# Now try to "upload" a set of too many chunks
+%info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1048576,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1100,
+        flowTotalSize => -s $0,
+        localChunkSize => 1,
+        file => $0,
+);
+@errors = $flowjs->validateRequest(
+    'POST',
+    \%info,
+);
+is_deeply [ sort @errors ], [
+  'Parameter [flowTotalChunks] should be less than 1000, but is [1100]',
+], "We reject a set of chunks that is larger than the proposed count";
+
+
+# Now try to "upload" this chunk:
+# Check that we can ask for the presence of a file
+# XXX we need to create the appropriate tempfile here!
+open my $testfile, '<', $0 or die "Couldn't read testfile '$0': $!";
+binmode $testfile;
+%info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1048576,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => -s $0,
+        localChunkSize => -s $0,
+        file => $0,
+);
+@errors = $flowjs->validateRequest(
+    'POST',
+    \%info,
+);
+# Save the data
+my $tempname = $flowjs->chunkName(\%info);
+ok $tempname, 'We get a temporary filename for the chunk';
+open my $fh, '>', $flowjs->chunkName(\%info)
+    or die "Couldn't create '$tempname': $!";
+binmode $fh;
+print $fh $_ for <$testfile>;
+close $fh;
+is_deeply \@errors, [], "The request is not obviously invalid";
+ok $flowjs->uploadComplete(\%info), "The upload is considered complete";
+is $flowjs->pendingUploads, 1, "We have one pending upload (even if it's complete)";
+is_deeply [$flowjs->pendingUploads], [$tempname], "We have one pending upload (even if it's complete)";
+
+
+my $payload = join '',
+              "\x89",
+              'PNG',
+              "\x0d\x0a",
+              "\x1a",
+              "\x0a",
+              (map { chr($_) x (1024 * 1024) } 1..3)
+              ;
+
+sub chunkSize { 1_000_000 };
+sub parts { int( length( $payload )/ chunkSize )+1 }
+sub part {
+    my( $index ) = @_;
+    substr $payload, ($index-1)*chunkSize, chunkSize
+}
+sub part_fh {
+    my $content = part(@_);
+    open my $fh, '<', \$content
+        or die "Couldn't open in-memory filehandle: $!";
+    binmode $fh;
+    
+    $fh;
+}
+
+# Upload a file in three chunks, first->last->middle
+# check that it's considered "complete"
+# We create a fake PNG that's basically just the PNG header and then nulls
+   $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+    flowChunkSize => chunkSize,
+);
+
+my @parts = 1..parts;
+my %seen;
+unshift @parts, pop @parts; # favour first and last chunks
+diag "Uploading sequence: @parts";
+ %info = (
+    flowChunkSize => chunkSize,
+    flowChunkNumber => 0,
+    flowTotalChunks => parts,
+    flowTotalSize => length($payload),
+    flowFilename => 'test.png',
+    flowIdentifier => 'test.png',
+    file => undef,
+    localChunkSize => undef,
+);
+
+my @uploaded_parts = ($tempname); # from above
+for my $chunk (@parts) {
+    %info = (
+        flowChunkSize => chunkSize,
+        flowChunkNumber => $chunk,
+        flowTotalChunks => parts,
+        flowTotalSize => length($payload),
+        flowFilename => 'test.png',
+        flowIdentifier => 'test.png',
+        file => part_fh($chunk),
+        localChunkSize => length part($chunk),
+    );
+    $seen{ $chunk } = $info{ localChunkSize };
+    @errors = $flowjs->validateRequest(
+        'POST',
+        \%info,
+    );
+    diag "Uploaded chunk $chunk";
+    is_deeply [ sort @errors ], [], "No errors for chunk $chunk";
+    
+    # save the upload
+    my $tempname = $flowjs->chunkName(\%info);
+    ok $tempname, 'We get a temporary filename for the chunk';
+    open my $fh, '>', $flowjs->chunkName(\%info)
+        or die "Couldn't create '$tempname': $!";
+    binmode $fh;
+    print $fh part($chunk);
+    close $fh;
+    push @uploaded_parts, $tempname;
+
+    my( $content_type, $ext ) = $flowjs->sniffContentType(\%info);
+    if( exists $seen{1}) {
+        if ( $flowjs->mime ) {
+            is $content_type, 'image/png', "Once we see the first chunk, we find the correct content type";
+            is $ext, 'png', "Once we see the first chunk, we find the correct extension";
+        }
+        else {
+            is $content_type, '', "Unknown content type or no MIME::Detect installed";
+            is $ext, '', "Unknown extension or no MIME::Detect installed";
+        }
+    } else {
+        is $content_type, undef, "Until we see the first chunk, we don't know the content type";
+        is $ext, undef, "Until we see the first chunk, we don't know the extension";
+    };
+
+    is $flowjs->pendingUploads, 2, "We have twp pending uploads";
+    is_deeply [sort $flowjs->pendingUploads], [ sort @uploaded_parts ],
+        "We get the list of uploaded partial files";
+
+    if( $chunk != $parts[-1]) {
+        ok !$flowjs->uploadComplete( \%info ), "An incomplete upload is not complete";
+    } else {
+        ok $flowjs->uploadComplete( \%info ), "A complete upload is complete";
+    };
+};
+
+# Check that we receive the complete file in the chunks:
+if( $flowjs->uploadComplete( \%info, undef )) {
+    pass "The upload is considered complete";
+    
+    # Combine all chunks to final name
+
+    my $result = '';
+    open my $fh, '>', \$result
+        or die $!;
+    binmode $fh;
+
+    my( $ok, @unlink_chunks ) = $flowjs->combineChunks( \%info, undef, $fh );
+    unlink @unlink_chunks;
+    
+    close $fh;
+    
+    ok $result eq $payload, "We can read the identical file from the parts again";
+    is $flowjs->pendingUploads, 1, "After combining the chunks, the upload count decreases";
+    is_deeply [$flowjs->pendingUploads], [$tempname], "Only one file remains";
+
+} else {
+    fail "The upload is considered complete";
+    SKIP: {
+        skip 2, "Upload was not completed, no sense in checking the files";
+    }
+}
+
+# Upload a file in three chunks, first->last->middle
+# check that starting with chunk 2 the chunks are rejected because we don't
+# allow this MIME type here
+   $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+    allowedContentType => sub { $_[0] =~ m!^text/plain$! },
+);
+
+@parts = 1..parts;
+%seen = ();
+unshift @parts, pop @parts; # favour first and last chunks
+
+is_deeply [$flowjs->pendingUploads], [$tempname], "Only one file remains";
+my %uploaded_parts = ($tempname => 1);
+for my $chunk (@parts, 2..parts) {
+    %info = (
+        flowChunkSize => chunkSize,
+        flowChunkNumber => $chunk,
+        flowTotalChunks => parts,
+        flowTotalSize => length($payload),
+        flowFilename => 'test.png',
+        flowIdentifier => 'test.png',
+        file => part_fh($chunk),
+        localChunkSize => length part($chunk),
+    );
+    $seen{ $chunk } = $info{ localChunkSize };
+    @errors = $flowjs->validateRequest(
+        'POST',
+        \%info,
+    );
+    is_deeply [ sort @errors ], [], "No errors for chunk $chunk";
+    
+    # save the upload
+    my $tempname = $flowjs->chunkName(\%info);
+    open my $fh, '>', $flowjs->chunkName(\%info)
+        or die "Couldn't create '$tempname': $!";
+    binmode $fh;
+    print $fh part($chunk);
+    close $fh;
+    $uploaded_parts{ $tempname } = 1;
+
+
+    my $res = $flowjs->disallowedContentType(\%info);
+    if( exists $seen{1}) {
+        if ( $flowjs->mime ) {
+            is $res, 'image/png', "Once we see the first chunk, we find the file is disallowed";
+        }
+        else {
+            is $res, '1', "Unknown content type or no MIME::Detect installed";
+        }
+    } else {
+        is $res, undef, "Until we see the first chunk, we don't know if the file is disallowed";
+    };
+
+    is $flowjs->pendingUploads, 2,
+        "Even invalid uploads get counted";
+    is_deeply [$flowjs->pendingUploads], [ sort keys %uploaded_parts ],
+        "Invalid upload parts also get listed"
+        or diag Dumper { got => [$flowjs->pendingUploads], expected => [ sort keys %uploaded_parts ] };
+};
+
+# Hopefully the test suite runs below 3600 seconds
+is $flowjs->staleUploads, 0, "At end we have no stale uploads";
+is_deeply [ sort $flowjs->staleUploads], [], "At end we have no stale uploads"
+    or diag Dumper [ sort $flowjs->staleUploads];
+
+# Now try aging some uploads:
+utime 0,0, $tempname;
+is $flowjs->staleUploads, 1, "We created a stale (single-file) upload";
+is_deeply [$flowjs->staleUploads], [$tempname], "We created a stale (single-file) upload";
+
+# We can make up to three parts of the other upload old before it gets
+# considered stale:
+my $items;
+delete $uploaded_parts{ $tempname };
+for my $partname (sort keys %uploaded_parts) {
+    utime 0,0, $partname;
+    if( $items++ < 3 ) {
+        is $flowjs->staleUploads, 1, "We still only have one stale upload (part $items)";
+        is_deeply [$flowjs->staleUploads], [$tempname], "We still only have one stale file";
+    } else {
+        is $flowjs->staleUploads, 2, "After all parts are stale, an upload is stale";
+        is_deeply [sort $flowjs->staleUploads], [sort $tempname, keys %uploaded_parts], "We now have more stale files"
+            or diag Dumper {
+                got => [$flowjs->staleUploads],
+                expected => [sort $tempname, keys %uploaded_parts],
+            };
+    };
+};
+
+
+
 done_testing;
\ No newline at end of file

From 875071302a5591ab9343ac48b02a6f1019895bd3 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Fri, 28 Jul 2017 14:56:09 +0300
Subject: [PATCH 02/18] Refactoring

---
 lib/HTTP/Upload/FlowJs/Utils.pm | 66 ++++++++++++---------------------
 1 file changed, 23 insertions(+), 43 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs/Utils.pm b/lib/HTTP/Upload/FlowJs/Utils.pm
index 4fd72b7..cecdff1 100644
--- a/lib/HTTP/Upload/FlowJs/Utils.pm
+++ b/lib/HTTP/Upload/FlowJs/Utils.pm
@@ -1,4 +1,4 @@
-package HTTP::Upload::FlowJs::Util;
+package HTTP::Upload::FlowJs::Utils;
 
 use strict;
 use warnings;
@@ -9,55 +9,35 @@ require Exporter;
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(clean_fragment mime_detect);
 
-use feature "fc";
+use feature qw(fc);
 use Unicode::Normalize;
 
-#
-# mime detect
-#
-
-my $mime_detect_fallback;
-sub mime_detect {
-    if ( not defined $mime_detect_fallback ) {
-        eval {
-            require MIME::Detect;
-            $mime_detect_fallback = 0;
-            1;
-        } or do {
-            $mime_detect_fallback = 1;
+BEGIN {
+    # clean_fragment
+    {
+        eval { require Text::CleanFragment };
+        my $subname = __PACKAGE__ . '::clean_fragment';
+        no strict 'refs';
+        if ( $@ ) {
+            *{$subname} = \&clean_fragment_fallback;
+        }
+        else {
+            *{$subname} = \&Text::CleanFragment::clean_fragment;
         }
     }
 
-    if ( $mime_detect_fallback ) {
-        return undef
-    }
-    elsif ( defined $mime_detect_fallback ) {
-        return MIME::Detect->new(@_);
-    }
-}
-
 
-#
-# clean_fragment
-#
-
-my $clean_fragment_fallback;
-sub clean_fragment {
-    if ( not defined $clean_fragment_fallback ) {
-        eval {
-            require Text::CleanFragment;
-            $clean_fragment_fallback = 0;
-            1;
-        } or do {
-            $clean_fragment_fallback = 1;
+    # mime_detect
+    {
+        eval { require MIME::Detect };
+        my $subname = __PACKAGE__ . '::mime_detect';
+        no strict 'refs';
+        if ( $@ ) {
+            *{$subname} = sub { undef };
+        }
+        else {
+            *{$subname} = sub { MIME::Detect->new(@_) };
         }
-    }
-
-    if ( $clean_fragment_fallback ) {
-        return clean_fragment_fallback(@_);
-    }
-    elsif ( defined $clean_fragment_fallback ) {
-        return Text::CleanFragment::clean_fragment(@_);
     }
 }
 

From ee5ba7e28c3363e696e6cd7e708209313e22c3c3 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Sat, 29 Jul 2017 23:16:11 +0300
Subject: [PATCH 03/18] Content type is undef if no mime decoder

---
 lib/HTTP/Upload/FlowJs.pm | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index b689787..643589e 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -679,20 +679,25 @@ sub sniffContentType {
     my( $content_type, $image_ext );
 
     my( $status, @messages ) = $self->chunkOK( $info, $sessionPrefix, 1 );
-    if( 200 == $status ) {
-        my $fh = $self->chunkFh( $info, $sessionPrefix, 1 );
-        my $t = $self->mime->mime_type($fh) if $self->mime;
-        if( $t ) {
-            $content_type = $t->mime_type;
-            $image_ext    = $t->extension;
-        } else {
-            $content_type = '';
-            $image_ext    = '';
-        };
 
-    } else {
-        # Chunk 1 not uploaded/complete yet
+    if ( $self->mime ) {
+        if( 200 == $status ) {
+
+            my $fh = $self->chunkFh( $info, $sessionPrefix, 1 );
+            my $t = $self->mime->mime_type($fh);
+            if( $t ) {
+                $content_type = $t->mime_type;
+                $image_ext    = $t->extension;
+            } else {
+                $content_type = '';
+                $image_ext    = '';
+            };
+
+        } else {
+            # Chunk 1 not uploaded/complete yet
+        }
     }
+
     return $content_type, $image_ext;
 };
 

From 402e42ddae0d7d33346831ff3990e42d3a63a717 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Sat, 29 Jul 2017 23:17:25 +0300
Subject: [PATCH 04/18] Fix tests

---
 t/003_http_upload_flowjs.t | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index 1e628dd..87f2e2e 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -224,8 +224,8 @@ for my $chunk (@parts) {
             is $ext, 'png', "Once we see the first chunk, we find the correct extension";
         }
         else {
-            is $content_type, '', "Unknown content type or no MIME::Detect installed";
-            is $ext, '', "Unknown extension or no MIME::Detect installed";
+            is $content_type, undef, "Unknown content type or no MIME::Detect installed";
+            is $ext, undef, "Unknown extension or no MIME::Detect installed";
         }
     } else {
         is $content_type, undef, "Until we see the first chunk, we don't know the content type";
@@ -318,7 +318,7 @@ for my $chunk (@parts, 2..parts) {
             is $res, 'image/png', "Once we see the first chunk, we find the file is disallowed";
         }
         else {
-            is $res, '1', "Unknown content type or no MIME::Detect installed";
+            is $res, undef, "Unknown content type or no MIME::Detect installed";
         }
     } else {
         is $res, undef, "Until we see the first chunk, we don't know if the file is disallowed";

From 2d58437be93a5a9b86529f35070b4b1f6d2a2d18 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Sun, 30 Jul 2017 10:11:42 +0300
Subject: [PATCH 05/18] Remove duplicated code

---
 lib/HTTP/Upload/FlowJs.pm | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 643589e..adda4c4 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -406,14 +406,6 @@ sub validateRequest {
                             $self->expectedChunkSize( $info ),
                             ;
 
-    } elsif( ($info->{ flowChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
-        # Uploaded chunk is a middle or end chunk but is too large
-        push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
-                            $info->{flowChunkNumber},
-                            $info->{flowChunkSize},
-                            $self->expectedChunkSize( $info ),
-                            ;
-
     } else {
         # Everything is OK with the chunk size and file size, I guess.
 

From 7f65baa89b5f55b2a47cdf36f83bf0e1171c7594 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Tue, 1 Aug 2017 14:00:09 +0300
Subject: [PATCH 06/18] Add forceChunkSize and pod for it

Also:
    * remove unneeded maxPendingUploads
    * chunkSize in jsConfig()
---
 lib/HTTP/Upload/FlowJs.pm | 35 ++++++++++++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index adda4c4..365b150 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -175,6 +175,16 @@ The minimum chunk size is required since the file type detection
 works on the first chunk. If the first chunk is too small, its file type
 cannot be checked.
 
+B<forceChunkSize> - force all chunks to be less or equal than C<maxChunkSize>
+
+Default: true
+
+Otherwise, the last chunk will be greater than or equal to C<maxChunkSize>
+(the last uploaded chunk will be at least this size and up to two the size).
+
+Note: when C<forceChunkSize> is C<false> it only make C<chunkSize> value in
+L</jsConfig> equal to C<maxChunkSize / 2>.
+
 B<simultaneousUploads> - simultaneously allowed uploads per file
 
 This is just an indication to the Javascript C<flow.js> client
@@ -206,8 +216,8 @@ sub new {
     $options{ maxFileSize } ||= 10_000_000;
     $options{ maxChunkSize } ||= 1024*1024;
     $options{ minChunkSize } ||= 1024;
+    $options{ forceChunkSize } ||= 1;
     $options{ simultaneousUploads } ||= 3;
-    $options{ maxPendingUploads } ||= 1000;
     $options{ mime } ||= mime_detect();
     $options{ allowedContentType } ||= sub { 1 };
 
@@ -228,10 +238,16 @@ sub mime {
 
 =head2 C<< $flowjs->jsConfig >>
 
+  # Perl HASH
   my $config = $flowjs->jsConfig(
       target => '/upload',
   );
 
+  # JSON string
+  my $config = $flowjs->jsConfigStr(
+      target => '/upload',
+  );
+
 Create a JSON string that encapsulates the configuration of the Perl
 object for inclusion with the JS side of the world
 
@@ -240,12 +256,17 @@ object for inclusion with the JS side of the world
 sub jsConfig {
     my ( $self, %override ) = @_;
 
+    # The last uploaded chunk will be at least this size and up to two the size
+    # when forceChunkSize is false
+    my $chunkSize = $self->{maxChunkSize};
+    $chunkSize = $chunkSize / 2 unless $self->{forceChunkSize};
+
     {
         map { $_ => $self->{$_} } (qw(
-            chunkSize
             simultaneousUploads
+            forceChunkSize
         )),
-        forceChunkSize => 1,
+        chunkSize => $chunkSize,
         testChunks => 1,
         withCredentials => 1,
         uploadMethod => 'POST',
@@ -406,6 +427,14 @@ sub validateRequest {
                             $self->expectedChunkSize( $info ),
                             ;
 
+    } elsif( ($info->{ flowChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
+        # Uploaded chunk is a middle or end chunk but is too large
+        push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
+                            $info->{flowChunkNumber},
+                            $info->{flowChunkSize},
+                            $self->expectedChunkSize( $info ),
+                            ;
+
     } else {
         # Everything is OK with the chunk size and file size, I guess.
 

From 1146a289bdd289b3a2546ac653b82189f3ed1943 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 2 Aug 2017 22:19:38 +0300
Subject: [PATCH 07/18] Add params method

---
 lib/HTTP/Upload/FlowJs.pm | 51 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 47 insertions(+), 4 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 365b150..66e4f2e 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -198,6 +198,10 @@ The default is to allow any kind of file
 If you need more advanced checking, do so after you've determined a file
 upload as complete with C<< $flowjs->uploadComplete >>.
 
+B<fileParameterName> - The name of the multipart POST parameter to use for the file chunk
+
+Default: file
+
 =back
 
 More interesting limits would be hard maxima for the number of pending
@@ -218,6 +222,7 @@ sub new {
     $options{ minChunkSize } ||= 1024;
     $options{ forceChunkSize } ||= 1;
     $options{ simultaneousUploads } ||= 3;
+    $options{ fileParameterName } ||= 'file';
     $options{ mime } ||= mime_detect();
     $options{ allowedContentType } ||= sub { 1 };
 
@@ -280,6 +285,43 @@ sub jsConfigStr {
     encode_json($self->js_Config(%override))
 }
 
+=head2 C<< $flowjs->params >>
+
+    my $params = params();                 # request params
+    my @parameter_names = $flowjs->params; # params needed by Flowjs
+
+    my %info;
+    @info{ @parameter_names } = @{$params}{@parameter_names};
+
+    $info{ file }           = $params{ file };
+    $info{ localChunkSize } = -s $params{ file };
+
+    my @invalid = $flowjs->validateRequest( 'POST', \%info );
+
+Returns needed params for validating request.
+
+=cut
+
+sub params {
+    my ( $self, $required_params ) = @_;
+
+    state $params = {
+        flowChunkNumber  => 1,
+        flowTotalChunks  => 1,
+        flowChunkSize    => 1,
+        flowTotalSize    => 1,
+        flowIdentifier   => 1,
+        flowFilename     => 1,
+        flowRelativePath => 0,
+    };
+
+    if ( $required_params ) {
+        return grep { $params->{$_} } keys( %{$params} );
+    }
+
+    return keys( %{$params} );
+}
+
 =head2 C<< $flowjs->validateRequest >>
 
     my $session_id = '';
@@ -294,6 +336,9 @@ sub jsConfigStr {
 Does formal validation of the request HTTP parameters. It does not
 check previously stored information.
 
+B<Note> when C<POST> there are addition required params C<localChunkSize>
+and C<$self->{fileParameterName}> (default 'file').
+
 =cut
 
 sub validateRequest {
@@ -304,11 +349,9 @@ sub validateRequest {
 
     my @invalid;
 
-    my @required = qw(flowChunkNumber flowTotalChunks flowChunkSize
-                      flowTotalSize flowFilename flowIdentifier
-                      );
+    my @required = $self->params('required');
     if( $method eq 'POST') {
-        push @required, 'file', 'localChunkSize'
+        push @required, $self->{fileParameterName}, 'localChunkSize'
             ;
     };
 

From e73020f3fb17733ecfabd11ca5f010fa07756e00 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 2 Aug 2017 22:20:49 +0300
Subject: [PATCH 08/18] require feature state

---
 lib/HTTP/Upload/FlowJs.pm | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 66e4f2e..74ecc88 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -8,6 +8,7 @@ use Data::Dumper;
 use vars '$VERSION';
 $VERSION = '0.01';
 
+use feature qw(state);
 use JSON qw(encode_json decode_json);
 
 =head1 NAME
@@ -371,7 +372,7 @@ sub validateRequest {
         if( exists $info->{ $param } and ! $info->{ $param } =~ /^[0-9]+$/) {
             push @invalid, sprintf 'Parameter [%s] should be numeric, but is [%s]; set to 0',
                                 $param,
-                                Dumper $info->{$param}
+                                $info->{$param}
                                 ;
             $info->{ $param } = 0;
         };
@@ -403,7 +404,7 @@ sub validateRequest {
         if( exists $info->{ $param } and $info->{ $param } =~ m![/\\]! ) {
             push @invalid, sprintf 'Parameter [%s] contains invalid path segments',
                                 $param,
-                                Dumper $info->{$param}
+                                $info->{$param}
                                 ;
         };
     };
@@ -414,7 +415,7 @@ sub validateRequest {
         if( exists $info->{ $param } and $info->{ $param } =~ m![/\\]\.\.[/\\]! ) {
             push @invalid, sprintf 'Parameter [%s] contains invalid upward path segments [%s]',
                                 $param,
-                                Dumper $info->{$param}
+                                $info->{$param}
                                 ;
         };
     };
@@ -424,7 +425,7 @@ sub validateRequest {
         if( exists $info->{ $param } and $info->{ $param } =~ m![\x00-\x1f]! ) {
             push @invalid, sprintf 'Parameter [%s] contains control characters [%s]',
                                 $param,
-                                Dumper $info->{$param}
+                                $info->{$param}
                                 ;
         };
     };

From 33fc2e522a7ce7973475014ce8036d61a136a3e5 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Thu, 3 Aug 2017 20:22:10 +0300
Subject: [PATCH 09/18] Add flowCurrentChunkSize to expected params also fix
 param validation

---
 lib/HTTP/Upload/FlowJs.pm                 | 107 ++++++++++++----------
 t/002_http_upload_disallowedContentType.t |   1 +
 t/003_http_upload_flowjs.t                |  15 ++-
 3 files changed, 75 insertions(+), 48 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 74ecc88..cf8b92f 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -23,22 +23,23 @@ plugins for L<Dancer> and L<Mojolicious> planned.
   use HTTP::Upload::FlowJs;
 
   my @parameter_names = (
-    'file', # The name of the file
-    'flowChunkNumber', # The index of the chunk in the current upload.
-                       # First chunk is 1 (no base-0 counting here).
-    'flowTotalChunks', # The total number of chunks.
-    'flowChunkSize', # The general chunk size. Using this value and
-                     # flowTotalSize you can calculate the total number of
-                     # chunks. Please note that the size of the data received in
-                     # the HTTP might be lower than flowChunkSize of this for
-                     # the last chunk for a file.
-    'flowTotalSize', #  The total file size.
-    'flowIdentifier', # A unique identifier for the file contained in the request.
-    'flowFilename', # The original file name (since a bug in Firefox results in
-                    # the file name not being transmitted in chunk
-                    # multipart posts).
-    'flowRelativePath', # The file's relative path when selecting a directory
-                        # (defaults to file name in all browsers except Chrome).
+    'file',                 # The name of the file
+    'flowChunkNumber',      # The index of the chunk in the current upload.
+                            # First chunk is 1 (no base-0 counting here).
+    'flowTotalChunks',      # The total number of chunks.
+    'flowCurrentChunkSize', # Current chunk size
+    'flowChunkSize',        # The general chunk size. Using this value and
+                            # flowTotalSize you can calculate the total number of
+                            # chunks. Please note that the size of the data received in
+                            # the HTTP might be lower than flowChunkSize of this for
+                            # the last chunk for a file.
+    'flowTotalSize',        #  The total file size.
+    'flowIdentifier',       # A unique identifier for the file contained in the request.
+    'flowFilename',         # The original file name (since a bug in Firefox results in
+                            # the file name not being transmitted in chunk
+                            # multipart posts).
+    'flowRelativePath',     # The file's relative path when selecting a directory
+                            # (defaults to file name in all browsers except Chrome).
   );
 
   # In your POST handler for /upload:
@@ -307,13 +308,14 @@ sub params {
     my ( $self, $required_params ) = @_;
 
     state $params = {
-        flowChunkNumber  => 1,
-        flowTotalChunks  => 1,
-        flowChunkSize    => 1,
-        flowTotalSize    => 1,
-        flowIdentifier   => 1,
-        flowFilename     => 1,
-        flowRelativePath => 0,
+        flowChunkNumber      => 1,
+        flowTotalChunks      => 1,
+        flowChunkSize        => 1,
+        flowCurrentChunkSize => 1,
+        flowTotalSize        => 1,
+        flowIdentifier       => 1,
+        flowFilename         => 1,
+        flowRelativePath     => 0,
     };
 
     if ( $required_params ) {
@@ -368,7 +370,7 @@ sub validateRequest {
     };
 
     # Numbers should be numbers
-    for my $param (qw(flowChunkNumber flowTotalChunks flowChunkSize flowTotalSize)) {
+    for my $param (qw(flowChunkNumber flowTotalChunks flowChunkSize flowTotalSize flowCurrentChunkSize)) {
         if( exists $info->{ $param } and ! $info->{ $param } =~ /^[0-9]+$/) {
             push @invalid, sprintf 'Parameter [%s] should be numeric, but is [%s]; set to 0',
                                 $param,
@@ -430,52 +432,65 @@ sub validateRequest {
         };
     };
 
-    if( exists $info->{ flowChunkSize } and $info->{ flowChunkSize } > $self->{maxChunkSize} ) {
-        push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is too large [%d], allowed is [%d]',
-                            $info->{flowChunkNumber},
-                            $info->{flowFilename},
-                            $info->{flowChunkSize},
-                            $self->{maxChunkSize},
-                            ;
 
-    } elsif( exists $info->{ flowChunkSize } and $info->{ flowChunkSize } < $self->{minChunkSize} ) {
-        push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is too small [%d], allowed is [%d]',
-                            $info->{flowChunkNumber},
-                            $info->{flowFilename},
-                            $info->{flowChunkSize},
-                            $self->{minChunkSize},
-                            ;
 
-    } elsif( ($info->{ flowTotalSize } || 0) > $self->{ maxFileSize } ) {
+    my $min_max_error = 0;
+    for my $param (qw(flowChunkSize flowCurrentChunkSize)) {
+        if( exists $info->{ $param } and $info->{ $param } > $self->{ maxChunkSize } ) {
+            $min_max_error = 1;
+            push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is too large [%d], allowed is [%d]',
+                                $info->{flowChunkNumber},
+                                $info->{flowFilename},
+                                $info->{$param},
+                                $self->{maxChunkSize},
+                                ;
+
+        }
+    }
+
+    for my $param (qw(flowChunkSize flowCurrentChunkSize)) {
+        if( exists $info->{ $param } and $info->{ $param } < $self->{ minChunkSize } ) {
+            $min_max_error = 1;
+            push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is too small [%d], allowed is [%d]',
+                                $info->{flowChunkNumber},
+                                $info->{flowFilename},
+                                $info->{$param},
+                                $self->{minChunkSize},
+                                ;
+
+        }
+    }
+
+    if( ! $min_max_error and ($info->{ flowTotalSize } || 0) > $self->{ maxFileSize } ) {
         # Uploaded file would be too large
-        push @invalid, sprintf 'Uploaded file [%s] would be too large ([%d]) expect [%d]',
+        push @invalid, sprintf 'Uploaded file [%s] would be too large ([%d]) allowed is [%d]',
                             $info->{flowFilename},
                             $info->{flowTotalSize},
                             $self->{maxFileSize},
                             ;
 
-    } elsif( $method eq 'POST' and $info->{ localChunkSize } > $info->{flowChunkSize} ) {
+    } elsif( ! $min_max_error and $method eq 'POST' and $info->{ localChunkSize } > $info->{flowChunkSize} ) {
         # Uploaded chunk is larger than the maximum chunk upload size
-        push @invalid, sprintf 'Uploaded chunk [%d] of [%s] is larger than it should be ([%d], expect [%d])',
+        push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is larger than it should be ([%d], allowed is [%d])',
                             $info->{flowChunkNumber},
                             $info->{flowFilename},
                             $info->{localChunkSize},
                             $self->{maxChunkSize},
                             ;
 
-    } elsif( ($info->{ flowChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
+    } elsif( ! $min_max_error and ($info->{ flowCurrentChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
         # Uploaded chunk is a middle or end chunk but is too small
         push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
                             $info->{flowChunkNumber},
-                            $info->{localChunkSize},
+                            $info->{flowCurrentChunkSize},
                             $self->expectedChunkSize( $info ),
                             ;
 
-    } elsif( ($info->{ flowChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
+    } elsif( ! $min_max_error and ($info->{ flowCurrentChunkSize } || 0 ) > $self->expectedChunkSize( $info )) {
         # Uploaded chunk is a middle or end chunk but is too large
         push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
                             $info->{flowChunkNumber},
-                            $info->{flowChunkSize},
+                            $info->{flowCurrentChunkSize},
                             $self->expectedChunkSize( $info ),
                             ;
 
diff --git a/t/002_http_upload_disallowedContentType.t b/t/002_http_upload_disallowedContentType.t
index 898b571..10b7cea 100644
--- a/t/002_http_upload_disallowedContentType.t
+++ b/t/002_http_upload_disallowedContentType.t
@@ -33,6 +33,7 @@ my $flowjs = HTTP::Upload::FlowJs->new(
 my %info = (
         flowChunkNumber => 1,
         flowChunkSize => -s $0,
+        flowCurrentChunkSize => -s $0,
         flowFilename => 'IMG_7363.JPG',
         flowIdentifier => '2226376-IMG_7363JPG',
         flowRelativePath => 'IMG_7363.JPG',
diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index 87f2e2e..ba664dc 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -34,12 +34,15 @@ my( $status, @errors ) = $flowjs->chunkOK(
         flowIdentifier => '2226376-IMG_7363JPG',
         flowRelativePath => 'IMG_7363.JPG',
         flowTotalChunks => 3,
-        flowTotalSize => 2226376
+        flowTotalSize => 2226376,
+        flowCurrentChunkSize => 129224,
     }
 );
 is $status, 416, "A non-existing directory+file is no error";
 is_deeply \@errors, [], "The request is not obviously invalid";
 
+
+
 # Check that different sessions get different names
    $flowjs = HTTP::Upload::FlowJs->new(
     incomingDirectory => $tempdir,
@@ -63,6 +66,8 @@ isn't $chunkName{1}, $chunkName{2}, "Different sessions get different filenames"
    $flowjs = HTTP::Upload::FlowJs->new(
     incomingDirectory => $tempdir,
 );
+
+
 # Now try to "upload" a chunk much larger than what is allowed:
 # Check that we can ask for the presence of a file
 my %info = (
@@ -74,6 +79,7 @@ my %info = (
         flowTotalChunks => 1,
         flowTotalSize => -s $0,
         localChunkSize => 10_000_000,
+        flowCurrentChunkSize => 1048576,
         file => $0,
 );
 @errors = $flowjs->validateRequest(
@@ -81,7 +87,7 @@ my %info = (
     \%info,
 );
 is_deeply [ sort @errors ], [
-    'Uploaded chunk [1] of [IMG_7363.JPG] is larger than it should be ([10000000], expect [1048576])',
+    'Uploaded chunk [1] of file [IMG_7363.JPG] is larger than it should be ([10000000], allowed is [1048576])',
 ], "We reject a chunk that is larger than the proposed size"
     or do { diag $_ for @errors };
 
@@ -95,6 +101,7 @@ is_deeply [ sort @errors ], [
         flowTotalChunks => 1100,
         flowTotalSize => -s $0,
         localChunkSize => 1,
+        flowCurrentChunkSize => 1048576,
         file => $0,
 );
 @errors = $flowjs->validateRequest(
@@ -120,6 +127,7 @@ binmode $testfile;
         flowTotalChunks => 1,
         flowTotalSize => -s $0,
         localChunkSize => -s $0,
+        flowCurrentChunkSize => -s $0,
         file => $0,
 );
 @errors = $flowjs->validateRequest(
@@ -185,6 +193,7 @@ diag "Uploading sequence: @parts";
     flowIdentifier => 'test.png',
     file => undef,
     localChunkSize => undef,
+    flowCurrentChunkSize => undef,
 );
 
 my @uploaded_parts = ($tempname); # from above
@@ -198,6 +207,7 @@ for my $chunk (@parts) {
         flowIdentifier => 'test.png',
         file => part_fh($chunk),
         localChunkSize => length part($chunk),
+        flowCurrentChunkSize => length part($chunk),
     );
     $seen{ $chunk } = $info{ localChunkSize };
     @errors = $flowjs->validateRequest(
@@ -294,6 +304,7 @@ for my $chunk (@parts, 2..parts) {
         flowIdentifier => 'test.png',
         file => part_fh($chunk),
         localChunkSize => length part($chunk),
+        flowCurrentChunkSize => length part($chunk),
     );
     $seen{ $chunk } = $info{ localChunkSize };
     @errors = $flowjs->validateRequest(

From d658169aebf15137afcab6c0790f55f247bfe5e1 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 9 Aug 2017 01:16:12 +0300
Subject: [PATCH 10/18] Fix forceChunkSize and jsConfig

---
 lib/HTTP/Upload/FlowJs.pm | 19 +++++++------
 t/004_js-config.t         | 57 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 8 deletions(-)
 create mode 100644 t/004_js-config.t

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index cf8b92f..80a2cc0 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -222,7 +222,7 @@ sub new {
     $options{ maxFileSize } ||= 10_000_000;
     $options{ maxChunkSize } ||= 1024*1024;
     $options{ minChunkSize } ||= 1024;
-    $options{ forceChunkSize } ||= 1;
+    $options{ forceChunkSize } //= 1;
     $options{ simultaneousUploads } ||= 3;
     $options{ fileParameterName } ||= 'file';
     $options{ mime } ||= mime_detect();
@@ -263,28 +263,31 @@ object for inclusion with the JS side of the world
 sub jsConfig {
     my ( $self, %override ) = @_;
 
+
     # The last uploaded chunk will be at least this size and up to two the size
     # when forceChunkSize is false
     my $chunkSize = $self->{maxChunkSize};
     $chunkSize = $chunkSize / 2 unless $self->{forceChunkSize};
 
-    {
-        map { $_ => $self->{$_} } (qw(
-            simultaneousUploads
-            forceChunkSize
-        )),
+    +{
+        (
+            map { $_ => $self->{$_} } (qw(
+                simultaneousUploads
+                forceChunkSize
+            ))
+        ),
         chunkSize => $chunkSize,
         testChunks => 1,
         withCredentials => 1,
         uploadMethod => 'POST',
         %override,
-    }
+    };
 }
 
 sub jsConfigStr {
     my ( $self, %override ) = @_;
 
-    encode_json($self->js_Config(%override))
+    encode_json($self->jsConfig(%override))
 }
 
 =head2 C<< $flowjs->params >>
diff --git a/t/004_js-config.t b/t/004_js-config.t
new file mode 100644
index 0000000..a91091e
--- /dev/null
+++ b/t/004_js-config.t
@@ -0,0 +1,57 @@
+#!perl -w
+use strict;
+use warnings;
+use Test::More tests => 3;
+use Data::Dumper;
+
+use HTTP::Upload::FlowJs;
+use File::Temp qw(tempdir);
+use ExtUtils::Command();
+
+my $tempdir = tempdir( );
+END {
+    if( defined $tempdir ) {
+        diag "Cleaning up $tempdir";
+        @ARGV = $tempdir;
+        ExtUtils::Command::rm_rf $tempdir;
+    };
+};
+
+my $flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+    forceChunkSize => 0,
+);
+
+is_deeply
+    $flowjs->jsConfig(addition => 'value'),
+    {
+        'chunkSize' => '524288',
+        'forceChunkSize' => 0,
+        'simultaneousUploads' => 3,
+        'testChunks' => 1,
+        'uploadMethod' => 'POST',
+        'withCredentials' => 1,
+        'addition' => 'value',
+    },
+    "jsConfig and chunkSize when forceChunkSize(0)";
+
+$flowjs = HTTP::Upload::FlowJs->new(
+    incomingDirectory => $tempdir,
+);
+
+is_deeply
+    $flowjs->jsConfig,
+    {
+        'chunkSize' => '1048576',
+        'forceChunkSize' => 1,
+        'simultaneousUploads' => 3,
+        'testChunks' => 1,
+        'uploadMethod' => 'POST',
+        'withCredentials' => 1,
+    },
+    "jsConfig and chunkSize when forceChunkSize(1)";
+
+
+ok $flowjs->jsConfigStr, "js str config";
+
+done_testing;

From 5379630c836d0bff2683a023e6f4a3211dca8c32 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Tue, 28 Nov 2017 12:58:14 +0300
Subject: [PATCH 11/18] Fix doc for ->new

---
 lib/HTTP/Upload/FlowJs.pm | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 80a2cc0..892ccb4 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -163,12 +163,22 @@ or L<Dancer> for that.
 
 =over 4
 
+B<incomingDirectory> - path for the temporary upload parts
+
+Required
+
 B<maxChunkCount> - hard maximum chunks allowed for a single upload
 
+Default 1000
+
 B<maxFileSize> - hard maximum total file size for a single upload
 
+Default 10_000_000
+
 B<maxChunkSize> - hard maximum chunk size for a single chunk
 
+Default 1048576
+
 B<minChunkSize> - hard minimum chunk size for a single chunk
 
 Default 1024
@@ -189,6 +199,8 @@ L</jsConfig> equal to C<maxChunkSize / 2>.
 
 B<simultaneousUploads> - simultaneously allowed uploads per file
 
+Default 3
+
 This is just an indication to the Javascript C<flow.js> client
 if you pass it the configuration from this object. This is not enforced
 in any way yet.
@@ -202,7 +214,7 @@ upload as complete with C<< $flowjs->uploadComplete >>.
 
 B<fileParameterName> - The name of the multipart POST parameter to use for the file chunk
 
-Default: file
+Default file
 
 =back
 

From af63cc80a3e211ddfd2a1cd84aadad7d8a842d54 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 14 Feb 2018 12:51:53 +0300
Subject: [PATCH 12/18] Fix message

---
 lib/HTTP/Upload/FlowJs.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 892ccb4..5f48668 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -503,7 +503,7 @@ sub validateRequest {
 
     } elsif( ! $min_max_error and ($info->{ flowCurrentChunkSize } || 0 ) > $self->expectedChunkSize( $info )) {
         # Uploaded chunk is a middle or end chunk but is too large
-        push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
+        push @invalid, sprintf 'Uploaded chunk [%s] is too large ([%d]) expect [%d]',
                             $info->{flowChunkNumber},
                             $info->{flowCurrentChunkSize},
                             $self->expectedChunkSize( $info ),

From 8072c4e5c8ce81829adc21c46e3db771e1629d52 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 14 Feb 2018 14:08:44 +0300
Subject: [PATCH 13/18] Last chunk could be less than minChunkSize on
 multi-chunk upload

---
 lib/HTTP/Upload/FlowJs.pm  |   6 +-
 t/003_http_upload_flowjs.t | 134 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 138 insertions(+), 2 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 5f48668..01a94e1 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -464,7 +464,11 @@ sub validateRequest {
     }
 
     for my $param (qw(flowChunkSize flowCurrentChunkSize)) {
-        if( exists $info->{ $param } and $info->{ $param } < $self->{ minChunkSize } ) {
+        if( exists $info->{ $param } and $info->{ $param } < $self->{ minChunkSize }
+            and ( $info->{flowChunkNumber} < $info->{flowTotalChunks} # only last chunk could be smaller
+               or $info->{flowTotalChunks} <= 1                       # when total chunks > 1
+            )
+        ) {
             $min_max_error = 1;
             push @invalid, sprintf 'Uploaded chunk [%d] of file [%s] is too small [%d], allowed is [%d]',
                                 $info->{flowChunkNumber},
diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index ba664dc..d3f8877 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -1,7 +1,7 @@
 #!perl -w
 use strict;
 use warnings;
-use Test::More tests => 86;
+use Test::More tests => 87;
 use Data::Dumper;
 
 use HTTP::Upload::FlowJs;
@@ -372,5 +372,137 @@ for my $partname (sort keys %uploaded_parts) {
 };
 
 
+subtest 'Too small checks on edges' => sub {
+    my $flowjs = HTTP::Upload::FlowJs->new(
+        incomingDirectory => $tempdir,
+        minChunkSize => 512,
+        maxChunkSize => 1024,
+    );
+
+    # Assume file size is 1280: two chunks
+    #   1 - 1024
+    #   2 - 256
+    my %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 2,
+        flowTotalSize => 1280,
+        localChunkSize => 1024,
+        flowCurrentChunkSize => 1024,
+        file => $0,
+    );
+    my @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors 1/2');
+
+    %info = (
+        flowChunkNumber => 2,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 2,
+        flowTotalSize => 1280,
+        localChunkSize => 256,
+        flowCurrentChunkSize => 256,
+        file => $0,
+    );
+
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+
+    is_deeply( \@errors, [], 'No errors 2/2');
+
+
+    # Assume file size is 1024: one chunk
+    #   1 - 1024
+    %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 1024,
+        localChunkSize => 1024,
+        flowCurrentChunkSize => 1024,
+        file => $0,
+    );
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors 1/1');
+
+    # Assume file size is 768: one chunk
+    #   1 - 768
+    %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 768,
+        localChunkSize => 768,
+        flowCurrentChunkSize => 768,
+        file => $0,
+    );
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors 1/1');
+
+
+    # Assume file size is 512: one chunk
+    #   1 - 512
+    %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 512,
+        localChunkSize => 512,
+        flowCurrentChunkSize => 512,
+        file => $0,
+    );
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors 1/1');
+
+    # Assume file size is 511: one chunk
+    #   1 - 511
+    %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 511,
+        localChunkSize => 511,
+        flowCurrentChunkSize => 511,
+        file => $0,
+    );
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, ['Uploaded chunk [1] of file [IMG_7363.JPG] is too small [511], allowed is [512]'], 'Has error 1/1');
+};
+
+diag explain \@errors;
 
 done_testing;
\ No newline at end of file

From e786abe8c90b5e60ca5ff024ed8bae24bb819b70 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 14 Feb 2018 14:23:35 +0300
Subject: [PATCH 14/18] Fix when real uploaded chunk size is less than provided

---
 lib/HTTP/Upload/FlowJs.pm  | 12 ++++++++++--
 t/003_http_upload_flowjs.t | 37 +++++++++++++++++++++++++++++++++++--
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 01a94e1..2a22c48 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -497,7 +497,7 @@ sub validateRequest {
                             $self->{maxChunkSize},
                             ;
 
-    } elsif( ! $min_max_error and ($info->{ flowCurrentChunkSize } || 0 ) < $self->expectedChunkSize( $info )) {
+    } elsif( ! $min_max_error and $info->{ flowCurrentChunkSize } < $self->expectedChunkSize( $info ) ) {
         # Uploaded chunk is a middle or end chunk but is too small
         push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
                             $info->{flowChunkNumber},
@@ -505,7 +505,15 @@ sub validateRequest {
                             $self->expectedChunkSize( $info ),
                             ;
 
-    } elsif( ! $min_max_error and ($info->{ flowCurrentChunkSize } || 0 ) > $self->expectedChunkSize( $info )) {
+    } elsif( ! $min_max_error and $method eq 'POST' and $info->{ localChunkSize } < $info->{ flowCurrentChunkSize } ) {
+        # Real uploaded chunk is smaller than provided chunk upload size
+        push @invalid, sprintf 'Uploaded chunk [%s] is too small ([%d]) expect [%d]',
+                            $info->{flowChunkNumber},
+                            $info->{localChunkSize},
+                            $info->{flowCurrentChunkSize},
+                            ;
+
+    } elsif( ! $min_max_error and $info->{ flowCurrentChunkSize } > $self->expectedChunkSize( $info ) ) {
         # Uploaded chunk is a middle or end chunk but is too large
         push @invalid, sprintf 'Uploaded chunk [%s] is too large ([%d]) expect [%d]',
                             $info->{flowChunkNumber},
diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index d3f8877..cae79f9 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -1,7 +1,7 @@
 #!perl -w
 use strict;
 use warnings;
-use Test::More tests => 87;
+use Test::More tests => 88;
 use Data::Dumper;
 
 use HTTP::Upload::FlowJs;
@@ -100,7 +100,7 @@ is_deeply [ sort @errors ], [
         flowRelativePath => 'IMG_7363.JPG',
         flowTotalChunks => 1100,
         flowTotalSize => -s $0,
-        localChunkSize => 1,
+        localChunkSize => 1048576,
         flowCurrentChunkSize => 1048576,
         file => $0,
 );
@@ -503,6 +503,39 @@ subtest 'Too small checks on edges' => sub {
     is_deeply( \@errors, ['Uploaded chunk [1] of file [IMG_7363.JPG] is too small [511], allowed is [512]'], 'Has error 1/1');
 };
 
+subtest 'Check local size' => sub {
+    my $flowjs = HTTP::Upload::FlowJs->new(
+        incomingDirectory => $tempdir,
+        minChunkSize => 512,
+        maxChunkSize => 1024,
+    );
+
+    my %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 768,
+        localChunkSize => 0,
+        flowCurrentChunkSize => 768,
+        file => $0,
+    );
+    my @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors on GET');
+
+    @errors = $flowjs->validateRequest(
+        'POST',
+        \%info,
+    );
+    is_deeply( \@errors, ['Uploaded chunk [1] is too small ([0]) expect [768]'], 'Has errors on POST');
+
+};
+
 diag explain \@errors;
 
 done_testing;
\ No newline at end of file

From fa3fe60e605b9e2f01f548a0f615152b5b613b9d Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 14 Feb 2018 14:34:50 +0300
Subject: [PATCH 15/18] Allow upload zero-size files

---
 lib/HTTP/Upload/FlowJs.pm  |  8 ++++++--
 t/003_http_upload_flowjs.t | 42 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/lib/HTTP/Upload/FlowJs.pm b/lib/HTTP/Upload/FlowJs.pm
index 2a22c48..24e175b 100644
--- a/lib/HTTP/Upload/FlowJs.pm
+++ b/lib/HTTP/Upload/FlowJs.pm
@@ -233,7 +233,7 @@ sub new {
     $options{ maxChunkCount } ||= 1000;
     $options{ maxFileSize } ||= 10_000_000;
     $options{ maxChunkSize } ||= 1024*1024;
-    $options{ minChunkSize } ||= 1024;
+    $options{ minChunkSize } //= 1024;
     $options{ forceChunkSize } //= 1;
     $options{ simultaneousUploads } ||= 3;
     $options{ fileParameterName } ||= 'file';
@@ -386,7 +386,7 @@ sub validateRequest {
 
     # Numbers should be numbers
     for my $param (qw(flowChunkNumber flowTotalChunks flowChunkSize flowTotalSize flowCurrentChunkSize)) {
-        if( exists $info->{ $param } and ! $info->{ $param } =~ /^[0-9]+$/) {
+        if( exists $info->{ $param } and $info->{ $param } !~ /^[0-9]+$/) {
             push @invalid, sprintf 'Parameter [%s] should be numeric, but is [%s]; set to 0',
                                 $param,
                                 $info->{$param}
@@ -557,6 +557,10 @@ sub expectedChunkSize {
         # No size, we guess it'll be zero:
         return 0
 
+    } elsif( ! $info->{flowTotalSize} ) {
+        # Total size is zero
+        return 0;
+
     } else {
         # The last chunk can be smaller or sized just like all the chunks
         # if the file size happens to be divided by the chunk size
diff --git a/t/003_http_upload_flowjs.t b/t/003_http_upload_flowjs.t
index cae79f9..b6124eb 100644
--- a/t/003_http_upload_flowjs.t
+++ b/t/003_http_upload_flowjs.t
@@ -1,7 +1,7 @@
 #!perl -w
 use strict;
 use warnings;
-use Test::More tests => 88;
+use Test::More tests => 89;
 use Data::Dumper;
 
 use HTTP::Upload::FlowJs;
@@ -536,6 +536,46 @@ subtest 'Check local size' => sub {
 
 };
 
+subtest 'Zero size' => sub {
+    my $flowjs = HTTP::Upload::FlowJs->new(
+        incomingDirectory => $tempdir,
+        minChunkSize => 0,
+        maxChunkSize => 1024,
+    );
+
+    my %info = (
+        flowChunkNumber => 1,
+        flowChunkSize => 1024,
+        flowFilename => 'IMG_7363.JPG',
+        flowIdentifier => '2226376-IMG_7363JPG',
+        flowRelativePath => 'IMG_7363.JPG',
+        flowTotalChunks => 1,
+        flowTotalSize => 0,
+        localChunkSize => 0,
+        flowCurrentChunkSize => 0,
+        file => $0,
+    );
+    my @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, [], 'No errors on GET');
+
+    # Min chunk size
+    $flowjs = HTTP::Upload::FlowJs->new(
+        incomingDirectory => $tempdir,
+        minChunkSize => 1,
+        maxChunkSize => 1024,
+    );
+
+    @errors = $flowjs->validateRequest(
+        'GET',
+        \%info,
+    );
+    is_deeply( \@errors, ['Uploaded chunk [1] of file [IMG_7363.JPG] is too small [0], allowed is [1]'], 'Has errors on GET');
+
+};
+
 diag explain \@errors;
 
 done_testing;
\ No newline at end of file

From ca2e5ddfc152a03246e3090a113e5022aa940403 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Wed, 14 Feb 2018 14:38:28 +0300
Subject: [PATCH 16/18] Add required param

---
 example/plack-server.psgi | 1 +
 1 file changed, 1 insertion(+)

diff --git a/example/plack-server.psgi b/example/plack-server.psgi
index 5a8159d..14452fc 100644
--- a/example/plack-server.psgi
+++ b/example/plack-server.psgi
@@ -42,6 +42,7 @@ my @parameter_names = (
     'flowChunkNumber', # The index of the chunk in the current upload.
                        # First chunk is 1 (no base-0 counting here).
     'flowTotalChunks', # The total number of chunks.
+    'flowCurrentChunkSize', # Current chunk size
     'flowChunkSize', # The general chunk size. Using this value and
                      # flowTotalSize you can calculate the total number of
                      # chunks. Please note that the size of the data received in

From 3eed6091f3e0800914a917f1c44b8f7b5b08d61c Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Sat, 3 Mar 2018 20:23:31 +0300
Subject: [PATCH 17/18] Use feature fc if possible

---
 lib/HTTP/Upload/FlowJs/Utils.pm | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/HTTP/Upload/FlowJs/Utils.pm b/lib/HTTP/Upload/FlowJs/Utils.pm
index cecdff1..3bf05d8 100644
--- a/lib/HTTP/Upload/FlowJs/Utils.pm
+++ b/lib/HTTP/Upload/FlowJs/Utils.pm
@@ -9,7 +9,7 @@ require Exporter;
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(clean_fragment mime_detect);
 
-use feature qw(fc);
+use if $] >= 5.016, feature => qw(fc);
 use Unicode::Normalize;
 
 BEGIN {
@@ -19,6 +19,8 @@ BEGIN {
         my $subname = __PACKAGE__ . '::clean_fragment';
         no strict 'refs';
         if ( $@ ) {
+            die "Need Text::CleanFragment or Perl >= 5.016\n\n" if $] < 5.016;
+
             *{$subname} = \&clean_fragment_fallback;
         }
         else {

From 14e88f4251f1b977856fd64eefa375c59c8fae31 Mon Sep 17 00:00:00 2001
From: Dmitry Latin <dim0xff@gmail.com>
Date: Sat, 3 Mar 2018 20:25:02 +0300
Subject: [PATCH 18/18] Move some modules to recommends, fix travis.yml

---
 .travis.yml | 16 ++++++++++++++++
 META.json   | 10 ++++++----
 META.yml    |  7 ++++---
 Makefile.PL | 15 ++++++++++-----
 4 files changed, 36 insertions(+), 12 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index e200c91..56c5cef 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,9 +13,20 @@ perl:
   - "5.26"
   - "blead"
 
+env:
+  - WITHOUT_RECOMMENDS=0
+  - WITHOUT_RECOMMENDS=1
+
 matrix:
   allow_failures:
     - perl: blead
+  exclude:
+    - perl: "5.10"
+      env: WITHOUT_RECOMMENDS=1
+    - perl: "5.12"
+      env: WITHOUT_RECOMMENDS=1
+    - perl: "5.14"
+      env: WITHOUT_RECOMMENDS=1
 
 sudo: false
 
@@ -27,6 +38,11 @@ before_install:
   - build-dist
   - cd $BUILD_DIR
   - cpan-install ExtUtils::MakeMaker~6.68
+  - if [ "$WITHOUT_RECOMMENDS" = "1" ]; then
+        for f in "META.json" "META.yml" "Makefile.PL"; do
+            cat $f | grep -P -v 'Filter::signatures|MIME::Detect|Text::CleanFragment|^recommends:' > $$ && mv -f $$ $f;
+        done;
+    fi
   - cpan-install --deps
 
 script:
diff --git a/META.json b/META.json
index eed6c73..05e34bc 100644
--- a/META.json
+++ b/META.json
@@ -34,12 +34,14 @@
          "requires" : {
             "Carp" : "0",
             "Data::Dumper" : "0",
-            "Filter::signatures" : "0.04",
             "JSON" : "0",
-            "MIME::Detect" : "0",
             "Test::More" : "0",
-            "Text::CleanFragment" : "0",
-            "perl" : "5.006"
+            "perl" : "5.010"
+         },
+         "recommends" : {
+            "Filter::signatures" : "0.10",
+            "MIME::Detect" : "0",
+            "Text::CleanFragment" : "0"
          }
       }
    },
diff --git a/META.yml b/META.yml
index be3961b..8c14878 100644
--- a/META.yml
+++ b/META.yml
@@ -24,12 +24,13 @@ provides:
 requires:
   Carp: '0'
   Data::Dumper: '0'
-  Filter::signatures: '0.04'
   JSON: '0'
-  MIME::Detect: '0'
   Test::More: '0'
+  perl: '5.010'
+recommends:
+  Filter::signatures: '0.10'
+  MIME::Detect: '0'
   Text::CleanFragment: '0'
-  perl: '5.006'
 resources:
   license: http://dev.perl.org/licenses/
   repository: git://github.com/Corion/HTTP-Upload-FlowJs.git
diff --git a/Makefile.PL b/Makefile.PL
index aaba03e..f031c14 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -42,7 +42,16 @@ my %module = (
                 file    => $main_file,
                 version => $main_version,
             }
-        }
+        },
+        prereqs => {
+            runtime => {
+                recommends => {
+                    'Filter::signatures' => '0.10', # For compatibility with Perl < 5.22
+                    'MIME::Detect'      => 0, # for user generated content
+                    'Text::CleanFragment' => 0, # we want to create clean local filenames
+                },
+            },
+        },
     },
     LICENSE             => 'perl',
     PL_FILES            => {},
@@ -51,13 +60,9 @@ my %module = (
     },
     PREREQ_PM => {
         'Carp' => 0,
-        'Filter::signatures' => '0.10', # For compatibility with Perl < 5.22
         'Test::More' => 0,
         'JSON'           => 0, # Just for the interface
         'Data::Dumper'      => 0, # for printing clean values to logfiles
-        
-        'MIME::Detect'      => 0, # for user generated content
-        'Text::CleanFragment' => 0, # we want to create clean local filenames
     },
     dist                => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
     clean               => { FILES => 'HTTP-Upload-FlowJs-*' },