예제 #1
0
        /// <summary>
        /// Create the proxy to the native session
        /// </summary>
        /// <returns></returns>

        public INativeSession CreateNativeSessionProxy()
        {
            INativeSession sessionClient = null;

            if (NativeServiceClientFactory == null)
            {
                lock (NativeServiceClientFactoryLock)
                {
                    if (NativeServiceClientFactory == null)
                    {
                        if (Session == null)
                        {
                            throw new Exception("Session is null");
                        }

                        string endpointAddressString =                         // get string form of address
                                                       NativeSessionEndpointAddress.Build(Session.ProcessId);
                        Uri endpointUri = new Uri(endpointAddressString);

                        EndpointAddress endpointAddress =
                            new EndpointAddress(endpointUri, ServiceEndpointIdentity);

                        string endpointConfigurationName = "NativeSession_TCPEndpoint";
                        NativeServiceClientFactory =
                            new ChannelFactory <INativeSession>(endpointConfigurationName, endpointAddress);
                    }
                }
            }

            sessionClient = NativeServiceClientFactory.CreateChannel();             // create channel to new client
            return(sessionClient);
        }
예제 #2
0
        /// <summary>
        /// Invoke service method thread method
        /// </summary>
        /// <param name="nativeClient"></param>
        /// <param name="serviceCodeInt"></param>
        /// <param name="opCodeInt"></param>
        /// <param name="argObject"></param>

        void InvokeNativeMethodThread(
            INativeSession nativeClient,
            int serviceCodeInt,
            int opCodeInt,
            NativeMethodTransportObject argObject)
        {
            object resultObj = null;

            try
            {
                InvokeNativeMethodEntered = true;

                resultObj = nativeClient.InvokeNativeMethod(serviceCodeInt, opCodeInt, argObject);
                InvokeNativeMethodResult = resultObj as NativeMethodTransportObject;

                //if (xxxNativeMethodInvoker.ServiceCallCount == 10) throw new Exception("There was no endpoint listening"); // debug

                if (InvokeNativeMethodResult != null)
                {
                    return;
                }
                else
                {
                    throw new Exception("Null result returned");
                }
            }

            catch (Exception ex)             // unexpected exception
            {
                InvokeNativeMethodResult    = null;
                InvokeNativeMethodException = ex;
                return;
            }
        }
예제 #3
0
        /// <summary>
        /// Call native method & process any exception
        /// </summary>
        /// <param name="nativeClient"></param>
        /// <param name="serviceCode"></param>
        /// <param name="opCode"></param>
        /// <param name="argObject"></param>
        /// <returns></returns>

        public static NativeMethodTransportObject InvokeNativeMethod(
            INativeSession nativeClient,
            int serviceCodeInt,
            int opCodeInt,
            NativeMethodTransportObject argObject)
        {
            NativeMethodTransportObject resultObj = NativeSessionClient.InvokeNativeMethod(nativeClient, serviceCodeInt, opCodeInt, argObject);

            return(resultObj);
        }
예제 #4
0
        /// <summary>
        /// Call native method & process any exception
        /// </summary>
        /// <param name="nativeClient"></param>
        /// <param name="serviceCode"></param>
        /// <param name="opCode"></param>
        /// <param name="argObject"></param>
        /// <returns></returns>

        public NativeMethodTransportObject InvokeNativeMethod(
            INativeSession nativeClient,
            int serviceCodeInt,
            int opCodeInt,
            NativeMethodTransportObject transportObject)
        {
            NativeMethodInvokerInstance = new NativeMethodInvoker();

            NativeMethodTransportObject resultObject =
                NativeMethodInvokerInstance.InvokeNativeMethod(
                    nativeClient,
                    serviceCodeInt,
                    opCodeInt,
                    transportObject);

            return(resultObject);
        }
예제 #5
0
        /// <summary>
        /// Call a service method and return result
        /// </summary>
        /// <param name="serviceCode"></param>
        /// <param name="subServiceCode"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>

        public NativeMethodTransportObject CallServiceMethod(
            ServiceCodes serviceCode,
            object subServiceCode,
            object parameters)
        {
            INativeSession nativeClient = CreateNativeSessionProxy();

            NativeMethodInvokerInstance = new NativeMethodInvoker();
            Services.Native.NativeMethodTransportObject resultObject =
                NativeMethodInvokerInstance.InvokeNativeMethod(
                    nativeClient,
                    (int)serviceCode,
                    (int)subServiceCode,
                    new NativeMethodTransportObject(parameters));
            ((IClientChannel)nativeClient).Close();
            return(resultObject);
        }
