public bool TryGetMessage(out RouteMessage routeMessageObj)
{
CancellationTokenSource cts = new CancellationTokenSource(Timeout);
routeMessageObj = Task.Run(() =>
{
int count;
lock (LockObj)
count = Sessions[SessionId].Count;
while (count < 1)
{
if (cts.Token.IsCancellationRequested)
{
return(null);
}
Thread.Sleep(500);
lock (LockObj)
count = Sessions[SessionId].Count;
}
lock (LockObj)
return(Sessions[SessionId].Dequeue());
}, cts.Token).Result;
return(routeMessageObj != null);
}
/// <summary>
/// Method converts route message from solver to server message.
/// </summary>
/// <param name="msg">Route message.</param>
/// <returns>Server message.</returns>
private static ServerMessage _ConvertRouteMessage(RouteMessage msg)
{
Debug.Assert(msg != null);
return(new ServerMessage(ServerMessageType.Info,
String.Format(MSG_FORMAT, msg.Type, msg.Description)));
}
public static void Main(string[] args, KeyStorage keyStorage)
{
//Usage
if (args.Length != 4)
{
throw new HelpException("Missing arguments");
}
string sourcePath = args [1];
string repoPath = args [2];
string receipientName = args [3];
//Source
if (Directory.Exists(sourcePath) == false)
{
throw new HelpException("Source directory not found: " + sourcePath);
}
//Repo
Repo repo = Repo.Create(repoPath);
//Sender and Recipient keys
PrivateKey senderKey = keyStorage.DefaultKey;
PublicKey recipientKey = keyStorage.GetPublic(receipientName);
//Prepare Route message recording of ChunkID
RouteRepo rr = new RouteRepo(repo);
//Prepare Encryption
EncryptedRepo er = new EncryptedRepo(rr, null);
er.AddKey(recipientKey);
Console.Write("Generating Tree...");
//Send Tree
ChunkHash tree = TreeChunk.GenerateChunk(sourcePath, er);
//TreeMessage
TreeMessage tm = new TreeMessage(tree, Path.GetDirectoryName(sourcePath));
Chunk tmc = Message.ToChunk(tm, senderKey);
ChunkHash tmch = er.WriteChunk(tmc);
er.StoreMessage("file", tmch);
//RouteMessage
RouteMessage rm = rr.RouteMessage;
rm.MessageChunkHash = tmch.bytes;
rm.To = receipientName;
//Store unencrypted RouteMessage
Chunk rmChunk = Message.ToChunk(rm);
repo.WriteChunk(rmChunk);
repo.StoreMessage("route", rmChunk.ChunkHash);
Console.WriteLine("RouteMessage Stored");
}
protected virtual bool RaiseSessionEvent(RouteMessage message)
{
if (SessionReceived != null)
{
SessionReceived?.Invoke(null, new SessionReceivedEventArgs
{
RouteMessageObj = message
});
return(true);
}
return(false);
}
public static void Main(string[] args, KeyStorage keyStorage)
{
if (args.Length != 2)
{
throw new HelpException("Missing arguments");
}
//Repo
Repo repo = Repo.Create(args [1]);
//Find message
ICollection <ChunkHash> messages = repo.GetMessageList("file");
EncryptedRepo es = new EncryptedRepo(repo, keyStorage);
//Iterate over all messages
foreach (ChunkHash mid in messages)
{
Console.Write(mid.ToString().Substring(0, 10) + "... ");
Message message = Message.FromChunk(es.ReadChunk(mid), keyStorage);
//No key found
if (message == null)
{
Console.WriteLine("no key");
continue;
}
if (message.Signature != null)
{
Console.Write("(signed by " + message.Signature.Name + ") ");
}
TreeMessage tm = message as TreeMessage;
if (tm != null)
{
Console.WriteLine("TreeMessage " + tm.Name);
continue;
}
RouteMessage rm = message as RouteMessage;
if (rm != null)
{
Console.WriteLine("RouteMessage to " + rm.To);
continue;
}
Console.WriteLine("unknown message type: " + message.GetType().Name);
}
}
public override async void SendMessageAsync(RouteMessage message)
{
var routeMsg = (CoolQRouteMessage)message;
OnMessageSending?.Invoke(routeMsg);
if (routeMsg.Canceled && !routeMsg.IsForced)
{
return;
}
if (routeMsg.DelayTime > TimeSpan.FromSeconds(0))
{
await Task.Delay(routeMsg.DelayTime).ConfigureAwait(false);
}
var msg = (routeMsg.EnableAt && routeMsg.MessageType != MessageType.Private
? new At(routeMsg.UserId) + " "
: "") + ((CoolQMessage)routeMsg.Message).Compose();
string info = routeMsg.Identity.ToString();
string status;
switch (routeMsg.MessageType)
{
case MessageType.Group:
status = CoolQHttpApiClient.SendGroupMessageAsync(routeMsg.GroupId, msg).Status;
break;
case MessageType.Discuss:
status = CoolQHttpApiClient.SendDiscussMessageAsync(routeMsg.DiscussId, msg).Status;
break;
case MessageType.Private:
status = CoolQHttpApiClient.SendPrivateMessageAsync(routeMsg.UserId, msg).Status;
break;
default:
throw new ArgumentOutOfRangeException();
}
Logger.Message(string.Format("({0}) 我: {{status: {1}}}\r\n {2}", info, status, CoolQCode.DecodeToString(msg)));
}
public Task CreateBlockChainRoute(RouteMessage routeMessage)
{
Console.WriteLine("Made it");
return(Task.CompletedTask);
}
public Task Route(RouteMessage routeMessage)
{
_pipelineBlock.Post(routeMessage);
return(Task.CompletedTask);
}
public Task GetCustomerAddress(IWorkContext context, RouteMessage <CustomerInfoRequest> request)
{
return(Task.CompletedTask);
}
public RouteRepo(Repo backendRepo) : base(backendRepo)
{
this.RouteMessage = new RouteMessage();
}
protected static void SendMessage(RouteMessage routeMsg) => DaylilyCore.Current.MessageDispatcher?.SendMessageAsync(routeMsg);
public abstract void SendMessageAsync(RouteMessage message);
