/// <summary> /// Create tables used for installation /// </summary> /// <param name="level"></param> /// <param name="worker"></param> public static void CreateTable(Level level, BackgroundTask worker) { Type[] baiscTypes = CreateBasicTable(); Assembly basicAssembly = baiscTypes[0].Assembly; Assembly[] assemblies = SysExtension.GetInstalledAssemblies(); int i = 0; foreach (Assembly asm in assemblies) { MessageBuilder messages = new MessageBuilder(); foreach (Type type in asm.GetTypes()) { if (type.BaseType != typeof(DPObject)) continue; if (asm == basicAssembly && Array.IndexOf(baiscTypes, type) >= 0) continue; TableAttribute[] A = type.GetAttributes<TableAttribute>(); if (A.Length == 0) continue; if (A[0].Level == level) messages.AddRange(CreateTable(type)); } worker.ReportProgress((int)(i * 100.0 / assemblies.Length), messages.ToString()); i++; } }
/// <summary> /// Upgrade DPO packages from SQL SERVER /// </summary> /// <param name="path"></param> /// <returns></returns> public MessageBuilder UpgradePackage(string path) { MessageBuilder messages = new MessageBuilder(); foreach (Type type in assembly.GetTypes()) { if (type.BaseType != typeof(DPObject)) continue; TableAttribute[] A = type.GetAttributes<TableAttribute>(); if (A.Length == 0 || !A[0].Pack) continue; Packing packing = new Packing(type); packing.Pack(); if (!packing) { messages.Add(Message.Information(string.Format("Table {0} is empty.", packing.TableName))); } else { string fileName = string.Format("{0}\\{1}.cs", path, packing.ClassName); StreamWriter sw = new StreamWriter(fileName); sw.Write(packing.ToString()); sw.Close(); messages.Add(Message.Information(string.Format("Table {0} packed into {1}.", packing.TableName, fileName))); } } return messages; }
// Update is called once per frame void Update() { if (Input.GetButton("Fire1") && Time.time > nextFire) { MessageBuilder msg = new MessageBuilder(MessageType.SHOOTING_MASTER_SIMPLE); msg.Add(humanEntity.Position.x).Add(humanEntity.Position.y).Add(humanEntity.Position.z); msg.Add(humanEntity.Rotation.x).Add(humanEntity.Rotation.y).Add(humanEntity.Rotation.z).Add(humanEntity.Rotation.w); msg.Add("qwe"); Debug.Log("123123"); TCPHandler.getInstance().send(msg.Build()); nextFire = Time.time + fireRate; Vector3 position = transform.TransformPoint(0, 0, 0.2f); ProjectileFactory.CreateProjectile(humanEntity, "qwe"); /* Instantiate(blaster, position, Quaternion.Euler( cameraHeadTransform.eulerAngles.x + 90, transform.eulerAngles.y, 0 ));*/ } }
public async Task<Response> ExecuteRequest(Request request) { if (!_tcpClient.Connected) { throw new InvalidOperationException("Connect first."); } var converter = new MessageConverter(); var requestBuffer = new MemoryStream(); var streamWriter = new HmBinaryMessageWriter(requestBuffer); var requestReader = new MessageReader(request); converter.Convert(requestReader, streamWriter); var networkStream = _tcpClient.GetStream(); requestBuffer.Position = 0; await requestBuffer.CopyToAsync(networkStream); await Task.Delay(100); //todo: implement buffered reader var streamReader = new HmBinaryMessageReader(networkStream); var responseBuilder = new MessageBuilder(); converter.Convert(streamReader, responseBuilder); var response = (Response)responseBuilder.Result; return response; }
private static void LogIn(Command cmd) { string str = cmd.Parameters[0]; instance.token = str; MessageBuilder mb = new MessageBuilder(MessageType.LOGIN); mb.Add(str); TCPHandler.getInstance().send(mb.Build()); }
public void MessageBuilder_Test_SetAddress_Succeeds() { var builder = new MessageBuilder(); Assert.AreEqual("/", builder.GetAddress()); builder.SetAddress("/this/is/a/test"); Assert.AreEqual("/this/is/a/test", builder.GetAddress()); }
private static void Main() { // new PrintAllTestsNames().print(); var allFiles = new BuildsFromFilesRetriver().Get(); var msg = new MessageBuilder(allFiles); new FileWriter().Write(msg.ReplacePlaceHolders.GetTextMessage()); new FileWriter().Write(msg.TestsHandler.FailedTests,msg.TestsHandler.Builds); new MailSender().SendMail(msg.ReplacePlaceHolders.GetHtmlMessage(), msg.TestsHandler.Versions); }
public MessageBuilderWithNewModelTests() { model = new PersonModel(); bulder = new MessageBuilder<PersonModel>(model); bulder.Add(new CreatePersonMessageMap()); bulder.Add(new ChangeAddressMessageMap()); }
public void MessageBuilder_Test_Reset() { var builder = new MessageBuilder(); builder.SetAddress("/test"); builder.PushAtom(1234); Assert.AreEqual("/test", builder.GetAddress()); Assert.AreEqual(1, builder.AtomCount); builder.Reset(); Assert.AreEqual("/", builder.GetAddress()); Assert.AreEqual(0, builder.AtomCount); }
private void doChat() { int requestCount = 0; byte[] bytesFrom; string dataFromClient = null; Byte[] sendBytes = null; string serverResponse = null; string rCount = null; requestCount = 0; while ((true)) { try { requestCount = requestCount + 1; NetworkStream networkStream = clientSocket.GetStream(); bytesFrom = new byte[(int)clientSocket.ReceiveBufferSize]; networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize); dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom); Console.WriteLine(dataFromClient.Substring(0,100)); /**Anfrage*/ dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$")); //Encrypt String MessageBuilder MB = new MessageBuilder(); String[] Request = MB.DeBuild(dataFromClient); RequestHandler RH = new RequestHandler(); String[] ResponseArray = RH.handleMe(Request); rCount = Convert.ToString(requestCount); /**Antwort*/ //Crypt String serverResponse = MB.Build(ResponseArray); sendBytes = Encoding.ASCII.GetBytes(serverResponse); networkStream.Write(sendBytes, 0, sendBytes.Length); networkStream.Flush(); Console.WriteLine(serverResponse); clientSocket.Close(); break; } catch (Exception ex) { Console.WriteLine(" >> " + ex.ToString()); } } }
void FixedUpdate() { if(login) { MessageBuilder mb = new MessageBuilder(MessageType.MOVEMENT_SYNC); mb.Add(playerObj.transform.position.x); mb.Add(playerObj.transform.position.y); mb.Add(playerObj.transform.position.z); mb.Add(playerObj.transform.rotation.x); mb.Add(playerObj.transform.rotation.y); mb.Add(playerObj.transform.rotation.z); mb.Add(playerObj.transform.rotation.w); TCPHandler.getInstance().send(mb.Build()); } }
public static MessageBuilder CreateTable(Assembly assembly) { MessageBuilder messages = new MessageBuilder(); foreach (Type type in assembly.GetTypes()) { if (type.BaseType != typeof(DPObject)) continue; if (!type.HasAttribute<TableAttribute>()) continue; messages.AddRange(CreateTable(type)); } return messages; }
public IStatus Get(string id) { try { using (var cmd = new DBCommand()) { return StatusDAL.Get(cmd, id); } } catch (Exception ex) { using (var builder = new MessageBuilder()) { string err = builder.AppendLine("读取状态信息错误!").AppendLine(ex).Message; throw new Exception(err); } } }
public Task HandleRequest(IRequestContext requestContext) { var converter = new MessageConverter(); var messageBuilder = new MessageBuilder(); converter.Convert(requestContext.Request, messageBuilder); var request = (Request)messageBuilder.Result; var response = HandleRequest(request); #if DEBUG System.Diagnostics.Debug.WriteLine(messageBuilder.Debug); Console.WriteLine(request); #endif var responseReader = new MessageReader(response); converter.Convert(responseReader, requestContext.Response); return Task.FromResult(0); }
public void MessageBuilder_Test_PushPopSetAtoms() { var builder = new MessageBuilder(); builder.PushAtom(new Atom(TypeTag.OscInt32)); builder.PushAtom(new byte[] { (byte)5 }); builder.PushAtom(5.0f); builder.PushAtom(6.0); builder.PushAtom(7); builder.PushAtom(8L); builder.PushAtom("Test"); Assert.AreEqual(7, builder.AtomCount); var last = builder.PopAtom(); Assert.AreEqual(6, builder.AtomCount); Assert.AreEqual("Test", last); builder.SetAtom(5, 1234); Assert.AreEqual(1234, builder.GetAtom(5)); }
public ICase Create(string id, string type, string text) { using (var cmd = new DBCommand()) { try { ICase instance = CaseDAL.Create(cmd, id, type, text); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建问题信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public IStatus Create(string id, string value) { using (var cmd = new DBCommand()) { try { IStatus instance = StatusDAL.Create(cmd, id,value); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建状态信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public ICollection Create(string id, decimal? value, decimal? offset) { using (var cmd = new DBCommand()) { try { ICollection instance = CollectionDAL.Create(cmd, id, value,offset); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建付费信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public IStatus Delete(IStatus instance) { using (var cmd = new DBCommand()) { try { StatusDAL.Delete(cmd, instance); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("删除状态信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public void MessageDispatch_Test_Dispatch() { MessageDispatch dispatch = new MessageDispatch(); MessageBuilder builder1 = new MessageBuilder(); builder1.SetAddress("/test1"); builder1.PushAtom(1); MessageBuilder builder2 = new MessageBuilder(); builder2.SetAddress("/test2"); builder2.PushAtom("TEST"); MessageBuilder builder3 = new MessageBuilder(); builder3.SetAddress("/test3"); builder3.PushAtom("TEST2"); String address = ""; Atom value = new Atom(); Action<osc.net.Message> callback = m => { address = m.Address; value = m.Atoms[0]; }; dispatch.RegisterMethod("/test1", callback); dispatch.RegisterMethod("/test2", callback); // Test dispatch.Dispatch(builder1.ToMessage()); Assert.AreEqual("/test1", address); Assert.AreEqual(1, value); dispatch.Dispatch(builder2.ToMessage()); Assert.AreEqual("/test2", address); Assert.AreEqual("TEST", value); // No callback registered, values should not be set dispatch.Dispatch(builder3.ToMessage()); Assert.AreNotEqual("/test3", address); Assert.AreNotEqual("TEST2", value); }
public ICustomer Create(string id, string name, string sex, string phone, string address) { using (var cmd = new DBCommand()) { try { ICustomer instance = CustomerDAL.Create(cmd, id,name,sex,phone,address); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建客户信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public IUser Create(string name, string password, UserRole? role) { using (var cmd = new DBCommand()) { try { string id = Guid.NewGuid().ToString(); IUser instance = UserDAL.Create(cmd, id,name, password, role); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建用户信息错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public void MessageParser_Test_Parse() { MessageParser parser = new MessageParser(); MessageBuilder builder = new MessageBuilder(); builder.SetAddress("/test"); builder.PushAtom(new Atom(TypeTag.OscInt32)); builder.PushAtom(new byte[] { (byte)5 }); builder.PushAtom(5.0f); builder.PushAtom(6.0); builder.PushAtom(7); builder.PushAtom(8L); builder.PushAtom("Test"); // Test osc.net.Message message = builder.ToMessage(); byte[] bytes = parser.Parse(message); osc.net.Message parsedMessage = parser.Parse(bytes); byte[] reparsedBytes = parser.Parse(parsedMessage); Assert.AreEqual(message, parsedMessage); CollectionAssert.AreEqual(bytes, reparsedBytes); }
public IApplication Create(string id, string customerId, string region, DateTime? dateApplied, DateTime? dateTraved, string offNoteNo, DateTime? offNoteDate, string remark) { using (var cmd = new DBCommand()) { try { IApplication instance = ApplicationDAL.Create(cmd, id, customerId, region, dateApplied, dateTraved, offNoteNo, offNoteDate, remark); cmd.Commit(); return instance; } catch (Exception ex) { cmd.RollBack(); using (var builder = new MessageBuilder()) { string err = builder.AppendLine("创建申请单错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
// Receive from udp socket and push value to subscribers. async void RunReceiveLoop(Stream pipeStream, Func <CancellationToken, Task>?waitForConnection) { RECONNECT: var token = cancellationTokenSource.Token; if (waitForConnection != null) { try { await waitForConnection(token).ConfigureAwait(false); } catch (IOException) { return; // connection closed. } } var buffer = new byte[65536]; while (!token.IsCancellationRequested) { ReadOnlyMemory <byte> value = Array.Empty <byte>(); try { var readLen = await pipeStream.ReadAsync(buffer, 0, buffer.Length, token).ConfigureAwait(false); if (readLen == 0) { if (waitForConnection != null) { server.Value.Dispose(); server = CreateLazyServerStream(); pipeStream = server.Value; goto RECONNECT; // end of stream(disconnect, wait reconnect) } } var messageLen = MessageBuilder.FetchMessageLength(buffer); if (readLen == (messageLen + 4)) { value = buffer.AsMemory(4, messageLen); // skip length header } else { // read more if (buffer.Length < (messageLen + 4)) { Array.Resize(ref buffer, messageLen + 4); } var remain = messageLen - (readLen - 4); await ReadFullyAsync(buffer, pipeStream, readLen, remain, token).ConfigureAwait(false); value = buffer.AsMemory(4, messageLen); } } catch (IOException) { return; // connection closed. } catch (Exception ex) { if (ex is OperationCanceledException) { return; } if (token.IsCancellationRequested) { return; } // network error, terminate. options.UnhandledErrorHandler("network error, receive loop will terminate." + Environment.NewLine, ex); return; } try { var message = MessageBuilder.ReadPubSubMessage(value.ToArray()); // can avoid copy? switch (message.MessageType) { case MessageType.PubSub: publisher.Publish(message, message, CancellationToken.None); break; case MessageType.RemoteRequest: { // NOTE: should use without reflection(Expression.Compile) var header = Deserialize <RequestHeader>(message.KeyMemory, options.MessagePackSerializerOptions); var(mid, reqTypeName, resTypeName) = (header.MessageId, header.RequestType, header.ResponseType); byte[] resultBytes; try { var t = AsyncRequestHandlerRegistory.Get(reqTypeName, resTypeName); var interfaceType = t.GetInterfaces().First(x => x.IsGenericType && x.Name.StartsWith("IAsyncRequestHandler")); var coreInterfaceType = t.GetInterfaces().First(x => x.IsGenericType && x.Name.StartsWith("IAsyncRequestHandlerCore")); var service = provider.GetRequiredService(interfaceType); // IAsyncRequestHandler<TRequest,TResponse> var genericArgs = interfaceType.GetGenericArguments(); // [TRequest, TResponse] var request = MessagePackSerializer.Deserialize(genericArgs[0], message.ValueMemory, options.MessagePackSerializerOptions); var responseTask = coreInterfaceType.GetMethod("InvokeAsync") !.Invoke(service, new[] { request, CancellationToken.None }); var task = typeof(ValueTask <>).MakeGenericType(genericArgs[1]).GetMethod("AsTask") !.Invoke(responseTask, null); await((System.Threading.Tasks.Task)task !); // Task<T> -> Task var result = task.GetType().GetProperty("Result") !.GetValue(task); resultBytes = MessageBuilder.BuildRemoteResponseMessage(mid, genericArgs[1], result !, options.MessagePackSerializerOptions); } catch (Exception ex) { // NOTE: ok to send stacktrace? resultBytes = MessageBuilder.BuildRemoteResponseError(mid, ex.ToString(), options.MessagePackSerializerOptions); } await pipeStream.WriteAsync(resultBytes, 0, resultBytes.Length).ConfigureAwait(false); } break; case MessageType.RemoteResponse: case MessageType.RemoteError: { var mid = Deserialize <int>(message.KeyMemory, options.MessagePackSerializerOptions); if (responseCompletions.TryRemove(mid, out var tcs)) { if (message.MessageType == MessageType.RemoteResponse) { tcs.TrySetResult(message); // synchronous completion, use memory buffer immediately. } else { var errorMsg = MessagePackSerializer.Deserialize <string>(message.ValueMemory, options.MessagePackSerializerOptions); tcs.TrySetException(new RemoteRequestException(errorMsg)); } } } break; default: break; } } catch (IOException) { return; // connection closed. } catch (Exception ex) { if (ex is OperationCanceledException) { continue; } options.UnhandledErrorHandler("", ex); } } }
public static async Task <string> Handle(MessageResult result) { var builder = new MessageBuilder(Constants.DefaultSeparator); var userDb = new DbWriter($"{AppDomain.CurrentDomain.BaseDirectory}User.csv", "Username;Password"); var cepDb = new DbWriter($"{AppDomain.CurrentDomain.BaseDirectory}Cep.csv", "UserId;Cep;Logradouro;Bairro;Complemento;Cidade;Uf;DataBusca"); switch (result.MessageType.ToUpper()) { case "CADASTRAR": { //TODO: Cadastrar usuário no CSV var username = result.GetFieldValue("USERNAME"); var password = result.GetFieldValue("PASSWORD"); if (string.IsNullOrWhiteSpace(password) || string.IsNullOrWhiteSpace(username)) { builder.AddFailure("Usuário ou senha estão vazios ou nulos"); } else if (password.Length < 8) { builder.AddFailure("A senha deve possuir pelo menos 8 caracteres"); } else { var emailRegex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$"); if (!emailRegex.Match(username).Success) { builder.AddFailure("Email invalido"); } else if (userDb.GetLines("Username", username).Count() > 0) { builder.AddFailure("Usuario ja cadastrado"); } else { password = UserHelper.Encrypt(password); Console.WriteLine(userDb.InsertLine(new string[] { username, password })); builder.AddSucess(); } } break; } case "LOGIN": { var username = result.GetFieldValue("USERNAME"); var password = result.GetFieldValue("PASSWORD"); var connectionDurationStr = result.GetFieldValue("CONNECTION_DURATION"); Int32.TryParse(connectionDurationStr, out int connectionDuration); if (connectionDuration <= 0) { builder.AddFailure("Tempo de conexão inválido"); break; } if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password)) { builder.AddFailure("Usuário ou senha inválidos"); break; } var userLines = userDb.GetLines("Username", username); if (userLines.Count != 1) { builder.AddFailure("Usuário ou senha inválidos"); break; } var user = userLines.FirstOrDefault(); if (user == null || !UserHelper.PasswordEquals(password, user[1])) { builder.AddFailure("Usuário ou senha inválidos"); break; } builder.AddSucess(); builder.AddField("TOKEN", UserHelper.GenerateToken(user[0], connectionDuration)); break; } case "CEP": { var token = result.GetFieldValue("TOKEN"); var userId = UserHelper.ValidateToken(token); if (string.IsNullOrWhiteSpace(userId)) { builder.AddFailure("Token inválido"); break; } var cep = result.GetFieldValue("CEP"); var client = new ViaCepClient(); var address = await client.GetAddressByCep(cep); if (address.Erro) { builder.AddFailure("Endereço não encontrado"); break; } builder.AddSucess(); builder.AddField("CEP", address.Cep); builder.AddField("LOGRADOURO", address.Logradouro); builder.AddField("BAIRRO", address.Bairro); builder.AddField("COMPLEMENTO", address.Complemento); builder.AddField("CIDADE", address.Localidade); builder.AddField("UF", address.Uf); //Salvar no Historico cepDb.InsertLine(new string[] { userId, address.Cep, address.Logradouro, address.Bairro, address.Complemento, address.Localidade, address.Uf, DateTime.Now.ToString() }); break; } case "HISTORICO": { var token = result.GetFieldValue("TOKEN"); var userId = UserHelper.ValidateToken(token); if (string.IsNullOrWhiteSpace(userId)) { builder.AddFailure("Token inválido"); break; } var results = cepDb.GetLines("UserId", userId); if (!results.Any()) { builder.AddFailure("Histórico vazio"); break; } builder.AddSucess(); int i = 0; foreach (var line in results) { builder.AddField("INDEX", i.ToString()); builder.AddField("USER_ID", line[0]); builder.AddField("CEP", line[1]); builder.AddField("LOGRADOURO", line[2]); builder.AddField("BAIRRO", line[3]); builder.AddField("COMPLEMENTO", line[4]); builder.AddField("CIDADE", line[5]); builder.AddField("UF", line[6]); builder.AddField("DATA_DA_BUSCA", line[7]); i++; } break; } default: { builder.AddFailure("Mensagem inválida"); break; } } return(builder.BuildValues()); }
public IMessage Echo(object value) { return(MessageBuilder <string> .WithPayload(value.ToString()).SetHeader("contentType", new MimeType("text", "plain")).Build()); }
internal CompilerException(CompilerResults results, MessageBuilder messageBuilder) : base(messageBuilder.GetMessage(results)) { _results = results; }
/// <summary> /// Creates new queue and sends response /// </summary> private async Task CreateQueue(MqClient client, TmqMessage message) { ushort?contentType; NetworkOptionsBuilder builder = null; if (message.Length == 2) { byte[] bytes = new byte[2]; await message.Content.ReadAsync(bytes); contentType = BitConverter.ToUInt16(bytes); } else { builder = new NetworkOptionsBuilder(); builder.Load(message.ToString()); contentType = builder.Id; } Channel channel = await CreateChannel(client, message, true); ChannelQueue queue = channel.FindQueue(contentType.Value); //if queue exists, we can't create. return duplicate response. if (queue != null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Duplicate)); } return; } //check authority if client can create queue if (_server.Authorization != null) { bool grant = await _server.Authorization.CanCreateQueue(client, channel, contentType.Value, builder); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } } //creates new queue ChannelQueueOptions options = ChannelQueueOptions.CloneFrom(channel.Options); IMessageDeliveryHandler delivery = channel.DeliveryHandler; if (builder != null) { builder.ApplyToQueue(options); if (!string.IsNullOrEmpty(builder.MessageDeliveryHandler)) { IMessageDeliveryHandler found = _server.Registry.GetMessageDelivery(builder.MessageDeliveryHandler); if (found != null) { delivery = found; } } } queue = await channel.CreateQueue(contentType.Value, options, delivery); //if creation successful, sends response if (queue != null && message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } }
public AsyncLogger(Layout loggingLayout, EnforcementConfig enforcementConfig, MessageBuilder messageBuilder, MessageTransmitterConfig messageTransmitterConfig) { layout = loggingLayout; cts = new CancellationTokenSource(); token = cts.Token; throttling = Throttling.FromConfig(enforcementConfig.Throttling); queue = NewBlockingCollection(); buffer = new ByteArray(enforcementConfig.TruncateMessageTo); messageTransmitter = MessageTransmitter.FromConfig(messageTransmitterConfig); flushCompletionMarker = new LogEventInfo(LogLevel.Off, string.Empty, nameof(flushCompletionMarker)); Task.Run(() => ProcessQueueAsync(messageBuilder)); processWithTimeoutAction = (asyncLogEventInfo, timeout) => Enqueue(asyncLogEventInfo, timeout); discardAction = asyncLogEventInfo => asyncLogEventInfo.Continuation(new InvalidOperationException($"Enqueue skipped")); }
public void TestTimestampValueReadOnly() { var timestamp = 12345L; Assert.Throws <ArgumentException>(() => MessageBuilder <string> .WithPayload("test").SetHeader(MessageHeaders.TIMESTAMP, timestamp).Build()); }
/// <summary> /// Creates new channel /// </summary> private async Task <Channel> CreateChannel(MqClient client, TmqMessage message, bool createForQueue) { Channel channel = _server.FindChannel(message.Target); if (channel != null) { return(channel); } //check create channel access if (_server.Authorization != null) { bool grant = await _server.Authorization.CanCreateChannel(client, _server, message.Target); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return(null); } } if (!createForQueue && message.Length > 0 && message.Content != null && message.Content.Length > 0) { NetworkOptionsBuilder builder = new NetworkOptionsBuilder(); builder.Load(message.ToString()); ChannelOptions options = ChannelOptions.CloneFrom(_server.Options); builder.ApplyToChannel(options); IChannelEventHandler eventHandler = _server.DefaultChannelEventHandler; if (!string.IsNullOrEmpty(builder.ChannelEventHandler)) { IChannelEventHandler e = _server.Registry.GetChannelEvent(builder.ChannelEventHandler); if (e != null) { eventHandler = e; } } IChannelAuthenticator authenticator = _server.DefaultChannelAuthenticator; if (!string.IsNullOrEmpty(builder.ChannelAuthenticator)) { IChannelAuthenticator e = _server.Registry.GetChannelAuthenticator(builder.ChannelAuthenticator); if (e != null) { authenticator = e; } } IMessageDeliveryHandler deliveryHandler = _server.DefaultDeliveryHandler; if (!string.IsNullOrEmpty(builder.MessageDeliveryHandler)) { IMessageDeliveryHandler e = _server.Registry.GetMessageDelivery(builder.MessageDeliveryHandler); if (e != null) { deliveryHandler = e; } } Channel ch = _server.CreateChannel(message.Target, authenticator, eventHandler, deliveryHandler, options); if (ch != null && message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } } Channel c = _server.CreateChannel(message.Target); if (!createForQueue && c != null && message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } return(c); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"]; int ClNonCustomerPort = (int)ArgumentValues["clNonCustomer Port"]; int ClCustomerPort = (int)ArgumentValues["clCustomer Port"]; log.Trace("(ServerIp:'{0}',ClNonCustomerPort:{1},ClCustomerPort:{2})", ServerIp, ClNonCustomerPort, ClCustomerPort); bool res = false; Passed = false; ProtocolClient client = new ProtocolClient(); try { MessageBuilder mb = client.MessageBuilder; // Step 1 await client.ConnectAsync(ServerIp, ClNonCustomerPort, true); bool establishHostingOk = await client.EstablishHostingAsync(); // Step 1 Acceptance bool step1Ok = establishHostingOk; client.CloseConnection(); // Step 2 await client.ConnectAsync(ServerIp, ClCustomerPort, true); bool checkInOk = await client.CheckInAsync(); Message requestMessage = mb.CreateCancelHostingAgreementRequest(null); await client.SendMessageAsync(requestMessage); Message responseMessage = await client.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.Ok; bool cancelHostingAgreementOk = idOk && statusOk; // Step 2 Acceptance bool step2Ok = checkInOk && cancelHostingAgreementOk; client.CloseConnection(); // Step 3 await client.ConnectAsync(ServerIp, ClCustomerPort, true); bool startConversationOk = await client.StartConversationAsync(); requestMessage = mb.CreateCheckInRequest(client.Challenge); await client.SendMessageAsync(requestMessage); responseMessage = await client.ReceiveMessageAsync(); idOk = responseMessage.Id == requestMessage.Id; statusOk = responseMessage.Response.Status == Status.ErrorNotFound; checkInOk = idOk && statusOk; // Step 3 Acceptance bool step3Ok = startConversationOk && checkInOk; client.CloseConnection(); // Step 4 await client.ConnectAsync(ServerIp, ClNonCustomerPort, true); establishHostingOk = await client.EstablishHostingAsync(); // Step 4 Acceptance bool step4Ok = establishHostingOk; client.CloseConnection(); // Step 5 await client.ConnectAsync(ServerIp, ClCustomerPort, true); checkInOk = await client.CheckInAsync(); // Step 5 Acceptance bool step5Ok = checkInOk; Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } client.Dispose(); log.Trace("(-):{0}", res); return(res); }
/// <summary> /// Gets connected instance list /// </summary> private async Task GetInstanceList(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } bool grant = await _server.AdminAuthorization.CanManageInstances(client, message); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } List <InstanceInformation> list = new List <InstanceInformation>(); //slave instances List <SlaveInstance> slaves = _server.SlaveInstances.GetAsClone(); foreach (SlaveInstance slave in slaves) { list.Add(new InstanceInformation { IsSlave = true, Host = slave.RemoteHost, IsConnected = slave.Client.IsConnected, Id = slave.Client.UniqueId, Name = slave.Client.Name, Lifetime = slave.ConnectedDate.LifetimeMilliseconds() }); } //master instances foreach (TmqStickyConnector connector in _server.InstanceConnectors) { InstanceOptions options = connector.Tag as InstanceOptions; TmqClient c = connector.GetClient(); list.Add(new InstanceInformation { IsSlave = false, Host = options?.Host, IsConnected = connector.IsConnected, Id = c.ClientId, Name = options?.Name, Lifetime = Convert.ToInt64(connector.Lifetime.TotalMilliseconds) }); } TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.InstanceList; await response.SetJsonContent(list); await client.SendAsync(response); }
/// <summary> /// Finds the queue and sends the information /// </summary> private async Task GetQueueInformation(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); if (channel == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } bool grant = await _server.AdminAuthorization.CanReceiveChannelQueues(client, channel); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } byte[] bytes = new byte[2]; await message.Content.ReadAsync(bytes); ushort id = BitConverter.ToUInt16(bytes); ChannelQueue queue = channel.FindQueue(id); if (queue == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } QueueInformation information = new QueueInformation { Channel = channel.Name, Id = id, Status = queue.Status.ToString().ToLower(), InQueueHighPriorityMessages = queue.HighPriorityLinkedList.Count, InQueueRegularMessages = queue.RegularLinkedList.Count, OnlyFirstAcquirer = channel.Options.SendOnlyFirstAcquirer, RequestAcknowledge = channel.Options.RequestAcknowledge, AcknowledgeTimeout = Convert.ToInt32(channel.Options.AcknowledgeTimeout.TotalMilliseconds), MessageTimeout = Convert.ToInt32(channel.Options.MessageTimeout.TotalMilliseconds), WaitForAcknowledge = channel.Options.WaitForAcknowledge, HideClientNames = channel.Options.HideClientNames, ReceivedMessages = queue.Info.ReceivedMessages, SentMessages = queue.Info.SentMessages, Deliveries = queue.Info.Deliveries, Unacknowledges = queue.Info.Unacknowledges, Acknowledges = queue.Info.Acknowledges, TimeoutMessages = queue.Info.TimedOutMessages, SavedMessages = queue.Info.MessageSaved, RemovedMessages = queue.Info.MessageRemoved, Errors = queue.Info.ErrorCount, LastMessageReceived = queue.Info.GetLastMessageReceiveUnix(), LastMessageSent = queue.Info.GetLastMessageSendUnix(), MessageLimit = queue.Options.MessageLimit }; TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.QueueInformation; await response.SetJsonContent(information); await client.SendAsync(response); }
/// <summary> /// Creates new queue and sends response /// </summary> private async Task UpdateQueue(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } NetworkOptionsBuilder builder = new NetworkOptionsBuilder(); builder.Load(message.ToString()); Channel channel = _server.FindChannel(message.Target); if (channel == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } ChannelQueue queue = channel.FindQueue(builder.Id); if (queue == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } bool grant = await _server.AdminAuthorization.CanUpdateQueueOptions(client, channel, queue, builder); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } builder.ApplyToQueue(queue.Options); if (builder.Status.HasValue) { await queue.SetStatus(builder.Status.Value); } //if creation successful, sends response if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } }
public void TestSimpleIMessageCreation() { var message = MessageBuilder <string> .WithPayload("foo").Build(); Assert.Equal("foo", message.Payload); }
private byte[] GetTestBytes() { MessageParser parser = new MessageParser(); MessageBuilder builder = new MessageBuilder(); builder.SetAddress("/test"); builder.PushAtom(new Atom(TypeTag.OscInt32)); builder.PushAtom(new byte[] { (byte)5 }); builder.PushAtom(5.0f); builder.PushAtom(6.0); builder.PushAtom(7); builder.PushAtom(8L); builder.PushAtom("Test"); return parser.Parse(builder.ToMessage()); }
public void TestIdHeaderValueReadOnly() { var id = Guid.NewGuid(); Assert.Throws <ArgumentException>(() => MessageBuilder <string> .WithPayload("test").SetHeader(MessageHeaders.ID, id)); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"]; int PrimaryPort = (int)ArgumentValues["primary Port"]; int BasePort = (int)ArgumentValues["Base Port"]; log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2})", ServerIp, PrimaryPort, BasePort); bool res = false; Passed = false; ProtocolClient client = new ProtocolClient(); ProfileServer profileServer = null; try { MessageBuilder mb = client.MessageBuilder; // Step 1 log.Trace("Step 1"); // Get port list. await client.ConnectAsync(ServerIp, PrimaryPort, false); Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>(); bool listPortsOk = await client.ListServerPorts(rolePorts); client.CloseConnection(); bool profileInitializationOk = true; byte[] testImageData = File.ReadAllBytes(Path.Combine("images", TestName + ".jpg")); int profileIndex = 1; int profileCount = 10; for (int i = 0; i < profileCount; i++) { ProtocolClient profileClient = new ProtocolClient(); profileClient.InitializeRandomProfile(profileIndex, testImageData); profileIndex++; if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer])) { profileClient.Dispose(); profileInitializationOk = false; break; } TestProfiles.Add(profileClient.Profile.Name, profileClient); } profileServer = new ProfileServer("TestServer", ServerIp, BasePort, client.GetIdentityKeys()); bool serverStartOk = profileServer.Start(); bool step1Ok = listPortsOk && profileInitializationOk && serverStartOk; log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED"); // Step 2 log.Trace("Step 2"); await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true); bool verifyIdentityOk = await client.VerifyIdentityAsync(); // Start neighborhood initialization process. Message requestMessage = mb.CreateStartNeighborhoodInitializationRequest((uint)profileServer.PrimaryPort, (uint)profileServer.ServerNeighborPort); await client.SendMessageAsync(requestMessage); Message responseMessage = await client.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.Ok; bool startNeighborhoodInitializationOk = idOk && statusOk; bool step2Ok = verifyIdentityOk && startNeighborhoodInitializationOk; log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED"); // Step 3 log.Trace("Step 3"); profileInitializationOk = true; profileCount = 5; for (int i = 0; i < profileCount; i++) { ProtocolClient profileClient = new ProtocolClient(); profileClient.InitializeRandomProfile(profileIndex, testImageData); profileIndex++; if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer])) { profileClient.Dispose(); profileInitializationOk = false; break; } TestProfiles.Add(profileClient.Profile.Name, profileClient); } bool step3Ok = profileInitializationOk; log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED"); // Step 4 log.Trace("Step 4"); List <SharedProfileAddItem> remoteProfiles = new List <SharedProfileAddItem>(); // Wait for update request. Message serverRequestMessage = null; Message clientResponseMessage = null; bool typeOk = false; List <SharedProfileAddItem> receivedItems = new List <SharedProfileAddItem>(); bool error = false; while (receivedItems.Count < 10) { serverRequestMessage = await client.ReceiveMessageAsync(); typeOk = serverRequestMessage.MessageTypeCase == Message.MessageTypeOneofCase.Request && serverRequestMessage.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest && serverRequestMessage.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate; clientResponseMessage = mb.CreateNeighborhoodSharedProfileUpdateResponse(serverRequestMessage); await client.SendMessageAsync(clientResponseMessage); if (!typeOk) { break; } foreach (SharedProfileUpdateItem updateItem in serverRequestMessage.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items) { if (updateItem.ActionTypeCase != SharedProfileUpdateItem.ActionTypeOneofCase.Add) { log.Trace("Received invalid update item action type '{0}'.", updateItem.ActionTypeCase); error = true; break; } receivedItems.Add(updateItem.Add); } if (error) { break; } } log.Trace("Received {0} profiles from target profile server.", receivedItems.Count); bool receivedProfilesOk = !error; remoteProfiles.AddRange(receivedItems); bool step4Ok = receivedProfilesOk; log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED"); // Step 5 log.Trace("Step 5"); profileInitializationOk = true; profileCount = 5; for (int i = 0; i < profileCount; i++) { ProtocolClient profileClient = new ProtocolClient(); profileClient.InitializeRandomProfile(profileIndex, testImageData); profileIndex++; if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer])) { profileClient.Dispose(); profileInitializationOk = false; break; } TestProfiles.Add(profileClient.Profile.Name, profileClient); } bool step5Ok = profileInitializationOk; log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED"); // Step 6 log.Trace("Step 6"); // Wait for finish request. serverRequestMessage = await client.ReceiveMessageAsync(); typeOk = serverRequestMessage.MessageTypeCase == Message.MessageTypeOneofCase.Request && serverRequestMessage.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest && serverRequestMessage.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.FinishNeighborhoodInitialization; bool finishNeighborhoodInitializationResponseOk = typeOk; clientResponseMessage = mb.CreateFinishNeighborhoodInitializationResponse(serverRequestMessage); await client.SendMessageAsync(clientResponseMessage); client.CloseConnection(); bool step6Ok = finishNeighborhoodInitializationResponseOk; log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED"); // Step 7 log.Trace("Step 7"); profileInitializationOk = true; profileCount = 5; for (int i = 0; i < profileCount; i++) { ProtocolClient profileClient = new ProtocolClient(); profileClient.InitializeRandomProfile(profileIndex, testImageData); profileIndex++; if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer])) { profileClient.Dispose(); profileInitializationOk = false; break; } TestProfiles.Add(profileClient.Profile.Name, profileClient); } await Task.Delay(20000); // Meanwhile we expect updates to arrive on our simulated profile server. error = false; List <IncomingServerMessage> psMessages = profileServer.GetMessageList(); List <SharedProfileAddItem> addUpdates = new List <SharedProfileAddItem>(); foreach (IncomingServerMessage ism in psMessages) { if (ism.Role != ServerRole.ServerNeighbor) { continue; } Message message = ism.IncomingMessage; if ((message.MessageTypeCase == Message.MessageTypeOneofCase.Request) && (message.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest) && (message.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate)) { foreach (SharedProfileUpdateItem updateItem in message.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items) { if (updateItem.ActionTypeCase == SharedProfileUpdateItem.ActionTypeOneofCase.Add) { SharedProfileAddItem addItem = updateItem.Add; addUpdates.Add(addItem); } else { log.Trace("Received invalid update action type {0}.", updateItem.ActionTypeCase); error = true; break; } } } if (error) { break; } } bool receivedUpdatesOk = !error; remoteProfiles.AddRange(addUpdates); bool profilesOk = client.CheckProfileListMatchAddItems(TestProfiles, remoteProfiles); bool step7Ok = profileInitializationOk && receivedUpdatesOk && profilesOk; log.Trace("Step 7: {0}", step7Ok ? "PASSED" : "FAILED"); Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok && step7Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } client.Dispose(); foreach (ProtocolClient protocolClient in TestProfiles.Values) { protocolClient.Dispose(); } if (profileServer != null) { profileServer.Shutdown(); } log.Trace("(-):{0}", res); return(res); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"]; int PrimaryPort = (int)ArgumentValues["primary Port"]; log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort); bool res = false; Passed = false; ProtocolClient client = new ProtocolClient(); try { MessageBuilder mb = client.MessageBuilder; // Step 1 log.Trace("Step 1"); // Get port list. await client.ConnectAsync(ServerIp, PrimaryPort, false); Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>(); bool listPortsOk = await client.ListServerPorts(rolePorts); client.CloseConnection(); await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true); bool hostingOk = await client.EstablishHostingAsync("Test"); client.CloseConnection(); await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true); bool checkInOk = await client.CheckInAsync(); bool step1Ok = listPortsOk && hostingOk && checkInOk; log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED"); // Step 2 log.Trace("Step 2"); byte[] serverId = new byte[5] { 0x40, 0x40, 0x40, 0x40, 0x40 }; List <CanKeyValue> clientData = new List <CanKeyValue>() { new CanKeyValue() { Key = "key1", StringValue = "value 1" }, new CanKeyValue() { Key = "key2", Uint32Value = 2 }, new CanKeyValue() { Key = "key3", BoolValue = true }, new CanKeyValue() { Key = "key4", BinaryValue = ProtocolHelper.ByteArrayToByteString(new byte[] { 1, 2, 3 }) }, }; CanIdentityData identityData1 = new CanIdentityData() { HostingServerId = ProtocolHelper.ByteArrayToByteString(serverId) }; identityData1.KeyValueList.AddRange(clientData); Message requestMessage = mb.CreateCanStoreDataRequest(identityData1); await client.SendMessageAsync(requestMessage); Message responseMessage = await client.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.ErrorInvalidValue; bool detailsOk = responseMessage.Response.Details == "data.hostingServerId"; // Step 2 Acceptance bool step2Ok = idOk && statusOk && detailsOk; log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED"); Passed = step1Ok && step2Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } client.Dispose(); log.Trace("(-):{0}", res); return(res); }
public bool IsExisting(string appId) { using (var cmd = new DBCommand()) { try { var od = AppCore.AppSingleton.FindObjDef<StatusObjDef>(); return StatusDAL.IsExisting(cmd, new Dictionary<IAttributeDefinition, object>() { { od.ID, appId } }); } catch (Exception ex) { using (var builder = new MessageBuilder()) { string err = builder.AppendLine("查找状态记录错误!").AppendLine(ex).Message; throw new Exception(err); } } } }
public static MessageBuilder User(this MessageBuilder builder, User user, Func <User, long> avatarid) { return(User(builder, user, avatarid(user))); }
/// <summary> /// Gets active consumers of channel /// </summary> public async Task GetChannelConsumers(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); //if auto creation active, try to create channel if (channel == null && _server.Options.AutoChannelCreation) { channel = _server.FindOrCreateChannel(message.Target); } if (channel == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } bool grant = await _server.AdminAuthorization.CanReceiveChannelConsumers(client, channel); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } List <ClientInformation> list = new List <ClientInformation>(); foreach (ChannelClient cc in channel.ClientsClone) { list.Add(new ClientInformation { Id = cc.Client.UniqueId, Name = cc.Client.Name, Type = cc.Client.Type, IsAuthenticated = cc.Client.IsAuthenticated, Online = cc.JoinDate.LifetimeMilliseconds(), }); } TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.ChannelConsumers; await response.SetJsonContent(list); await client.SendAsync(response); }
public void CustomConversionServiceFailure() { var conversionService = new GenericConversionService(); var instance = CreateInstance(conversionService); Assert.False(conversionService.CanConvert(typeof(int), typeof(string))); var invocableHandlerMethod = CreateInvocableHandlerMethod(instance, "SimpleString", typeof(string)); Assert.Throws <MessageConversionException>(() => invocableHandlerMethod.Invoke(MessageBuilder.WithPayload(123).Build())); }
public void CustomMessageConverterFailure() { IMessageConverter messageConverter = new ByteArrayMessageConverter(); var instance = CreateInstance(messageConverter); var invocableHandlerMethod = CreateInvocableHandlerMethod(instance, "SimpleString", typeof(string)); Assert.Throws <MessageConversionException>(() => invocableHandlerMethod.Invoke(MessageBuilder.WithPayload(123).Build())); }
public ReplacePlaceHolders(MessageBuilder messageBuilder) { _messageBuilder = messageBuilder; }
public void MessageCall() { var mb = MessageBuilder.Create(); { var w = mb.BuildRoot <Message.WRITER>(); w.which = Message.WHICH.Call; Assert.AreEqual(Message.WHICH.Call, w.which); w.Call.AllowThirdPartyTailCall = true; w.Call.InterfaceId = ulong.MaxValue; w.Call.MethodId = 0x1111; w.Call.Params.CapTable.Init(6); w.Call.Params.CapTable[0].which = CapDescriptor.WHICH.None; w.Call.Params.CapTable[1].which = CapDescriptor.WHICH.ReceiverAnswer; w.Call.Params.CapTable[1].ReceiverAnswer.QuestionId = 0x12345678u; w.Call.Params.CapTable[1].ReceiverAnswer.Transform.Init(2); w.Call.Params.CapTable[1].ReceiverAnswer.Transform[0].which = PromisedAnswer.Op.WHICH.GetPointerField; w.Call.Params.CapTable[1].ReceiverAnswer.Transform[0].GetPointerField = 0x2222; w.Call.Params.CapTable[1].ReceiverAnswer.Transform[1].which = PromisedAnswer.Op.WHICH.Noop; w.Call.Params.CapTable[2].which = CapDescriptor.WHICH.ReceiverHosted; w.Call.Params.CapTable[2].ReceiverHosted = 12345678u; w.Call.Params.CapTable[3].which = CapDescriptor.WHICH.SenderHosted; w.Call.Params.CapTable[3].SenderHosted = 23456789u; w.Call.Params.CapTable[4].which = CapDescriptor.WHICH.SenderPromise; w.Call.Params.CapTable[4].SenderPromise = 34567890u; w.Call.Params.CapTable[5].which = CapDescriptor.WHICH.ThirdPartyHosted; w.Call.Params.CapTable[5].ThirdPartyHosted.Id.SetStruct(1, 0); w.Call.Params.CapTable[5].ThirdPartyHosted.Id.WriteData(0, double.Epsilon); w.Call.Params.CapTable[5].ThirdPartyHosted.VineId = 111111u; Assert.AreEqual(CapDescriptor.WHICH.None, w.Call.Params.CapTable[0].which); Assert.AreEqual(CapDescriptor.WHICH.ReceiverAnswer, w.Call.Params.CapTable[1].which); Assert.AreEqual(CapDescriptor.WHICH.ReceiverHosted, w.Call.Params.CapTable[2].which); Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, w.Call.Params.CapTable[3].which); Assert.AreEqual(CapDescriptor.WHICH.SenderPromise, w.Call.Params.CapTable[4].which); Assert.AreEqual(CapDescriptor.WHICH.ThirdPartyHosted, w.Call.Params.CapTable[5].which); var content = w.Call.Params.Content.Rewrap <DynamicSerializerState>(); content.SetStruct(1, 0); content.WriteData(0, double.PositiveInfinity); w.Call.QuestionId = 0x77777777u; w.Call.SendResultsTo.which = Call.sendResultsTo.WHICH.ThirdParty; w.Call.SendResultsTo.ThirdParty.SetStruct(1, 0); w.Call.SendResultsTo.ThirdParty.WriteData(0, double.NegativeInfinity); w.Call.Target.which = MessageTarget.WHICH.PromisedAnswer; w.Call.Target.PromisedAnswer.QuestionId = 5555555u; } var r = Message.READER.create(DeserializerState.CreateRoot(mb.Frame)); Assert.AreEqual(Message.WHICH.Call, r.which); Assert.IsTrue(r.Call.AllowThirdPartyTailCall); Assert.AreEqual(ulong.MaxValue, r.Call.InterfaceId); Assert.AreEqual((ushort)0x1111, r.Call.MethodId); var capTable = r.Call.Params.CapTable; Assert.AreEqual(6, capTable.Count); Assert.AreEqual(CapDescriptor.WHICH.None, capTable[0].which); Assert.AreEqual(CapDescriptor.WHICH.ReceiverAnswer, capTable[1].which); Assert.AreEqual(0x12345678u, capTable[1].ReceiverAnswer.QuestionId); var transform = capTable[1].ReceiverAnswer.Transform; Assert.AreEqual(2, transform.Count); Assert.AreEqual(PromisedAnswer.Op.WHICH.GetPointerField, transform[0].which); Assert.AreEqual((ushort)0x2222, transform[0].GetPointerField); Assert.AreEqual(PromisedAnswer.Op.WHICH.Noop, transform[1].which); Assert.AreEqual(CapDescriptor.WHICH.ReceiverHosted, capTable[2].which); Assert.AreEqual(12345678u, capTable[2].ReceiverHosted); Assert.AreEqual(CapDescriptor.WHICH.SenderHosted, capTable[3].which); Assert.AreEqual(23456789u, capTable[3].SenderHosted); Assert.AreEqual(CapDescriptor.WHICH.SenderPromise, capTable[4].which); Assert.AreEqual(34567890u, capTable[4].SenderPromise); Assert.AreEqual(CapDescriptor.WHICH.ThirdPartyHosted, capTable[5].which); var tph = capTable[5].ThirdPartyHosted; Assert.AreEqual(ObjectKind.Struct, tph.Id.Kind); Assert.AreEqual(double.Epsilon, tph.Id.ReadDataDouble(0)); Assert.AreEqual(111111u, tph.VineId); Assert.AreEqual(ObjectKind.Struct, r.Call.Params.Content.Kind); Assert.AreEqual(double.PositiveInfinity, r.Call.Params.Content.ReadDataDouble(0)); Assert.AreEqual(0x77777777u, r.Call.QuestionId); var srt = r.Call.SendResultsTo; Assert.AreEqual(Call.sendResultsTo.WHICH.ThirdParty, srt.which); Assert.AreEqual(ObjectKind.Struct, srt.ThirdParty.Kind); Assert.AreEqual(double.NegativeInfinity, srt.ThirdParty.ReadDataDouble(0)); Assert.AreEqual(MessageTarget.WHICH.PromisedAnswer, r.Call.Target.which); Assert.AreEqual(5555555u, r.Call.Target.PromisedAnswer.QuestionId); }
static void Main(string[] args) { bool isServer = false; int port = 10000; if (args.Length > 0) { isServer = args[0].Equals("server"); } else { Console.WriteLine("Is this a server?"); var response = Console.ReadLine().Trim().ToLower(); isServer = response.Equals("yes") || response.Equals("y"); } string strport; if (args.Length > 1) { strport = args[1]; } else { Console.WriteLine("What port?"); strport = Console.ReadLine().Trim(); } int temp; if (int.TryParse(strport, out temp)) port = temp; if (isServer) { var server = new OscUdpServer( new OscEndpoint(port) ); server.MessageReceived += (s, e) => { Console.WriteLine("Message received:"); PrintMessage(e.Message); }; Console.WriteLine("Begin listening on port {0}", port); server.BeginListen(); Console.WriteLine("Press 'q' to quit..."); var value = ""; while (value.ToLower() != "q") { value = Console.ReadLine(); } } else { var client = new OscUdpClient( new OscEndpoint(port) ); Console.WriteLine("Begin sending messages on port {0}", port); client.Connect(); Console.WriteLine("Enter message data, or type 'q' to quit.\r\nEx: /foo/bar iii 1 2 3"); var value = Console.ReadLine().Trim(); while (value.ToLower() != "q") { var parts = value.Split(new string[] { " " }, StringSplitOptions.None); var builder = new MessageBuilder(); try { builder.SetAddress(parts[0]); for (int i = 0; i < parts[1].Length; i++) { switch (parts[1][i]) { case 'i': builder.PushAtom(int.Parse(parts[2 + i])); break; case 'f': builder.PushAtom(float.Parse(parts[2 + i])); break; case 's': builder.PushAtom(parts[2 + i]); break; case 'b': builder.PushAtom(Encoding.ASCII.GetBytes(parts[2 + i])); break; } } Console.WriteLine("Sending message..."); try { client.SendMessage(builder.ToMessage()); } catch (Exception exc) { Console.WriteLine("Failed to send message: {0}", exc.Message); } Console.WriteLine("Message Sent!"); } catch (Exception ex) { Console.WriteLine("Failed to build message: {0}", ex.Message); } value = Console.ReadLine().Trim(); } } }
public void SendChatPacket(WorldObject source, MessageBuilder builder, ChatMsg msgType, WorldObject whisperTarget = null, CreatureTextRange range = CreatureTextRange.Normal, Team team = Team.Other, bool gmOnly = false) { if (source == null) { return; } var localizer = new CreatureTextLocalizer(builder, msgType); switch (msgType) { case ChatMsg.MonsterWhisper: case ChatMsg.RaidBossWhisper: { if (range == CreatureTextRange.Normal) //ignores team and gmOnly { if (!whisperTarget || !whisperTarget.IsTypeId(TypeId.Player)) { return; } localizer.Invoke(whisperTarget.ToPlayer()); return; } break; } default: break; } switch (range) { case CreatureTextRange.Area: { uint areaId = source.GetAreaId(); var players = source.GetMap().GetPlayers(); foreach (var pl in players) { if (pl.GetAreaId() == areaId && (team == 0 || pl.GetTeam() == team) && (!gmOnly || pl.IsGameMaster())) { localizer.Invoke(pl); } } return; } case CreatureTextRange.Zone: { uint zoneId = source.GetZoneId(); var players = source.GetMap().GetPlayers(); foreach (var pl in players) { if (pl.GetZoneId() == zoneId && (team == 0 || pl.GetTeam() == team) && (!gmOnly || pl.IsGameMaster())) { localizer.Invoke(pl); } } return; } case CreatureTextRange.Map: { var players = source.GetMap().GetPlayers(); foreach (var pl in players) { if ((team == 0 || pl.GetTeam() == team) && (!gmOnly || pl.IsGameMaster())) { localizer.Invoke(pl); } } return; } case CreatureTextRange.World: { var smap = Global.WorldMgr.GetAllSessions(); foreach (var session in smap) { Player player = session.GetPlayer(); if (player != null) { if ((team == 0 || player.GetTeam() == team) && (!gmOnly || player.IsGameMaster())) { localizer.Invoke(player); } } } return; } case CreatureTextRange.Normal: default: break; } float dist = GetRangeForChatType(msgType); var worker = new PlayerDistWorker(source, dist, localizer); Cell.VisitWorldObjects(source, worker, dist); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"]; int PrimaryPort = (int)ArgumentValues["primary Port"]; log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort); bool res = false; Passed = false; ProtocolClient client = new ProtocolClient(); try { MessageBuilder mb = client.MessageBuilder; // Step 1 log.Trace("Step 1"); // Get port list. await client.ConnectAsync(ServerIp, PrimaryPort, false); Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>(); bool listPortsOk = await client.ListServerPorts(rolePorts); client.CloseConnection(); bool profileInitializationOk = true; byte[] testImageData = File.ReadAllBytes(Path.Combine("images", TestName + ".jpg")); int profileIndex = 1; int profileCount = 10; for (int i = 0; i < profileCount; i++) { ProtocolClient profileClient = new ProtocolClient(); profileClient.InitializeRandomProfile(profileIndex, testImageData); profileIndex++; if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer])) { profileClient.Dispose(); profileInitializationOk = false; break; } TestProfiles.Add(profileClient.Profile.Name, profileClient); } bool step1Ok = listPortsOk && profileInitializationOk; log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED"); // Step 2 log.Trace("Step 2"); await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true); bool verifyIdentityOk = await client.VerifyIdentityAsync(); // Start neighborhood initialization process. Message requestMessage = mb.CreateStartNeighborhoodInitializationRequest(1, 1); await client.SendMessageAsync(requestMessage); Message responseMessage = await client.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.Ok; bool startNeighborhoodInitializationOk = idOk && statusOk; // Wait for update request. Message serverRequestMessage = null; Message clientResponseMessage = null; bool typeOk = false; List <SharedProfileAddItem> receivedItems = new List <SharedProfileAddItem>(); bool error = false; while (receivedItems.Count < TestProfiles.Count) { serverRequestMessage = await client.ReceiveMessageAsync(); typeOk = serverRequestMessage.MessageTypeCase == Message.MessageTypeOneofCase.Request && serverRequestMessage.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest && serverRequestMessage.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate; clientResponseMessage = mb.CreateNeighborhoodSharedProfileUpdateResponse(serverRequestMessage); await client.SendMessageAsync(clientResponseMessage); if (!typeOk) { break; } foreach (SharedProfileUpdateItem updateItem in serverRequestMessage.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items) { if (updateItem.ActionTypeCase != SharedProfileUpdateItem.ActionTypeOneofCase.Add) { log.Trace("Received invalid update item action type '{0}'.", updateItem.ActionTypeCase); error = true; break; } receivedItems.Add(updateItem.Add); } if (error) { break; } } log.Trace("Received {0} profiles from target profile server.", receivedItems.Count); bool receivedProfilesOk = !error && client.CheckProfileListMatchAddItems(TestProfiles, receivedItems); log.Trace("Waiting 450 seconds ..."); await Task.Delay(450 * 1000); client.CloseConnection(); bool step2Ok = verifyIdentityOk && startNeighborhoodInitializationOk && receivedProfilesOk; log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED"); // Step 3 log.Trace("Step 3"); await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true); bool neighborhoodInitializationProcessOk = await client.NeighborhoodInitializationProcessAsync(1, 1, TestProfiles); bool step3Ok = neighborhoodInitializationProcessOk; log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED"); Passed = step1Ok && step2Ok && step3Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } client.Dispose(); foreach (ProtocolClient protocolClient in TestProfiles.Values) { protocolClient.Dispose(); } log.Trace("(-):{0}", res); return(res); }
public void MessageWithMoreThanOneMessageIdAttributeThrowExcptionEvenWithIdsSetToNull() { var invalidMessage = new MessageWithTooManyMessageIds(); Assert.Throws <Exception>(() => MessageBuilder.GetMessageId(invalidMessage)); }
internal void SendMessage(string text, MessagePriority priority = MessagePriority.Default) { chat.DoSend(MessageBuilder.PrivMsg(chat.UserName, Name, text), chat.ChatLimiter, priority); }
/// <summary> /// Initializes a new instance of the <see cref="DW.CodedUI.WindowNotFoundException" /> class. /// </summary> /// <param name="use">The conditions how the window has been searched.</param> /// <param name="useTimeout">A value that indicates if a timeout was used.</param> /// <param name="useInterval">A value that indicates if an interval was used.</param> /// <param name="intervalTime">The time used in the interval.</param> /// <param name="timeout">The elapsed search time.</param> /// <param name="is">The relationship to another object.</param> public WindowNotFoundException(Use use, bool useTimeout, bool useInterval, uint intervalTime, TimeSpan timeout, Is @is) : base(MessageBuilder.BuildErrorMessage(use, useTimeout, useInterval, intervalTime, timeout, @is)) { }
private void ResetErrorMessage() { currentErrorMessage = null; currentErrorBuilder = null; }
public CreatureTextLocalizer(MessageBuilder builder, ChatMsg msgType) { _builder = builder; _msgType = msgType; }
static void TestMessageToBytes() { var messageBuilder = new MessageBuilder(); messageBuilder.SetAddress("/a/b/c"); messageBuilder.PushAtom(123); messageBuilder.PushAtom(321.123f); messageBuilder.PushAtom("foObar"); messageBuilder.PushAtom(Encoding.ASCII.GetBytes("foObarR")); var message = messageBuilder.ToMessage(); PrintMessage(message); var parser = new MessageParser(); var bytes = parser.Parse(message); // round trip var newmessage = parser.Parse(bytes); System.Diagnostics.Debug.Assert(message.Equals(newmessage), "Roundtrip messages are not equal."); PrintMessage(newmessage); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"]; int PrimaryPort = (int)ArgumentValues["primary Port"]; log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort); bool res = false; Passed = false; ProtocolClient clientCallee = new ProtocolClient(); ProtocolClient clientCalleeAppService = new ProtocolClient(0, SemVer.V100, clientCallee.GetIdentityKeys()); ProtocolClient clientCaller = new ProtocolClient(); ProtocolClient clientCallerAppService = new ProtocolClient(0, SemVer.V100, clientCaller.GetIdentityKeys()); try { MessageBuilder mbCallee = clientCallee.MessageBuilder; MessageBuilder mbCalleeAppService = clientCalleeAppService.MessageBuilder; MessageBuilder mbCaller = clientCaller.MessageBuilder; MessageBuilder mbCallerAppService = clientCallerAppService.MessageBuilder; // Step 1 log.Trace("Step 1"); // Get port list. byte[] pubKeyCallee = clientCallee.GetIdentityKeys().PublicKey; byte[] identityIdCallee = clientCallee.GetIdentityId(); byte[] pubKeyCaller = clientCaller.GetIdentityKeys().PublicKey; byte[] identityIdCaller = clientCaller.GetIdentityId(); await clientCallee.ConnectAsync(ServerIp, PrimaryPort, false); Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>(); bool listPortsOk = await clientCallee.ListServerPorts(rolePorts); clientCallee.CloseConnection(); // Establish hosting agreement for identity 1. await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true); bool establishHostingOk = await clientCallee.EstablishHostingAsync(); clientCallee.CloseConnection(); // Check-in and initialize the profile of identity 1. await clientCallee.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClCustomer], true); bool checkInOk = await clientCallee.CheckInAsync(); bool initializeProfileOk = await clientCallee.InitializeProfileAsync("Test Identity", null, new GpsLocation(0, 0), null); // Add application service to the current session. string serviceName = "Test Service"; bool addAppServiceOk = await clientCallee.AddApplicationServicesAsync(new List <string>() { serviceName }); // Step 1 Acceptance bool step1Ok = listPortsOk && establishHostingOk && checkInOk && initializeProfileOk && addAppServiceOk; log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED"); // Step 2 log.Trace("Step 2"); await clientCaller.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true); bool verifyIdentityOk = await clientCaller.VerifyIdentityAsync(); Message requestMessage = mbCaller.CreateCallIdentityApplicationServiceRequest(identityIdCallee, serviceName); await clientCaller.SendMessageAsync(requestMessage); // Step 2 Acceptance bool step2Ok = verifyIdentityOk; log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED"); // Step 3 log.Trace("Step 3"); Message serverRequestMessage = await clientCallee.ReceiveMessageAsync(); byte[] receivedPubKey = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CallerPublicKey.ToByteArray(); bool pubKeyOk = StructuralComparisons.StructuralComparer.Compare(receivedPubKey, pubKeyCaller) == 0; bool serviceNameOk = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.ServiceName == serviceName; bool incomingCallNotificationOk = pubKeyOk && serviceNameOk; byte[] calleeToken = serverRequestMessage.Request.ConversationRequest.IncomingCallNotification.CalleeToken.ToByteArray(); Message serverResponseMessage = mbCallee.CreateIncomingCallNotificationResponse(serverRequestMessage); await clientCallee.SendMessageAsync(serverResponseMessage); // Connect to clAppService and send initialization message. await clientCalleeAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true); Message requestMessageAppServiceCallee = mbCalleeAppService.CreateApplicationServiceSendMessageRequest(calleeToken, null); await clientCalleeAppService.SendMessageAsync(requestMessageAppServiceCallee); // Step 3 Acceptance bool step3Ok = incomingCallNotificationOk; log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED"); // Step 4 log.Trace("Step 4"); Message responseMessage = await clientCaller.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.Ok; byte[] callerToken = responseMessage.Response.ConversationResponse.CallIdentityApplicationService.CallerToken.ToByteArray(); bool callIdentityOk = idOk && statusOk; // Connect to clAppService and send initialization message. await clientCallerAppService.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClAppService], true); Message requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, null); await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller); Message responseMessageAppServiceCaller = await clientCallerAppService.ReceiveMessageAsync(); idOk = responseMessageAppServiceCaller.Id == requestMessageAppServiceCaller.Id; statusOk = responseMessageAppServiceCaller.Response.Status == Status.Ok; bool initAppServiceMessageOk = idOk && statusOk; // And close connection to clNonCustomer port. clientCaller.CloseConnection(); // Step 4 Acceptance bool step4Ok = callIdentityOk && initAppServiceMessageOk; log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED"); // Step 5 log.Trace("Step 5"); Message responseMessageAppServiceCallee = await clientCalleeAppService.ReceiveMessageAsync(); idOk = responseMessageAppServiceCallee.Id == requestMessageAppServiceCallee.Id; statusOk = responseMessageAppServiceCallee.Response.Status == Status.Ok; bool typeOk = (responseMessageAppServiceCallee.MessageTypeCase == Message.MessageTypeOneofCase.Response) && (responseMessageAppServiceCallee.Response.ConversationTypeCase == Response.ConversationTypeOneofCase.SingleResponse) && (responseMessageAppServiceCallee.Response.SingleResponse.ResponseTypeCase == SingleResponse.ResponseTypeOneofCase.ApplicationServiceSendMessage); bool appServiceSendOk = idOk && statusOk && typeOk; clientCalleeAppService.CloseConnection(); // Step 5 Acceptance bool step5Ok = appServiceSendOk; log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED"); // Step 6 log.Trace("Step 6"); await Task.Delay(2000); // We should be disconnected now, send or receive should throw. string callerMessage1 = "Message #1 to callee."; byte[] messageBytes = Encoding.UTF8.GetBytes(callerMessage1); requestMessageAppServiceCaller = mbCallerAppService.CreateApplicationServiceSendMessageRequest(callerToken, messageBytes); bool disconnectedOk = false; try { await clientCallerAppService.SendMessageAsync(requestMessageAppServiceCaller); await clientCallerAppService.ReceiveMessageAsync(); } catch { log.Trace("Expected exception occurred."); disconnectedOk = true; } // Step 6 Acceptance bool step6Ok = disconnectedOk; log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED"); Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } clientCallee.Dispose(); clientCalleeAppService.Dispose(); clientCaller.Dispose(); clientCallerAppService.Dispose(); log.Trace("(-):{0}", res); return(res); }
/// <summary> /// Writes the response back to the original sender. /// </summary> /// <param name="mb">The <see cref="MessageBuilder"/> containing the data to write</param> /// <param name="requestComplete">Indicates if this completes the transaction (all responses and callbacks have been written)</param> public void WriteResponse(MessageBuilder mb, bool requestComplete) { Write(socket, mb, TIMEOUT_ERROR_RESPONSE, RESPONSE_SUCCESS_TAG, false, requestComplete); }
/// <summary> /// Implementation of the test itself. /// </summary> /// <returns>true if the test passes, false otherwise.</returns> public override async Task <bool> RunAsync() { IPAddress NodeIp = (IPAddress)ArgumentValues["Node IP"]; int PrimaryPort = (int)ArgumentValues["primary Port"]; log.Trace("(NodeIp:'{0}',PrimaryPort:{1})", NodeIp, PrimaryPort); bool res = false; Passed = false; ProtocolClient clientCallee = new ProtocolClient(); ProtocolClient clientCalleeAppService = new ProtocolClient(0, new byte[] { 1, 0, 0 }, clientCallee.GetIdentityKeys()); ProtocolClient clientCaller = new ProtocolClient(); ProtocolClient clientCallerAppService = new ProtocolClient(0, new byte[] { 1, 0, 0 }, clientCaller.GetIdentityKeys()); try { MessageBuilder mbCallee = clientCallee.MessageBuilder; MessageBuilder mbCalleeAppService = clientCalleeAppService.MessageBuilder; MessageBuilder mbCaller = clientCaller.MessageBuilder; MessageBuilder mbCallerAppService = clientCallerAppService.MessageBuilder; // Step 1 log.Trace("Step 1"); // Get port list. byte[] pubKeyCallee = clientCallee.GetIdentityKeys().PublicKey; byte[] identityIdCallee = clientCallee.GetIdentityId(); byte[] pubKeyCaller = clientCaller.GetIdentityKeys().PublicKey; byte[] identityIdCaller = clientCaller.GetIdentityId(); await clientCallee.ConnectAsync(NodeIp, PrimaryPort, false); Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>(); bool listPortsOk = await clientCallee.ListNodePorts(rolePorts); clientCallee.CloseConnection(); // Establish home node for identity 1. await clientCallee.ConnectAsync(NodeIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true); bool establishHomeNodeOk = await clientCallee.EstablishHomeNodeAsync(); clientCallee.CloseConnection(); // Check-in and initialize the profile of identity 1. await clientCallee.ConnectAsync(NodeIp, (int)rolePorts[ServerRoleType.ClCustomer], true); bool checkInOk = await clientCallee.CheckInAsync(); bool initializeProfileOk = await clientCallee.InitializeProfileAsync("Test Identity", null, 0x12345678, null); clientCallee.CloseConnection(); // Step 1 Acceptance bool step1Ok = listPortsOk && establishHomeNodeOk && checkInOk && initializeProfileOk; log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED"); // Step 2 log.Trace("Step 2"); await clientCaller.ConnectAsync(NodeIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true); bool verifyIdentityOk = await clientCaller.VerifyIdentityAsync(); Message requestMessage = mbCaller.CreateCallIdentityApplicationServiceRequest(identityIdCallee, "Test Service"); await clientCaller.SendMessageAsync(requestMessage); Message responseMessage = await clientCaller.ReceiveMessageAsync(); bool idOk = responseMessage.Id == requestMessage.Id; bool statusOk = responseMessage.Response.Status == Status.ErrorNotAvailable; bool callIdentityOk = idOk && statusOk; // Step 2 Acceptance bool step2Ok = verifyIdentityOk && callIdentityOk; log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED"); Passed = step1Ok && step2Ok; res = true; } catch (Exception e) { log.Error("Exception occurred: {0}", e.ToString()); } clientCallee.Dispose(); clientCalleeAppService.Dispose(); clientCaller.Dispose(); clientCallerAppService.Dispose(); log.Trace("(-):{0}", res); return(res); }