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);
        }
Пример #2
0
        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 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);
        }
Пример #4
0
        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 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);
        }
Пример #7
0
        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);
        }
Пример #9
0
        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 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;
        }
Пример #11
0
 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);
     }
 }
        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;
        }
Пример #15
0
        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);
        }
Пример #17
0
        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));
            }
        }
Пример #19
0
 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);
     }
 }
Пример #20
0
        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);
            }
        }
        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);
        }
Пример #23
0
        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);
            }
        }
Пример #24
0
        /// <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);
        }
Пример #25
0
        /// <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;
     }
 }
Пример #27
0
        /// <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);
        }
Пример #28
0
        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);
            }
        }
Пример #30
0
        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);
        }
Пример #31
0
        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);
        }
Пример #32
0
 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;
 }
Пример #33
0
        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);
        }
Пример #34
0
 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;
 }
Пример #35
0
        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));
        }
Пример #36
0
        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);
        }
Пример #37
0
        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);
        }
Пример #38
0
 public static IXDChannel GetLocalChannel(string name, XDTransportMode mode)
 {
     return new XDChannelImpl(name, mode, false);
 }
Пример #39
0
 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;
 }
Пример #42
0
 public static IXDChannel GetNetworkChannel(string name, XDTransportMode mode)
 {
     return(new XDChannelImpl(name, mode, true));
 }
        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);
        }
Пример #44
0
 public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode)
 {
     return GetBroadcasterForMode(transportMode, false);
 }
Пример #45
0
 internal static string GetNetworkListenerName(XDTransportMode transportMode)
 {
     return(string.Concat(transportMode, "_", RelayChannel));
 }
Пример #46
0
 public IXDBroadcaster GetBroadcasterForMode(XDTransportMode transportMode)
 {
     return(GetBroadcasterForMode(transportMode, false));
 }
Пример #47
0
 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;
 }
Пример #49
0
 public XDChannelImpl(string name, XDTransportMode mode, bool propagatesNetwork)
 {
     Name      = name;
     Mode      = mode;
     Propagate = propagatesNetwork;
 }
Пример #50
0
 public XDChannelImpl(string name, XDTransportMode mode, bool propagatesNetwork)
 {
     Name = name;
     Mode = mode;
     Propagate = propagatesNetwork;
 }
Пример #51
0
        /// <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);
        }