public SimpleMessageDispatcher(IMessageListener messageListener, ITransportMessageCodecFactory transportMessageCodecFactory, ILogger logger)
{
_messageListener = messageListener;
_logger = logger;
_transportMessageEncoder = transportMessageCodecFactory.GetEncoder();
_transportMessageDecoder = transportMessageCodecFactory.GetDecoder();
}
public ClientRemoteConnectorInfoManager(RemoteWSFrameworkConnectionInfo info,
IMessageListener<WebSocketConnectionGroup, WebSocketConnectionHolder, RemoteOperationContext> listener,
ConcurrentDictionary<string, WebSocketConnectionGroup> globalConnectionGroups)
: base(listener, globalConnectionGroups)
{
_delegatingAsyncConnectorInfoManager =
new RemoteDelegatingAsyncConnectorInfoManager(this);
_info = info;
_timer = new Timer(state =>
{
WebSocketConnectionHolder[] connections = state as WebSocketConnectionHolder[];
if (null != connections)
{
for (int i = 0; i < 2; i++)
{
if (connections[i] == null || !connections[i].Operational)
{
WebSocketWrapper vr = WebSocketWrapper.Create(_info, listener, Handshake);
vr.ConnectAsync().ContinueWith((result, o) =>
{
if (result.IsCompleted)
{
connections[(int)o] = result.Result;
}
else if (result.IsFaulted)
{
TraceUtil.TraceException("Failed to establish connection", result.Exception);
}
}, i);
}
}
}
}, _connections, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5));
}
private void SubscribeTopic(IMessageListener listener)
{
var destination = _session.CreateTopic(_name);
var sub = _session.CreateDurableSubscriber(destination, TibcoSatellite.TibcoAddress.ToString());
sub.MessageListener = listener;
}
public void Restart() {
this._messageListener.Stop();
this._messageListener.Dispose();
this._messageListener = this._messageListener.Clone();
this._messageListener.Start();
}
private void SubscribeQueue(IMessageListener listener)
{
var destination = _session.CreateQueue(_name);
var messageConsumer = _session.CreateConsumer(destination);
messageConsumer.MessageListener = listener;
}
public static void UnregisterView(IMessageListener view)
{
if (_registeredViews.Contains(view))
{
_registeredViews.Remove(view);
}
}
public void AddListener(IMessageListener listener)
{
if (listeners.Contains(listener))
throw new ArgumentException("Listener already registered", "listener");
listeners.Add(listener);
}
private IConsumerHolder Start(string topicPattern, string groupId, IMessageListener listener, MessageListenerConfig listenerConfig, ConsumerType consumerType)
{
ISubscribeHandle subscribeHandle = engine.Start(new Subscriber(topicPattern, groupId, listener, listenerConfig, consumerType));
return new DefaultConsumerHolder(subscribeHandle);
}
public static void Disconnect()
{
IsConnected = false;
_messageListener = null;
try
{
try
{
if (_serverObject != null)
_serverObject.Detach(_clientObject);
}
catch (Exception)
{
_serverObject = null;
}
}
finally
{
if (_channel != null)
{
ChannelServices.UnregisterChannel(_channel);
_channel = null;
}
}
}
public Subscriber(String topicPattern, String groupId, IMessageListener consumer, MessageListenerConfig messageListenerConfig, ConsumerType consumerType)
{
TopicPattern = topicPattern;
GroupId = groupId;
Consumer = consumer;
ConsumerType = consumerType;
MessageListenerConfig = messageListenerConfig;
}
public TransportClient(IMessageSender messageSender, IMessageListener messageListener, ILogger logger, IServiceExecutor serviceExecutor)
{
_messageSender = messageSender;
_messageListener = messageListener;
_logger = logger;
_serviceExecutor = serviceExecutor;
messageListener.Received += MessageListener_Received;
}
public Chat CreateChat(string auctionId, string participant, IMessageListener messageListener)
{
CurrentChat = new Chat(auctionId, participant);
CurrentChat.AddIMessageListener(messageListener);
Chats.Add(CurrentChat);
OnChatCreated(EventArgs.Empty);
return CurrentChat;
}
public TransportClient(IMessageSender messageSender, IMessageListener messageListener, ILogger logger, ISerializer<byte[]> serializer)
{
_messageSender = messageSender;
_messageListener = messageListener;
_logger = logger;
_serializer = serializer;
messageListener.Received += MessageListener_Received;
}
public void Subscribe(string key, IMessageListener listener)
{
if (key != _key) return;
if (_type == "topic")
SubscribeTopic( listener);
else
SubscribeQueue(listener);
}
public void AddListener(IMessageListener messageListener)
{
messageListener.Initialize(dataStoreManager);
messageListeners.Add(messageListener);
var instance = messageListener as IVariableFallbackHandler;
if (instance != null)
variableHandler.AddFallbackHandler(instance);
}
public void SendConnectionRequest(string name, string remoteEndpointId, byte[] payload, System.Action<ConnectionResponse> responseCallback, IMessageListener listener)
{
Debug.LogError("SendConnectionRequest called from dummy implementation");
if (responseCallback != null)
{
ConnectionResponse obj = ConnectionResponse.Rejected(0, string.Empty);
responseCallback.Invoke(obj);
}
}
public void TestSetup() {
// ensure an empty db context exists
using (TestDbContext dbContext = TestDbContext.CreateReset()) {
dbContext.SaveChanges();
}
// set-up a listener
this._messageListener = new TcpMessageListener(
new TcpClientFactory(), new JsonMessageDeserializerFactory(new DefaultMessageTypeResolver()), this._messageEventDispatcher);
}
public ConsumerContext(Topic topic, String groupId, IMessageListener consumer, Type messageClazz,
ConsumerType consumerType, MessageListenerConfig messageListenerConfig)
{
Topic = topic;
GroupId = groupId;
Consumer = consumer;
MessageClazz = messageClazz;
ConsumerType = consumerType;
SessionId = Guid.NewGuid().ToString();
MessageListenerConfig = messageListenerConfig;
}
public Chat CreateChat(string auctionId, IMessageListener messageListener)
{
CurrentChat = new Chat(auctionId, XMPPConnection.UserName);
if (messageListener != null)
{
CurrentChat.AddIMessageListener(messageListener);
}
Chats.Add(CurrentChat);
OnChatCreated(EventArgs.Empty);
return CurrentChat;
}
public void TestSetup() {
try {
this._messageSink.Start();
}
catch (SocketException ex) {
Assert.Inconclusive("This unit test is currently unstable for unknown reasons. Please try to run it again.\r\n\r\n Underlying exception:\r\n {0}", ex);
}
this._messageListener = new TcpMessageListener(
new TcpClientFactory(), new JsonMessageDeserializerFactory(CreateTypeResolver()), this._messageEventDispatcher);
}
public void AcceptConnectionRequest(string remoteEndpointId, byte[] payload,
IMessageListener listener)
{
Misc.CheckNotNull(remoteEndpointId, "remoteEndpointId");
Misc.CheckNotNull(payload, "payload");
Misc.CheckNotNull(listener, "listener");
GooglePlayGames.OurUtils.Logger.d("Calling AcceptConncectionRequest");
mManager.AcceptConnectionRequest(remoteEndpointId, payload, ToMessageListener(listener));
GooglePlayGames.OurUtils.Logger.d("Called!");
}
public void SetupBeforeEachTest()
{
this.taskLibrary = A.Fake<ITaskLibrary>();
this.messageListener = A.Fake<IMessageListener>();
this.cancellationTokenSource = new CancellationTokenSource();
A.CallTo(() => this.taskLibrary.CreateCancellationTokenSource()).Returns(this.cancellationTokenSource);
this.task = new Task(() => { });
A.CallTo(() => this.taskLibrary.ExecuteAsync(A<Action>._)).Returns(this.task);
this.componentUnderTest = new MessageSubscription(this.taskLibrary, this.messageListener);
}
/// <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 Task.Run(() =>
{
MessageListener.OnReceived(sender, message);
});
};
}
public void AddMessageHandler(IMessageListener listener, string user = null)
{
_jc.OnMessage += new MessageHandler((sender, message) =>
{
if(!string.IsNullOrEmpty(message.Body) &&
(user == null || user == message.From.Bare))
{
log.Info(string.Format("Message from {0}: {1}", message.From.Bare, message.Body));
listener.ProcessMessage(message);
}
});
}
public TradesCache(IMessageListener<Trade> messageListener)
{
if (messageListener == null) throw new ArgumentNullException("messageListener");
// IMessageListener <Trade> acts as the back end for this example.
Trades = messageListener.Messages
.Buffer(TimeSpan.FromMilliseconds(50)) //add a small buffer so inital load (about 5000-10000) trades are batched
.Where(buffer=> buffer.Count!=0) //I hate the fact that empty buffers produce a notification
.ToObservableChangeSet(trade=>trade.Id) //convert this into a dynamic data observable
.AsObservableCache(); //cache it
_cleanup = Trades;
}
public AutoTestVSRunInformation()
{
InitializeComponent();
runFeedback.CanGoToTypes = true;
_provider = new FeedbackProvider(
new LabelItembehaviour(runFeedback.linkLabelCancelRun),
new LabelItembehaviour(runFeedback.linkLabelDebugTest),
new LabelItembehaviour(runFeedback.linkLabelTestDetails),
new LabelItembehaviour(runFeedback.linkLabelErrorDescription));
runFeedback.SetFeedbackProvider(_provider);
_listener = new FeedbackListener(_provider);
Connect.AddListener(_listener);
}
public RunFeedbackForm(string path)
{
InitializeComponent();
Text += " - " + path;
runFeedback1.ShowIcon = false;
_provider = new FeedbackProvider(
new LabelItembehaviour(runFeedback1.linkLabelCancelRun),
new LabelItembehaviour(runFeedback1.linkLabelDebugTest),
new LabelItembehaviour(runFeedback1.linkLabelTestDetails),
new LabelItembehaviour(runFeedback1.linkLabelErrorDescription));
runFeedback1.SetFeedbackProvider(_provider);
_listener = new FeedbackListener(_provider);
_syncContext = AsyncOperationManager.SynchronizationContext;
RunFeedbackFormResize(this, new EventArgs());
UpdateMenu(false);
}
///<summary>
///</summary>
///<param name="subscriber"></param>
///<param name="filter">the filter associated with this subscriber</param>
/// <returns>return if the <paramref name="subscriber"/>is already subscribed</returns>
/// <remarks>if there is already a filer, subscribing will generate a DisJunction filter for them. <see cref="MessageFilters.DisJunctionFilter"/>
/// </remarks>
public bool Subscribe(IMessageListener subscriber, IMessageFilter filter)
{
if (filter == null)
filter = NullMsgFilter.Instance;
if (generalSubscribers.ContainsKey(subscriber)) {
IMessageFilter existingFilter = generalSubscribers[subscriber];
if (existingFilter != null)
generalSubscribers[subscriber] = MessageFilters.DisJunctionFilter(
new IMessageFilter[] {filter, existingFilter});
else
generalSubscribers[subscriber] = filter;
return true;
}
else {
generalSubscribers.Add(subscriber, filter);
return false;
}
}
public static void Connect(IMessageListener messageListener)
{
Timer.Change(0, Timeout.Infinite);
if (messageListener == null) return;
if (string.IsNullOrWhiteSpace(LocalSettings.MessagingServerName)) return;
_messageListener = messageListener;
var serverProv = new BinaryServerFormatterSinkProvider
{
TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full
};
var clientProv = new BinaryClientFormatterSinkProvider();
IDictionary props = new Hashtable();
props["port"] = 0;
_channel = new TcpChannel(props, clientProv, serverProv);
ChannelServices.RegisterChannel(_channel, false);
var url = String.Format("tcp://{0}:{1}/ChatServer", LocalSettings.MessagingServerName, LocalSettings.MessagingServerPort);
try
{
_serverObject = (MessagingServerObject)Activator.GetObject(typeof(MessagingServerObject), url);
_clientObject = new MessagingClientObject();
_serverObject.Attach(_clientObject);
}
catch
{
HandleError();
return;
}
IsConnected = true;
Timer.Change(0, 1000);
}
public MessageBind(IMessageListener listener)
{
Listener = listener;
m_messageTypes = new List <object>();
}
public void RegisterMessageListener(IMessageListener listener)
{
_messageListener = listener;
}
public void StopAdvertising()
{
mClient.Call("stopAdvertising");
mAdvertisingMessageListener = null;
}
public PayloadCallback(IMessageListener listener) : base(
"com/google/games/bridge/PayloadCallbackProxy$Callback")
{
mListener = listener;
}
public void AddMessageListener(IMessageListener listener)
{
_messageHandler.AddListener(listener);
}
public void AcceptConnectionRequest(string remoteEndpointId, byte[] payload, IMessageListener listener)
{
Debug.LogError("AcceptConnectionRequest in dummy implementation called");
}
public void Unsubscribe(IMessageListener listener)
{
_listeners.Remove(listener);
}
public void Subscribe(IMessageListener listener)
{
_listeners.Add(listener);
}
public static DispatchingConsumer Instance(IModel channel, IMessageListener messageListener,
in bool isClosed)
public void Subscribe(string key, IMessageListener listener)
{
_destinations.ForEach(x => x.Subscribe(key, listener));
}
public void RemoveMessageListener(IMessageListener listener)
{
_messageHandler.RemoveListener(listener);
}
/// <summary>
/// Determines whether the specified listener is registered with this filter.
/// </summary>
/// <param name="listener"></param>
/// <returns></returns>
public bool ContainsListener(IMessageListener listener)
{
return(this.listeners.IndexOf(listener) >= 0);
}
public void SendConnectionRequest(string name, string remoteEndpointId, byte[] payload,
Action <ConnectionResponse> responseCallback, IMessageListener listener)
{
Misc.CheckNotNull(remoteEndpointId, "remoteEndpointId");
Misc.CheckNotNull(payload, "payload");
Misc.CheckNotNull(responseCallback, "responseCallback");
Misc.CheckNotNull(listener, "listener");
responseCallback = Callbacks.AsOnGameThreadCallback(responseCallback);
using (var nativeListener = ToMessageListener(listener))
{
mManager.SendConnectionRequest(
name,
remoteEndpointId,
payload,
(localClientId, response) => responseCallback(response.AsResponse(localClientId)),
nativeListener);
}
}
public void SendConnectionRequest(string name, string remoteEndpointId, byte[] payload,
System.Action <ConnectionResponse> responseCallback, IMessageListener listener)
{
Debug.LogError("SendConnectionRequest called from dummy implementation");
if (responseCallback != null)
{
ConnectionResponse obj = ConnectionResponse.Rejected(0, string.Empty);
responseCallback.Invoke(obj);
}
}
public SimpleRabbitListenerEndpoint(IApplicationContext context, IMessageListener listener = null, ILoggerFactory loggerFactory = null)
: base(context, loggerFactory)
{
MessageListener = listener;
}
public DefaultChannelHandler(IMessageListener messageListener, ISerializer <byte[]> serializer)
{
_messageListener = messageListener;
_serializer = serializer;
}
public static void RegisterListener(string name, IMessageListener listener)
{
_destinations[name] = listener;
}
/// <summary>
/// Initializes a new instance of the <see cref="StatusbarViewModel"/> class.
/// </summary>
/// <param name="baseServices">The base services.</param>
/// <param name="messageListener">The message listener.</param>
public StatusbarViewModel(IViewModelBaseServices baseServices, IMessageListener messageListener)
: base(baseServices, messageListener)
{
$specialContent1$
}
public override async Task StartAsync(string ip, int port)
{
_serverMessageListener = await _messageListenerFactory(new IPEndPoint(IPAddress.Parse(ip), port));
}
public void StopAllConnections()
{
mClient.Call("stopAllEndpoints");
mAdvertisingMessageListener = null;
}
/// <summary>
///
/// </summary>
/// <param name="handler"></param>
/// <returns></returns>
public AnycastClient AddListener(IMessageListener listener)
{
_listeners.Add(listener);
return(this);
}
public OnGameThreadMessageListener(IMessageListener listener)
{
mListener = Misc.CheckNotNull(listener);
}
public ChannelAwareMessageListener(DirectReplyToMessageListenerContainer container, IMessageListener listener)
{
_container = container;
_listener = listener;
}
public void SendConnectionRequest(string name, string remoteEndpointId, byte[] payload,
Action <ConnectionResponse> responseCallback, IMessageListener listener)
{
Misc.CheckNotNull(listener, "listener");
var listenerOnGameThread = new OnGameThreadMessageListener(listener);
var cb =
new DiscoveringConnectionLifecycleCallback(responseCallback, listenerOnGameThread, mClient);
using (var connectionLifecycleCallback =
new AndroidJavaObject("com.google.games.bridge.ConnectionLifecycleCallbackProxy", cb))
using (mClient.Call <AndroidJavaObject>("requestConnection", name, remoteEndpointId,
connectionLifecycleCallback))
{
;
}
}
/// <summary>
/// Creates local holder instance.
/// </summary>
/// <param name="grid">Ignite instance.</param>
/// <param name="listener">Filter.</param>
/// <returns>
/// New instance of <see cref="MessageListenerHolder" />
/// </returns>
public static MessageListenerHolder CreateLocal <T>(Ignite grid, IMessageListener <T> listener)
{
Debug.Assert(listener != null);
return(new MessageListenerHolder(grid, listener, (id, msg) => listener.Invoke(id, (T)msg)));
}
//create worker manager, create message listener and start listening to the queue
private async Task <int> RunAsync(AgentSettings settings)
{
Trace.Info(nameof(RunAsync));
_listener = HostContext.GetService <IMessageListener>();
if (!await _listener.CreateSessionAsync(HostContext.AgentShutdownToken))
{
return(Constants.Agent.ReturnCode.TerminatedError);
}
_term.WriteLine(StringUtil.Loc("ListenForJobs", DateTime.UtcNow));
IJobDispatcher jobDispatcher = null;
CancellationTokenSource messageQueueLoopTokenSource = CancellationTokenSource.CreateLinkedTokenSource(HostContext.AgentShutdownToken);
try
{
var notification = HostContext.GetService <IJobNotification>();
if (!String.IsNullOrEmpty(settings.NotificationSocketAddress))
{
notification.StartClient(settings.NotificationSocketAddress);
}
else
{
notification.StartClient(settings.NotificationPipeName, HostContext.AgentShutdownToken);
}
// this is not a reliable way to disable auto update.
// we need server side work to really enable the feature
// https://github.com/Microsoft/vsts-agent/issues/446 (Feature: Allow agent / pool to opt out of automatic updates)
bool disableAutoUpdate = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("agent.disableupdate"));
bool autoUpdateInProgress = false;
Task <bool> selfUpdateTask = null;
jobDispatcher = HostContext.CreateService <IJobDispatcher>();
while (!HostContext.AgentShutdownToken.IsCancellationRequested)
{
TaskAgentMessage message = null;
bool skipMessageDeletion = false;
try
{
Task <TaskAgentMessage> getNextMessage = _listener.GetNextMessageAsync(messageQueueLoopTokenSource.Token);
if (autoUpdateInProgress)
{
Trace.Verbose("Auto update task running at backend, waiting for getNextMessage or selfUpdateTask to finish.");
Task completeTask = await Task.WhenAny(getNextMessage, selfUpdateTask);
if (completeTask == selfUpdateTask)
{
autoUpdateInProgress = false;
if (await selfUpdateTask)
{
Trace.Info("Auto update task finished at backend, an agent update is ready to apply exit the current agent instance.");
Trace.Info("Stop message queue looping.");
messageQueueLoopTokenSource.Cancel();
try
{
await getNextMessage;
}
catch (Exception ex)
{
Trace.Info($"Ignore any exception after cancel message loop. {ex}");
}
return(Constants.Agent.ReturnCode.AgentUpdating);
}
else
{
Trace.Info("Auto update task finished at backend, there is no available agent update needs to apply, continue message queue looping.");
}
}
}
message = await getNextMessage; //get next message
if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
{
if (disableAutoUpdate)
{
Trace.Info("Refresh message received, skip autoupdate since environment variable agent.disableupdate is set.");
}
else
{
if (autoUpdateInProgress == false)
{
autoUpdateInProgress = true;
var agentUpdateMessage = JsonUtility.FromString <AgentRefreshMessage>(message.Body);
var selfUpdater = HostContext.GetService <ISelfUpdater>();
selfUpdateTask = selfUpdater.SelfUpdate(agentUpdateMessage, jobDispatcher, HostContext.StartupType != StartupType.Service, HostContext.AgentShutdownToken);
Trace.Info("Refresh message received, kick-off selfupdate background process.");
}
else
{
Trace.Info("Refresh message received, skip autoupdate since a previous autoupdate is already running.");
}
}
}
else if (string.Equals(message.MessageType, JobRequestMessageTypes.AgentJobRequest, StringComparison.OrdinalIgnoreCase))
{
if (autoUpdateInProgress)
{
skipMessageDeletion = true;
}
else
{
var newJobMessage = JsonUtility.FromString <AgentJobRequestMessage>(message.Body);
jobDispatcher.Run(newJobMessage);
}
}
else if (string.Equals(message.MessageType, JobCancelMessage.MessageType, StringComparison.OrdinalIgnoreCase))
{
var cancelJobMessage = JsonUtility.FromString <JobCancelMessage>(message.Body);
bool jobCancelled = jobDispatcher.Cancel(cancelJobMessage);
skipMessageDeletion = autoUpdateInProgress && !jobCancelled;
}
else
{
Trace.Error($"Received message {message.MessageId} with unsupported message type {message.MessageType}.");
}
}
finally
{
if (!skipMessageDeletion && message != null)
{
try
{
await _listener.DeleteMessageAsync(message);
}
catch (Exception ex)
{
Trace.Error($"Catch exception during delete message from message queue. message id: {message.MessageId}");
Trace.Error(ex);
}
finally
{
message = null;
}
}
}
}
}
finally
{
if (jobDispatcher != null)
{
await jobDispatcher.ShutdownAsync();
}
//TODO: make sure we don't mask more important exception
await _listener.DeleteSessionAsync();
messageQueueLoopTokenSource.Dispose();
}
return(Constants.Agent.ReturnCode.Success);
}
/// <summary>
/// Removes the specified listener.
/// </summary>
/// <param name="listener"></param>
public void RemoveListener(IMessageListener listener)
{
this.listeners.Remove(listener);
this.EnsureInstalledHooks();
}
public void Register(IMessageListener <T> listener)
{
MessageEvent += listener.OnMessaged;
}
public void SetListener(IMessageListener listener) => throw new NotImplementedException();
/// <summary>
/// Invoke the specified listener a Spring Rabbit MessageListener.
/// </summary>
/// <remarks>Default implementation performs a plain invocation of the
/// <code>OnMessage</code> methods</remarks>
/// <param name="listener">The listener to invoke.</param>
/// <param name="message">The received message.</param>
protected virtual void DoInvokeListener(IMessageListener listener, Message message)
{
try
{
listener.OnMessage(message);
}
catch (Exception e)
{
throw this.WrapToListenerExecutionFailedExceptionIfNeeded(e);
}
}
public void Unregister(IMessageListener <T> listener)
{
MessageEvent -= listener.OnMessaged;
}
