Example #1
0
        private InstrumentControlProxy()
        {
            // Create the objects that represent the control/event connections...

            // Make initial attempt to connect to the Instrument Control server.
            // Get the number of times to re-try if the connection attempt fails.
            NameValueCollection nvc = (NameValueCollection)System.Configuration.ConfigurationManager.GetSection("Separator/InstrumentControlConnection");
            int retryCount, retryWait;

            try
            {
                retryCount = int.Parse(nvc.Get("RetryCount"));
                retryWait  = int.Parse(nvc.Get("RetryWait_ms"));
            }
            catch
            {
                // Set default values in case the parse fails
                retryCount = 3;
                retryWait  = 2000;                      // milliseconds
            }

            do
            {
                try
                {
                    myXmlRpcProxy = new InstrumentControlXmlRpcProxy(
                        RemotingInfo.GetInstance().IcsServerURL);
                    retryCount = 0;                     // Clear the retry count as we're now connected.
                }
                catch (Exception ex)
                {
                    // Connection attempt failed.  Re-try if the number of attempts so far is
                    // within the retry count specified in the application configuration file,
                    // otherwise propagate an exception to tell the caller we failed to connect.
                    myXmlRpcProxy = null;
                    LogFile.AddMessage(TraceLevel.Warning, "retryCount = " + retryCount + " " + ex.Message);
                    if (--retryCount <= 0)
                    {
                        throw new ApplicationException(
                                  SeparatorResourceManager.GetSeparatorString(
                                      StringId.ExFailedToConnectToInstrumentControl));
                    }
                    // Pause before retrying connection attempt
                    Thread.Sleep(retryWait);
                }
            } while (retryCount > 0);
        }
Example #2
0
 /// <summary>
 /// </summary>
 public void Unsubscribe()
 {
     try
     {
         if (myXmlRpcProxy != null && IsConnectionEnabled)
         {
             // Disconnect from the XML-RPC server
             myXmlRpcProxy.Unsubscribe(RemotingInfo.GetInstance().IcsEventSinkURL);
         }
     }
     catch (Exception ex)
     {
         LogFile.LogException(TraceLevel.Error, ex);
         //DisableConnection();
         throw new ApplicationException(
                   "Unsubscribe exception", ex);
     }
 }
Example #3
0
 /// <summary>
 /// Make the connection to the Instrument Control XML-RPC server.
 /// </summary>
 public void Subscribe()
 {
     try
     {
         if (myXmlRpcProxy != null)
         {
             // Register for Instrument Control Events
             myXmlRpcProxy.Subscribe(RemotingInfo.GetInstance().IcsEventSinkURL);
         }
     }
     catch (Exception ex)
     {
         LogFile.LogException(TraceLevel.Error, ex);
         //DisableConnection();
         throw new ApplicationException(
                   SeparatorResourceManager.GetSeparatorString(
                       StringId.ExFailedToSubscribeToInstrumentControl), ex);
     }
 }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        public void Halt()
        {
            bool haltResult = false, unsubscribeResult = false;

            try
            {
                if (IsConnectionEnabled)
                {
                    // Tell the XML-RPC server to shut down its "RoboSep" command handling
                    haltResult = myXmlRpcProxy.Halt();

                    // Disconnect from the XML-RPC server
                    unsubscribeResult = myXmlRpcProxy.Unsubscribe(
                        RemotingInfo.GetInstance().IcsEventSinkURL);
                }
            }
            catch (WebException wex)
            {
                if (wex.Status != WebExceptionStatus.ConnectionClosed)
                {
                    // Log the details of the exception
                    LogException(wex, "Halt1");
                }
            }
            catch (Exception ex)
            {
                // Log the details of the exception
                LogException(ex, "Halt2");
            }
            finally
            {
                LogFile.AddMessage(TraceLevel.Verbose,
                                   "Instrument Control API Halt() returned " +
                                   haltResult.ToString());

                LogFile.AddMessage(TraceLevel.Verbose,
                                   "Instrument Control API Unsubscribe() returned " +
                                   unsubscribeResult.ToString());

                DisableConnection();
            }
        }
