/// <summary>
/// Downloads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public byte[] DownloadFile(string fileName, ActionWorker worker)
{
byte[] result = null;
var requestUrl = Host + @"/";
if (!string.IsNullOrEmpty(InitialDir))
{
requestUrl += InitialDir + @"/";
}
requestUrl += fileName;
var request = (FtpWebRequest)WebRequest.Create(requestUrl);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var ms = new MemoryStream())
using (var response = (FtpWebResponse)request.GetResponse())
{
response.GetResponseStream().CopyTo(ms);
worker.ReportProgress(Color.Green, "Downloaded OK.");
ms.Close();
result = ms.ToArray();
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to download file. " + exception.Message);
}
return(result);
}
/// <summary>
/// Возращает все данный поставленных лайках и о скаченных файлах, для отрисовки на клиенте
/// </summary>
/// <returns></returns>
public async Task <ActionResult> Get()
{
ActionWorker worker = new ActionWorker(actionRepository, fileRepository, Request.UserHostAddress);
var action = await worker.GetActionCheckSheets(); //ToDo: await
return(Json(action, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Gets the directory file names.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
private string getDirectoryFileNames(Uri uri, ActionWorker worker)
{
var dirInfo = new DirectoryInfo(uri.LocalPath);
var result = string.Join("\n", dirInfo.GetFiles().Select(x => x.Name).ToArray());
return(result);
}
/// <summary>
/// Gets the file names.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="mask"></param>
/// <returns></returns>
public IEnumerable <string> GetFileNames(ActionWorker worker, string mask)
{
var result = new List <string>();
var request = (FtpWebRequest)WebRequest.Create(Host + @"/" + InitialDir);
request.Method = WebRequestMethods.Ftp.ListDirectory;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var response = (FtpWebResponse)request.GetResponse())
{
var sr = new StreamReader(response.GetResponseStream());
var listResult = sr.ReadToEnd();
result.AddRange(listResult.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to list FTP directory. " + exception.Message);
}
var fileNames = result.Where(x => Regex.IsMatch(x, mask)).ToList();
return(fileNames);
}
private bool deleteCmdProcessor(string cmdName, ActionWorker worker, Uri uri, object[] cmdArgs)
{
var fileName = cmdArgs[0].ToString();
using (var webClient = new WebClient())
{
webClient.Credentials = getCredentials();
if (uri.Scheme == Uri.UriSchemeFtp)
{
deleteFtpFile(uri, webClient.Credentials);
}
else if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
{
webClient.DownloadString(uri);
}
else if (uri.Scheme == Uri.UriSchemeFile)
{
var fullFileName = Path.Combine(uri.LocalPath, fileName);
if (File.Exists(fullFileName))
{
File.Delete(fullFileName);
}
}
}
return(true);
}
/// <summary>
/// Downloads XafDelta messages into replication storage database.
/// </summary>
/// <param name="xafDeltaModule">The xaf delta module.</param>
/// <param name="objectSpace">The object space.</param>
/// <param name="worker">The worker.</param>
public void Download(XafDeltaModule xafDeltaModule, IObjectSpace objectSpace, ActionWorker worker)
{
worker.ReportProgress(Localizer.DownloadStarted);
var transportList = (from m in xafDeltaModule.ModuleManager.Modules
where m is IXafDeltaTransport && ((IXafDeltaTransport) m).UseForDownload
select m).Cast<IXafDeltaTransport>().ToList();
worker.ReportProgress(string.Format(Localizer.TransportFound, transportList.Count()));
foreach (var transport in transportList.TakeWhile(x => !worker.CancellationPending))
{
worker.ReportProgress(string.Format(Localizer.DownloadUsing, transport));
try
{
worker.ReportProgress(string.Format(Localizer.OpenTransport, transport));
transport.Open(TransportMode.Download, worker);
var existingReplicaNames = from c in objectSpace.GetObjects<Package>() select c.FileName;
var fileNames = transport.GetFileNames(worker,
@"(" + Ticket.FileMask + "|" + Package.FileMask + ")").ToList();
fileNames = fileNames.Except(existingReplicaNames).ToList();
worker.ReportProgress(string.Format(Localizer.FilesForDownload, fileNames.Count));
foreach (var fileName in fileNames.TakeWhile(x => !worker.CancellationPending))
{
// worker.ReportProgress(string.Format(Localizer.DownloadFile, fileName));
var fileData = transport.DownloadFile(fileName, worker);
if(fileData != null && fileData.Length > 0)
{
if (fileName.EndsWith(Package.PackageFileExtension))
{
var replica = Package.ImportFromBytes(objectSpace, fileName, fileData);
replica.Save();
}
else
{
var replicaTicket = Ticket.ImportTicket(objectSpace, fileData);
replicaTicket.Save();
}
if (!fileName.Contains(ReplicationNode.AllNodes))
transport.DeleteFile(fileName, worker);
objectSpace.CommitChanges();
}
}
}
catch (Exception exception)
{
objectSpace.Rollback();
worker.ReportError(Localizer.DownloadError, exception.Message);
}
finally
{
worker.ReportProgress(Localizer.CloseTransport, transport);
transport.Close();
}
}
worker.ReportProgress(Color.Blue, Localizer.DownloadFinished);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadPackageContext"/> class.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="worker">The worker.</param>
/// <param name="objectSpace">The object space.</param>
/// <param name="currentNodeId">The current node id.</param>
public LoadPackageContext(Package package, ActionWorker worker,
IObjectSpace objectSpace, string currentNodeId)
{
CurrentNodeId = currentNodeId;
Package = package;
Worker = worker;
ObjectSpace = objectSpace;
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadPackageContext"/> class.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="worker">The worker.</param>
/// <param name="objectSpace">The object space.</param>
/// <param name="currentNodeId">The current node id.</param>
public LoadPackageContext(Package package, ActionWorker worker,
IObjectSpace objectSpace, string currentNodeId)
{
CurrentNodeId = currentNodeId;
Package = package;
Worker = worker;
ObjectSpace = objectSpace;
}
private byte[] downloadCmdProcessor(string cmdName, ActionWorker worker, Uri uri, object[] cmdArgs)
{
byte[] result;
using (var webClient = new WebClient())
{
webClient.Credentials = getCredentials();
result = webClient.DownloadData(uri);
}
return(result);
}
public void DeleteFile(string fileName, ActionWorker worker)
{
if (client != null)
{
client.DeleteFile(fileName);
}
else
{
worker.ReportError(Localizer.ClientIsNotOpened);
}
}
public BuildContext(IObjectSpace appObjectSpace, ObjectSpace snapObjectSpace, ReplicationNode targetNode,
ActionWorker worker)
{
AppObjectSpace = appObjectSpace;
SnapObjectSpace = snapObjectSpace;
TargetNode = targetNode;
Worker = worker;
DoneObjects = new Queue <object>();
Map = new Dictionary <object, object>();
SnapSources = new Dictionary <IModelClass, IList <object> >();
}
private Uri uploadUriProcessor(string cmdName, ActionWorker worker, string baseUri, object[] cmdArgs)
{
var fileName = cmdArgs[0].ToString();
var uri = new Uri(UploadUrl);
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
{
uri = new Uri(UploadUrl + @"/" + fileName);
}
return(uri);
}
/// <summary>
/// Loads pending packages.
/// </summary>
/// <param name="worker">The worker.</param>
public bool Load(ActionWorker worker)
{
if (IsLoading)
{
return(false);
}
bool loadResult;
Owner.DoBeforeLoad(new LoadEventArgs(worker));
worker.ReportProgress(Localizer.LoadingStarted);
Interlocked.Increment(ref loadNesting);
try
{
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
var currentNodeId = ReplicationNode.GetCurrentNodeId(applicationObjectSpace);
// select pending input packages
var inputPackages =
applicationObjectSpace.GetObjects <Package>(CriteriaOperator.Parse(
"ApplicationName = ? And (RecipientNodeId = ? Or RecipientNodeId = ?) " +
"And (SenderNodeId <> ?)",
Owner.ApplicationName, currentNodeId, ReplicationNode.AllNodes,
Owner.CurrentNodeId)).
Where(x => x.LoadedDateTime == DateTime.MinValue).ToList();
worker.ReportProgress(string.Format(Localizer.PackagesSelectedForLoading, inputPackages.Count));
// load each package until cancellation or error occured
loadResult = true;
foreach (var inputPackage in inputPackages.OrderBy(x => x.PackageDateTime).TakeWhile(z => !worker.CancellationPending))
{
// loadResult &= LoadPackage(new LoadPackageContext(inputReplica,worker, applicationObjectSpace, currentNodeId));
loadResult &= LoadPackage(worker, inputPackage);
if (!loadResult)
{
break;
}
}
applicationObjectSpace.CommitChanges();
}
}
finally
{
Interlocked.Decrement(ref loadNesting);
worker.ReportProgress(Color.Blue, Localizer.LoadingIsFinished);
}
Owner.DoAfterLoad(new LoadEventArgs(worker));
return(loadResult);
}
public BuildContext(IObjectSpace objectSpace, Dictionary <object, object> doneObjects,
IObjectSpace packageObjectSpace, ReplicationNode targetNode,
ActionWorker worker, Queue <object> mapQueue, HashSet <string> selectedSourceObjects,
List <IModelClass> selectedTypes)
{
ObjectSpace = objectSpace;
DoneObjects = doneObjects;
PackageObjectSpace = packageObjectSpace;
TargetNode = targetNode;
Worker = worker;
MapQueue = mapQueue;
SelectedSourceObjects = selectedSourceObjects;
SelectedTypes = selectedTypes;
}
/// <summary>
/// Executes the specified action worker asynchronously.
/// </summary>
/// <param name="actionName">Name of the action.</param>
/// <param name="eventHandler">The event handler.</param>
/// <param name="actionWorker">The action worker.</param>
/// <param name="completeHandler">The complete handler.</param>
public void ExecuteAction(string actionName, DoWorkEventHandler eventHandler,
ActionWorker actionWorker, RunWorkerCompletedEventHandler completeHandler)
{
BackgroundWorker worker;
if(!workers.TryGetValue(actionName, out worker))
{
worker = new BackgroundWorker {WorkerReportsProgress = true, WorkerSupportsCancellation = true};
worker.ProgressChanged += progressChanged;
worker.DoWork += eventHandler;
worker.RunWorkerCompleted += completeHandler;
workers.Add(actionName, worker);
}
actionWorker.Worker = worker;
worker.RunWorkerAsync(actionWorker);
}
private Uri deleteUriProcessor(string cmdName, ActionWorker worker, string baseUri, object[] cmdArgs)
{
var uri = new Uri(baseUri);
var fileName = cmdArgs[0].ToString();
if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
{
uri = new Uri(baseUri + @"?DeleteFile=" + fileName);
}
else
{
uri = new Uri(baseUri + @"/" + fileName);
}
return(uri);
}
/// <summary>
/// Opens the specified transport in selected mode.
/// </summary>
/// <param name="transportMode">The transport mode.</param>
/// <param name="worker">The worker.</param>
public void Open(TransportMode transportMode, ActionWorker worker)
{
Close();
client = new TransportServiceClient();
if (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
{
if (client.ClientCredentials != null)
{
client.ClientCredentials.UserName.UserName = UserName;
client.ClientCredentials.UserName.Password = Password;
}
}
OnBeforeOpen(new BeforeOpenArgs(client));
client.Open();
worker.ReportProgress(Localizer.ClientOpened);
}
/// <summary>
/// Starts the server.
/// </summary>
/// <param name="srcDeviceId">The source device identifier.</param>
/// <param name="communicationService">The communication service.</param>
private void StartServer(string srcDeviceId, IServer <Command, FetchRequest, GrpcResponse> communicationService)
{
// Grpc server
CommunicationServer server = new CommunicationServer(communicationService, srcDeviceId);
// Grpc server actions
server.OnAction = async(cmd, streamId, token, header) => { return(await ActionWorker.ProcessCommand(srcDeviceId, cmd, streamId, token, header)); };
server.OnStreaming = async(cmd, stream, token, header) => { return(await ActionWorker.ProcessCommand(srcDeviceId, cmd, stream.Id, token, header)); };
server.OnStreamOpened = async(stream, token, header) => { return(await ActionWorker.StreamConnected(stream, token, header)); };
server.OnClientDisconnected = async(id) => { await ActionWorker.StreamDisconnected(id); };
server.OnLog += (sender, srcid, msg, level) =>
{
CommonBaseHandler.Log(sender.ToString(), msg, level);
};
server.Start();
}
/// <summary>
/// Executes the specified action worker asynchronously.
/// </summary>
/// <param name="actionName">Name of the action.</param>
/// <param name="eventHandler">The event handler.</param>
/// <param name="actionWorker">The action worker.</param>
/// <param name="completeHandler">The complete handler.</param>
public void ExecuteAction(string actionName, DoWorkEventHandler eventHandler,
ActionWorker actionWorker, RunWorkerCompletedEventHandler completeHandler)
{
BackgroundWorker worker;
if (!workers.TryGetValue(actionName, out worker))
{
worker = new BackgroundWorker {
WorkerReportsProgress = true, WorkerSupportsCancellation = true
};
worker.ProgressChanged += progressChanged;
worker.DoWork += eventHandler;
worker.RunWorkerCompleted += completeHandler;
workers.Add(actionName, worker);
}
actionWorker.Worker = worker;
worker.RunWorkerAsync(actionWorker);
}
/// <summary>
/// Opens the specified transport in selected mode.
/// </summary>
/// <param name="transportMode">The transport mode.</param>
/// <param name="worker">The worker.</param>
public void Open(TransportMode transportMode, ActionWorker worker)
{
var request = (FtpWebRequest)WebRequest.Create(Host + @"/" + InitialDir);
request.Method = WebRequestMethods.Ftp.PrintWorkingDirectory;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var response = (FtpWebResponse)request.GetResponse())
{
var sr = new StreamReader(response.GetResponseStream());
var currentDir = sr.ReadToEnd();
worker.ReportProgress("FTP connection is opened. Current FTP directory is '" + currentDir + "'");
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to open FTP connection. " + exception.Message);
}
}
/// <summary>
/// Executes the command.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdName">Name of the CMD.</param>
/// <param name="workStr">The work STR.</param>
/// <param name="finishStr">The finish STR.</param>
/// <param name="worker">The worker.</param>
/// <param name="baseUri">The base URI.</param>
/// <param name="uriProcessor">The URI processor.</param>
/// <param name="cmdProcessor">The CMD processor.</param>
/// <param name="postProcessor">The post processor.</param>
/// <param name="cmdArgs">The CMD args.</param>
/// <returns></returns>
private T executeCommand <T>(string cmdName, string workStr, string finishStr,
ActionWorker worker, string baseUri,
Func <string, ActionWorker, string, object[], Uri> uriProcessor,
Func <string, ActionWorker, Uri, object[], T> cmdProcessor,
Func <string, ActionWorker, object, T> postProcessor,
params object[] cmdArgs)
{
var uri = uriProcessor(cmdName, worker, baseUri, cmdArgs);
var args = new GetUriArgs(cmdName, uri, cmdArgs);
OnCustomUri(args);
uri = args.ResultUri;
T result = default(T);
if (uriIsValid(uri))
{
OnBeforeCommand(new CommandArgs(cmdName, uri, cmdArgs));
worker.ReportProgress(workStr, cmdArgs);
try
{
result = cmdProcessor(cmdName, worker, uri, cmdArgs);
}
catch (Exception exception)
{
worker.ReportError(Localization.Localizer.CommandError, cmdName, exception.Message);
}
OnAfterCommand(new CommandArgs(cmdName, uri, cmdArgs));
if (postProcessor != null)
{
result = postProcessor(cmdName, worker, result);
}
worker.ReportProgress(finishStr, cmdArgs);
}
else
{
worker.ReportError(Localization.Localizer.InvalidUri, uri.ToString());
}
return(result);
}
/// <summary>
/// Gets the file names.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="mask"></param>
/// <returns></returns>
public IEnumerable <string> GetFileNames(ActionWorker worker, string mask)
{
IEnumerable <string> result = null;
if (client != null)
{
try
{
result = client.GetFileNames(mask);
worker.ReportProgress(Localizer.FileListingOk);
}
catch (Exception exception)
{
worker.ReportError(Localizer.FileListingError, exception.Message);
}
}
else
{
worker.ReportError(Localizer.ClientIsNotOpened);
}
return(result);
}
public void StartMemoryWorkers()
{
this.StopMemoryWorkers();
this.ActionWorker = new ActionWorker(this._memoryHandler);
this.ActorWorker = new ActorWorker(this._memoryHandler);
this.ChatLogWorker = new ChatLogWorker(this._memoryHandler);
this.CurrentPlayerWorker = new CurrentPlayerWorker(this._memoryHandler);
this.InventoryWorker = new InventoryWorker(this._memoryHandler);
this.JobResourceWorker = new JobResourceWorker(this._memoryHandler);
this.PartyWorker = new PartyWorker(this._memoryHandler);
this.TargetWorker = new TargetWorker(this._memoryHandler);
this.ActionWorker.StartScanning();
this.ActorWorker.StartScanning();
this.ChatLogWorker.StartScanning();
this.CurrentPlayerWorker.StartScanning();
this.InventoryWorker.StartScanning();
this.JobResourceWorker.StartScanning();
this.PartyWorker.StartScanning();
this.TargetWorker.StartScanning();
}
private IEnumerable <string> listingCmdProcessor(string cmdName, ActionWorker worker, Uri uri, object[] cmdArgs)
{
string responceString;
var credentials = getCredentials();
if (uri.Scheme == Uri.UriSchemeFtp)
{
responceString = getFtpFileNames(uri, credentials);
}
else if (uri.Scheme == Uri.UriSchemeFile)
{
responceString = getDirectoryFileNames(uri, worker);
}
else
{
responceString = getWebFileNames(uri, credentials);
}
var mask = cmdArgs[0].ToString();
var names = Regex.Matches(responceString, mask).Cast <Match>().Select(x => x.Value).Distinct();
return(names);
}
private bool uploadCmdProcessor(string cmdName, ActionWorker worker, Uri uri, object[] cmdArgs)
{
var fileName = cmdArgs[0].ToString();
var fileData = (byte[])cmdArgs[1];
using (var webClient = new WebClient())
{
if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
{
webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
}
webClient.Credentials = getCredentials();
if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
{
var tempFileName = Path.Combine(Path.GetTempPath(), fileName);
File.WriteAllBytes(tempFileName, fileData);
try
{
webClient.UploadFile(uri, tempFileName);
}
finally
{
if (File.Exists(tempFileName))
{
File.Delete(tempFileName);
}
}
}
else
{
webClient.UploadData(uri, fileData);
}
}
return(true);
}
/// <summary>
/// Loads the package.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="package">The package.</param>
public bool LoadPackage(ActionWorker worker, Package package)
{
bool result;
Interlocked.Increment(ref loadNesting);
try
{
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
var currentNodeId = ReplicationNode.GetCurrentNodeId(applicationObjectSpace);
result = LoadPackage(new LoadPackageContext(package, worker,
applicationObjectSpace, currentNodeId));
applicationObjectSpace.CommitChanges();
}
var packageObjectSpace = ObjectSpace.FindObjectSpaceByObject(package);
packageObjectSpace.CommitChanges();
}
finally
{
Interlocked.Decrement(ref loadNesting);
}
return(result);
}
/// <summary>
/// Downloads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public byte[] DownloadFile(string fileName, ActionWorker worker)
{
byte[] result = null;
if (client != null)
{
try
{
OnBeforeDownload(new WcfClientArgs(client, fileName));
result = client.DownloadFile(fileName);
OnAfterDownload(new WcfClientArgs(client, fileName));
worker.ReportProgress(Localizer.DownloadOk);
}
catch (Exception exception)
{
worker.ReportError(Localizer.DownloadError, fileName, exception.Message);
}
}
else
{
worker.ReportError(Localizer.ClientIsNotOpened);
}
return(result);
}
protected virtual void OnMessageReceived(IQueueItem message)
{
if (message != null)
{
//if (_Action != null)
// Task.Factory.StartNew(() => _Action(item));
//else
// Task.Factory.StartNew(() => DoMessageReceived(item));
if (EnableDynamicWait)
{
ActionWorker.DynamicWaitAck(true);
}
}
else
{
if (EnableDynamicWait)
{
ActionWorker.DynamicWaitAck(false);
}
}
OnMessageReceived(new GenericEventArgs <IQueueItem>(message));
}
/// <summary>
/// Create and save packages for pending records.
/// </summary>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public bool BuildPackages(ActionWorker worker)
{
bool result;
worker.ReportProgress(Localizer.BuildingPackages);
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
Owner.DoBeforeBuildPackages(new BeforeBuildPackagesArgs(applicationObjectSpace));
try
{
var unsavedSessions =
applicationObjectSpace.GetObjects<ProtocolSession>(CriteriaOperator.Parse("Not SessionIsSaved"));
// select session (don't replicate external sessions for broadcasts)
var sessionsToSave = (from c in unsavedSessions where !(c is ExternalProtocolSession)
|| (Owner.ReplicateExternalData
&& Owner.RoutingType != RoutingType.BroadcastRouting)
orderby c.CommitedOn select c).ToList();
var rootContext = new SaveProtocolParams(worker, applicationObjectSpace,
new Dictionary<ReplicationNode, PackageSaveInfo>(),
applicationObjectSpace.GetObjects<ReplicationNode>(),
ReplicationNode.GetCurrentNode(applicationObjectSpace));
prepareDataForSave(rootContext, sessionsToSave);
createPackages(rootContext);
// close created packages
rootContext.CreatedPackages.Values.ToList().ForEach(x => x.Package.CloseUnitOfWork(true));
result = !worker.CancellationPending;
if(result)
Owner.DoAfterBuildPackages(new AfterBuildPackagesArgs(from c in
rootContext.CreatedPackages.Values select c.Package));
}
catch (Exception exception)
{
worker.ReportError(
Localizer.PackageSaveFailed, exception.Message);
result = false;
}
// on success, commit changes to app database and package storage
if (result)
applicationObjectSpace.CommitChanges();
}
if (result)
worker.ReportProgress(Color.Blue, Localizer.PackageSavingIs,
(worker.CancellationPending ? Localizer.Aborted : Localizer.Finished));
return result;
}
/// <summary>
/// Executes the specified action.
/// </summary>
/// <param name="actionName">Name of the action.</param>
/// <param name="eventHandler">The event handler.</param>
/// <param name="actionWorker">The action worker.</param>
/// <param name="completeHandler">The complete handler.</param>
public void ExecuteAction(string actionName, DoWorkEventHandler eventHandler, ActionWorker actionWorker, RunWorkerCompletedEventHandler completeHandler)
{
eventHandler(null, new DoWorkEventArgs(actionWorker));
completeHandler(null, new RunWorkerCompletedEventArgs(null, null, false));
}
/// <summary>
/// Opens the specified transport in selected mode.
/// </summary>
/// <param name="transportMode">The transport mode.</param>
/// <param name="worker">The worker.</param>
public void Open(TransportMode transportMode, ActionWorker worker)
{
var request = (FtpWebRequest)WebRequest.Create(Host + @"/" + InitialDir );
request.Method = WebRequestMethods.Ftp.PrintWorkingDirectory;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var response = (FtpWebResponse)request.GetResponse())
{
var sr = new StreamReader(response.GetResponseStream());
var currentDir = sr.ReadToEnd();
worker.ReportProgress("FTP connection is opened. Current FTP directory is '" + currentDir + "'");
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to open FTP connection. " + exception.Message);
}
}
/// <summary>
/// Uploads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileData">The file data.</param>
/// <param name="recipientAddress">The recipient address.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public bool UploadFile(string fileName, byte[] fileData, string recipientAddress, ActionWorker worker)
{
var result = false;
var requestUrl = Host + @"/";
if (!string.IsNullOrEmpty(InitialDir))
requestUrl += InitialDir + @"/";
requestUrl += fileName;
var request = (FtpWebRequest)WebRequest.Create(requestUrl);
request.Method = WebRequestMethods.Ftp.UploadFile;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var ms = new MemoryStream(fileData))
using (var reqStream = request.GetRequestStream())
{
ms.CopyTo(reqStream);
}
var responce = (FtpWebResponse) request.GetResponse();
result = responce.StatusCode == FtpStatusCode.CommandOK || responce.StatusCode == FtpStatusCode.ClosingData;
if(result)
worker.ReportProgress(Color.Green, "Uploaded OK");
else
worker.ReportProgress(Color.Red, "Uploading failed with status '" + responce.StatusDescription + "'");
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Uploading error: " + exception.Message);
}
return result;
}
/// <summary>
/// Builds the snapshot.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="targetNode">The target node.</param>
/// <returns></returns>
public bool BuildSnapshot(ActionWorker worker, ReplicationNode targetNode)
{
if (targetNode == null)
{
throw new ArgumentNullException("targetNode");
}
if (targetNode.Session.IsNewObject(targetNode))
{
throw new UnsavedTargetNodeException();
}
if (targetNode.Disabled)
{
throw new DisabledTargetNodeException();
}
var result = false;
worker.ReportProgress(string.Format(Localizer.BuildingSnapshotForNode, targetNode.Name));
XafDeltaModule.Instance.LoadService.BeginLoad();
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
targetNode = applicationObjectSpace.GetObjectByKey <ReplicationNode>(targetNode.Oid);
Owner.DoBeforeBuildPackages(new BeforeBuildPackagesArgs(applicationObjectSpace));
var package = Owner.MessagingService.CreateOutputPackage(applicationObjectSpace, targetNode,
PackageType.Snapshot);
try
{
var doneObjects = new Dictionary <object, object>();
using (var snapshotObjectSpace = new ObjectSpace(package.UnitOfWork))
{
var mapStack = new Queue <object>();
var rootContext = new BuildContext(applicationObjectSpace, doneObjects,
snapshotObjectSpace, targetNode, worker, mapStack,
new HashSet <string>(), new List <IModelClass>());
foreach (var modelClass in XafDeltaModule.XafApp.Model.BOModel.Where(x => !x.NonSnapshot())
.TakeWhile(x => !worker.CancellationPending))
{
if (!modelClass.TypeInfo.IsAbstract && modelClass.TypeInfo.IsPersistent &&
(modelClass.TypeInfo.IsInterface || modelClass.TypeInfo.Implements <IXPObject>()))
{
buildClassSnapshot(new ClassBuildContext(rootContext, modelClass));
}
}
if (doneObjects.Keys.Count > 0)
{
snapshotObjectSpace.CommitChanges();
snapshotPostBuild(snapshotObjectSpace);
snapshotObjectSpace.CommitChanges();
createSnapshotMaps(rootContext);
snapshotObjectSpace.CommitChanges();
worker.ReportProgress(string.Format(Localizer.TotalObjectsSnapshoted,
doneObjects.Keys.Count));
result = true;
}
else
{
snapshotObjectSpace.Rollback();
worker.ReportProgress(Color.DarkMagenta, Localizer.NoObjectsFoundForSnapshot);
}
}
package.CloseUnitOfWork(doneObjects.Keys.Count > 0);
result &= !worker.CancellationPending;
if (result)
{
Owner.OnAfterBuildSnapshot(new AfterBuildSnapshotArgs(targetNode));
}
}
catch (Exception exception)
{
worker.ReportError(Localizer.SnapshotFailed, exception.Message);
result = false;
}
// on success, commit changes to app database and package storage
if (result)
{
package.CreateLogRecord(PackageEventType.Created);
applicationObjectSpace.CommitChanges();
}
}
XafDeltaModule.Instance.LoadService.EndLoad();
if (result)
{
worker.ReportProgress(Color.Blue, Localizer.SnapshotBuildingIs,
(worker.CancellationPending ? Localizer.Aborted : Localizer.Finished));
}
return(result);
}
/// <summary>
/// Opens the specified transport in selected mode.
/// </summary>
/// <param name="transportMode">The transport mode.</param>
/// <param name="worker">The worker.</param>
public void Open(TransportMode transportMode, ActionWorker worker)
{
}
/// <summary>
/// Gets the file names.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="mask"></param>
/// <returns></returns>
public IEnumerable<string> GetFileNames(ActionWorker worker, string mask)
{
var result = new List<string>();
var request = (FtpWebRequest)WebRequest.Create(Host + @"/" + InitialDir);
request.Method = WebRequestMethods.Ftp.ListDirectory;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var response = (FtpWebResponse)request.GetResponse())
{
var sr = new StreamReader(response.GetResponseStream());
var listResult = sr.ReadToEnd();
result.AddRange(listResult.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to list FTP directory. " + exception.Message);
}
var fileNames = result.Where(x => Regex.IsMatch(x, mask)).ToList();
return fileNames;
}
public BuildContext(IObjectSpace objectSpace, Dictionary<object, object> doneObjects,
IObjectSpace packageObjectSpace, ReplicationNode targetNode,
ActionWorker worker, Queue<object> mapQueue, HashSet<string> selectedSourceObjects,
List<IModelClass> selectedTypes)
{
ObjectSpace = objectSpace;
DoneObjects = doneObjects;
PackageObjectSpace = packageObjectSpace;
TargetNode = targetNode;
Worker = worker;
MapQueue = mapQueue;
SelectedSourceObjects = selectedSourceObjects;
SelectedTypes = selectedTypes;
}
public bool BuildSnapshot(ActionWorker worker, ReplicationNode targetNode)
{
if (targetNode == null) throw new ArgumentNullException("targetNode");
if (targetNode.Session.IsNewObject(targetNode)) throw new UnsavedTargetNodeException();
if (targetNode.Disabled) throw new DisabledTargetNodeException();
var result = false;
worker.ReportProgress(string.Format(Localizer.BuildingSnapshotForNode, targetNode.Name));
XafDeltaModule.Instance.LoadService.BeginLoad();
using (var appObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
targetNode = appObjectSpace.GetObjectByKey<ReplicationNode>(targetNode.Oid);
Owner.DoBeforeBuildPackages(new BeforeBuildPackagesArgs(appObjectSpace));
var package = Owner.MessagingService.CreateOutputPackage(appObjectSpace, targetNode,
PackageType.Snapshot);
try
{
var doneObjectsCount = 0;
using (var snapObjectSpace = new ObjectSpace(package.UnitOfWork))
{
var rootContext = new BuildContext(appObjectSpace, snapObjectSpace, targetNode, worker);
foreach (var modelClass in XafDeltaModule.XafApp.Model.BOModel.Where(x => !x.NonSnapshot())
.TakeWhile(x => !worker.CancellationPending))
{
if (!modelClass.TypeInfo.IsAbstract && modelClass.TypeInfo.IsPersistent
&& (modelClass.TypeInfo.IsInterface || modelClass.TypeInfo.Implements<IXPObject>()))
doneObjectsCount += buildClassSnapshot(new ClassBuildContext(rootContext, modelClass));
}
if (doneObjectsCount > 0 && !worker.CancellationPending)
{
worker.ReportProgress(Localizer.CommitChanges);
snapObjectSpace.CommitChanges();
//snapshotPostBuild(snapObjectSpace);
snapObjectSpace.CommitChanges();
createSnapshotMaps(rootContext);
worker.ReportProgress(Localizer.CommitChanges);
snapObjectSpace.CommitChanges();
worker.ReportProgress(string.Format(Localizer.TotalObjectsSnapshoted,
doneObjectsCount));
result = true;
}
else
{
snapObjectSpace.Rollback();
if (worker.CancellationPending)
worker.ReportProgress(Color.DarkMagenta, Localizer.Aborted);
else
worker.ReportProgress(Color.DarkMagenta, Localizer.NoObjectsFoundForSnapshot);
}
}
package.CloseUnitOfWork(doneObjectsCount > 0 && !worker.CancellationPending);
result &= !worker.CancellationPending;
if (result)
Owner.OnAfterBuildSnapshot(new AfterBuildSnapshotArgs(targetNode));
}
catch (Exception exception)
{
worker.ReportError(Localizer.SnapshotFailed, exception.Message);
result = false;
}
// on success, commit changes to app database and package storage
if (result)
{
package.CreateLogRecord(PackageEventType.Created);
appObjectSpace.CommitChanges();
}
}
XafDeltaModule.Instance.LoadService.EndLoad();
if (result)
{
worker.ReportProgress(Color.Blue, Localizer.SnapshotBuildingIs,
(worker.CancellationPending ? Localizer.Aborted : Localizer.Finished));
}
return result;
}
/// <summary>
/// Uploads pending XafDelta messages to intermidiate net storages.
/// </summary>
/// <param name="xafDeltaModule">The xaf delta module.</param>
/// <param name="objectSpace">The object space.</param>
/// <param name="worker">The worker.</param>
public void Upload(XafDeltaModule xafDeltaModule, IObjectSpace objectSpace, ActionWorker worker)
{
worker.ReportProgress(Localizer.UploadStarted);
var transportList = (from m in XafDeltaModule.XafApp.Modules
where m is IXafDeltaTransport && ((IXafDeltaTransport)m).UseForUpload
select m).Cast<IXafDeltaTransport>().ToList().AsReadOnly();
if (transportList.Count > 0)
{
var replicas = (from r in objectSpace.GetObjects<Package>() where r.IsOutput
&& r.GetEventDateTime(PackageEventType.Sent) == DateTime.MinValue
orderby r.PackageDateTime
select r).ToList();
var tickets = (from t in objectSpace.GetObjects<Ticket>(CriteriaOperator.Parse("IsNull(ProcessingDateTime)"), true)
where t.Package != null && t.Package.IsInput
orderby t.TicketDateTime select t).ToList();
var messages = replicas.Cast<IReplicationMessage>().Union(tickets.Cast<IReplicationMessage>()).ToList();
var uploadData = new Dictionary<IXafDeltaTransport, List<IReplicationMessage>>();
worker.ReportProgress(string.Format(Localizer.FoundForUpload, messages.Count()));
foreach (var message in messages.TakeWhile(x => !worker.CancellationPending))
{
var args = new SelectUploadTransportArgs(message, transportList[0]);
Owner.OnSelectUploadTransport(args);
if(args.Transport != null)
{
List<IReplicationMessage> list;
if(!uploadData.TryGetValue(args.Transport, out list))
{
list = new List<IReplicationMessage>();
uploadData.Add(args.Transport, list);
}
list.Add(message);
}
}
if(!worker.CancellationPending && uploadData.Keys.Count > 0)
{
foreach (var transport in uploadData.Keys.TakeWhile(x => !worker.CancellationPending))
{
try
{
worker.ReportProgress(string.Format(Localizer.OpenTransport, transport));
transport.Open(TransportMode.Upload, worker);
var messageList = uploadData[transport];
foreach (var message in messageList)
{
var recipientAddress = message.RecipientAddress;
// worker.ReportProgress(string.Format(Localizer.UploadingFile, message));
transport.UploadFile(message.ToString(), message.GetData(), recipientAddress, worker);
if (message is Package)
((Package)message).CreateLogRecord(PackageEventType.Sent);
else
((Ticket) message).ProcessingDateTime = DateTime.Now;
objectSpace.CommitChanges();
}
}
catch (Exception exception)
{
objectSpace.Rollback();
worker.ReportError(Localizer.UploadError, exception.Message);
}
finally
{
worker.ReportProgress(string.Format(Localizer.CloseTransport, transport));
transport.Close();
}
}
}
}
else
worker.ReportProgress(Color.BlueViolet, Localizer.UploadTransportNotFound);
worker.ReportProgress(Color.Blue, Localizer.UploadFinished);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadEventArgs"/> class.
/// </summary>
/// <param name="worker">The worker.</param>
public LoadEventArgs(ActionWorker worker)
{
Worker = worker;
}
/// <summary>
/// Loads the package.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="package">The package.</param>
public bool LoadPackage(ActionWorker worker, Package package)
{
bool result;
Interlocked.Increment(ref loadNesting);
try
{
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
var currentNodeId = ReplicationNode.GetCurrentNodeId(applicationObjectSpace);
result = LoadPackage(new LoadPackageContext(package, worker,
applicationObjectSpace, currentNodeId));
applicationObjectSpace.CommitChanges();
}
var packageObjectSpace = ObjectSpace.FindObjectSpaceByObject(package);
packageObjectSpace.CommitChanges();
}
finally
{
Interlocked.Decrement(ref loadNesting);
}
return result;
}
/// <summary>
/// Loads pending packages.
/// </summary>
/// <param name="worker">The worker.</param>
public bool Load(ActionWorker worker)
{
if (IsLoading) return false;
bool loadResult;
Owner.DoBeforeLoad(new LoadEventArgs(worker));
worker.ReportProgress(Localizer.LoadingStarted);
Interlocked.Increment(ref loadNesting);
try
{
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
var currentNodeId = ReplicationNode.GetCurrentNodeId(applicationObjectSpace);
// select pending input packages
var inputPackages =
applicationObjectSpace.GetObjects<Package>(CriteriaOperator.Parse(
"ApplicationName = ? And (RecipientNodeId = ? Or RecipientNodeId = ?) " +
"And (SenderNodeId <> ?)",
Owner.ApplicationName, currentNodeId, ReplicationNode.AllNodes,
Owner.CurrentNodeId)).
Where(x => x.LoadedDateTime == DateTime.MinValue).ToList();
worker.ReportProgress(string.Format(Localizer.PackagesSelectedForLoading, inputPackages.Count));
// load each package until cancellation or error occured
loadResult = true;
foreach (var inputPackage in inputPackages.OrderBy(x => x.PackageDateTime).TakeWhile(z => !worker.CancellationPending))
{
// loadResult &= LoadPackage(new LoadPackageContext(inputReplica,worker, applicationObjectSpace, currentNodeId));
loadResult &= LoadPackage(worker, inputPackage);
if(!loadResult) break;
}
applicationObjectSpace.CommitChanges();
}
}
finally
{
Interlocked.Decrement(ref loadNesting);
worker.ReportProgress(Color.Blue, Localizer.LoadingIsFinished);
}
Owner.DoAfterLoad(new LoadEventArgs(worker));
return loadResult;
}
public BuildContext(IObjectSpace appObjectSpace, ObjectSpace snapObjectSpace, ReplicationNode targetNode,
ActionWorker worker)
{
AppObjectSpace = appObjectSpace;
SnapObjectSpace = snapObjectSpace;
TargetNode = targetNode;
Worker = worker;
DoneObjects = new Queue<object>();
Map = new Dictionary<object, object>();
SnapSources = new Dictionary<IModelClass, IList<object>>();
}
/// <summary>
/// Downloads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public byte[] DownloadFile(string fileName, ActionWorker worker)
{
byte[] result = null;
var requestUrl = Host + @"/";
if (!string.IsNullOrEmpty(InitialDir))
requestUrl += InitialDir + @"/";
requestUrl += fileName;
var request = (FtpWebRequest)WebRequest.Create(requestUrl);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.Credentials = new NetworkCredential(UserName, Password);
try
{
using (var ms = new MemoryStream())
using (var response = (FtpWebResponse)request.GetResponse())
{
response.GetResponseStream().CopyTo(ms);
worker.ReportProgress(Color.Green, "Downloaded OK.");
ms.Close();
result = ms.ToArray();
}
}
catch (Exception exception)
{
worker.ReportProgress(Color.Red, "Error: failed to download file. " + exception.Message);
}
return result;
}
public void DeleteFile(string fileName, ActionWorker worker)
{
if (client != null)
client.DeleteFile(fileName);
else
worker.ReportError(Localizer.ClientIsNotOpened);
}
/// <summary>
/// Downloads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public byte[] DownloadFile(string fileName, ActionWorker worker)
{
byte[] result = null;
if (client != null)
{
try
{
OnBeforeDownload(new WcfClientArgs(client, fileName));
result = client.DownloadFile(fileName);
OnAfterDownload(new WcfClientArgs(client, fileName));
worker.ReportProgress(Localizer.DownloadOk);
}
catch (Exception exception)
{
worker.ReportError(Localizer.DownloadError, fileName, exception.Message);
}
}
else
worker.ReportError(Localizer.ClientIsNotOpened);
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadEventArgs"/> class.
/// </summary>
/// <param name="worker">The worker.</param>
public LoadEventArgs(ActionWorker worker)
{
Worker = worker;
}
/// <summary>
/// Gets the file names.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="mask"></param>
/// <returns></returns>
public IEnumerable<string> GetFileNames(ActionWorker worker, string mask)
{
IEnumerable<string> result = null;
if(client != null)
{
try
{
result = client.GetFileNames(mask);
worker.ReportProgress(Localizer.FileListingOk);
}
catch (Exception exception)
{
worker.ReportError(Localizer.FileListingError, exception.Message);
}
}
else
worker.ReportError(Localizer.ClientIsNotOpened);
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="SaveProtocolParams"/> class.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="applicationObjectSpace">The modelApplication object space.</param>
/// <param name="createdPackagesDict">The created packages dict.</param>
/// <param name="allNodes">All nodes.</param>
/// <param name="currentNode">The current node.</param>
public SaveProtocolParams(ActionWorker worker, IObjectSpace applicationObjectSpace,
Dictionary<ReplicationNode, PackageSaveInfo> createdPackagesDict,
IEnumerable<ReplicationNode> allNodes,
ReplicationNode currentNode)
{
Worker = worker;
ObjectSpace = applicationObjectSpace;
CreatedPackages = createdPackagesDict;
AllNodes = allNodes;
CurrentNode = currentNode;
}
/// <summary>
/// Opens the specified transport in selected mode.
/// </summary>
/// <param name="transportMode">The transport mode.</param>
/// <param name="worker">The worker.</param>
public void Open(TransportMode transportMode, ActionWorker worker)
{
Close();
client = new TransportServiceClient();
if(!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
{
if (client.ClientCredentials != null)
{
client.ClientCredentials.UserName.UserName = UserName;
client.ClientCredentials.UserName.Password = Password;
}
}
OnBeforeOpen(new BeforeOpenArgs(client));
client.Open();
worker.ReportProgress(Localizer.ClientOpened);
}
/// <summary>
/// Executes the specified action.
/// </summary>
/// <param name="actionName">Name of the action.</param>
/// <param name="eventHandler">The event handler.</param>
/// <param name="actionWorker">The action worker.</param>
/// <param name="completeHandler">The complete handler.</param>
public void ExecuteAction(string actionName, DoWorkEventHandler eventHandler, ActionWorker actionWorker, RunWorkerCompletedEventHandler completeHandler)
{
eventHandler(null, new DoWorkEventArgs(actionWorker));
completeHandler(null, new RunWorkerCompletedEventArgs(null, null, false));
}
/// <summary>
/// Uploads the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileData">The file data.</param>
/// <param name="recipientAddress">The recipient address.</param>
/// <param name="worker">The worker.</param>
/// <returns></returns>
public bool UploadFile(string fileName, byte[] fileData, string recipientAddress, ActionWorker worker)
{
var result = false;
if (client != null)
{
try
{
OnBeforeUpload(new WcfClientArgs(client, fileName));
client.UploadFile(fileName, fileData);
OnAfterUpload(new WcfClientArgs(client, fileName));
worker.ReportProgress(Localizer.UploadOk);
result = true;
}
catch (Exception exception)
{
worker.ReportError(Localizer.UploadError, fileName, exception.Message);
}
}
else
worker.ReportError(Localizer.ClientIsNotOpened);
return result;
}
public void DeleteFile(string fileName, ActionWorker worker)
{
throw new NotImplementedException();
}
public void DeleteFile(string fileName, ActionWorker worker)
{
executeCommand <bool>("Delete", Localization.Localizer.Deleting, Localization.Localizer.Deleted, worker, DownloadUrl, deleteUriProcessor,
deleteCmdProcessor, null, fileName);
}
