/// <summary>
        /// This method adds a service event to the collection.
        /// </summary>
        /// <param name="status">The event status</param>
        /// <param name="theEvent">The event</param>
        public void ServiceEventAdd(XimuraServiceStatus status, ServiceEvent value)
        {
            lock (this)
            {
                if (EventsCollection == null)
                    EventsCollection = new Dictionary<XimuraServiceStatus, ServiceEvent>();

                if (EventsCollection.ContainsKey(status))
                    EventsCollection[status] += value;
                else
                    EventsCollection.Add(status, value);
            }
        }
        /// <summary>
        /// This method handles service event removal.
        /// </summary>
        /// <param name="status">The service status.</param>
        /// <param name="value">The event.</param>
        public void ServiceEventRemove(XimuraServiceStatus status, ServiceEvent value)
        {
            lock (this)
            {
                if (EventsCollection == null)
                    EventsCollection = new Dictionary<XimuraServiceStatus, ServiceEvent>();

                if (!EventsCollection.ContainsKey(status))
                    return;

                ServiceEvent current = EventsCollection[status] - value;

                if (current == null)
                    EventsCollection.Remove(status);
                else
                    EventsCollection[status] = current;
            }
        }
        private void ProcessEvent(XimuraServiceStatus status)
        {
            if (EventsCollection == null || !EventsCollection.ContainsKey(status))
                return;

            ProcessEvent(EventsCollection[status]);
        }
        /// <summary>
        /// This method stops a running service
        /// </summary>
        public virtual void Stop()
        {
            //Check whether we are in design mode. If so, do not proceed.
            if (this.DesignMode)
                return;

            //First check whether we are not already stopped or stopping, if not return
            if (m_ServiceStatus == XimuraServiceStatus.Stopped ||
                m_ServiceStatus == XimuraServiceStatus.Stopping)
                //|| m_ServiceStatus == XimuraServiceStatus.NotStarted
                return;

            XimuraServiceStatus oldStatus = m_ServiceStatus;
            m_ServiceStatus = XimuraServiceStatus.Stopping;
            try
            {
                //This method is overriden by the specific service.
                InternalStop();
            }
            catch (Exception ex)
            {
                m_ServiceStatus = oldStatus;
                throw ex;
            }
            m_ServiceStatus = XimuraServiceStatus.Stopped;
            ProcessEvent(m_ServiceStatus);
        }
        /// <summary>
        /// This method continues a paused service
        /// </summary>
        public virtual void Continue()
        {
            //Check whether we are in design mode. If so, do not proceed.
            if (this.DesignMode)
                return;

            //First check whether we are paused, if not return
            if (m_ServiceStatus != XimuraServiceStatus.Paused)
                return;

            try
            {
                m_ServiceStatus = XimuraServiceStatus.Resuming;
                //This method is overriden by the specific service.
                InternalContinue();
            }
            catch (NotImplementedException)
            {
                //Do nothing as we shouldn't really get here
                return;
            }
            catch (Exception ex)
            {
                m_ServiceStatus = XimuraServiceStatus.Paused;
                throw ex;
            }

            m_ServiceStatus = XimuraServiceStatus.Started;
            ProcessEvent(XimuraServiceStatus.Resumed);
        }
        /// <summary>
        /// This method pauses the service
        /// </summary>
        public virtual void Pause()
        {
            //Check whether we are in design mode. If so, do not proceed.
            if (this.DesignMode)
                return;

            //First check whether we are running, if not return
            if (m_ServiceStatus != XimuraServiceStatus.Started)
                return;

            try
            {
                m_ServiceStatus = XimuraServiceStatus.Pausing;
                //This method is overriden by the specific service.
                InternalPause();
            }
            catch (NotImplementedException)
            {
                m_ServiceStatus = XimuraServiceStatus.Started;
            }
            catch (Exception ex)
            {
                m_ServiceStatus = XimuraServiceStatus.Started;
                throw ex;
            }

            m_ServiceStatus = XimuraServiceStatus.Paused;
            ProcessEvent(m_ServiceStatus);
        }
        /// <summary>
        /// This method starts the service based on the default async settings
        /// </summary>
        public virtual void Start()
        {
            //Check whether we are in design mode. If so, do not proceed.
            if (this.DesignMode || !mServiceEnabled)
                return;

            //First check whether we are running, if not return
            if (!(m_ServiceStatus == XimuraServiceStatus.Stopped ||
                m_ServiceStatus == XimuraServiceStatus.NotStarted))
                throw new XimuraServiceException("Cannot start the service.");

            try
            {
                m_ServiceStatus = XimuraServiceStatus.Starting;

                //This method is overriden by the specific service.
                InternalStart();

            }
            catch (Exception ex)
            {
                m_ServiceStatus = XimuraServiceStatus.NotStarted;
                throw ex;
            }

            m_ServiceStatus = XimuraServiceStatus.Started;
            ProcessEvent(m_ServiceStatus);
        }
Beispiel #8
0
 /// <summary>
 /// The main constructor.
 /// </summary>
 /// <param name="status">The status of the service.</param>
 public ServiceEventArgs(XimuraServiceStatus status)
 {
     m_status = status;
 }