public MessageClient AddSubscriber(IClient client, string messageClientId, string endpointId, MessageDestination messageDestination, Subtopic subtopic, Selector selector)
{
lock (_objLock)
{
if (subtopic != null)
{
MessagingAdapter serviceAdapter = this._messageDestination.ServiceAdapter as MessagingAdapter;
if ((serviceAdapter != null) && !serviceAdapter.AllowSubscribe(subtopic))
{
ASObject extendedData = new ASObject();
extendedData["subtopic"] = subtopic.Value;
throw new MessageException(extendedData);
}
}
if (!this._subscribers.Contains(messageClientId))
{
MessageClient messageClient = new MessageClient(client, messageDestination.SubscriptionManager, messageClientId, endpointId, messageDestination)
{
Subtopic = subtopic,
Selector = selector
};
client.RegisterMessageClient(messageClient);
this.AddSubscriber(messageClient);
return(messageClient);
}
return(this._subscribers[messageClientId] as MessageClient);
}
}
public override void Push(IMessage message, MessageClient messageClient)
{
if (this.ChannelDefinition.Properties.IsPollingEnabled)
{
IEndpointPushHandler handler = messageClient.Client.GetEndpointPushHandler(this.Id);
if (handler != null)
{
IMessage messageClone = message.Copy() as IMessage;
messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
messageClone.clientId = messageClient.ClientId;
handler.PushMessage(messageClone);
}
/*
* IMessage messageClone = message.Clone() as IMessage;
* messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
* messageClone.clientId = messageClient.ClientId;
* messageClient.AddMessage(messageClone);
*/
}
else
{
if (log.IsWarnEnabled)
{
log.Warn("Push request received for the non-polling AMF endpoint '" + this.Id + "'");
}
}
}
public async Task SendMessageOneWay_FromHost_1000x()
{
TestMessageProcessor.Count = 0;
using (var listener = new MessageListener(registry)) {
using (var client = new MessageClient(registry)) {
listener.ConnectionReceived += (sender, e) => {
for (var i = 0; i < 1000; i++)
{
e.Host.SendOneWay(new TestRequestOneWayMessage());
}
e.Host.Stop();
};
listener.Listen(IPAddress.Loopback, 10934);
await client.ConnectAsync("localhost", 10934, CancellationToken.None);
await Task.Delay(200);
client.Disconnect();
}
Assert.That(TestMessageProcessor.Count, Is.EqualTo(1_000));
listener.Stop();
}
}
/// <summary>
/// 开启客户版客户端
/// </summary>
public void Start()
{
httpProxy = new HttpProxy();
_MouseAndKeyHelper = new MouseAndKeyHelper();
_mCleint = new MessageClient(this._userName, this.Dgcode);
_mCleint.OnMessage += webCient_OnMessage;
_mCleint.OnNotice += _mClient_OnNotice;
var isConnected = _mCleint.Connect();
_mCleint.isCloseing = false;
cts = new CancellationTokenSource();
if (timer == null)
{
timer = new System.Windows.Forms.Timer();
}
timer.Interval = 1000;//每秒查询一次鼠标和键盘休闲时间
timer.Tick += new EventHandler(timer_Event);
}
public async void Start()
{
MessageClient messageClient = App.Current.Resources["MessageClient"] as MessageClient;
messageClient.DataReceived += messageClient_DataReceived;
if (await messageClient.Start(IpAddress, PortNumber))
{
messageClient.SubscribeToData(Devices.PIBRELLA, Pibrella.OBJECT_GREEN_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.PIBRELLA, Pibrella.OBJECT_YELLOW_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.PIBRELLA, Pibrella.OBJECT_RED_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.PIBRELLA, Pibrella.OBJECT_BUTTON, Pibrella.DATA_BUTTON_STATUS);
//messageClient.SubscribeToServerState(ServerStates.STATE_NETDUINO_ISCONNECTED);
//messageClient.SubscribeToServerState(ServerStates.STATE_RASPBERRYPIB_ISCONNECTED);
//messageClient.SubscribeToServerState(ServerStates.STATE_WINDOWSPHONE_ISCONNECTED);
//messageClient.SubscribeToServerState(ServerStates.STATE_SURFACE_ISCONNECTED);
//messageClient.SubscribeToServerState(ServerStates.STATE_VOLTAGE_CONTROL);
messageClient.PublishCommand(Devices.PIBRELLA, Pibrella.OBJECT_GREEN_LED, Pibrella.COMMAND_TOGGLE_LED);
messageClient.PublishCommand(Devices.PIBRELLA, Pibrella.OBJECT_YELLOW_LED, Pibrella.COMMAND_TOGGLE_LED);
messageClient.PublishCommand(Devices.PIBRELLA, Pibrella.OBJECT_RED_LED, Pibrella.COMMAND_TOGGLE_LED);
messageClient.PublishCommand(Devices.PIBRELLA, Pibrella.OBJECT_BUTTON, Pibrella.COMMAND_BUTTON_PRESSED);
}
}
public IAsyncEnumerable <Message> GetMessagesBy(User user, MessageClient client, int MessagesCount)
{
if (user is null)
{
return(null);
}
switch (client)
{
case MessageClient.Sender:
{
var entity = GetAllAsNoTracking()
.Where(j => j.SenderId == user.Id)
.OrderByDescending(x => x.dateTime)
.Take(MessagesCount)
.ToAsyncEnumerable();
return(entity);
}
case MessageClient.Receiver:
{
var entity = GetAllAsNoTracking()
.Where(j => j.ReceiverId == user.Id)
.OrderByDescending(x => x.dateTime)
.Take(MessagesCount)
.ToAsyncEnumerable();
return(entity);
}
}
return(null);
}
public String PostRequest(Iso8583Request req)
{
byte[] reqMsg = null;
if (req.RequestString != null)
{
String sReq = req.RequestString.Trim();
if (String.IsNullOrEmpty(sReq))
{
throw new HttpResponseException(HttpStatusCode.NoContent);
}
System.Text.RegularExpressions.Regex ws = new System.Text.RegularExpressions.Regex(@"\s+");
sReq = ws.Replace(sReq, "");
reqMsg = MessageUtility.StringToHex(sReq, true);
if (reqMsg == null)
{
//throw new HttpResponseException(HttpStatusCode.InternalServerError);
_outputData = "Error: Invalid request message string (not valid hexadecimal)";
}
}
try
{
MessageClient client = new MessageClient(req.ServerHost, req.ServerPort, null, this.PrintModel);
client.IsSslEnabled = req.IsSSL;
if (req.RequestString != null)
{
if (reqMsg != null)
{
client.SendBytes(reqMsg);
}
}
else
{
client.Model = HttpContext.Current.Session != null ? HttpContext.Current.Session["model"] : null;
if (client.Model != null)
{
_iso8583ResponseEvent.Reset();
client.SendModel();
_iso8583ResponseEvent.WaitOne();
}
else
{
_outputData = "Error: Invalid request message (cannot be null value)";
}
}
}
catch
{
//throw new HttpResponseException(HttpStatusCode.InternalServerError);
_outputData = "Error: Cannot send request message to ISO 8583 server.";
}
if (_outputData.IndexOf("Error: ") == 0)
{
Logger.GetInstance().WriteLine(_outputData);
}
return(_outputData);
}
public System.Threading.Tasks.Task PublishAsync <TEvent>(string topic, TEvent domainEvent) where TEvent : class, IEvent
{
return(Task.Factory.StartNew(() =>
{
var topicBytes = MessageClient.TextToBytes(topic);
var content = MessageClient.ObjectToJsonString(domainEvent);
var contentBytes = MessageClient.TextToBytes(content);
var lenBytes = BitConverter.GetBytes(topicBytes.Length);
var body = new byte[topicBytes.Length + contentBytes.Length + 4];
Array.Copy(lenBytes, 0, body, 0, 4);
Array.Copy(topicBytes, 0, body, 4, topicBytes.Length);
Array.Copy(contentBytes, 0, body, 4 + topicBytes.Length, contentBytes.Length);
try
{
MessageClient.Current.SendBytes(new byte[] { 0x01, 0x00, 0x00, 0x02 }, body);
Task.Factory.StartNew(() =>
{
TryFailedItems();
});
}
catch (Exception) //只关心发送，数据转换失败必须由调用方处理
{
if (body != null && body.Length > 0)
{
SaveFailedItem(topic, body);
}
}
}));
}
private void startButton_Click(object sender, EventArgs e)
{
startButton.Enabled = false;
configGroupBox.Enabled = false;
clickGroupBox.Enabled = true;
IntPtr flashHandle;
try
{
flashHandle = FlashHandle.Get();
}
catch (InvalidOperationException)
{
MessageBox.Show("FlashPlayerのハンドルが見つかりません。\r\n"
+ "IEでClickerHeroesを開いてください。", "エラー", MessageBoxButtons.OK, MessageBoxIcon.Error);
startButton.Enabled = true;
configGroupBox.Enabled = true;
clickGroupBox.Enabled = false;
return;
}
SetConfig();
client = new MessageClient(flashHandle, config);
stopButton.Enabled = true;
}
public void RemovedCallback(string key, object value, CacheItemRemovedReason callbackReason)
{
if (callbackReason == CacheItemRemovedReason.Expired)
{
lock (_objLock)
{
if (this._subscribers.Contains(key))
{
try
{
MessageClient subscriber = this.GetSubscriber(key);
if (subscriber != null)
{
if (log.get_IsDebugEnabled())
{
log.Debug(__Res.GetString("SubscriptionManager_CacheExpired", new object[] { subscriber.ClientId }));
}
if (this._messageDestination != null)
{
MessageBroker messageBroker = this._messageDestination.Service.GetMessageBroker();
subscriber.Timeout();
}
}
}
catch (Exception exception)
{
if (log.get_IsErrorEnabled())
{
log.Error(__Res.GetString("SubscriptionManager_CacheExpired", new object[] { string.Empty }), exception);
}
}
}
}
}
}
public void MessageRoomTest()
{
SymConfig symConfig = new SymConfig();
SymConfigLoader symConfigLoader = new SymConfigLoader();
symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig.json");
SymBotAuth botAuth = new SymBotAuth(symConfig);
botAuth.authenticate();
SymBotClient botClient = SymBotClient.initBot(symConfig, botAuth);
OutboundMessage message = new OutboundMessage();
message.message = "<messageML>Hello world!</messageML>";
FileStream fileStream = File.OpenRead("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/AttachmentTest.txt");
List <FileStream> attachments = new List <FileStream>();
attachments.Add(fileStream);
message.attachments = attachments;
apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream();
stream.streamId = "fu1cJFoklnYlR9vu1AOZ5X___pzXDKPXdA";
MessageClient messageClient = new MessageClient(botClient);
InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false);
Assert.IsTrue(resp.messageId != null);
}
public static (MessageServer messageServer, IEnumerable <MessageClient> clients) CreateClientsAndServer([CallerMemberName] string systemName = "", params string[] clientNames)
{
//TODO: Get server name from somewhere else
MessageClientIdentity serverInfo = new MessageClientIdentity(systemName, "Server", ECDiffieHellmanCurve.P256);
MessageClientIdentity[] clientsInfo = new MessageClientIdentity[clientNames.Count()];
MessageClient[] messageClients = new MessageClient[clientNames.Count()];
for (int i = 0; i < clientNames.Count(); i++)
{
clientsInfo[i] = new MessageClientIdentity(systemName, clientNames[i], ECDiffieHellmanCurve.P256);
messageClients[i] = new MessageClientConfigurationBuilder()
.Identity(clientsInfo[i])
.TrustCoordinatorIdentity(serverInfo)
.RabbitMQServerHostName(Properties.Resources.RabbitMQServerName)
.RabbitMQCredentials(Properties.Resources.Username, Properties.Resources.Password)
.QueuesAreDurable(false)
.AutoDeleteQueuesOnClose(true)
.CreateMessageClient();
}
var messageServer = new MessageServerConfigurationBuilder()
.Identity(serverInfo)
.AddClientInfoRange(clientsInfo)
.RabbitMQServerHostName(Properties.Resources.RabbitMQServerName)
.RabbitMQCredentials(Properties.Resources.Username, Properties.Resources.Password)
.QueuesAreDurable(false)
.AutoDeleteQueuesOnClose(true)
.CreateMessageServer();
return(messageServer, messageClients);
}
public ActionResult Message(string email, string name, string message)
{
var isValid = this.IsCaptchaValid("Captcha is not valid");
if (isValid)
{
MessageClient.SendMessageAsync($"From:{email}({name})-{message}");
return(new JsonResult()
{
Data = new { Status = "Success", Message = "Thanks for the message!", Url = Url.Action("Contact", "Contact", null, Request.Url.Scheme) },
JsonRequestBehavior = JsonRequestBehavior.DenyGet
});
}
//Failed captcha
var dictionary = new RouteValueDictionary()
{
};
dictionary.Add("email", email);
dictionary.Add("name", name);
dictionary.Add("message", message);
return(new JsonResult()
{
Data = new { Status = "Failure", Message = "Captcha is not correct.", Url = Url.Action("Contact", "Contact", dictionary, Request.Url.Scheme) },
JsonRequestBehavior = JsonRequestBehavior.DenyGet
});
}
public void RemovedCallback(string key, object value, CacheItemRemovedReason callbackReason)
{
if (callbackReason == CacheItemRemovedReason.Expired)
{
lock (_objLock) {
if (_subscribers.Contains(key))
{
try {
MessageClient messageClient = GetSubscriber(key);
if (messageClient != null)
{
if (log.IsDebugEnabled)
{
log.Debug(__Res.GetString(__Res.SubscriptionManager_CacheExpired, messageClient.ClientId));
}
if (_messageDestination != null)
{
//MessageBroker messageBroker = _messageDestination.Service.GetMessageBroker();
_TimeoutContext context = new _TimeoutContext(messageClient);
FluorineWebSafeCallContext.SetData(FluorineContext.FluorineContextKey, context);
messageClient.Timeout();
FluorineWebSafeCallContext.FreeNamedDataSlot(FluorineContext.FluorineContextKey);
}
}
} catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.Error(__Res.GetString(__Res.SubscriptionManager_CacheExpired, string.Empty), ex);
}
}
}
}
}
}
private static void LinkTest()
{
ConsoleHelper.WriteLine("回车开始连接测试...");
ConsoleHelper.ReadLine();
var count = 60 * 1000;
MessageClient mclient;
Task.Run(() =>
{
ConsoleHelper.WriteLine("单机连接测试正在初始化...");
for (int i = 0; i < count; i++)
{
mclient = new MessageClient();
mclient.OnConnected += Mclient_OnConnected;
mclient.ConnectAsync();
}
Task.Run(() =>
{
while (_connectCount < count)
{
Thread.Sleep(1000);
ConsoleHelper.WriteLine($"单机连接测试已建立连接：{_connectCount} 未连接：{count - _connectCount}");
}
ConsoleHelper.WriteLine($"单机{count}连接已完成！");
});
});
}
public PibrellaBoardLEDsMonitor()
{
messageClient = new MessageClient(Environment.Devices.RASPBERRY_PI_B, HEARTBEAT_PERIOD_IN_MILLESECONDS);
pibrella.ButtonPressed += HandleButtonPressed;
pibrella.Connection.Open();
}
public void SendLogToRepo(string threadName, string tempLogPath, MessageClient msgSenderRepo, MessageServer msgReciever)
{
int trycount = 0;
HiResTimer hrt = new HiResTimer();
while (trycount <= 5)
{
trycount++;
Console.WriteLine("\n({0})Sending logs to repository...", threadName);
Message msgToRepo = msgSenderRepo.SetupUploadMessageToRepo(threadName, tempLogPath, "http://localhost:4140/ICommService/BasicHttp", "http://localhost:8180/ICommService/BasicHttp");
msgSenderRepo.channel.PostMessage(msgToRepo);
Console.WriteLine("\n({0})Waiting for message from repository...", threadName);
hrt.Start();
Message msgFromRepo = msgReciever.TryGetMessage("Repository", threadName);
hrt.Stop();
Console.WriteLine("");
Console.WriteLine("\n({0})Recieved message from repository in {0} microsec.", threadName, hrt.ElapsedMicroseconds);
Console.WriteLine("");
TestLoadStatus loadStat = msgReciever.Parse(msgFromRepo);
Console.WriteLine(loadStat.loadMessage);
if (loadStat.status)
{
break;
}
if (trycount <= 5)
{
Thread.Sleep(500);
continue;
}
throw new Exception("Failed sending logs to repository");
}
}
/// <summary>
/// 启动远程服务器功能（1.绘制屏幕2.收集并发送鼠标键盘命令）
/// </summary>
/// <param name="userName"></param>
public void Init(string lastID, string userName)
{
this._username = userName;
_lastID = lastID;
_mClient = new MessageClient(userName);
_mClient.OnFile += _mClient_OnFile;
_mClient.ReConnectFaild += _mClient_ReConnectFaild;
_mClient.OnNotice += _mClient_OnNotice;
_mClient.OnError += onError;
_mClient.OnMsg += onMsg;
_mClient.OnMessage += _mClient_OnMessage;
_isConnected = _mClient.Connect();
while (!_isConnected)
{
Thread.Sleep(10);
}
if (!_isConnected)
{
OnConnectedFaild();
}
else
{
_isConnected = true;
}
}
private void AddSubscriber(MessageClient messageClient)
{
lock (_objLock)
{
if (!_subscribers.Contains(messageClient.ClientId))
{
_subscribers[messageClient.ClientId] = messageClient;
// Add the MessageClient to the Cache with the expiration item
int timeOutMinutes = 20;
if (_messageDestination.DestinationDefinition.Properties.Network != null)
{
timeOutMinutes = _messageDestination.DestinationDefinition.Properties.Network.SessionTimeout;
}
HttpRuntime.Cache.Insert(messageClient.ClientId, messageClient, null,
Cache.NoAbsoluteExpiration,
new TimeSpan(0, timeOutMinutes, 0),
CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(this.RemovedCallback));
/*
* HttpRuntime.Cache.Insert( messageClient.ClientId, messageClient, null,
* DateTime.Now.AddSeconds(timeOutMinutes),
* TimeSpan.Zero,
* CacheItemPriority.Default, new CacheItemRemovedCallback(this.RemovedCallback) );
*/
}
}
}
public CacheClient(
MessageClient messenger,
ICacheClient cacheClient,
DiscordApiClient discordClient)
{
_messenger = messenger;
_cacheClient = cacheClient;
_discordClient = discordClient;
_messenger.ChannelCreate += OnChannelCreate;
_messenger.ChannelDelete += OnChannelDelete;
_messenger.ChannelUpdate += OnChannelUpdate;
_messenger.GuildBanAdd += OnGuildBanAdd;
_messenger.GuildBanRemove += OnGuildBanRemove;
_messenger.GuildCreate += OnGuildCreate;
_messenger.GuildDelete += OnGuildDelete;
_messenger.GuildUpdate += OnGuildUpdate;
_messenger.UserUpdate += OnUserUpdate;
_messenger.GuildRoleCreate += OnGuildRoleCreate;
_messenger.GuildRoleDelete += OnGuildRoleDelete;
_messenger.GuildRoleUpdate += OnGuildRoleUpdate;
_messenger.GuildMemberAdd += OnGuildMemberAdd;
_messenger.GuildMemberRemove += OnGuildMemberRemove;
_messenger.GuildMemberUpdate += OnGuildMemberUpdate;
}
public void Sending_message_should_succeed_when_packet_types_are_preloaded()
{
var c = new MessageClient(framedClient, serializer.Object, messageHandler.Object);
c.PreLoadTypesFromAssemblyOfType <TestData>();
serializer.Setup(s => s.Serialize(It.IsAny <TestData>(), It.IsAny <MemoryStream>()))
.Callback((TestData d, MemoryStream ms) =>
{
ms.Write(new byte[] { 0, 1, 2, 3, 4 }, 0, 5);
});
rawClient.Setup(rc => rc.Send(It.IsAny <byte[]>())).Callback((byte[] b) =>
{
var length = BitConverter.ToInt32(b, 0);
var messageId = BitConverter.ToInt32(b, 4);
Assert.Equal(4 + 4 + 5, length);
Assert.Equal(4 + 4 + 5, b.Length);
Assert.Equal(3, messageId);
Assert.Equal(new byte[] { 0, 1, 2, 3, 4 }, new ArraySegment <byte>(b, 8, 5));
});
c.Send(CreateSampleTestData());
}
public void Open()
{
InstanceContext context = new InstanceContext(this);
messageClient = new MessageClient(context, "WSDualHttpBinding_IMessage");
messageClient.Subscribe("client1");
}
public JMessageClient(string appKey, string masterSecret)
{
if (string.IsNullOrEmpty(appKey))
{
throw new ArgumentNullException(nameof(appKey));
}
if (string.IsNullOrEmpty(masterSecret))
{
throw new ArgumentNullException(nameof(masterSecret));
}
AppKey = appKey;
MasterSecret = masterSecret;
var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(appKey + ":" + masterSecret));
HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", auth);
User = new UserClient();
Message = new MessageClient();
Group = new GroupClient();
Report = new ReportClient(appKey, masterSecret);
Chatroom = new ChatroomClient();
}
public TaskSenderHost(string taskCode, string assembly, string type)
{
this.client = new MessageClient();
this.assembly = assembly;
this.type = type;
this.taskCode = taskCode;
}
public DiscordClient(DiscordClientConfigurations config)
{
_apiClient = new DiscordApiClient(
config.Token, config.Pool
);
_websocketClient = new MessageClient(
new MessageClientConfiguration
{
Token = config.Token,
ExchangeName = config.RabbitMQExchangeName,
MessengerConfigurations = config.RabbitMQUri,
QueueName = config.RabbitMQQueueName
}
);
_websocketClient.MessageCreate += OnMessageCreate;
_websocketClient.MessageUpdate += OnMessageUpdate;
_websocketClient.GuildCreate += OnGuildJoin;
_websocketClient.GuildDelete += OnGuildLeave;
_websocketClient.UserUpdate += OnUserUpdate;
_websocketClient.Start();
}
public void CancelTimeout(MessageClient messageClient)
{
lock (_objLock)
{
HttpRuntime.Cache.Remove(messageClient.ClientId);
}
}
//private static Mutex sendMessageMutex = new Mutex();
public DifferentCarbox(GlobalSettings settings) : base(settings)
{
RequireSeed = true;
RequiredNumRuleSets = 1;
AutoPlay = true;
Seed = new candidate(OBFunctions.tagconvexhullpoints(settings.seed), settings.numOfRuleSets);
_runDirectory = Path.Combine(settings.OutputDirAbs, "RandomRuleApplication", CARBOXTYPE);
if (Directory.Exists(_runDirectory))
{
Directory.Delete(_runDirectory, true);
}
Directory.CreateDirectory(_runDirectory);
jobBuffer = new JobBuffer(_runDirectory);
var learnDirectory = Path.Combine(settings.OutputDirAbs, "morfLearn");
computation = new Computation(_runDirectory, learnDirectory, "point", "stiff");
writer = new StreamWriter(Path.Combine(_runDirectory, CARBOXTYPE + ".txt"));
System.Random rnd = new System.Random();
var port = rnd.Next(1, 65535);
//port = 9999;
server = new LearningServer(learnDirectory, port, _runDirectory);
client = new MessageClient(port);
}
public void OBOAuth()
{
SymOBOAuth oboAuth = new SymOBOAuth(symConfig);
oboAuth.sessionAppAuthenticate();
SymOBOUserAuth auth = oboAuth.getUserAuth("*****@*****.**");
// auth.setSessionToken("eyJhbGciOiJSUzUxMiJ9.eyJzdWIiOiJzdGlzaGxlciIsImlzcyI6InN5bXBob255IiwiYXBwUGVybWlzc2lvbnMiOlsiQUNUX0FTX1VTRVIiLCJHRVRfQkFTSUNfQ09OVEFDVF9JTkZPIiwiR0VUX1BSRVNFTkNFIiwiTElTVF9VU0VSX1NUUkVBTVMiLCJNQU5BR0VfUk9PTVMiLCJTRU5EX01FU1NBR0VTIl0sImFwcEdyb3VwSWQiOiJhZG55LXcxNDYiLCJzZXNzaW9uSWQiOiJiNGI3N2NjMWUyYzg4ODAxMWNmNWI3MWI5YmQwYTZhNjJlNDI0MTMzMzJlMGRkNDk1NWQzYzk3ZjViNjE4MWMyNWE2MTVmYThkMjNmNjM2YmNmNDJiNTMxOGI4ZDlkNDgwMDAwMDE2NjhjZTIyOGNjMDAwMDUyYjAwMDAwMDAxOSIsInVzZXJJZCI6IjkwOTE1ODY3NzIxNzUzIn0.hSsZOBEH-OlUzOjDl_NhoxVTrlbJSEaxnmV0s5VQO92VgYaTBc0eUbcHaCYzmRtafil8dy_4_pOSMSR9VupDayklL9igT2cRHZGKvryR4_2hNDym3Xs-uYCxC83O1l9CTm2ISrSVgVabzVOznN23sZLQ6IoIj2EORS6B8eemGlGTWjZge1iav464kFosQ5glSDSecY4mTcbh4sYE3mwINlCEML5VqpEbc0Pdu1ZOesLMBHsa3KzlGuIUEjtigP4NZeYPc31G-rzxSKHWeMo3Mqwwk_0dSL6voQgw-29fly0uIGTF7wCSngk3g9n4Lv_0m4Yh5xDcyQ0h4RRxny-Sgg");
// symConfig.agentHost = "alphadyne.symphony.com";
SymOBOClient client = SymOBOClient.initOBOClient(symConfig, auth);
OutboundMessage message = new OutboundMessage();
message.message = "<messageML>Hello it is mike fron NET 2</messageML>";
apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream();
stream.streamId = "IzgD3nNbpoaNJ6_To7Ds0n___pmCBYMrdA";
//stream.streamId = "AQpEsS9DJM1ZRrGF7Kb7i3___pui0wKcdA";
MessageClient messageClient = new MessageClient(client);
InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false);
Assert.IsTrue(resp.message != null);
}
public void PushMessageToClients(ICollection subscribers, IMessage message)
{
MessageDestination destination = base.GetDestination(message) as MessageDestination;
SubscriptionManager subscriptionManager = destination.SubscriptionManager;
if ((subscribers != null) && (subscribers.Count > 0))
{
IMessage message2 = message.Clone() as IMessage;
foreach (string str in subscribers)
{
MessageClient subscriber = subscriptionManager.GetSubscriber(str);
if (subscriber != null)
{
if (log.get_IsDebugEnabled())
{
if (message2 is BinaryMessage)
{
log.Debug(__Res.GetString("MessageServicePushBinary", new object[] { message.GetType().Name, str }));
}
else
{
log.Debug(__Res.GetString("MessageServicePush", new object[] { message.GetType().Name, str }));
}
}
base._messageBroker.GetEndpoint(subscriber.Endpoint).Push(message2, subscriber);
}
}
}
}
public async void Start()
{
MessageClient messageClient = App.Current.Resources["MessageClient"] as MessageClient;
messageClient.MessageStringReceived += messageClient_MessageStringReceived;
if (await messageClient.Start(IpAddress, PortNumber))
{
messageClient.SubscribeToData(Devices.RASPBERRY_PI_B, Pibrella.OBJECT_GREEN_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.RASPBERRY_PI_B, Pibrella.OBJECT_YELLOW_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.RASPBERRY_PI_B, Pibrella.OBJECT_RED_LED, Pibrella.DATA_LED_STATUS);
messageClient.SubscribeToData(Devices.NETDUINO_3_WIFI, MCP4921.OBJECT_ANALOG_DATA, MCP4921.DATA_ANALOG_VALUE);
messageClient.SubscribeToTraffic(Devices.NETDUINO_3_WIFI, Devices.WINDOWS_PHONE);
messageClient.SubscribeToTraffic(Devices.WINDOWS_PHONE, Devices.NETDUINO_3_WIFI);
messageClient.SubscribeToTraffic(Devices.RASPBERRY_PI_B, Devices.SERVER);
messageClient.SubscribeToTraffic(Devices.SERVER, Devices.RASPBERRY_PI_B);
messageClient.SubscribeToServerState(ServerStates.STATE_CONNECTION_NETDUINO_3_WIFI);
messageClient.SubscribeToServerState(ServerStates.STATE_CONNECTION_RASPBERRY_B);
messageClient.SubscribeToServerState(ServerStates.STATE_CONNECTION_WINDOWS_PHONE);
messageClient.SubscribeToServerState(ServerStates.STATE_CONNECTION_WINDOWS_SURFACE);
messageClient.SubscribeToServerState(ServerStates.STATE_MCP4921_VOLTAGE);
}
DeviceModel serverModel = deviceModels.FirstOrDefault(x => x.Name == Devices.SERVER);
serverModel.IsConnected = true;
DeviceModel surfaceModel = deviceModels.FirstOrDefault(x => x.Name == Devices.WINDOWS_SURFACE);
surfaceModel.IsConnected = true;
}
public void StartClient(IPEndPoint serverInfo)
{
if (IsOnline)
{
_messages.Add(new Tuple <Guid, string>(Guid.Empty, "[Cannot Start Client While Online]"));
UpdateText();
return;
}
_networkClient = new NetworkClient();
_messageClient = new MessageClient(_networkClient);
_messageClient.Started += ClientStarted;
_messageClient.Stopped += ClientStopped;
_messageClient.Received.Register(NetCode.RawMessage, ClientOnRawMessageReceived);
_messageClient.Received.Register(NetCode.UpdateUsername, ClientOnUpdateUsernameRecieved);
_messageClient.Received.Register(NetCode.GuidNotification, ClientOnGuidNotificationReceived);
_messageClient.Received.Register(NetCode.UserMessage, ClientOnUserMessageReceived);
_messageClient.Sent.Register(NetCode.UpdateUsername, ClientOnUpdateUsernameSent);
_messageClient.Sent.Register(NetCode.RawMessage, ClientOnMessageSent);
_messageClient.Sent.Register(NetCode.UserMessage, ClientOnMessageSent);
if (!_networkClient.TryConnect(serverInfo))
{
_messages.Add(new Tuple <Guid, string>(Guid.Empty, "[Client Failed To Connect]"));
UpdateText();
_networkClient.Close();
_networkClient = null;
}
}
public void Run()
{
InstanceContext context = new InstanceContext(this);
_messageClient = new MessageClient(context, "WSDualHttpBinding_IMessage");
for (int i = 0; i < 5; i++)
{
string message = string.Format("message #{0}", i);
_messageClient.SendMessage(message);
}
}
public void Setup()
{
// Create client
this.client = new MessageClient();
this.client.NumberOfMessages = 3;
this.client.NumberOfIterations = 1;
// Setup service
MessageService.EndpointAddress = ListenUri;
MessageService.ContractTypes = new List<Type>();
MessageService.CompletionHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
}
public void Open()
{
try
{
InstanceContext context = new InstanceContext(this);
_messageClient = new MessageClient(context, "WSDualHttpBinding_IMessage");
_messageClient.Subscribe();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void Setup()
{
// Create client
this.client = new MessageClient();
this.client.NumberOfMessages = 3;
this.client.NumberOfIterations = 3;
// Setup and start service
MessageService.EndpointAddress = "amqp:message_queue";
MessageService.ContractTypes = new List<Type>();
MessageService.ContractTypes.Add(typeof(IInteropService));
MessageService.CompletionHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
MessageService.IntendedInvocationCount = this.client.NumberOfIterations * this.client.NumberOfMessages * MessageService.ContractTypes.Count;
MessageService.StartService(Util.GetCustomBinding());
}
public WcfDriver(XmlDocument xmlDocument)
{
_xmlDocument = xmlDocument;
_id = "FE9E907F-2186-4186-B5EA-53B7609303C0";
_thisLock = new object();
// _configFileName = Path.Combine(DriverManager.ConfigFilePath, _configFileName);
ReadXml();
if (!ServiceManager.DesignMode)
{
InstanceContext context = new InstanceContext(this);
messageClient = new MessageClient(context, "WSDualHttpBinding_IMessage");
messageClient.Subscribe();
}
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
using (MessageClient client = new MessageClient())
{
client.Host = "127.0.0.1";
client.Port = 8088;
client.HeartBeatPeriod = 10000; //10 second
client.Start();
Program.client = client;
Console.WriteLine("Press enter to exit...");
Thread.Sleep(1000);
Thread t1 = new Thread(SendData1);
t1.Start();
Thread t2 = new Thread(SendData2);
t2.Start();
Console.ReadLine();
}
Console.ReadLine();
}
public override void onMessageSent(MessageClient client, Message message, string recipientId)
{
mMessageAdapter.addMessage(message, MessageAdapter.DIRECTION_OUTGOING);
}
private void MainForm_Load(object sender, EventArgs e)
{
//ServicePointManager.ServerCertificateValidationCallback += (from, cert, chain, sslPolicyErrors) =>
//{
// LogMsg("HTTP Remote Certificate Validation Callback!");
// return true;
//};
m_Client = MessageClient.CreateNewClient();
m_Client.SetClientId(1);
m_Client.IsOrderlyProcess = true;
m_Client.Events.OnHandshake += OnConnect;
m_Client.Events.OnDisconnect += OnDisconnect;
m_Client.Events.OnError += OnError;
//m_Client.SetValidationCallback(new RemoteCertificateValidationCallback((from, cert, chain, policyErrors) =>
//{
// LogMsg("WebSocket Remote Certificate Validation Callback!");
// return true;
//}));
m_Client.Handlers.AddHandler(new EnterLobbyHandler(this));
m_Client.Handlers.AddHandler(new GetRoomListHandler(this));
m_Client.Handlers.AddHandler(new CreateRoomHandler(this));
m_Client.Handlers.AddHandler(new EnterRoomHandler(this));
m_Client.Handlers.AddHandler(new ExitRoomHandler(this));
m_Client.Handlers.AddHandler(new RoomMessageHandler(this));
listRooms.Items.Clear();
listUsers.Items.Clear();
gbChatRoom.Enabled = false;
gbLobby.Enabled = false;
gbLogin.Enabled = true;
timerAutoRelogin.Enabled = false;
this.AcceptButton = btnSend;
DisableEditing(cbbChatToWho);
}
public override void Push(IMessage message, MessageClient messageClient) {
IEndpointPushHandler handler = messageClient.Client.GetEndpointPushHandler(this.Id);
if (handler != null) {
IMessage messageClone = message.Copy() as IMessage;
messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
messageClone.clientId = messageClient.ClientId;
handler.PushMessage(messageClone);
}
/*
IMessage messageClone = message.Clone() as IMessage;
messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
messageClone.clientId = messageClient.ClientId;
messageClient.AddMessage(messageClone);
*/
}
public override void onShouldSendPushData(MessageClient client, Message message, IList<PushPair> pushPairs)
{
// Left blank intentionally
}
public override void onMessageDelivered(MessageClient client, MessageDeliveryInfo deliveryInfo)
{
Log.d(TAG, "onDelivered");
}
public override void onMessageFailed(MessageClient client, Message message, MessageFailureInfo failureInfo)
{
StringBuilder sb = new StringBuilder();
sb.Append("Sending failed: ").Append(failureInfo.SinchError.Message);
Toast.makeText(this, sb.ToString(), Toast.LENGTH_LONG).show();
Log.d(TAG, sb.ToString());
}
public override void Push(IMessage message, MessageClient messageClient) {
/*
IMessageConnection messageConnection = messageClient.MessageConnection;
Debug.Assert(messageConnection != null);
if (messageConnection != null)
messageConnection.Push(message, messageClient);
*/
ISession session = messageClient.Session;
System.Diagnostics.Debug.Assert(session != null);
session.Push(message, messageClient);
}
public override void Push(IMessage message, MessageClient messageClient) {
if (this.ChannelDefinition.Properties.IsPollingEnabled) {
IEndpointPushHandler handler = messageClient.Client.GetEndpointPushHandler(this.Id);
if (handler != null) {
IMessage messageClone = message.Copy() as IMessage;
messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
messageClone.clientId = messageClient.ClientId;
handler.PushMessage(messageClone);
}
/*
IMessage messageClone = message.Clone() as IMessage;
messageClone.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
messageClone.clientId = messageClient.ClientId;
messageClient.AddMessage(messageClone);
*/
} else {
if (log.IsWarnEnabled)
log.Warn("Push request received for the non-polling AMF endpoint '" + this.Id + "'");
}
}
public override void onIncomingMessage(MessageClient client, Message message)
{
mMessageAdapter.addMessage(message, MessageAdapter.DIRECTION_INCOMING);
}
public virtual void Push(IMessage message, MessageClient messageClient) {
throw new NotSupportedException();
}
public void Go()
{
InstanceContext context = new InstanceContext(this);
messageClient = new MessageClient(context, "WSDualHttpBinding_IMessage");
//for (int i = 0; i < 5; i++)
//{
string message = string.Format("message #{0}", 0);
Console.WriteLine(">>> listening " + message);
messageClient.AddMessage(message, "client1");
//}
}