예제 #6
0
        internal void InvokeNativeMethod(
            INativeSession nativeClient,
            int serviceCodeInt,
            int opCodeInt,
            NativeMethodTransportObject argObject)
        {
            //NativeMethodInvoker.ServiceCallSyncLock.WaitOne(); // get the mutex (beware of deadlocks)

            if (SynchronizationContext.Current is WindowsFormsSynchronizationContext && NativeMethodInvoker.RunUIServiceCallsOnSeparateThread)
            {             // do in separate thread if this is the UI thread
                ThreadStart ts           = delegate() { InvokeNativeMethodThread(nativeClient, serviceCodeInt, opCodeInt, argObject); };
                Thread      workerThread = new Thread(ts);
                workerThread.Name         = "InvokeNativeMethod " + serviceCodeInt + ", " + opCodeInt;
                workerThread.IsBackground = true;
                workerThread.SetApartmentState(ApartmentState.STA);

                InvokeNativeMethodResult    = null;
                InvokeNativeMethodException = null;
                InvokeNativeMethodEntered   = false;
                workerThread.Start();
                while (!InvokeNativeMethodEntered)
                {
                    Thread.Sleep(1);                                                // loop until worker thread activates and the method is entered
                }
                while (workerThread.IsAlive)
                {
                    if (InvokeNativeMethodResult != null || InvokeNativeMethodException != null)
                    {
                        break;
                    }
                    Thread.Sleep(2);
                    Application.DoEvents();
                }

                //NativeMethodInvoker.ServiceCallSyncLock.ReleaseMutex(); // release after call (keeps other non-UI threads from making calls until we are complete)
            }

            else             // non-UI thread, just call directly
            {
                //NativeMethodInvoker.ServiceCallSyncLock.ReleaseMutex(); // release before call
                InvokeNativeMethodThread(nativeClient, serviceCodeInt, opCodeInt, argObject);
            }

            return;
        }
예제 #7
0
        /// <summary>
        /// Call native method & process any exception
        /// </summary>
        /// <param name="nativeClient"></param>
        /// <param name="serviceCode"></param>
        /// <param name="opCode"></param>
        /// <param name="argObject"></param>
        /// <returns></returns>

        public NativeMethodTransportObject InvokeNativeMethod(
            INativeSession nativeClient,
            int serviceCodeInt,
            int opCodeInt,
            NativeMethodTransportObject transportObject)
        {
            NativeMethodTransportObject resultObj = null;
            string servicesExceptionHeader        = "*** InvokeNativeMethod Exception ***\r\n";      // this exception header is added by the services upon an exception
            bool   isException = false;

            int    t0 = 0;
            string classAndMethod = "", msg = "", exceptionType = "";

            if (LogServiceCalls)
            {
                t0             = ComOps.TimeOfDay.Milliseconds();
                classAndMethod = DebugLog.GetCallingClassAndMethodPrefix();
                if (IDebugLog != null)
                {
                    IDebugLog.Message("[ServiceCallBegin]" + classAndMethod + "Begin");
                }
            }

            DateTime callStart = DateTime.Now;

            if (ServiceCallCount == 0)
            {
                FirstServiceCallTime = DateTime.Now;
            }
            LastServiceCallTime = DateTime.Now;

            NativeMethodCaller nmc = new NativeMethodCaller();

            InServiceCall = true;
            nmc.InvokeNativeMethod(nativeClient, serviceCodeInt, opCodeInt, transportObject);
            resultObj     = nmc.InvokeNativeMethodResult;         // any result returned
            InServiceCall = false;

            ServiceCallCount++;             // count it as complete

            // Regular exception thown on the client?

            if (nmc.InvokeNativeMethodException != null)
            {
                isException = true;

                msg = DebugLog.FormatExceptionMessage(nmc.InvokeNativeMethodException);

                // Check if link to services no longer exists (e.g. Server process killed or Mobius server restarted)

                if (Lex.Contains(msg, "There was no endpoint listening") ||
                    Lex.Contains(msg, "Count not connect") ||
                    Lex.Contains(msg, "A connection attempt failed"))                           // && ServiceCallCount > 1)
                {
                    msg =
                        @"The connection to Mobius services has been lost. 
Session start time: {0:G}, Service Calls: {1}, Last service call: {2:G})

Do you want to restart the Mobius client?";

                    msg = String.Format(msg, FirstServiceCallTime, ServiceCallCount, LastServiceCallTime);

                    DebugLog.Message(msg);
                    DialogResult dr = MessageBox.Show(msg, "No connection to Mobius services", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Error);
                    if (dr == DialogResult.Yes)
                    {
                        Process p = Process.Start(Application.ExecutablePath);
                    }
                    Environment.Exit(-1);
                }
            }

            // Check if exception from services by looking at header in string passed back from services

            else if
            (resultObj != null && resultObj.Value is string && (resultObj.Value as string).StartsWith(servicesExceptionHeader))
            {
                isException = true;

                msg = (resultObj.Value as string).Substring(servicesExceptionHeader.Length);
                int i1 = msg.IndexOf("\n");
                exceptionType = msg.Substring(0, i1 - 1);
                msg           = msg.Substring(i1 + 1);
            }

            if (!isException)
            {
                if (LogServiceCalls)
                {
                    t0 = ComOps.TimeOfDay.Milliseconds() - t0;

                    if (IDebugLog != null)
                    {
                        IDebugLog.Message("[ServiceCallEnd]" + classAndMethod +
                                          " Time: " + t0 + " ms");
                    }
                }
                return(resultObj);                // normal return value
            }

            else             // the call threw an exception
            {
                bool userQueryException = Lex.Eq(exceptionType, "UserQueryException");
                bool queryException     = Lex.Eq(exceptionType, "QueryException");

                if (IDebugLog != null && !userQueryException)
                {
                    IDebugLog.Message(msg);                                                           // log any exceptions except user query exception
                }
                if (userQueryException)
                {
                    throw new UserQueryException(msg);
                }

                else if (queryException)
                {
                    throw new QueryException(msg);
                }

                else
                {
                    throw new Exception(msg);
                }
            }
        }
