/// <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; }
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> /// 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> /// 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); }