Brennan’s Blog

Due to my problems with copying large files over a USB 2.0 connection I created the SlowCopy Utility. (Offwhite.SlowCopy.zip) It is a command-line utility which takes a source and destination filename as well as an optional chunk size (MB) and wait time (seconds). I was able to copy that 2.6GB MSDN ISO file off my external drive successfully with this utility when a direct copy was failing after a few seconds. I did it with 100MB chunks with a 2 second wait. After 100MB it sleeps for 2 seconds which allows the buffer to clear before copying more data to the destination file.

The utility includes a configuration file which you can use to set the default chunk size and wait time as well as turn off the Verbose setting which writes out the progress as it reaches each of the sleep checkpoints.

This could also be useful when copying files over a network connected drive when connectivity fizzles out after enough data is passed. I once had a problem with an ethernet card which could not handle copying large files off my file server. This utility would have helped in that case.

Here is the code which makes it all work.

using System;
using System.Configuration;
using System.IO;
using System.Threading;

namespace Offwhite.SlowCopy
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length >= 2)
            {
                string sourceFilename = args[0];
                string destinationFilename = args[1];
                string chunkSizeStr = ConfigurationManager.AppSettings["DefaultChunkSize"];
                string waitTimeStr = ConfigurationManager.AppSettings["DefaultWaitTime"];
                if (args.Length >= 3)
                {
                    chunkSizeStr = args[2];
                }
                if (args.Length >= 4)
                {
                    waitTimeStr = args[3];
                }
                int chunkSize;
                int waitTime;
                int.TryParse(chunkSizeStr, out chunkSize);
                int.TryParse(waitTimeStr, out waitTime);

                bool verbose = "true".Equals(ConfigurationManager.AppSettings["Verbose"]);

                chunkSize = chunkSize*1024*1000;
                if (verbose)
                {
                    Console.WriteLine("Chunk Size (MB) = " + chunkSize);
                }

                try
                {
                    if (!File.Exists(sourceFilename))
                    {
                        Console.WriteLine("Source file does not exists: " +
                            sourceFilename);
                        return;
                    }

                    if (File.Exists(destinationFilename))
                    {
                        Console.WriteLine("Warning: destination already exists: " +
                            destinationFilename);
                        return;
                    }

                    FileStream input = File.OpenRead(sourceFilename);
                    FileStream output = File.Create(destinationFilename);

                    int BufferSize = 1024;
                    byte[] buffer = new byte[BufferSize];
                    int bytesRead;
                    long byteCount = 0;
                    long totalByteCount = 0;

                    while ((bytesRead = input.Read(buffer, 0, BufferSize)) > 0)
                    {
                        output.Write(buffer, 0, bytesRead);
                        byteCount += bytesRead;
                        totalByteCount += bytesRead;
                        if (byteCount > chunkSize)
                        {

                            if (verbose)
                            {
                                Console.WriteLine(
                                    "Resting for {0} seconds after {1} bytes",
                                    waitTimeStr, totalByteCount);
                            }
                            Thread.Sleep(waitTime*1000);
                            byteCount = 0;
                        }
                    }

                    input.Close();
                    output.Close();
                }
                catch (IOException ex)
                {
                    Console.WriteLine("An error has occurred: " +
                        ex.Message);
                }
            }
            else
            {
                PrintUsage();
            }
        }

        private static void PrintUsage()
        {
            Console.WriteLine(String.Format(
                "Usage: {0} <source> <destination> " +
                "[chunk size (MB)] [wait time (seconds)]",
                Environment.CommandLine));
        }
    }
}