/// <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)
{
if (client != null)
{
client.DeleteFile(fileName);
}
else
{
worker.ReportError(Localizer.ClientIsNotOpened);
}
}
/// <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);
}
/// <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>
/// 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>
/// 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>
/// 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);
}
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 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;
}
/// <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>
/// 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;
}
public void DeleteFile(string fileName, ActionWorker worker)
{
if (client != null)
client.DeleteFile(fileName);
else
worker.ReportError(Localizer.ClientIsNotOpened);
}
/// <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>
/// 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>
/// 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;
}
