public bool SendMessage(string machineName, int port, PackageMessage message)
{
var keyString = machineName + ":" + port;
dicTcpSendClients.TryGetValue(keyString, out TcpClient tcpClient);
try
{
if (tcpClient == null)
{
tcpClient = new TcpClient(machineName, port);
dicTcpSendClients.TryAdd(keyString, tcpClient);
}
else if (tcpClient.Connected == false)
{
dicTcpSendClients.TryRemove(keyString, out tcpClient);
return(false);
}
Byte[] data = System.Text.Encoding.Unicode.GetBytes(message.ToJsonSerializeString());
NetworkStream stream = tcpClient.GetStream();
stream.Write(data, 0, data.Length);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
return(true);
}
public async void PublishPackageMessageAsync(PackageMessage packageMessage)
{
var text = JsonConvert.SerializeObject(packageMessage, Formatting.None);
await Ipfs.PubSub.PublishAsync(packageMessage.Scope, text);
logger.LogInformation($"PackageMessage {packageMessage.File} has been published to network.");
}
private async Task Delete(PackageMessage message)
{
var task = new DeletePackageTask(notifier, support);
// ReSharper disable RedundantArgumentName
await ProcessPackage(
message.UserInfo, message.FeedName, message.PackageName,
PackageState.DeletingQueued, PackageState.DamagedDeleting,
tryWithPackageItemBefore : async pi =>
{
Trace.TraceInformation("Deleting package {0}", pi);
// ReSharper disable once ConvertToLambdaExpression
return(await pi.Move(PackageState.Deleting, pi.Name));
},
tryWithPackage : async(pi, p) =>
{
await task.DeletePackage(message.UserInfo, pi.Feed, pi.Name, pi, p);
}, tryWithPackageItemAfter : async pi =>
{
await pi.Delete();
Trace.TraceInformation("Finished deleting package {0}", pi);
});
// ReSharper restore RedundantArgumentName
}
public bool Validate(PackageMessage message, out IList <string> errors)
{
errors = new List <string>();
if (string.IsNullOrWhiteSpace(message.File))
{
errors.Add("Path is null or empty.");
}
if (string.IsNullOrWhiteSpace(message.ServerId))
{
errors.Add("ServerId is null or empty.");
}
if (message.ServerSignature == null || message.ServerSignature.Length == 0)
{
errors.Add("Server signature is null or empty.");
}
if (!serverIdentityService.Derivation.VerifySignatureMessage(message.ToBinary().ConvertToBase64(), message.ServerSignature, message.ServerId))
{
errors.Add("Server signature do not match address and/or binary of message.");
}
return(errors.Count == 0);
}
private async Task Index(PackageMessage message)
{
var task = new IndexPackageTask(configuration, notifier, support, addInfoBuilder, pdbStoreManager, fileCompressor);
// ReSharper disable RedundantArgumentName
await ProcessPackage(
message.UserInfo, message.FeedName, message.PackageName,
PackageState.IndexingQueued, PackageState.DamagedIndexing,
tryWithPackageItemBefore : async pi =>
{
Trace.TraceInformation("Indexing package {0}", pi);
// ReSharper disable once ConvertToLambdaExpression
return(await pi.Move(PackageState.Indexing, pi.Name));
},
tryWithPackage : async(pi, p) =>
{
await task.IndexPackage(message.UserInfo, pi.Feed, pi.Name, pi, p);
},
tryWithPackageItemAfter : async pi =>
{
await pi.Delete();
Trace.TraceInformation("Finished indexing package {0}", pi);
});
// ReSharper restore RedundantArgumentName
}
protected virtual void HandleReceviceMessage()
{
for (int i = 0; i < HandlerMessageCount; i++)
{
new Task(() =>
{
PackageMessage receviceMessage = null;
do
{
receviceMessage = connect.GetReceviceMessage();
if (RaisePackageMessage != null)
{
RaisePackageMessage(receviceMessage);
}
try
{
foreach (var handler in MessageHandlers)
{
if (!handler.HanderMessage(receviceMessage.Message))
{
break;
}
}
}
catch
{
}
} while (receviceMessage != null);
}).Start();
}
}
public void One()
{
var package = TestPackage.CreateBinary(1);
var storeNotifications = Mediator.SendAndWait(new StorePackageCommand(package));
Assert.IsTrue(storeNotifications[0] is PackageStoredNotification);
var notification = storeNotifications.FindLast <PackageStoredNotification>();
var message = new PackageMessage
{
File = notification.File,
Scope = package.Scopes ?? "twitter.com",
ServerId = ServerIdentityService.Id
};
message.ServerSignature = ServerIdentityService.Sign(message.ToBinary());
var packageB = Mediator.SendAndWait(new FetchPackageCommand(message.File));
//Assert.AreEqual(3, notifications.Count, "There should be one notifications");
//Assert.IsTrue(notifications[0] is ClaimAddedNotification);
//Assert.IsTrue(notifications[1] is PackageAddedNotification);
Assert.IsNotNull(packageB);
}
public async Task Signal(PackageMessage message)
{
Trace.TraceInformation("Signaling message {0}", message);
var file = Path.Combine(configuration.RootPath, Guid.NewGuid() + ".tmp");
File.WriteAllText(file, JsonConvert.SerializeObject(message));
File.Move(file, Path.ChangeExtension(file, ".run"));
}
public async Task Signal(PackageMessage message)
{
var queue = queueClient.GetQueueReference(QueueName);
await queue.CreateIfNotExistsAsync();
var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(message));
await queue.AddMessageAsync(queueMessage);
}
public void Validate(PackageMessage message)
{
Validate(message, out IList <string> errors);
if (errors.Count > 0)
{
throw new ApplicationException(string.Join(" - ", errors));
}
}
private static async void CheckForChanges(Object obj, EventArgs args)
{
timer2.Stop();
try
{
// Check logged in
if (steamClient.IsConnected && isLoggedOn)
{
// Get the last change ID
if (previousChangeNumber == 0 && File.Exists(LastChangeFile))
{
var contents = File.ReadAllText(LastChangeFile);
previousChangeNumber = contents == "" ? 0 : UInt32.Parse(contents);
}
// Get latest changes. If more than 5000, returns 0
var JobID = steamApps.PICSGetChangesSince(previousChangeNumber, true, true);
var callback = await JobID;
if (previousChangeNumber < callback.CurrentChangeNumber)
{
Log.Info(
$"{callback.CurrentChangeNumber - callback.LastChangeNumber:N0} changes, {callback.AppChanges.Count} apps, {callback.PackageChanges.Count} packages"
);
// Save apps
foreach (var appID in callback.AppChanges.Keys)
{
var appPayload = AppMessage.create(appID);
AbstractConsumer.Produce(AbstractConsumer.queue_cs_apps, appPayload);
}
// Save packages
foreach (var packageID in callback.PackageChanges.Keys)
{
var packagePayload = PackageMessage.create(packageID);
AbstractConsumer.Produce(AbstractConsumer.queue_cs_packages, packagePayload);
}
// Save changes
var changePayload = ChangeMessage.create(callback.CurrentChangeNumber, callback);
AbstractConsumer.Produce(AbstractConsumer.queue_go_changes, changePayload);
// Update change number
previousChangeNumber = callback.CurrentChangeNumber;
File.WriteAllText(LastChangeFile, previousChangeNumber.ToString());
}
}
}
catch (Exception ex)
{
Log.Error("Failed checking for changes - " + ex.Message);
}
finally
{
timer2.Start();
}
}
public bool SendMessage(string machineName, TinctMessage message)
{
PackageMessage pmsg = new PackageMessage();
pmsg.SourceName = NodeInfo.NodeName;
pmsg.DestinationName = machineName;
pmsg.SendTimeStamp = DateTimeExtension.GetTimeStamp();
pmsg.Message = message;
return(SendMessage(machineName, masterPort, pmsg));
}
private async Task Retry(PackageMessage message)
{
var deleteTask = new DeletePackageTask(notifier, support);
// ReSharper disable RedundantArgumentName
if (!await ProcessPackage(
message.UserInfo, message.FeedName, message.PackageName,
PackageState.Partial, PackageState.DamagedDeleting,
tryWithPackageItemBefore: async pi =>
{
Trace.TraceInformation("Retrying package {0}", pi);
return(await pi.Move(PackageState.Deleting, pi.Name));
},
tryWithPackage: async(pi, p) =>
{
await deleteTask.DeletePackage(message.UserInfo, pi.Feed, pi.Name, pi, p);
},
tryWithPackageItemAfter: async pi =>
{
await pi.Delete();
}))
// ReSharper restore RedundantArgumentName
{
return;
}
var indexTask = new IndexPackageTask(configuration, notifier, support, addInfoBuilder, pdbStoreManager, fileCompressor);
// ReSharper disable RedundantArgumentName
if (!await ProcessPackage(
message.UserInfo, message.FeedName, message.PackageName,
PackageState.Original, PackageState.DamagedIndexing,
tryWithPackageItemBefore: async pi =>
{
return(await pi.Copy(PackageState.Indexing, pi.Name));
},
tryWithPackage: async(pi, p) =>
{
await indexTask.IndexPackage(message.UserInfo, pi.Feed, pi.Name, pi, p);
},
tryWithPackageItemAfter: async pi =>
{
Trace.TraceInformation("Finished retrying package {0}", pi);
await pi.Delete();
}))
// ReSharper restore RedundantArgumentName
{
return;
}
}
public async Task Process(PackageMessage message)
{
var before = DateTime.Now;
try
{
switch (message.PackageState)
{
case PackageState.New:
await Queue(message);
break;
case PackageState.IndexingQueued:
await Index(message);
break;
case PackageState.DeletingQueued:
await Delete(message);
break;
case PackageState.Partial:
await Retry(message);
break;
case PackageState.Original:
case PackageState.Indexing:
case PackageState.Succeded:
case PackageState.Deleting:
case PackageState.Deleted:
throw new NotSupportedException();
default:
throw new ArgumentOutOfRangeException("packageState", message.PackageState, null);
}
support.TrackRequest(message.PackageState, before, DateTime.Now - before, true);
}
catch (Exception e)
{
support.TrackException(e, new { message });
support.TrackRequest(message.PackageState, before, DateTime.Now - before, false);
throw;
}
}
private void UpdateSlaveNodeInfo(PackageMessage msg)
{
var nodeInfo = SlaveNodes.FirstOrDefault(node => node.NodeName == msg.SourceName);
if (nodeInfo == null)
{
NodeInfo newnodeInfo = new NodeInfo();
newnodeInfo.LastUpdateTime = msg.ReceviceTimeStamp;
newnodeInfo.Status = NodeStatus.Running;
newnodeInfo.NodeName = msg.SourceName;
SlaveNodes.Add(newnodeInfo);
}
else
{
nodeInfo.LastUpdateTime = msg.ReceviceTimeStamp;
nodeInfo.Status = NodeStatus.Running;
nodeInfo.NodeName = msg.SourceName;
}
}
private async Task Queue(PackageMessage message)
{
var task = new QueuePackageTask();
PackageName newPackageName = null;
// ReSharper disable RedundantArgumentName
await ProcessPackage(
message.UserInfo, message.FeedName, message.PackageName,
PackageState.New, PackageState.DamagedNew,
tryWithPackageItemBefore : async pi =>
{
Trace.TraceInformation("Reading package {0}", pi);
return(pi);
},
tryWithPackage : async(pi, p) =>
{
newPackageName = await task.ReadName(message.UserInfo, p);
await notifier.Starting(message.UserInfo, newPackageName);
},
tryWithPackageItemAfter : async pi =>
{
Trace.TraceInformation("Queueing package {0} as {1}", pi, newPackageName);
if (await pi.Copy(PackageState.Original, newPackageName) == null)
{
throw new Exception(string.Format("Failed to copy package {0} to {1}", pi, newPackageName));
}
if (await pi.Move(PackageState.IndexingQueued, newPackageName) == null)
{
throw new Exception(string.Format("Failed to move package {0} to {1}", pi, newPackageName));
}
message.PackageState = PackageState.IndexingQueued;
message.PackageName = newPackageName;
await scheduler.Signal(message);
Trace.TraceInformation("Finished queueing package {0} as {1}", pi, newPackageName);
});
// ReSharper restore RedundantArgumentName
}
protected override Task <int> OnExecute(CommandLineApplication app)
{
var context = StartupSpike.CreateStartupSpike();
if (string.IsNullOrEmpty(PackageMessage))
{
PackageMessage = "ipfs://QmUWpEZyccMkPRhRL1wSYTZpcXDMNgHD5oEiF1i8XxCsbt";
}
var message = new PackageMessage
{
File = PackageMessage,
Scope = "twitter.com",
ServerId = context.ServerIdentityService.Id
};
message.ServerSignature = context.ServerIdentityService.Sign(message.ToBinary());
context.PackageService.PublishPackageMessageAsync(message);
return(Task.FromResult(0));
}
/// <summary>
/// Deserialize Message
/// </summary>
public void Read(IReader r)
{
// Read Map Length
var len = r.ReadMapHeader();
for (var i = 0; i < len; i++)
{
var tag = r.ReadTag();
switch (tag)
{
case 100: // Read message
Message = r.ReadMessage <PackageMessage>();
break;
case 101: // Read dep_dep
DepDep = r.ReadMessage <DependMessage>();
break;
default:
r.Skip();
break;
}
}
}
public async Task Process([QueueTrigger(WebJobsSchedulerService.QueueName)] PackageMessage message)
{
await processor.Process(message);
}
public Task Signal(PackageMessage message)
{
return(Task.Delay(TimeSpan.Zero));
}
public Task Process(PackageMessage message)
{
throw new NotImplementedException();
}
public PackagePublishedNotification(Package package, PackageMessage message)
{
Package = package;
Message = message;
}
public void PublishPackageMessageAsync(PackageMessage packageMessage)
{
tempMessage = packageMessage;
}
private void UpdateMasteNodeInfo(PackageMessage message)
{
MasterNodeInfo.LastUpdateTime = message.ReceviceTimeStamp;
MasterNodeInfo.Status = NodeStatus.Running;
}
private void EnQueueMessage()
{
while (true)
{
Console.WriteLine("Waiting for a connection... ");
TcpClient acceptClient = listener.AcceptTcpClient();
new Task(() =>
{
Console.WriteLine("Connected!");
NetworkStream stream = acceptClient.GetStream();
List <byte> lists = new List <byte>();
int readStep = 0;
while (true)
{
Byte[] bytes = new Byte[8192 * 10];
try
{
readStep = stream.Read(bytes, 0, bytes.Length);
lists.AddRange(bytes);
if (readStep < bytes.Length)
{
long receviceTime = DateTimeExtension.GetTimeStamp();
var data = System.Text.Encoding.Unicode.GetString(lists.ToArray(), 0, lists.Count);
var message = PackageMessage.GetObjectBySerializeString(data);
if (message != null)
{
message.ReceviceTimeStamp = receviceTime;
MessageQueues.Enqueue(message);
}
else
{
///Filter some message
}
if (MessageQueues.Count == 1)
{
eventqueue.Set();
eventqueue.Reset();
}
lists.Clear();
}
}
catch (IOException e)
{
Console.WriteLine(e.Message);
var remoteName = GetRemoteName(acceptClient);
if (dicTcpAcceptClients.Count > 0)
{
var m1 = dicTcpSendClients.Where(m => m.Key.Contains(remoteName)).First();
m1.Value.Close();
dicTcpSendClients.TryRemove(m1.Key, out TcpClient clienttcp);
clienttcp = null;
}
stream.Close();
acceptClient.Close();
return;
}
}
;
}).Start();
}
}
protected virtual bool SendMessage(string machineName, int port, PackageMessage message)
{
return(connect.SendMessage(machineName, port, message));
}