private void RegisterNetworkListener(XDTransportMode mode) { if (disposed) { return; } if (!IsAlive) { return; } // listen on the network channel for this mode Task.Factory.StartNew(() => { propagateListener.RegisterChannel( NetworkRelayBroadcaster.GetNetworkListenerName(mode)); propagateListener.MessageReceived += OnNetworkMessageReceived; }).ContinueWith(t => { var e = t.Exception; if (!disposed) { Thread.Sleep(networkReTryTimeoutMilliSeconds); // retry attach listener RegisterNetworkListener(mode); } }, TaskContinuationOptions.OnlyOnFaulted); }
private void RegisterNetworkListener(XDTransportMode mode) { if (disposed) { return; } if (!IsAlive) { return; } Task.Factory.StartNew(() => { propagateListener.RegisterChannel( NetworkRelayBroadcaster.GetNetworkListenerName(mode)); propagateListener.MessageReceived += OnNetworkMessageReceived; }).ContinueWith(t => { // ReSharper disable once UnusedVariable var e = t.Exception; if (disposed) { return; } Thread.Sleep(NetworkReTryTimeoutMilliSeconds); RegisterNetworkListener(mode); }, TaskContinuationOptions.OnlyOnFaulted); }
private void InitializeMode(XDTransportMode mode) { listener?.Dispose(); listener = client.Listeners.GetListenerForMode(mode); listener.MessageReceived += OnMessageReceived; if (statusCheckBox.Checked) { listener.RegisterChannel("Status"); } if (channel1Check.Checked) { listener.RegisterChannel("BinaryChannel1"); } if (channel2Check.Checked) { listener.RegisterChannel("BinaryChannel2"); } if (broadcast != null) { var message = $"{uniqueInstanceName} is changing mode to {mode}"; broadcast.SendToChannel("Status", message); } broadcast = client.Broadcasters.GetBroadcasterForMode(mode, propagateCheck.Checked); }
public NetworkRelayBroadcaster(ISerializer serializer, XDTransportMode originalTransportMode, IXDBroadcaster networkBroadcaster) { Validate.That(serializer).IsNotNull(); Validate.That(networkBroadcaster).IsNotNull(); this.serializer = serializer; this.originalTransportMode = originalTransportMode; this.networkBroadcaster = networkBroadcaster; networkChannel = GetNetworkListenerName(originalTransportMode); }
public NetworkRelayMessage(string machineName, XDTransportMode originatingTransportMode, string channel, string message) { Validate.That(machineName).IsNotNullOrEmpty(); Validate.That(channel).IsNotNullOrEmpty(); Validate.That(message).IsNotNullOrEmpty(); this.machineName = machineName; this.originatingTransportMode = originatingTransportMode; this.channel = channel; this.message = message; }
public NetworkRelayBroadcaster(ISerializer serializer, XDTransportMode originalTransportMode, IXDBroadcaster networkBroadcaster) { serializer.Requires("serializer").IsNotNull(); networkBroadcaster.Requires("networkBroadcaster").IsNotNull(); this.serializer = serializer; this.originalTransportMode = originalTransportMode; this.networkBroadcaster = networkBroadcaster; networkChannel = GetNetworkListenerName(originalTransportMode); }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode) { switch (transportMode) { case XDTransportMode.HighPerformanceUI: return new XDWinMsgBroadcaster(serializer); case XDTransportMode.Compatibility: return new XDIOStreamBroadcaster(serializer); default: throw new ArgumentOutOfRangeException(nameof(transportMode), transportMode, null); } }
public NetworkRelayMessage(string machineName, XDTransportMode originatingTransportMode, string channel, string message) { machineName.Requires("machineName").IsNotNullOrWhiteSpace(); channel.Requires("channel").IsNotNullOrWhiteSpace(); message.Requires("message").IsNotNullOrWhiteSpace(); MachineName = machineName; OriginatingTransportMode = originatingTransportMode; Channel = channel; Message = message; }
/// <summary> /// Creates an concrete implementation of IXDListener to listen for messages using /// either a specific XDTransportMode. /// </summary> /// <param name="transport"></param> /// <returns></returns> public static IXDListener CreateListener(XDTransportMode transport) { switch (transport) { case XDTransportMode.IOStream: return new XDIOStreamListener(); case XDTransportMode.MailSlot: return new TheCodeKing.Net.Messaging.Concrete.MailSlot.XDMailSlotListener(); default: return new XDListener(true); } }
internal NetworkRelayListener(IXDBroadcaster nativeBroadcast, IXDListener nativeListener, IXDListener propagateListener, XDTransportMode mode) { nativeBroadcast.Requires("nativeBroadcast").IsNotNull(); nativeListener.Requires("nativeListener").IsNotNull(); propagateListener.Requires("propagateListener").IsNotNull(); this.nativeBroadcast = nativeBroadcast; this.propagateListener = propagateListener; this.nativeListener = nativeListener; this.nativeListener.MessageReceived += OnMessageReceived; RegisterNetworkListener(mode); }
/// <summary> /// Default constructor. /// </summary> /// <param name = "nativeBroadcast"></param> /// <param name = "nativeListener"></param> /// <param name = "propagateListener"></param> /// <param name = "mode"></param> internal NetworkRelayListener(IXDBroadcaster nativeBroadcast, IXDListener nativeListener, IXDListener propagateListener, XDTransportMode mode) { Validate.That(nativeBroadcast).IsNotNull(); Validate.That(nativeListener).IsNotNull(); Validate.That(propagateListener).IsNotNull(); this.nativeBroadcast = nativeBroadcast; this.propagateListener = propagateListener; this.nativeListener = nativeListener; this.nativeListener.MessageReceived += OnMessageReceived; RegisterNetworkListener(mode); }
public IXDListener GetListenerForMode(XDTransportMode transportMode) { switch (transportMode) { case XDTransportMode.HighPerformanceUI: return(new XDWinMsgListener(serializer)); case XDTransportMode.Compatibility: return(new XDIOStreamListener(serializer)); default: throw new ArgumentOutOfRangeException(nameof(transportMode), transportMode, null); } }
/// <summary> /// Creates an concrete implementation of IXDListener to listen for messages using /// either a specific XDTransportMode. /// </summary> /// <param name="transport"></param> /// <returns></returns> public static IXDListener CreateListener(XDTransportMode transport) { switch (transport) { case XDTransportMode.IOStream: return(new XDIOStreamListener()); case XDTransportMode.MailSlot: return(new TheCodeKing.Net.Messaging.Concrete.MailSlot.XDMailSlotListener()); default: return(new XDListener(true)); } }
private IXDListener GetListenerForModeInternal(XDTransportMode transportMode) { switch (transportMode) { case XDTransportMode.HighPerformanceUI: return new XDWinMsgListener(serializer); case XDTransportMode.Compatibility: return new XDIOStreamListener(serializer); case XDTransportMode.RemoteNetwork: return CreateNetworkListener(new UniqueIdentityProvider()); default: throw new ArgumentOutOfRangeException(nameof(transportMode), transportMode, null); } }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode) { switch (transportMode) { case XDTransportMode.HighPerformanceUI: return(new XDWinMsgBroadcaster(serializer)); case XDTransportMode.Compatibility: return(new XDIOStreamBroadcaster(serializer, Settings.IoStreamMessageTimeoutInMilliseconds)); default: throw new ArgumentOutOfRangeException(nameof(transportMode), transportMode, null); } }
private IXDListener GetListenerForModeInternal(XDTransportMode transportMode) { switch (transportMode) { case XDTransportMode.HighPerformanceUI: return(new XDWinMsgListener(serializer)); case XDTransportMode.Compatibility: return(new XDIOStreamListener(serializer)); case XDTransportMode.RemoteNetwork: return(CreateNetworkListener(new UniqueIdentityProvider())); default: throw new ArgumentOutOfRangeException(nameof(transportMode), transportMode, null); } }
/// <summary> /// Initialize the broadcast and listener mode. /// </summary> /// <param name = "mode">The new mode.</param> private void InitializeMode(XDTransportMode mode) { if (listener != null) { // ensure we dispose any previous listeners, dispose should aways be // called on IDisposable objects when we are done with it to avoid leaks listener.Dispose(); } // creates an instance of the IXDListener object using the given implementation listener = client.Listeners.GetListenerForMode(mode); // attach the message handler listener.MessageReceived += OnMessageReceived; // register the channels we want to listen on if (statusCheckBox.Checked) { listener.RegisterChannel("Status"); } // register if checkbox is checked if (channel1Check.Checked) { listener.RegisterChannel("BinaryChannel1"); } // register if checkbox is checked if (channel2Check.Checked) { listener.RegisterChannel("BinaryChannel2"); } // if we already have a broadcast instance if (broadcast != null) { // send in plain text var message = string.Format("{0} is changing mode to {1}", uniqueInstanceName, mode); broadcast.SendToChannel("Status", message); } // create an instance of IXDBroadcast using the given mode broadcast = client.Broadcasters.GetBroadcasterForMode(mode, propagateCheck.Checked); }
/// <summary> /// Initialize the broadcast and listener mode. /// </summary> /// <param name="mode">The new mode.</param> private void InitializeMode(XDTransportMode mode) { if (listener != null) { // ensure we dispose any previous listeners, dispose should aways be // called on IDisposable objects when we are done with it to avoid leaks listener.Dispose(); } // creates an instance of the IXDListener object using the given implementation listener = XDListener.CreateListener(mode); // attach the message handler listener.MessageReceived += new XDListener.XDMessageHandler(OnMessageReceived); // register the channels we want to listen on if (statusCheckBox.Checked) { listener.RegisterChannel("Status"); } // register if checkbox is checked if (channel1Check.Checked) { listener.RegisterChannel("Channel1"); } // register if checkbox is checked if (channel2Check.Checked) { listener.RegisterChannel("Channel2"); } // if we already have a broadcast instance if (broadcast != null) { broadcast.SendToChannel("Status", string.Format("{0} is changing mode to {1}", this.Handle, mode)); } // create an instance of IXDBroadcast using the given mode, // note IXDBroadcast does not implement IDisposable broadcast = XDBroadcast.CreateBroadcast(mode, propagateCheck.Checked); }
/// <summary> /// Creates an instance of IXDBroadcast with the otption to propagate over the local network. /// </summary> /// <param name="mode">The broadcast mode.</param> /// <param name="propagateNetwork">true to propagate messages over the local network.</param> /// <returns></returns> public static IXDBroadcast CreateBroadcast(XDTransportMode mode, bool propagateNetwork) { // MailSlots can communicate over a network by default, so // no need to use the NetworkRelayBroadcast instance for this type. if (mode == XDTransportMode.MailSlot) { return new XDMailSlotBroadcast(propagateNetwork); } IXDBroadcast broadcast = CreateBroadcast(mode); if (propagateNetwork) { // create a wrapper to broadcast that will also send messages over network return new NetworkRelayBroadcast(broadcast, XDBroadcast.CreateBroadcast(XDTransportMode.MailSlot, true)); } else { return broadcast; } }
/// <summary> /// Initialize the broadcast and listener mode. /// </summary> /// <param name="mode">The new mode.</param> public static void InitializeMode(XDTransportMode mode) { if (listener != null) { // ensure we dispose any previous listeners, dispose should aways be // called on IDisposable objects when we are done with it to avoid leaks listener.Dispose(); } listener = XDListener.CreateListener(mode); // attach the message handler listener.MessageReceived += OnMessageReceived; listener.RegisterChannel(CHANNEL_NAME); // create an instance of IXDBroadcast using the given mode, // note IXDBroadcast does not implement IDisposable broadcast = XDBroadcast.CreateBroadcast(mode, false); }
public IXDListener GetListenerForMode(XDTransportMode transportMode) { var listener = GetListenerForModeInternal(transportMode); if (transportMode == XDTransportMode.RemoteNetwork) { return listener; } var networkListener = CreateNetworkListener(new MachineNameIdentityProvider()); if (networkListener == null || !networkListener.IsAlive) { return listener; } var networkBroadcaster = client.Broadcasters.GetBroadcasterForMode(transportMode); listener = new NetworkRelayListener(networkBroadcaster, listener, networkListener, transportMode); return listener; }
/// <summary> /// Creates an instance of IXDBroadcast with the otption to propagate over the local network. /// </summary> /// <param name="mode">The broadcast mode.</param> /// <param name="propagateNetwork">true to propagate messages over the local network.</param> /// <returns></returns> public static IXDBroadcast CreateBroadcast(XDTransportMode mode, bool propagateNetwork) { // MailSlots can communicate over a network by default, so // no need to use the NetworkRelayBroadcast instance for this type. if (mode == XDTransportMode.MailSlot) { return(new XDMailSlotBroadcast(propagateNetwork)); } IXDBroadcast broadcast = CreateBroadcast(mode); if (propagateNetwork) { // create a wrapper to broadcast that will also send messages over network return(new NetworkRelayBroadcast(broadcast, XDBroadcast.CreateBroadcast(XDTransportMode.MailSlot, true))); } else { return(broadcast); } }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode, bool propagateNetwork) { var broadcaster = GetBroadcasterForModeInternal(transportMode); if (!propagateNetwork || transportMode == XDTransportMode.RemoteNetwork) { return broadcaster; } var remoteBroadcaster = CreateNetworkBroadcaster(); if (!remoteBroadcaster.IsAlive) { throw new ConfigurationErrorsException( "The RemoteNetwork Broadcaster is not configured. Check the configuration settings."); } var relayBroadcaster = new NetworkRelayBroadcaster( serializer, transportMode, remoteBroadcaster); return client.Broadcasters.GetMulticastBroadcaster(broadcaster, relayBroadcaster); }
public IXDListener GetListenerForMode(XDTransportMode transportMode) { var listener = GetListenerForModeInternal(transportMode); if (transportMode == XDTransportMode.RemoteNetwork) { return(listener); } var networkListener = CreateNetworkListener(new MachineNameIdentityProvider()); if (networkListener == null || !networkListener.IsAlive) { return(listener); } var networkBroadcaster = client.Broadcasters.GetBroadcasterForMode(transportMode); listener = new NetworkRelayListener(networkBroadcaster, listener, networkListener, transportMode); return(listener); }
public IXDListener GetListenerForMode(XDTransportMode transportMode) { var listener = Container.Resolve<IXDListener>(Convert.ToString(transportMode)); if (listener == null) { throw new NotSupportedException( string.Format( "No concrete IXDListener for mode {0} could be loaded. Install the {0} assembly in the program directory.", transportMode)); } if (transportMode != XDTransportMode.RemoteNetwork) { var networkListener = Container.Use<IIdentityProvider, MachineNameIdentityProvider>() .Resolve<IXDListener>(Convert.ToString(XDTransportMode.RemoteNetwork)); if (networkListener != null && networkListener.IsAlive) { var networkBroadcaster = client.Broadcasters.GetBroadcasterForMode(transportMode, false); listener = new NetworkRelayListener(networkBroadcaster, listener, networkListener, transportMode); } } return listener; }
public IXDListener GetListenerForMode(XDTransportMode transportMode) { var listener = Container.Resolve <IXDListener>(Convert.ToString(transportMode)); if (listener == null) { throw new NotSupportedException( string.Format( "No concrete IXDListener for mode {0} could be loaded. Install the {0} assembly in the program directory.", transportMode)); } if (transportMode != XDTransportMode.RemoteNetwork) { var networkListener = Container.Use <IIdentityProvider, MachineNameIdentityProvider>() .Resolve <IXDListener>(Convert.ToString(XDTransportMode.RemoteNetwork)); if (networkListener != null && networkListener.IsAlive) { var networkBroadcaster = client.Broadcasters.GetBroadcasterForMode(transportMode, false); listener = new NetworkRelayListener(networkBroadcaster, listener, networkListener, transportMode); } } return(listener); }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode, bool propagateNetwork) { var broadcaster = Container.Resolve<IXDBroadcaster>(Convert.ToString(transportMode)); if (broadcaster == null) { throw new NotSupportedException( string.Format( "No concrete IXDBroadcast for mode {0} could be loaded. Install the {0} assembly in the program directory.", transportMode)); } if (propagateNetwork && transportMode != XDTransportMode.RemoteNetwork) { var remoteBroadcaster = messagingClient.Broadcasters.GetBroadcasterForMode(XDTransportMode.RemoteNetwork); if (!remoteBroadcaster.IsAlive) { throw new ConfigurationErrorsException("The RemoteNetwork Broadcaster is not configured. Check the configuration settings."); } var relayBroadcaster = new NetworkRelayBroadcaster(Container.Resolve<ISerializer>(), transportMode, remoteBroadcaster); broadcaster = messagingClient.Broadcasters.GetMulticastBroadcaster(broadcaster, relayBroadcaster); } return broadcaster; }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode, bool propagateNetwork) { var broadcaster = GetBroadcasterForModeInternal(transportMode); if (!propagateNetwork || transportMode == XDTransportMode.RemoteNetwork) { return(broadcaster); } var remoteBroadcaster = CreateNetworkBroadcaster(); if (!remoteBroadcaster.IsAlive) { throw new ConfigurationErrorsException( "The RemoteNetwork Broadcaster is not configured. Check the configuration settings."); } var relayBroadcaster = new NetworkRelayBroadcaster( serializer, transportMode, remoteBroadcaster); return(client.Broadcasters.GetMulticastBroadcaster(broadcaster, relayBroadcaster)); }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode, bool propagateNetwork) { var broadcaster = Container.Resolve <IXDBroadcaster>(Convert.ToString(transportMode)); if (broadcaster == null) { throw new NotSupportedException( string.Format( "No concrete IXDBroadcast for mode {0} could be loaded. Install the {0} assembly in the program directory.", transportMode)); } if (propagateNetwork && transportMode != XDTransportMode.RemoteNetwork) { var remoteBroadcaster = messagingClient.Broadcasters.GetBroadcasterForMode(XDTransportMode.RemoteNetwork); if (!remoteBroadcaster.IsAlive) { throw new ConfigurationErrorsException("The RemoteNetwork Broadcaster is not configured. Check the configuration settings."); } var relayBroadcaster = new NetworkRelayBroadcaster(Container.Resolve <ISerializer>(), transportMode, remoteBroadcaster); broadcaster = messagingClient.Broadcasters.GetMulticastBroadcaster(broadcaster, relayBroadcaster); } return(broadcaster); }
public static IXDChannel GetLocalChannel(string name, XDTransportMode mode) { return new XDChannelImpl(name, mode, false); }
public static IXDChannel GetNetworkChannel(string name, XDTransportMode mode) { return new XDChannelImpl(name, mode, true); }
internal static string GetNetworkListenerName(XDTransportMode transportMode) { return string.Concat(transportMode, "_", RelayChannel); }
public XDBroadcasterHintAttribute(XDTransportMode mode) : base(Convert.ToString(mode), typeof(IXDBroadcaster)) { this.mode = mode; }
public static IXDChannel GetNetworkChannel(string name, XDTransportMode mode) { return(new XDChannelImpl(name, mode, true)); }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode) { return GetBroadcasterForMode(transportMode, false); }
internal static string GetNetworkListenerName(XDTransportMode transportMode) { return(string.Concat(transportMode, "_", RelayChannel)); }
public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode) { return(GetBroadcasterForMode(transportMode, false)); }
public static IXDChannel GetLocalChannel(string name, XDTransportMode mode) { return(new XDChannelImpl(name, mode, false)); }
public XDListenerHintAttribute(XDTransportMode mode) : base(Convert.ToString(mode), typeof(IXDListener)) { this.mode = mode; }
public XDChannelImpl(string name, XDTransportMode mode, bool propagatesNetwork) { Name = name; Mode = mode; Propagate = propagatesNetwork; }