/// <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);
}