Example #5
0
 /// <summary>
 /// Retrieve Instrument Control server information including version number.
 /// </summary>
 /// <param name="gatewayURL"></param>
 /// <param name="gatewayInterfaceVersion"></param>
 /// <param name="serverUptime_seconds"></param>
 /// <param name="instrumentControlVersion"></param>
 /// <param name="instrumentSerialNumber"></param>
 /// <param name="serviceConnection"></param>
 public void GetServerInfo(out string gatewayURL, out string gatewayInterfaceVersion,
                           out string serverUptime_seconds, out string instrumentControlVersion,
                           out string instrumentSerialNumber, out string serviceConnection)
 {
     gatewayURL = gatewayInterfaceVersion = serverUptime_seconds = string.Empty;
     instrumentControlVersion = instrumentSerialNumber = serviceConnection = string.Empty;
     try
     {
         if (IsConnectionEnabled)
         {
             string[] serverInfo = myXmlRpcProxy.GetServerInfo();
             if (serverInfo != null && serverInfo.GetLength(0) == 5)
             {
                 gatewayURL = serverInfo[0];
                 gatewayInterfaceVersion  = serverInfo[1];
                 serverUptime_seconds     = serverInfo[2];
                 instrumentControlVersion = serverInfo[3];
                 instrumentSerialNumber   = serverInfo[4];
             }
             serviceConnection = RemotingInfo.GetInstance().HostDomainName;
             // If the service connection indicates the loopback address or local
             // machine, clear the service connection information (this will trigger
             // the UI to display a localised prompt for the user to connect a
             // cable and re-start.
             if (serviceConnection == RemotingInfo.GetInstance().LocalMachineName ||
                 serviceConnection == RemotingInfo.GetInstance().LoopbackAddress)
             {
                 serviceConnection = string.Empty;
             }
         }
     }
     catch (Exception ex)
     {
         // Log the details of the exception
         LogException(ex, "GetServerInfo");
     }
 }
Example #6
0
        private SeparatorImpl()
        {
            try
            {
                // -------------------
                // Set the fully-qualified machine name for the server (optionally supplied in
                // the application configuration file).
                NameValueCollection nvc = (NameValueCollection)System.Configuration.ConfigurationManager.GetSection("Separator/InstrumentControlConnection");

                string serverAddress = string.Empty;
                try
                {
                    serverAddress = nvc.Get("ServerAddress");
                }
                finally
                {
                    // Ignore any exceptions -- if we can't read the IP address configuration
                    // setting then we act as if it were not specified.
                }

                RemotingInfo.ConfigureInstance(serverAddress);

                string configuredAddress = (serverAddress == null || serverAddress == string.Empty) ?
                                           "<Not specified>" : serverAddress;
                LogFile.AddMessage(TraceLevel.Verbose, "Configured address = " + configuredAddress);

                // -------------------
                // Register an event handler for IInstrumentControlEvents
                RemotingConfiguration.Configure("Separator.exe.config", false);

                // -------------------
                // Setup TCP Server channel
                BinaryClientFormatterSinkProvider tcpClientSinkProvider = new BinaryClientFormatterSinkProvider();

                BinaryServerFormatterSinkProvider tcpServerSinkProvider = new BinaryServerFormatterSinkProvider();
                tcpServerSinkProvider.TypeFilterLevel = TypeFilterLevel.Full;

                ListDictionary tcpChannelProperties = new ListDictionary();
                tcpChannelProperties.Add("name", "SeparatorAPI");
                tcpChannelProperties.Add("port", 3149);

                TcpChannel tcpChannel = new TcpChannel(tcpChannelProperties, tcpClientSinkProvider, tcpServerSinkProvider);

                ChannelServices.RegisterChannel(tcpChannel, false);

                RemotingConfiguration.RegisterWellKnownServiceType(
                    typeof(InstrumentControlEventSink),
                    RemotingInfo.GetInstance().IcsEventSinkURI,
                    WellKnownObjectMode.Singleton);

                myTCPSvr         = OrcaTCPServer.GetInstance();
                myTCPSvr.TCPPort = myTCP_Port;
                // -------------------
                // Create the InstrumentControlEventSink
                try
                {
                    theInstrumentControlEventSink =
                        (IInstrumentControlEvents)Activator.GetObject(
                            typeof(InstrumentControlEventSink),
                            RemotingInfo.GetInstance().IcsEventSinkURL);
                    theInstrumentControlEventSink.ping();                        // Call a method to trigger the server
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            catch (Exception ex)
            {
                myInstrument = null;

                Console.WriteLine(ex.GetType());
                Console.WriteLine(ex.Message + "\n" + ex.InnerException);
                Console.WriteLine(ex.StackTrace);

                throw new ApplicationException();
            }
        }