Ask Ben: Splitting And Joining Large Binary Files Using Buffers In ColdFusion

<!---
	Get the large target binary file that we want to split
	up in to several parts. Our demo file is only about
	5 megabytes, but this should be sufficient to demo.
--->
<cfset strTargetFile = ExpandPath( "crazy_insane.jpg" ) />

<!---
	Set the name of the re-compiled target file. This will
	be the path to which we recombine all the individual
	data chunks.
--->
<cfset strNewTargetFile = ExpandPath( "crazy_insane_new.jpg" ) />


<!---
	Set the number of bytes that we want to use for our
	file chunking size. For our demo purposes (since we don't
	have a huge file), let's use about a megabyte.
--->
<cfset intBufferSize = (1024 * 1024) />


<!---
	Create a file input stream to read in the chunks of the
	binary file at a time so that we can split it up.
--->
<cfset objInputStream = CreateObject(
	"java",
	"java.io.FileInputStream"
	).Init(
		JavaCast( "string", strTargetFile )
		)
	/>

<!---
	Create a byte buffer into which we will read the file
	parts. This byte buffer will determine how large the
	file chunks are. We are going to use the underlying
	byte array of a string to create our byte array buffer.

	Let's make our byte buffer so that it is about a
	megabyte in size (1024 * 1024 bytes).
--->
<cfset arrBuffer = RepeatString( " ", intBufferSize ).GetBytes() />


<!---
	Now, we want to keep looping over the input stream and
	reading files until we no longer can read any more data.
	We are going to use an index loop with a huge max just
	to use the counter aspect of it.
--->
<cfloop
	index="intFileIndex"
	from="1"
	to="99999"
	step="1">

	<!--- Read from the input stream. --->
	<cfset intBytesRead = objInputStream.Read(
		arrBuffer,
		JavaCast( "int", 0 ),
		JavaCast( "int", ArrayLen( arrBuffer ) )
		) />

	<!---
		Check to see if we read any bytes from the buffer.
		If so, then we want to write those to file. If not,
		then we are done reading data.
	--->
	<cfif (intBytesRead GT 0)>

		<!---
			Our buffer contains a certain amount of data. We
			cannont simply write this buffer to disk in whole
			because it might not be completely full. Therefore,
			we cannot use a plain CFFile. Let's create a file
			output stream so that we can leverage its buffer-
			using Write() method.

			When choosing the file name for this file chunk,
			use the index value of the current read iteration
			to creat a "part" file.
		--->
		<cfset objOutputStream = CreateObject(
			"java",
			"java.io.FileOutputStream"
			).Init(
				JavaCast(
					"string",
					"#strTargetFile#.part#intFileIndex#"
					)
				)
			/>

		<!--- Write our buffer to that file outpu stream. --->
		<cfset objOutputStream.Write(
			arrBuffer,
			JavaCast( "int", 0 ),
			JavaCast( "int", intBytesRead )
			) />

		<!--- Close the file output stream. --->
		<cfset objOutputStream.Close() />

	<cfelse>

		<!---
			We are done reading data. Close the file input
			stream to free it up as a system resource.
		--->
		<cfset objInputStream.Close() />

		<!--- Break out of read loop. --->
		<cfbreak />

	</cfif>

</cfloop>



<!--- END: Split ----------------------------------- --->



<!---
	We have now split our large binary file in to several
	smaller files. Let's see if we can put it back together
	again in a new binary file.
--->

<!---
	Again, we don't want to be reading the whole file into
	memory, so let's create a file output stream to which
	we can write out smaller file data.
--->
<cfset objOutputStream = CreateObject(
	"java",
	"java.io.FileOutputStream"
	).Init(
		JavaCast( "string", strNewTargetFile )
		)
	/>


<!---
	Now, we want to loop until we no longer can find any
	smaller chunk files. Sure we could just use the file
	index found above, but let's do this assuming we don't
	have any of the data from above.
--->
<cfloop
	index="intFileIndex"
	from="1"
	to="99999"
	step="1">

	<!--- Get the file name of the next chunk file. --->
	<cfset strFileName = "#strTargetFile#.part#intFileIndex#" />

	<!--- Check to see if which file part exists. --->
	<cfif FileExists( strFileName )>

		<!---
			Since we knows that these smaller files are not
			too big, we can simply do a binary read of the
			complete chunk files into memory.
		--->
		<cffile
			action="readbinary"
			file="#strFileName#"
			variable="binFileData"
			/>

		<!---
			Write that file data to our output stream. We are
			going to pretend that the binar data read we just
			did was actually a byte buffer.
		--->
		<cfset objOutputStream.Write(
			binFileData,
			JavaCast( "int", 0 ),
			JavaCast( "int", ArrayLen( binFileData ) )
			) />

	<cfelse>

		<!---
			We have finished reading in smaller chunk files.
			We can now close the new target file output stream
			which will finalize this process.
		--->
		<cfset objOutputStream.Close() />

		<!--- Break out of this loop. --->
		<cfbreak />

	</cfif>

</cfloop>