public override object GetParametersInstance()
    {
        CopyFileHandlerParameters parms = new CopyFileHandlerParameters();

        parms.FileSets = new List <FileSet>();

        FileSet fs1 = new FileSet();

        fs1.Sources      = new List <string>();
        fs1.Destinations = new List <string>();
        fs1.Sources.Add(@"C:\MyDir\MyFile.txt");
        fs1.Sources.Add(@"C:\MyDir\MySubDir\");
        fs1.Sources.Add(@"\\server\share$\Dir001");
        fs1.Sources.Add(@"s3://mybucket/dir001/");
        fs1.Sources.Add(@"s3://mybucket/dir002/MyFile.txt");
        fs1.Destinations.Add(@"C:\MyDest\");
        fs1.Destinations.Add(@"s3://mybucket/destdir/");
        parms.FileSets.Add(fs1);

        return(parms);
    }
    public override ExecuteResult Execute(HandlerStartInfo startInfo)
    {
        OnProgress("CopyFileHandler", "Handler Execution Begins.", StatusType.Running, 0, cheapSequence++);
        ExecuteResult result = new ExecuteResult();

        result.Status = StatusType.Success;

        // TODO : Implement DryRun Functionality
        if (startInfo.IsDryRun)
        {
            throw new NotImplementedException("Dry Run Functionality Has Not Yet Been Implemented.");
        }

        try
        {
            if (startInfo.Parameters != null)
            {
                parameters = HandlerUtils.Deserialize <CopyFileHandlerParameters>(startInfo.Parameters);
            }

            bool isValid = Validate();

            if (isValid)
            {
                if (parameters.FileSets != null)
                {
                    foreach (FileSet set in parameters.FileSets)
                    {
                        if (set != null && set.Sources != null && set.Destinations != null)
                        {
                            OnLogMessage("CopyFileHandler", $"Starting {config.Action} From [{string.Join(",", set.Sources.ToArray())}] To [{string.Join(",", set.Destinations)}].");
                            foreach (String destination in set.Destinations)
                            {
                                if (Utilities.IsDirectory(destination) && config.PurgeDestination)
                                {
                                    ZephyrDirectory clearDir = Utilities.GetZephyrDirectory(destination, clients);
                                    clearDir.Purge(config.StopOnError, config.Verbose, "Purge", Logger);
                                    OnLogMessage("CopyFileHandler", $"Directory [{destination}] Was Purged.");
                                }

                                foreach (String source in set.Sources)
                                {
                                    if (Utilities.IsDirectory(source))
                                    {
                                        ZephyrDirectory sourceDir = Utilities.GetZephyrDirectory(source, clients);
                                        if (Utilities.IsDirectory(destination))
                                        {
                                            // Copy/Move Directory To Directory
                                            ZephyrDirectory destDir = Utilities.GetZephyrDirectory(destination, clients);
                                            if (config.Action == FileAction.Copy)
                                            {
                                                sourceDir.CopyTo(destDir, config.Recurse, config.OverwriteExisting, config.StopOnError, config.Verbose, "Copy", Logger);
                                            }
                                            else
                                            {
                                                sourceDir.MoveTo(destDir, config.OverwriteExisting, config.StopOnError, config.Verbose, "Move", Logger);
                                            }
                                        }
                                        else
                                        {
                                            // This should never occur, as this scenario is addressed in "Validate".
                                            throw new Exception($"Can Not Copy Directory [{source}] To File [{destination}]");
                                        }
                                    }
                                    else
                                    {
                                        ZephyrFile sourceFile = Utilities.GetZephyrFile(source, clients);
                                        if (Utilities.IsDirectory(destination))
                                        {
                                            // Copy/Move File To Directory
                                            ZephyrDirectory destDir = Utilities.GetZephyrDirectory(destination, clients);
                                            if (config.Action == FileAction.Copy)
                                            {
                                                sourceFile.CopyTo(destDir, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Copy", Logger);
                                            }
                                            else
                                            {
                                                sourceFile.MoveTo(destDir, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Move", Logger);
                                            }
                                        }
                                        else
                                        {
                                            // Copy/Move File To File
                                            ZephyrFile destFile = Utilities.GetZephyrFile(destination, clients);
                                            if (config.Action == FileAction.Copy)
                                            {
                                                sourceFile.CopyTo(destFile, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Copy", Logger);
                                            }
                                            else
                                            {
                                                sourceFile.MoveTo(destFile, config.OverwriteExisting, true, config.StopOnError, config.Verbose, "Move", Logger);
                                            }
                                        }
                                    }
                                }
                            }
                            OnLogMessage("CopyFileHandler", $"Finished {config.Action} From [{string.Join(",", set.Sources.ToArray())}] To [{string.Join(",", set.Destinations)}].");
                        }
                    }
                }
            }
            else
            {
                OnLogMessage("CopyFileHandler", "Validation Failed.", LogLevel.Error);
                throw new Exception("Validation Failed.");
            }
        }
        catch (Exception e)
        {
            OnProgress("CopyFileHandler", "Handler Execution Failed.", StatusType.Failed, 0, cheapSequence++, false, e);
            throw e;
        }

        OnProgress("CopyFileHandler", "Handler Execution Completed.", StatusType.Complete, 0, cheapSequence++);
        return(result);
    }