public override byte[] GetFile(RFFileAvailableEvent availableFile)
{
using (var activity = new RFInputFilesActivity(mContext))
{
return(activity.GetInputFile(availableFile.FileAttributes.FullPath).Data);
}
}
protected static string GenerateUniqueKey(RFFileAvailableEvent e)
{
return(String.Format("{0}_{1}_{2}_{3}",
DateTime.Now.ToString("yyyyMMdd_HHmmss"),
_counter++,
e.FileKey,
e.FileAttributes.FileName));
}
public virtual void ArchiveFile(RFFileAvailableEvent availableFile)
{
if (ArchivePath.NotBlank())
{
var destinationPath = CombinePath(ArchivePath, availableFile.FileAttributes.FileName);
MoveFile(availableFile.FileAttributes.FullPath, destinationPath);
}
}
public override void PutFile(RFFileAvailableEvent file, RFMonitoredFile fileConfig, byte[] data)
{
var directory = Path.Combine(RootDirectory, fileConfig.PutSubDirectory ?? String.Empty);
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, file.FileAttributes.FileName); // file name could have subdirectories
Directory.CreateDirectory(Path.GetDirectoryName(path));
InternalPutFile(path, file, data);
}
public override byte[] GetFile(RFFileAvailableEvent availableFile)
{
var sw = Stopwatch.StartNew();
var data = _connection.RetrieveFile(availableFile.FileAttributes.FullPath);
if (data != null && sw.Elapsed.TotalSeconds > 0)
{
var kBytesPerSec = (data.Length / 1024.0) / sw.Elapsed.TotalSeconds;
RFStatic.Log.Info(this, "Retrieved file {0} @ {1} kB/s", availableFile.FileAttributes.FileName, kBytesPerSec);
}
return(data);
}
public override void PutFile(RFFileAvailableEvent file, RFMonitoredFile fileConfig, byte[] data)
{
var uniqueKey = GenerateUniqueKey(file);
var fileEntry = new RFFile
{
Attributes = file.FileAttributes,
FileKey = file.FileKey,
Data = data,
UniqueKey = uniqueKey
};
mContext.SaveEntry(RFDocument.Create(
RFFileKey.Create(mKeyDomain, file.FileKey, uniqueKey),
fileEntry));
}
protected RFFileAvailableEvent ProcessCandidate(RFMonitoredFile file, RFFileTrackedAttributes candidate, ref List <RFFileAvailableEvent> foundFiles)
{
if (!IsStillWrittenTo(candidate))
{
var fae = new RFFileAvailableEvent
{
FileKey = file.FileKey,
FileAttributes = candidate,
SourceSite = SiteKey
};
foundFiles.Add(fae);
return(fae);
}
return(null);
}
protected void InternalPutFile(string path, RFFileAvailableEvent file, byte[] data)
{
File.WriteAllBytes(path, data);
if (PreserveModifiedDate)
{
try
{
File.SetLastWriteTimeUtc(path, file.FileAttributes.ModifiedDate);
File.SetCreationTimeUtc(path, file.FileAttributes.ModifiedDate);
}
catch (Exception ex)
{
RFStatic.Log.Warning(this, "Unable to set modified date on file {0}: {1}", path, ex.Message);
}
}
}
public override void PutFile(RFFileAvailableEvent file, RFMonitoredFile fileConfig, byte[] data)
{
var directory = GetUnixDirectory(fileConfig.PutSubDirectory);
if (UseTemporaryName)
{
var tmpFileName = file.FileAttributes.FileName + ".tmp";
_connection.PutFile(directory, tmpFileName, data);
_connection.MoveFile(
RFFileHelpers.GetUnixPath(directory, tmpFileName),
RFFileHelpers.GetUnixPath(directory, file.FileAttributes.FileName));
}
else
{
_connection.PutFile(directory, file.FileAttributes.FileName, data);
}
}
public override void PutFile(RFFileAvailableEvent file, RFMonitoredFile fileConfig, byte[] data)
{
var fileName = file.FileAttributes.FileName;
if (fileName.Contains('.'))
{
fileName = fileName.Substring(0, fileName.LastIndexOf('.')) + file.FileAttributes.ModifiedDate.ToString("_HHmmss") + fileName.Substring(fileName.LastIndexOf('.'));
}
else
{
fileName += file.FileAttributes.ModifiedDate.ToString("_HHmmsss");
}
// mirror path is \modified-date\source-site\relative-location\<org_filename>_HHmmss.<ext>
var mirrorDirectory = Path.Combine(file.FileAttributes.ModifiedDate.ToString("yyyy-MM-dd"), file.SourceSite.ToString(), fileConfig.PutSubDirectory ?? String.Empty);
var mirrorPath = Path.Combine(mirrorDirectory, fileName);
PutMirroredFile(mirrorPath, file, data);
}
private bool ProcessFile(RFFileAvailableEvent availableFile, byte[] data, RFMonitoredFile monitoredFile, RFSeenFiles seenFiles)
{
string finalName = null;
data = DecryptFile(data, availableFile.FileAttributes, out finalName);
finalName = monitoredFile.TransformName(finalName);
var decryptedFile = new RFFileAvailableEvent
{
FileKey = availableFile.FileKey,
FileAttributes = new RFFileTrackedAttributes
{
FileName = finalName,
FileSize = data.Length,
FullPath = availableFile.FileAttributes.FullPath,
ModifiedDate = availableFile.FileAttributes.ModifiedDate
},
SourceSite = availableFile.SourceSite
};
Log.Info("Storing new file {0} to {1}", finalName, mConfig.DestinationSite);
mConfig.DestinationSite.PutFile(decryptedFile, monitoredFile, data);
// mark original encrypted version as seen
MarkSeenFile(seenFiles, availableFile); // only if successful on both fronts
if (mConfig.DestinationSite is RFDocumentFileSite || mConfig.DestinationSite is RFLocalFileSite)
{
Log.Action("Download", "File Transfer", RFDate.NullDate, "Downloaded file {0} from {1}", availableFile.FileAttributes.FileName, mConfig.SourceSite);
}
else if (mConfig.SourceSite is RFDocumentFileSite || mConfig.SourceSite is RFLocalFileSite)
{
Log.Action("Upload", "File Transfer", RFDate.NullDate, "Uploaded file {0} to {1}", availableFile.FileAttributes.FileName, mConfig.DestinationSite);
}
else
{
Log.Action("Copy", "File Transfer", RFDate.NullDate, "Copied file {0} from {1} to {2}", availableFile.FileAttributes.FileName, mConfig.SourceSite, mConfig.DestinationSite);
}
return(true);
}
protected void PutMirroredFile(string mirrorPath, RFFileAvailableEvent file, byte[] data)
{
var physicalPath = Path.Combine(RootDirectory, mirrorPath); // file name could have subdirectories
Directory.CreateDirectory(Path.GetDirectoryName(physicalPath));
// if file exists and is the same, ignore
if (File.Exists(physicalPath))
{
var existingFile = File.ReadAllBytes(physicalPath);
if (Enumerable.SequenceEqual(existingFile, data))
{
return;
}
// same name and modified date, but different content? perhaps bad transport - we will update so remove readonly flag
File.SetAttributes(physicalPath, File.GetAttributes(physicalPath) & ~FileAttributes.ReadOnly);
}
InternalPutFile(physicalPath, file, data);
File.SetAttributes(physicalPath, File.GetAttributes(physicalPath) | FileAttributes.ReadOnly);
InternalPutMirroredFile(file.SourceSite, file.FileAttributes.FileSize, file.FileAttributes.FileName, file.FileAttributes.FullPath, file.FileAttributes.ModifiedDate,
DateTime.Now, false, mirrorPath);
}
protected static bool HaveSeenFile(RFSeenFiles seenFiles, RFFileAvailableEvent e)
{
return(seenFiles.HaveSeenFile(e.FileKey, e.FileAttributes));
}
public abstract void PutFile(RFFileAvailableEvent file, RFMonitoredFile fileConfig, byte[] data);
public abstract byte[] GetFile(RFFileAvailableEvent availableFile);
public abstract void DeleteFile(RFFileAvailableEvent file);
public override byte[] GetFile(RFFileAvailableEvent availableFile)
{
return(File.ReadAllBytes(availableFile.FileAttributes.FullPath));
}
public override void DeleteFile(RFFileAvailableEvent file)
{
// not deleting from the catalog
return;
}
protected static void MarkSeenFile(RFSeenFiles seenFiles, RFFileAvailableEvent e)
{
seenFiles.MarkSeenFile(e.FileKey, e.FileAttributes);
}
public override void DeleteFile(RFFileAvailableEvent file)
{
_connection.DeleteFile(file.FileAttributes.FullPath);
}