예제 #8
0
        /// <summary>
        /// ExecuteLongRunningCommand
        /// </summary>
        /// <param name="longRunningCommandObject"></param>

        public static void ExecuteLongRunningCommand(object longRunningCommandObject)
        {
            //Assume that the invocation of this was already outside of the gui thread
            // -- a good thing since we're going to "sleep" between status polls...
            LongRunningCommand longRunningCommand = (LongRunningCommand)longRunningCommandObject;

            if (ServiceFacade.UseRemoteServices)
            {
                //verify the taskType client-side...
                // no reason to make a round-trip to the server if we can fail faster
                Services.Native.ScheduledTaskTypes taskType =
                    (ScheduledTaskTypes)Enum.Parse(
                        typeof(ScheduledTaskTypes), longRunningCommand.Command);

                INativeSession nativeClient = ServiceFacade.CreateNativeSessionProxy();
                Services.Native.NativeMethodTransportObject resultObject =
                    ServiceFacade.InvokeNativeMethod(nativeClient,
                                                     (int)ServiceCodes.MobiusTaskSchedulerService,
                                                     (int)MobiusTaskSchedulerService.SubmitJob,
                                                     new Services.Native.NativeMethodTransportObject(new object[] { (int)taskType, longRunningCommand.CommandArgs }));

                Services.Native.ScheduledTask task = (Services.Native.ScheduledTask)resultObject.Value;
                if (task != null)
                {
                    //do a SHORT sleep before the first check in case the task failed or completed very quickly
                    task.SuggestedTimeBetweenPolls = TimeSpan.FromSeconds(0.03);
                    while (task.Status == ScheduledTaskStatus.Running)
                    {
                        if (longRunningCommand.UpdateProgress != null && task.Result != null &&
                            !String.IsNullOrEmpty(task.Result.ToString()))
                        {
                            longRunningCommand.UpdateProgress(task.Result.ToString(), ComOps.UmlautMobius.String, longRunningCommand.AllowCancel);
                        }
                        Thread.Sleep(task.SuggestedTimeBetweenPolls);
                        resultObject =
                            ServiceFacade.InvokeNativeMethod(nativeClient,
                                                             (int)ServiceCodes.MobiusTaskSchedulerService,
                                                             (int)MobiusTaskSchedulerService.CheckJobStatus,
                                                             new Services.Native.NativeMethodTransportObject(new object[] { task.JobId }));
                        task = (Services.Native.ScheduledTask)resultObject.Value;
                    }
                    longRunningCommand.Result = task.Result;
                }
                ((System.ServiceModel.IClientChannel)nativeClient).Close();

                longRunningCommand.IsRunning = false;
                longRunningCommand.SignalCompletion();

                if (longRunningCommand.OnCompletion != null)
                {
                    longRunningCommand.OnCompletion();
                }
                if (longRunningCommand.HideProgress != null)
                {
                    longRunningCommand.HideProgress();
                }
                if (longRunningCommand.ShowResponse != null && task.Result != null)
                {
                    longRunningCommand.ShowResponse(task.Result.ToString());
                }
            }
        }