void OnActionProgressUpdated(object sender, ServiceMessageEventArgs e)
{
if (actionToken != e.ActionToken)
{
return;
}
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
CurrentProgress = e.ActionProgressCurrent;
RaisePropertyChanged(nameof(CurrentProgress));
if (e.ActionProgressTotal != TotalProgress)
{
TotalProgress = e.ActionProgressTotal;
RaisePropertyChanged(nameof(TotalProgress));
}
if (CurrentProgress == TotalProgress)
{
Installing = true;
RaisePropertyChanged(nameof(Installing));
}
RaisePropertyChanged(nameof(InstallButtonText));
}));
}
public IExecutor CreateInstance(ExecutorArgs executorArgs, ServiceMessageEventArgs args)
{
var executor = (IExecutor)ActivatorUtilities.CreateInstance(args.Services, this.ExecutorType, new object[] { executorArgs });
executorArgs.TasksManager.CurrentExecutor = executor;
return(executor);
}
void client_MessageReceived(object sender, MessageEventArgs e)
{
var message = new ServiceMessageEventArgs
{
Client = client,
Request = request
};
//不是指定消息不处理
if (e.Message is ScsCallbackMessage)
{
//消息类型转换
var data = e.Message as ScsCallbackMessage;
message.Result = data.MessageValue;
}
else if (e.Message is ScsResultMessage)
{
//消息类型转换
var data = e.Message as ScsResultMessage;
message.Result = data.MessageValue;
}
//把数据发送到客户端
if (OnCallback != null)
{
OnCallback(this, message);
}
}
/// <summary>
/// 消息回调
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void reqService_OnCallback(object sender, ServiceMessageEventArgs args)
{
if (args.Result is ResponseMessage)
{
var resMsg = args.Result as ResponseMessage;
base.QueueMessage(resMsg);
}
else if (args.Result is CallbackMessage)
{
var callbackMsg = args.Result as CallbackMessage;
if (callback != null)
{
var callbackType = callback.GetType();
//获取接口的类型
var interfaces = callbackType.GetInterfaces();
if (interfaces.Length > 0)
{
//判断类型是否相同
if (interfaces.Any(type => type.FullName == callbackMsg.ServiceName))
{
var method = CoreHelper.GetMethodFromType(callbackType, callbackMsg.MethodName);
//执行委托
DynamicCalls.GetMethodInvoker(method).Invoke(callback, callbackMsg.Parameters);
}
}
}
}
}
private void OnIndexChanged(object sender, ServiceMessageEventArgs e)
{
wapkg.RequestAvailableDistributions();
foreach (var d in Dists.ToList())
{
wapkg.RequestAvailablePackages(d);
}
}
protected void RaiseReceivedMessageEvent(object sender, ServiceMessageEventArgs e)
{
var handler = ReceivedMessage;
if (handler != null)
{
handler(sender, e);
}
}
void reqService_OnCallback(object sender, ServiceMessageEventArgs args)
{
if (args.Result is ResponseMessage)
{
var resMsg = args.Result as ResponseMessage;
QueueMessage(resMsg);
}
}
protected void RaiseReceivedMessageEvent(ServiceMessage serviceMessage)
{
var handler = ReceivedMessage;
if (handler != null)
{
ServiceMessageEventArgs e = new ServiceMessageEventArgs(serviceMessage.IsSuccessful, serviceMessage.Message);
handler(this, e);
}
}
protected void RaiseReceivedMessageEvent(bool success, string message)
{
var handler = ReceivedMessage;
if (handler != null)
{
ServiceMessageEventArgs e = new ServiceMessageEventArgs(success, message);
handler(this, e);
}
}
void OnAvailableDistributionsAccepted(object sender, ServiceMessageEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
Items.Clear();
foreach (var dist in e.Distributions)
{
Items.Add(new AvailableDistribution(dist));
}
Items.Add(new DistribuionFileInstallerItem());
}));
}
void OnDistributionsChanged(object sender, ServiceMessageEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
Items.Clear();
foreach (var d in e.Distributions)
{
Items.Add(new Distribution()
{
Name = d
});
wapkg.RequestPackages(d);
}
}));
}
private Task _HandleProcessingResult(SqlConnection dbconnection, ServiceMessageEventArgs serviceArgs, bool isSync)
{
SSSBMessage message = serviceArgs.Message;
CancellationToken token = serviceArgs.Token;
Task processTask = serviceArgs.Completion.ContinueWith(async(antecedent) =>
{
try
{
if (isSync)
{
await this.HandleSyncProcessingResult(dbconnection, message, token, antecedent);
}
else
{
await this.HandleAsyncProcessingResult(message, token, antecedent);
}
}
catch (OperationCanceledException)
{
// NOOP
}
catch (PPSException)
{
// Already Logged
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
}
}, isSync ? TaskContinuationOptions.ExecuteSynchronously : TaskContinuationOptions.None).Unwrap();
var disposeTask = processTask.ContinueWith((antecedent) =>
{
try
{
this.OnDispose(serviceArgs);
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
}
}, TaskContinuationOptions.ExecuteSynchronously);
return(processTask);
}
private void OnDistsChanged(object sender, ServiceMessageEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
var selected = SelectedDistro;
Dists.Clear();
foreach (var d in e.Distributions)
{
Dists.Add(d);
}
if (Dists.Contains(selected))
{
SelectedDistro = selected;
RaisePropertyChanged(nameof(SelectedDistro));
}
}));
}
private void OnSourcesChanged(object sender, ServiceMessageEventArgs e)
{
Application.Current.Dispatcher.Invoke(() =>
{
Sources.Clear();
foreach (var src in e.Sources)
{
Sources.Add(new SourceDefinition(src));
}
foreach (var sd in Sources)
{
sd.ApplySources(Sources);
}
RaisePropertyChanged(nameof(Sources));
RaisePropertyChanged(nameof(ListViewVisibility));
});
}
void OnActionComplete(object sender, ServiceMessageEventArgs e)
{
if (actionToken != e.ActionToken)
{
return;
}
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
CurrentProgress = 0;
TotalProgress = 1;
SuggestedName = Name;
ButtonEnabled = true;
Installing = false;
RaisePropertyChanged(nameof(CurrentProgress));
RaisePropertyChanged(nameof(TotalProgress));
RaisePropertyChanged(nameof(InstallButtonText));
RaisePropertyChanged(nameof(SuggestedName));
RaisePropertyChanged(nameof(ButtonEnabled));
RaisePropertyChanged(nameof(Installing));
}));
actionToken = null;
}
public async Task HandleMessage(SqlConnection dbconnection,
IMessageHandler <ServiceMessageEventArgs> messageHandler,
ServiceMessageEventArgs serviceArgs)
{
var previousServiceArgs = serviceArgs;
bool isSync = true;
Task processTask = Task.FromException(new Exception($"The message: {serviceArgs.Message.MessageType} ConversationHandle: {serviceArgs.Message.ConversationHandle} is not handled"));
// handle message in its own transaction
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
{
serviceArgs = await messageHandler.HandleMessage(this.SSSBService, previousServiceArgs);
transactionScope.Complete();
}
isSync = serviceArgs.Completion.IsCompleted;
processTask = this._HandleProcessingResult(dbconnection, serviceArgs, isSync);
if (isSync)
{
await processTask;
}
}
void OnPackagesChanged(object sender, ServiceMessageEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
foreach (var i in Items)
{
if (i.Name == e.RelatedDistribution)
{
int count = i.Packages.Count - 1;
for (int x = 0; x < count; x++)
{
i.Packages.RemoveAt(0);
}
if (i.Packages.Count == 0)
{
i.Packages.Add(new PackageInstallerItem(e.RelatedDistribution));
}
foreach (var pkg in e.Packages)
{
i.Packages.Add(new InstalledPackage(e.RelatedDistribution)
{
Name = pkg.Item1,
Revision = "r" + pkg.Item2.ToString()
});
}
((PackageInstallerItem)i.Packages[0]).InstalledPackages = e.Packages;
i.Packages.Move(0, i.Packages.Count - 1);
wapkg.RequestAvailablePackages(i.Name);
break;
}
}
}));
}
void OnAvailablePackagesAccepted(object sender, ServiceMessageEventArgs e)
{
if (e.RelatedDistribution == null || e.RelatedDistribution != targetDistro)
{
return;
}
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
var nogroup = new List <AvailablePackage>();
var groups = new Dictionary <string, IList <AvailablePackage> >();
foreach (var pkg in e.Packages)
{
if (InstalledPackages != null)
{
bool flag = false;
foreach (var installed in InstalledPackages)
{
if (pkg.Item1 == installed.Item1 && pkg.Item2 <= installed.Item2)
{
flag = true;
break;
}
}
if (flag)
{
continue;
}
}
ICollection <AvailablePackage> dst = nogroup;
if (pkg.Item3 != null)
{
if (!groups.ContainsKey(pkg.Item3))
{
groups.Add(pkg.Item3, new List <AvailablePackage>());
}
dst = groups[pkg.Item3];
}
dst.Add(new AvailablePackage(targetDistro)
{
Name = pkg.Item1,
Revision = pkg.Item2 == null ? "virtual" : "r" + pkg.Item2.ToString()
});
}
foreach (var k in groups.Keys.OrderBy(x => x))
{
PackageGroup dstGroup = null;
foreach (var x in AvailableItems)
{
var g = x as PackageGroup;
if (g != null && g.Name == k)
{
dstGroup = g;
break;
}
}
if (dstGroup == null)
{
dstGroup = new PackageGroup(k);
var list = new List <PackageGroup>();
foreach (var x in AvailableItems)
{
var g = x as PackageGroup;
if (g == null)
{
break;
}
list.Add(g);
}
if (list.Count > 0)
{
bool done = false;
for (int i = 1; i < list.Count; i++)
{
if (string.Compare(list[i - 1].Name, k) < 0 && string.Compare(k, list[i].Name) < 0)
{
AvailableItems.Insert(i, dstGroup);
done = true;
break;
}
}
if (!done)
{
if (string.Compare(k, list[0].Name) < 0)
{
AvailableItems.Insert(0, dstGroup);
}
else
{
AvailableItems.Add(dstGroup);
}
}
}
else
{
AvailableItems.Add(dstGroup);
}
}
dstGroup.Push(groups[k].OrderBy(x => x.Name));
}
foreach (var x in AvailableItems.ToList())
{
var g = x as PackageGroup;
if (g != null)
{
if (!groups.Keys.Contains(g.Name))
{
AvailableItems.Remove(x);
}
continue;
}
AvailableItems.Remove(x);
}
foreach (var pkg in nogroup.OrderBy(x => x.Name))
{
AvailableItems.Add(pkg);
}
AvailableItems.Add(new PackageFileInstallerItem(targetDistro));
}));
}
private void OnTextAccepted(object sender, ServiceMessageEventArgs e)
{
RecentMessage = e.Text;
RaisePropertyChanged(nameof(RecentMessage));
}
public override async Task <ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs serviceMessageArgs)
{
MessageAtributes messageAtributes = null;
SSSBMessage originalMessage = null;
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
XElement envelopeXml = serviceMessageArgs.Message.GetMessageXML();
byte[] originalMessageBody = Convert.FromBase64String(envelopeXml.Element("body").Value);
XElement originalMessageXml = originalMessageBody.GetMessageXML();
messageAtributes = originalMessageXml.GetMessageAttributes();
messageAtributes.isDefered = true;
messageAtributes.attemptNumber = (int)envelopeXml.Attribute("attemptNumber");
string messageType = (string)envelopeXml.Attribute("messageType");
string serviceName = (string)envelopeXml.Attribute("serviceName");
string contractName = (string)envelopeXml.Attribute("contractName");
long sequenceNumber = (long)envelopeXml.Attribute("sequenceNumber");
MessageValidationType validationType = (MessageValidationType)Enum.Parse(typeof(MessageValidationType), envelopeXml.Attribute("validationType").Value);
Guid conversationHandle = Guid.Parse(envelopeXml.Attribute("conversationHandle").Value);
Guid conversationGroupID = Guid.Parse(envelopeXml.Attribute("conversationGroupID").Value);
originalMessage = new SSSBMessage(conversationHandle, conversationGroupID, validationType, contractName);
originalMessage.SequenceNumber = sequenceNumber;
originalMessage.ServiceName = serviceName;
originalMessage.Body = originalMessageBody;
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
return(serviceMessageArgs);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
return(serviceMessageArgs);
}
catch (Exception ex)
{
this.Logger.LogError(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
return(serviceMessageArgs);
}
OnDemandTaskManager taskManager = serviceMessageArgs.Services.GetRequiredService <OnDemandTaskManager>();
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
var task = await taskManager.GetTaskInfo(messageAtributes.TaskID.Value);
serviceMessageArgs.TaskID = messageAtributes.TaskID.Value;
var executorArgs = new ExecutorArgs(taskManager, task, originalMessage, messageAtributes);
await ExecuteTask(executorArgs, serviceMessageArgs);
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogCritical(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
}
return(serviceMessageArgs);
}
protected virtual void OnDispose(ServiceMessageEventArgs serviceArgs)
{
serviceArgs.Dispose();
}
public ICustomMessageHandler Create(ServiceMessageEventArgs args)
{
return(_func(args));
}
