protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
RequestWindowFeature(WindowFeatures.NoTitle);
SetContentView(Resource.Layout.passcode_main);
_listener = new MessageListener(ACTION_SHAKE, ACTION_DISMISS);
_listener.MessageReceived += HandleMessageReceived;
_numbersEntered = 0;
InitButtons();
_selectedLayout = FindViewById<LinearLayout>(Resource.Id.passcode_toplayout);
if(Intent != null)
{
bool showCancel = Intent.GetBooleanExtra(EXTRA_SHOW_CANCEL, false);
_cancelButton.Visibility = showCancel ? ViewStates.Visible : ViewStates.Invisible;
_passcodeLength = Intent.GetIntExtra(EXTRA_LENGTH, 4);
_animationIn = Intent.GetIntExtra(EXTRA_IN_ANIMATION, 0);
_animationOut = Intent.GetIntExtra(EXTRA_OUT_ANIMATION, 0);
}
HideUnusedCircles();
_passcodeEntered = new int[_passcodeLength];
_shakeAnimation = AnimationUtils.LoadAnimation(this, Resource.Animation.passcode_shake);
}
/// <summary>
/// 启动消息侦程序线程
/// </summary>
private void Start(MessageListener listener)
{
ThreadPool.STPStartInfo stp = new ThreadPool.STPStartInfo();
stp.MaxStackSize = MaxThreads;
stp.MaxWorkerThreads = MaxThreads;
ThreadPool.SmartThreadPool smartThreadpool = new ThreadPool.SmartThreadPool(stp);
while (true)
{
MQMessage message = null;
if (messageQueue.QueueConfig.isTransactional)
{
MessageQueueTransaction tran = new MessageQueueTransaction();
message = new MQMessage(tran);
message.Begin();
message.messageContent = messageQueue.Receive(tran).Body.ToString();
}
else
{
message = new MQMessage(null);
message.messageContent = messageQueue.Receive().Body.ToString();
}
System.Threading.Interlocked.Increment(ref Counter);
while (Counter >= MaxThreads)
{
System.Threading.Thread.Sleep(100);
}
smartThreadpool.QueueWorkItem(CallBack, message);
}
}
public virtual void addMessageListener(MessageListener l)
{
((Parser)source).ErrorReported += new MessageEventHandler(l.reportError);
((Parser)source).WarningReported += new MessageEventHandler(l.reportWarning);
//messageListeners.Add(l);
addDoneListener(l);
}
/// <summary>
/// returns an array of message listeners registered at the moment.
/// </summary>
public MessageListener[] GetClients() {
lock(this) {
MessageListener[] result = new MessageListener[m_clients.Count];
m_clients.Values.CopyTo(result, 0);
return result;
}
}
public void Dispose()
{
cancel.Cancel();
channelFactory.Close();
proxy.Unregist();
(proxy as IDisposable).Dispose();
_listener = null;
proxy = null;
}
/// <summary>
/// Add a new messagelistener.
/// </summary>
public void AddClient(MessageListener ml, String forUser) {
lock(this) {
if (!m_clients.ContainsKey(forUser)) {
m_clients.Add(forUser, ml);
} else {
throw new AlreadyRegisteredException("a message listener is already registered for user: " +
forUser);
}
}
}
static void Main()
{
var bus = new TopicBasedPubSub();
var messageListener = new MessageListener(bus);
var startables = new List<IStartable>();
var midgetFactory = new MidgetFactory();
var midgetHouse = new MidgetHouse(bus, midgetFactory);
var consolePrinter = new QueuedHandler<OrderPaid>(Messages.Paid, new ConsolePrintingOrderHandler(bus));
bus.Subscribe(consolePrinter);
startables.Add(consolePrinter);
var cashier = new Cashier(bus);
var queuedCashier = new QueuedHandler<TakePayment>(Messages.OrderBilled, cashier);
bus.Subscribe(queuedCashier);
startables.Add(queuedCashier);
startables.Add(cashier);
var assistantManager = new QueuedHandler<PriceOrder>(Messages.OrderPrepared, new AssistantManager(bus));
bus.Subscribe(assistantManager);
startables.Add(assistantManager);
var chefs = new List<QueuedHandler<CookFood>>();
var rand = new Random();
for (int i = 0; i < NumberOfChefs; i++)
{
var chef = new TimeToLiveDispatcher<CookFood>(new Chef(bus, rand.Next(1000)));
var queuedHandler = new QueuedHandler<CookFood>(string.Format("Chef {0}", i), chef);
chefs.Add(queuedHandler);
startables.Add(queuedHandler);
}
var distributionStrategy = new QueuedDispatcher<CookFood>(bus, chefs);
startables.Add(distributionStrategy);
foreach (var startable in startables)
{
startable.Start();
}
var monitor = new Monitor(startables);
monitor.Start();
var waiter = new Waiter(bus);
for (int i = 0; i < 10; i++)
{
var correlationId = Guid.NewGuid();
var orderId = waiter.PlaceOrder(correlationId);
}
Console.ReadKey();
}
public ActiveMQListener(string destQueue, MessageListener msgProcessor)
{
string brokerUrl = ConfigurationManager.AppSettings["BrokerURL"];
ConnectionFactory connFactory = new ConnectionFactory(brokerUrl);
IConnection conn = connFactory.CreateConnection();
ISession session = conn.CreateSession();
IDestination destination = SessionUtil.GetDestination(session, destQueue,DestinationType.Queue);
IMessageConsumer consumer = session.CreateConsumer(destination);
consumer.Listener += msgProcessor;
conn.Start();
}
static void Main(string[] args)
{
Console.Title = "CloudServiceBus: Client";
AmazonSQS sqs = AwsFacade.GetSqsClient();
var requestQueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
//create a queue for responses:
var queueName = Guid.NewGuid().ToString();
var createQueueRequest = new CreateQueueRequest();
createQueueRequest.QueueName = queueName;
var createQueueResponse = sqs.CreateQueue(createQueueRequest);
var responseQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
var listener = new MessageListener();
ThreadPool.QueueUserWorkItem(new WaitCallback(listener.StartListening), responseQueueUrl);
Console.WriteLine("*");
Console.WriteLine("Sending messages on URL: {0}", requestQueueUrl);
Console.WriteLine("Receiving responses on URL: {0}", responseQueueUrl);
Console.WriteLine("*");
var messageBody = Console.ReadLine();
while (messageBody != "x")
{
var parts = messageBody.Split(' ');
if (parts[0] == "get")
{
var duration = int.Parse(parts[1]);
var serviceRequest = new GetChangedEmployeesRequest();
serviceRequest.LastChangeDate = DateTime.Now.AddDays(duration).Date;
serviceRequest.ResponseQueueUrl = responseQueueUrl;
var request = new SendMessageRequest();
request.QueueUrl = requestQueueUrl;
request.RequestToBody(serviceRequest);
SendMessage(request, sqs, serviceRequest);
}
if (parts[0] == "flush")
{
var serviceRequest = new FlushDataStoreRequest();
serviceRequest.StoreIdentifier = "Sixeyed-CloudServiceBus-ResponseData";
var request = new SendMessageRequest();
request.QueueUrl = requestQueueUrl;
request.RequestToBody(serviceRequest);
SendMessage(request, sqs, serviceRequest);
}
messageBody = Console.ReadLine();
}
}
public void TestReceiveMessageAsync()
{
const int NUM_MSGS = 100;
const int MESSAGE_RECEIVE_TIMEOUT = 1000; // 1.0s
//Apache.NMS.Util.Atomic<bool> stopped = new Apache.NMS.Util.Atomic<bool>(false);
using (IConnection connection = this.GetConnection())
using (IMessageConsumer consumer = this.GetConsumer("con1"))
using (IMessageProducer producer = this.GetProducer("pro1"))
{
try
{
MessageListener ackcallback = CreateListener(NUM_MSGS);
MessageListener callback = (m) =>
{
if (!connection.IsStarted)
{
waiter.Set();
throw new Exception("Received Message " + msgCount + " on stopped connection.");
}
ackcallback(m);
Logger.Info("MsgCount : " + msgCount);
};
consumer.Listener += callback;
connection.ExceptionListener += DefaultExceptionListener;
connection.Start();
ITextMessage message = producer.CreateTextMessage();
for (int i = 0; i < NUM_MSGS; i++)
{
message.Text = "num:" + i;
producer.Send(message);
}
if (!waiter.WaitOne(MESSAGE_RECEIVE_TIMEOUT))
{
Assert.IsNull(asyncEx, "OnExceptionListener Event when raised. Message : {0}.", asyncEx?.Message);
Assert.Fail("Received {0} of {1} messages in {2}ms.", msgCount, NUM_MSGS, MESSAGE_RECEIVE_TIMEOUT);
}
Assert.IsNull(asyncEx, "OnExceptionListener Event when raised. Message : {0}.", asyncEx?.Message);
Assert.AreEqual(NUM_MSGS, msgCount, "Failed to Received All Messages sent.");
}
catch (Exception ex)
{
Logger.Warn("Async execption: " + this.GetTestException(asyncEx));
this.PrintTestFailureAndAssert(this.GetMethodName(), "Unexpected Exception.", ex);
}
}
}
public static IApplicationBuilder UseMessageListener(this IApplicationBuilder app)
{
Listener = app.ApplicationServices.GetService <MessageListener>();
var lifetime = app.ApplicationServices.GetService <IHostApplicationLifetime>();
lifetime.ApplicationStarted.Register(OnStarted);
lifetime.ApplicationStopping.Register(OnStopping);
return(app);
}
/// <summary>
/// 注册监听
/// </summary>
/// <param name="publishType"></param>
/// <param name="listener"></param>
/// <returns></returns>
public bool Subscribe(Type publishType, MessageListener listener)
{
DelgateMessageEntity en = _entitydels.Find((e) => { return(e.listenType == publishType); });
if (en == null)
{
en = new DelgateMessageEntity(publishType);
_entitydels.Add(en);
}
return(en.Subscribe(listener));
}
public HttpServiceHost(Func <EndPoint, Task <IMessageListener> > messageListenerFactory, IServiceExecutor serviceExecutor, HttpMessageListener httpMessageListener) : base(serviceExecutor)
{
_messageListenerFactory = messageListenerFactory;
_serverMessageListener = httpMessageListener;
_serverMessageListener.Received += async(sender, message) =>
{
await Task.Run(() =>
{
MessageListener.OnReceived(sender, message);
});
};
}
public void EnsureReceived_provides_custom_error_details_on_timeout()
{
using var listener = MessageListener.Start(_source);
_source.Publish(new TestMessage("01"));
var timeout = TimeSpan.FromMilliseconds(100);
var ex = Assert.ThrowsAsync <TimeoutException>(
() => listener.EnsureReceived <TestMessage>(x => x.Id == "001", timeout));
Assert.That(ex.Message.Replace("\r", ""), Is.EqualTo(@"Failed to receive matching TestMessage within 100ms.
Last recorded TestMessage messages:
TestMessage: { Id=""01"" Text=null }".Replace("\r", "")));
}
/// <summary>
/// start as an asynchronous operation.
/// </summary>
/// <param name="ip">The ip.</param>
/// <param name="port">The port.</param>
public override async Task StartAsync(string ip, int port)
{
if (_serverMessageListener != null)
{
return;
}
_serverMessageListener = await _messageListenerFactory(new IPEndPoint(IPAddress.Parse(ip), 53));
_serverMessageListener.Received += async(sender, message) =>
{
await Task.Run(() => { MessageListener.OnReceived(sender, message); });
};
}
public void GetMessages_Of_T_should_messages_in_order_from_latest_to_oldest()
{
var msg1 = new TestMessage("001");
var msg2 = new TestMessage("002");
var msg3 = new TestMessage("003");
using var listener = MessageListener.Start(_source);
_source.Publish(msg1);
_source.Publish(msg2);
_source.Publish(msg3);
Assert.That(listener.GetMessages <TestMessage>().ToArray(),
Is.EqualTo(new[] { msg3, msg2, msg1 }));
}
public async Task <JoinLobbyResponse> JoinLobby(string lobbyName)
{
MessageListener <JoinLobbyResponse> joinLobbyResponseListener = new MessageListener <JoinLobbyResponse>();
joinLobbyResponseListener.Subscribe(_messageProcessor);
JoinLobbyRequest joinLobbyRequest = new JoinLobbyRequest(Guid.NewGuid(), _loggedInUser, lobbyName);
await _networkConnector.SendMessageAsync(joinLobbyRequest, CancellationToken.None);
JoinLobbyResponse joinLobbyResponse = await joinLobbyResponseListener.ReceiveMessageAsync();
joinLobbyResponseListener.Unsubscribe();
return(joinLobbyResponse);
}
public async Task <GetAllLobbiesResponse> GetAllLobbies()
{
MessageListener <GetAllLobbiesResponse> getAllLobbiesResponseListener = new MessageListener <GetAllLobbiesResponse>();
getAllLobbiesResponseListener.Subscribe(_messageProcessor);
GetAllLobbiesRequest getAllLobbiesRequest = new GetAllLobbiesRequest();
await _networkConnector.SendMessageAsync(getAllLobbiesRequest, CancellationToken.None);
GetAllLobbiesResponse getAllLobbiesResponse = await getAllLobbiesResponseListener.ReceiveMessageAsync();
getAllLobbiesResponseListener.Unsubscribe();
return(getAllLobbiesResponse);
}
public async Task <CreateLobbyResponse> CreateLobby(string lobbyName)
{
MessageListener <CreateLobbyResponse> createLobbyResponseListener = new MessageListener <CreateLobbyResponse>();
createLobbyResponseListener.Subscribe(_messageProcessor);
CreateLobbyRequest createLobbyRequest = new CreateLobbyRequest(Guid.NewGuid(), _loggedInUser, lobbyName);
await _networkConnector.SendMessageAsync(createLobbyRequest, CancellationToken.None);
CreateLobbyResponse createLobbyResponse = await createLobbyResponseListener.ReceiveMessageAsync();
createLobbyResponseListener.Unsubscribe();
return(createLobbyResponse);
}
public async Task <StartGameResponse> StartGame(string lobbyName)
{
MessageListener <StartGameResponse> startGameResponseListener = new MessageListener <StartGameResponse>();
startGameResponseListener.Subscribe(_messageProcessor);
StartGameRequest startGameRequest = new StartGameRequest(Guid.NewGuid(), lobbyName, _loggedInUser.Id);
await _networkConnector.SendMessageAsync(startGameRequest, CancellationToken.None);
StartGameResponse startGameResponse = await startGameResponseListener.ReceiveMessageAsync();
startGameResponseListener.Unsubscribe();
return(startGameResponse);
}
public void RemoveListener(int cmdId, MessageListener listener)
{
ListenerInfo item;
for (int i = listeners.Count - 1; i >= 0; i--)
{
item = listeners[i];
if (item.CmdId == cmdId && item.Listener == listener)
{
listeners.Remove(item);
}
}
}
public async Task <LoginResponse> LoginAsync(string username, string password)
{
MessageListener <LoginResponse> loginResponseListener = new MessageListener <LoginResponse>();
loginResponseListener.Subscribe(_messageProcessor);
LoginRequest loginRequest = new LoginRequest(Guid.NewGuid(), username, password);
await _networkConnector.SendMessageAsync(loginRequest, CancellationToken.None);
LoginResponse loginResponse = await loginResponseListener.ReceiveMessageAsync();
loginResponseListener.Unsubscribe();
return(loginResponse);
}
public override async Task StartAsync(string ip, int port)
{
if (_serverMessageListener != null)
{
return;
}
_serverMessageListener = await _messageListenerFactory(new IPEndPoint(IPAddress.Parse(ip), AppConfig.ServerOptions.Ports.UdpPort));
_serverMessageListener.Received += async(sender, message) =>
{
await MessageListener.OnReceived(sender, message);
};
}
public void CanListenForMessages()
{
var listener = new MessageListener<ControllerMessage>();
var mediator = new ControllerMessageMediator();
mediator.Subscribe("test", listener);
var testMessage = new ControllerMessage { Header = "test", Body = "testing123" };
var uselessMessage = new ControllerMessage { Header = "poop", Body = "xxxx" };
var callCount = 0;
listener.MessageRecieved += m => callCount++;
mediator.Send(testMessage);
mediator.Send(uselessMessage);
Assert.AreEqual(1, callCount);
}
public async Task <RegisterResponse> RegisterAsync(string email, string username, string password)
{
MessageListener <RegisterResponse> registerResponseListener = new MessageListener <RegisterResponse>();
registerResponseListener.Subscribe(_messageProcessor);
RegisterRequest registerRequest = new RegisterRequest(Guid.NewGuid(), email, username, password);
await _networkConnector.SendMessageAsync(registerRequest, CancellationToken.None);
RegisterResponse registerResponse = await registerResponseListener.ReceiveMessageAsync();
registerResponseListener.Unsubscribe();
return(registerResponse);
}
public void Connect(string host, int port)
{
messageListener = new MessageListener(this.logger);
messageListener.DoneListeningForMessages += disconnectedFromServer;
tcpClient = new TcpClient();
//tcpClient.NoDelay = true;
logger.Write <Client>("Connecting...");
tcpClient.Connect(host, port);
logger.Write <Client>("Connected");
startListeningForMessagesInANewThread();
OnConnected?.Invoke();
}
/// <summary>
/// 启动主机。
/// </summary>
/// <param name="endPoint">主机终结点。</param>
/// <returns>一个任务。</returns>
public override async Task StartAsync(EndPoint endPoint)
{
if (_serverMessageListener != null)
{
return;
}
_serverMessageListener = await _messageListenerFactory(endPoint);
_serverMessageListener.Received += async(sender, message) =>
{
await MessageListener.OnReceived(sender, message);
};
}
private (ChatPacketHandler, IEntity) Data()
{
var server = Mock.Server();
var player = Mock.Player("a", server).Get();
var l = new MessageListener(player);
player.Components.Add(l);
var handler = new ChatPacketHandler();
return(handler, player);
}
public IDisposable AddMessageListener(MessageListener <T> listener)
{
if (listener == null)
{
throw new ArgumentNullException(nameof(listener));
}
lock (this._Listeners)
return((IDisposable) new Scope((Action)(() => this._Listeners.Add(listener)), (Action)(() =>
{
lock (this._Listeners)
this._Listeners.Remove(listener);
})));
}
public void CreateConsumer(string queue, MessageListener message)
{
Connection connection = ConnectionActiveMq();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IDestination dest = session.GetQueue(queue);
IMessageConsumer consumer = session.CreateConsumer(dest);
connection.Start();
consumer.Listener += new MessageListener(message);
}
public MainFormPresenter(MainForm view)
{
this.view = view;
this.orderService = new SaleOrderService();
this.productService = new ProductService();
this.keyBoardService = new KeyBoardService();
init();
view.ipAddressLabel.Text = "IP:" + GetAddressIP();
view.logo.Text = "ERP-MOS-" + SystemInfo.VERSION;
SyncBackUtil.getInstance().startSyncThread(1 * 60 * 1000); //启动后台同步进程
MessageListener.getInstance().startListener(); //启动mq队列监听
NetCheckUtil.getInstance().startNetCheck(this);
}
/// <summary>
/// 发布消息，注意当前方法工作在消息发布线程，不是业务线程
/// </summary>
/// <param name="workMessage"></param>
protected override void Publish(ref string workMessage)
{
//避免监控线程超时，发布重复消息
if (published)
{
return;
}
published = true;
//在子线程推送消息
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
workMessage += string.Format("\r\nPub2 CallService Begin:{0}.\r\n", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
int count = 0;
foreach (SubscriberInfo info in this.SubscriberInfoList.ToArray())
{
if (!Context.NoResultRecord(publishResult))
{
//可能执行完服务后，监听器又断开了，因此需要再次获取
MessageListener currLst = MessageCenter.Instance.GetListener(info.FromIP, info.FromPort);
if (currLst != null)
{
count++;
MessageCenter.Instance.NotifyOneMessage(currLst, info.MessageID, publishResult);
string text = string.Format("\r\n[{0}]Pub2 To,SessionID: {1} \r\n>>[ID:{2}]消息长度：{3} 字节 ,消息内容摘要：\r\n{4}",
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"),
info.SessionID,
info.MessageID,
publishResult.Length.ToString("###,###"),
DataConverter.DeEncrypt8bitString(publishResult.Length > 256 ? publishResult.Substring(0, 256) : publishResult)
);
workMessage += text;
//真正发布给监听器才算一次发布
lastPublishTime = DateTime.Now;
}
else
{
string text = string.Format("\r\n[{0}]Pub2 未找到监听器， Session,ID: {1} \r\n>>[ID:{2}]消息长度：{3} 字节 ,消息内容摘要：\r\n{4}",
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), info.SessionID, info.MessageID, publishResult.Length.ToString("###,###"),
publishResult.Length > 256 ? publishResult.Substring(0, 256) : publishResult);
workMessage += text;
this.SubscriberInfoList.Remove(info);
}
workMessage += string.Format("\r\n[{0}]请求处理完毕--Pub2 Count: {1} ,All usetime:{2}ms-------", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), count, sw.ElapsedMilliseconds);
}
}
sw.Stop();
workMessage += string.Format("\r\nPub2 CallService All Usetime:{0}ms.\r\n", sw.ElapsedMilliseconds);
}
/// <summary>
/// Add a new messagelistener.
/// </summary>
public void AddClient(MessageListener ml, String forUser)
{
lock (this) {
if (!m_clients.ContainsKey(forUser))
{
m_clients.Add(forUser, ml);
}
else
{
throw new AlreadyRegisteredException("a message listener is already registered for user: " +
forUser);
}
}
}
public void TestMessageListenerThrowsOnCloseInMessageCallback()
{
const int NUM_MSGS = 2;
const int MESSAGE_RECEIVE_TIMEOUT = 5000; // 5.0s
using (IConnection connection = this.GetConnection("default"))
using (IMessageConsumer consumer = this.GetConsumer("con1"))
using (IMessageProducer producer = this.GetProducer("pro1"))
{
try
{
//bool close = false;
MessageListener ackcallback = CreateListener(NUM_MSGS);
MessageListener callback = (m) =>
{
try
{
connection.Close();
}
catch (NMSException ex)
{
asyncEx = ex;
}
ackcallback(m);
};
consumer.Listener += callback;
connection.ExceptionListener += DefaultExceptionListener;
connection.Start();
ITextMessage message = producer.CreateTextMessage();
// Send a couple of messages and verify that an exception is
// thrown if the listener trys to Close() the connection.
producer.Send(message);
producer.Send(message);
if (!waiter.WaitOne(MESSAGE_RECEIVE_TIMEOUT))
{
Assert.Fail("Received {0} of {1} messages in {2}ms.", msgCount, NUM_MSGS, MESSAGE_RECEIVE_TIMEOUT);
}
connection.Stop();
Assert.NotNull(asyncEx, "Failed to receive Exception on MessageListener after {0} messages.", msgCount);
Assert.True(asyncEx is IllegalStateException, "Failed to Recieve the correct IllegalStateException Exception, received : {0}", asyncEx);
}
catch (Exception ex)
{
this.PrintTestFailureAndAssert(this.GetMethodName(), "Unexpected Exception.", ex);
}
}
}
public MsgDispatcher(Channel channel, MessageListener l, MembershipListener l2, RequestHandler req_handler, MessageResponder responder, bool deadlock_detection, bool concurrent_processing)
{
this.channel = channel;
this._ncacheLog = ((GroupChannel)channel).NCacheLog;
this.deadlock_detection = deadlock_detection;
this.concurrent_processing = concurrent_processing;
msg_listener = l;
membership_listener = l2;
_req_handler = req_handler;
_msgResponder = responder;
channel.UpHandler = this;
start();
}
public WhenDisposingListener()
{
var guid = Guid.NewGuid();
var configuration = new FakeListenerConfiguration
{
Binding = @"\\.\pipe\" + guid,
Mutex = "Harvester: " + guid
};
configuration["identity"] = "Everyone";
messageListener = new PipeMessageListener(messageProcessor.Object, configuration);
messageListener.Start();
}
public PhotonAgent()
{
WorkDirectory = Configuration.WorkDirectory;
Sessions = new AgentSessionManager();
MessageRegistry = new MessageProcessorRegistry();
Variables = new VariableSetDocumentManager();
RepositorySources = new RepositorySourceManager();
messageListener = new MessageListener(MessageRegistry);
RepositorySources.RepositorySourceDirectory = Configuration.RepositoryDirectory;
messageListener.ConnectionReceived += MessageListener_ConnectionReceived;
messageListener.ThreadException += MessageListener_ThreadException;
}
public TwitchService(IConfiguration config, MessageListener messageListener)
{
_messageListener = messageListener;
var credentials = new ConnectionCredentials(config["Bot:Username"], config["Bot:AccessToken"]);
var wsClient = new WebSocketClient();
_client = new TwitchClient(wsClient);
_client.Initialize(credentials);
_channelsToJoin = config["Bot:ChannelNames"].Split(",");
_client.OnJoinedChannel += ClientOnOnJoinedChannel;
_client.OnMessageReceived += ClientOnOnMessageReceived;
}
public IMicroClient CreateClient(ServiceAddress serviceAddress)
{
var lazyClient = _clients.GetOrAdd(serviceAddress, k => new Lazy <IMicroClient>(() =>
{
_logger.LogDebug($"创建客户端：{serviceAddress}创建客户端。");
var listener = new MessageListener();
var sender = new HttpClientMessageSender(_logger, _clientFactory, _codecFactory, serviceAddress.ToString(),
listener);
return(new MicroClient(_logger, sender, listener, _microExecutor));
}
));
return(lazyClient.Value);
}
public MsgDispatcher(Channel channel, MessageListener l, MembershipListener l2, RequestHandler req_handler, MessageResponder responder, bool deadlock_detection, bool concurrent_processing)
{
this.channel = channel;
this._ncacheLog = ((GroupChannel)channel).NCacheLog;
this.deadlock_detection = deadlock_detection;
this.concurrent_processing = concurrent_processing;
msg_listener = l;
membership_listener = l2;
_req_handler = req_handler;
_msgResponder = responder;
channel.UpHandler = this;
start();
}
public void LifeCycleTest()
{
var listenerSuccess = false;
var publisher = new InteractionMessenger();
var message = new GenericInteractionMessage<int>(1);
var listener = new MessageListener(publisher, m =>
{
((GenericInteractionMessage<int>)m).Value.Is(1);
listenerSuccess = true;
});
//------------------
listenerSuccess.Is(false);
publisher.Raise(message);
listenerSuccess.Is(true);
//------------------
listenerSuccess = false;
listener.Dispose();
publisher.Raise(message);
listenerSuccess.Is(false);
try
{
listener.RegisterAction(_ =>{});
}
catch (Exception e)
{
e.GetType().Is(typeof(ObjectDisposedException));
}
}
public void removeListener(MessageListener listener)
{
listeners.Remove(listener);
}
public void addListener(MessageListener listener)
{
listeners.Add(listener);
}
public MessageListenerHandler (object target)
{
this.target = target;
listener = target as MessageListener;
if (listener == null)
listener = new MessageListener (target);
}
public void RegisterMe(MessageListener listener, String forUser) {
ChatroomServer server = ChatroomServer.GetSingleton();
server.AddClient(listener, forUser);
}
private void subscribe(string messageType, MessageListener msgListener)
{
try
{
IDestination destination = session.GetTopic(messageType);
MessageConsumer consumer = (MessageConsumer)session.CreateConsumer(destination);
consumer.Listener += new MessageListener(OnMessage);
}
catch (Exception e) { }
}
public virtual void addMessageListener(MessageListener l)
{
eventSupport.addMessageListener(l);
}
//private Action<Message> messageHandle;
public Subscriber(string serviceUri, Action<Message> handle)
{
_serviceUri = serviceUri;
//messageHandle = handle;
_listener = new MessageListener(handle);
}
public virtual Channel startChannel(Session session, string profile, bool base64Encoding, string data, MessageListener listener)
{
StartChannelProfile p = new StartChannelProfile(profile, base64Encoding, data);
ArrayList l = new ArrayList();
l.Add(p);
return ((SessionImpl) session).startChannelRequest(l, listener, true);
}
public override void removeMessageListener(MessageListener l)
{
parserEventSupport.removeMessageListener(l);
}
public override void addMessageListener(MessageListener l)
{
parserEventSupport.addMessageListener(l);
}
public void ResponsiveMessageTest()
{
var listenerSuccess = false;
var publisher = new InteractionMessenger();
var message = new GenericResponsiveInteractionMessage<int,string>(1);
var listener = new MessageListener(publisher, m =>
{
var rm = (GenericResponsiveInteractionMessage<int, string>)m;
rm.Value.Is(1);
rm.Response = "test";
listenerSuccess = true;
});
listenerSuccess.Is(false);
publisher.GetResponse(message).Response.Is("test");
listenerSuccess.Is(true);
}
public void removeMessageListener(MessageListener listener)
{
messageHandler.removeListener(listener);
}
public void SourceReferenceMemoryLeakTest()
{
var handler1Called = false;
var publisherStrongReference = new InteractionMessenger();
var publisherWeakReference = new WeakReference<InteractionMessenger>(publisherStrongReference);
var message = new GenericInteractionMessage<int>(1, "Dummy1");
var listener = new MessageListener(publisherStrongReference);
listener.RegisterAction("Dummy1", _ =>handler1Called = true);
publisherStrongReference.Raise(message);
handler1Called.Is(true);
listener.Dispose();
publisherStrongReference = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
InteractionMessenger resultPublisher = null;
publisherWeakReference.TryGetTarget(out resultPublisher).Is(false);
resultPublisher.IsNull();
}
public virtual void removeMessageListener(MessageListener l)
{
((Parser)source).ErrorReported -= new MessageEventHandler(l.reportError);
((Parser)source).WarningReported -= new MessageEventHandler(l.reportWarning);
///messageListeners.Remove(l);
removeDoneListener(l);
}
public void AddHandlerKindTest()
{
var handler1Called = false;
var handler2Called = false;
var handler3Called = false;
var handler4Called = false;
var handler5Called = false;
var publisher = new InteractionMessenger();
var message0 = new GenericInteractionMessage<int>(1);
var message1 = new GenericInteractionMessage<int>(1, "Dummy1");
var message2 = new GenericInteractionMessage<int>(1, "Dummy2");
var listener1 = new MessageListener(publisher)
{
{"Dummy1", _ => handler1Called = true},
{"Dummy2",
_ => handler2Called = true,
_ => handler3Called = true
},
_ => handler4Called = true,
{"Dummy1", _ => handler5Called = true}
};
publisher.Raise(message0);
handler1Called.Is(false);
handler2Called.Is(false);
handler3Called.Is(false);
handler4Called.Is(true);
handler5Called.Is(false);
handler4Called = false;
publisher.Raise(message1);
handler1Called.Is(true);
handler2Called.Is(false);
handler3Called.Is(false);
handler4Called.Is(true);
handler5Called.Is(true);
handler1Called = false;
handler4Called = false;
handler5Called = false;
publisher.Raise(message2);
handler1Called.Is(false);
handler2Called.Is(true);
handler3Called.Is(true);
handler4Called.Is(true);
handler5Called.Is(false);
handler1Called = false;
handler2Called = false;
handler3Called = false;
handler4Called = false;
handler5Called = false;
listener1.Dispose();
publisher.Raise(message0);
publisher.Raise(message1);
publisher.Raise(message2);
handler1Called.Is(false);
handler2Called.Is(false);
handler3Called.Is(false);
handler4Called.Is(false);
handler5Called.Is(false);
}
public void RemoveListener (MessageListener listener)
{
RemoveListener ((object)listener);
}
/// <summary>Returns a <code>SharedChannel</code> which supports the specified
/// <code>profile</code> and calls back on the specified
/// <code>DataListener</code>. Once it is no longer needed, call
/// <code>release</code> on the <code>SharedChannel</code>
/// to return it to the pool of available channels.</summary>
/// <param name="profile">Name of profile for the requested
/// <code>SharedChannel</code>.</param>
/// <param name="listener"><code>DataListener</code> for the requested
/// <code>SharedChannel</code>.</param>
/// <returns>A <code>SharedChannel</code>.</returns>
/// <seealso cref="MessageListener"></seealso>
/// <seealso cref="SharedChannel"></seealso>
/// <exception cref="BEEPException" />
/// <deprecated></deprecated>
public virtual SharedChannel getSharedChannel(string profile, MessageListener listener)
{
lock (this)
{
SharedChannel sharedCh = null;
bool found = false;
lock (availableChannels)
{
for(int i=0;i<availableChannels.Count;i++)
{
sharedCh = (SharedChannel) availableChannels[i];
if (sharedCh.getProfile().Equals(profile))
{
log.trace("Found an available channel for sharing");
availableChannels.RemoveAt(i);
found = true;
break;
}
}
}
// nothing found, so create one and return it
if (!found)
{
sharedCh = new SharedChannel(this.session.startChannel(profile, listener), this);
}
// clean up channels that have expired
garbageCollect();
if (log.isTraceEnabled())
{
log.trace("Sharing channel number:" + sharedCh.Number);
}
return sharedCh;
}
}
public virtual void removeMessageListener(MessageListener l)
{
eventSupport.removeMessageListener(l);
}
// Add a parser message listener
public void addMessageListener(MessageListener listener)
{
messageHandler.addListener(listener);
}
