예제 #1
0
        /// <summary>
        /// Prova a mettere il task specificato in coda per l'elaborazione associandolo all'identificativo specificato
        /// e restituisce true se l'inserimento viene completate con successo. In caso contrario, restituisce false ed
        /// imposta l'errore esplicativo.
        /// </summary>
        /// <param name="tm">i metadati relativi al task di cui è stata richiesta l'elaborazione</param>
        /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante l'accodamento del task, altrimenti false</returns>
        /// <remarks>
        /// Se il task viene accodato con successo, l'oggetto dedicato all'eventuale errore è impostato al valore null,
        /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server,
        /// oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryQueueTask(TaskMetadata tm, string taskRequestId, out ServiceFault error)
        {
            bool result;

            string taskProcId;

            if (m_TaskScheduler.InsertUserTask(tm, out taskProcId))
            {
                if (TryInsertIdPair(taskRequestId, taskProcId))
                {
                    WriteToLog("TryQueueTask: task scheduled with request id = {0}, processing id = {1}.",
                               taskRequestId, taskProcId);
                    error  = null;
                    result = true;
                }
                else
                {
                    string errorDetails = "TryQueueTask: unable to insert task identifiers within table: " +
                                          string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId);
                    HandleError(errorDetails, ServiceFaultCode.InternalError, out error);
                    result = false;
                }
            }
            else
            {
                HandleError("TryQueueTask: unable to queue a new task.", ServiceFaultCode.InternalError, out error);
                result = false;
            }

            return(result);
        }
예제 #2
0
        /// <summary>
        /// Verifica che i metadati del task associato all'identificativo specificato siano esistenti ed eventualmente
        /// li copia in output e restituisce true. In caso contrario restituisce false ed imposta i metadati in output
        /// al valore null e un errore esplicativo.
        /// </summary>
        /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param>
        /// <param name="tm">la copia dei metadati relativi al task di cui è stata richiesta l'elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante il recupero dei metadati, altrimenti false</returns>
        /// <remarks>
        /// Se i metadati richiesti vengono trovati, l'oggetto dedicato all'eventuale errore è impostato al valore null,
        /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server, oltre
        /// ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryGetUserTask(string taskRequestId, out TaskMetadata tm, out ServiceFault error)
        {
            string taskProcId;

            if (!TryGetProcessingId(taskRequestId, out taskProcId))
            {
                string errorDetails = string.Format("TryGetUserTask: unable to find processing id for request id = {0}.", taskRequestId);
                HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error);

                tm = null;
                return(false);
            }

            if (!m_TaskScheduler.TryGetUserTask(taskProcId, out tm))
            {
                string errorDetails = "TryGetUserTask: unable to find task for " +
                                      string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId);
                HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error);

                tm = null;
                return(false);
            }

            error = null;
            return(true);
        }
예제 #3
0
        /// <summary>
        /// Permette il trasferimento dei risultati relativi ad un task già elaborato e specificato dal proprio
        /// identificativo, impostando l'oggetto che dovrà contenere queste informazioni.
        /// </summary>
        /// <param name="id">l'identificativo precedentemente associato alla richiesta di elaborazione</param>
        /// <param name="results">i risultati relativi al task di cui è stata completata l'elaborazione</param>
        public void GetResults(string id, out TaskResults results)
        {
            m_Container.WriteToLog("GetResults: task request id = {0}.", id);

            ServiceFault fault = null;

            // Ottiene la copia dei metadati relativi al task.
            TaskMetadata tm;

            if (!m_Container.TryGetUserTask(id, out tm, out fault))
            {
                throw new FaultException <ServiceFault>(fault);
            }

            m_Container.WriteToLog("GetResults: sending results from file {0}.", tm.PathToTargetFile);

            // Prepara e invia il risultato.
            try
            {
                results = new TaskResults()
                {
                    ElapsedTime       = m_Container.GetProcessingTime(tm),
                    EncounteredErrors = tm.Errors,
                    Contents          = File.ReadAllText(tm.PathToTargetFile)
                };
            }
            catch (Exception e)
            {
                m_Container.HandleError(e.ToString(), ServiceFaultCode.SendTaskResultsFailed, out fault);
                throw new FaultException <ServiceFault>(fault);
            }
        }
예제 #4
0
        /// <summary>
        /// Prova a generare un identificativo di 16 byte sicuro dal punto di vista crittografico, restituendo true
        /// se la procedura viene completata correttamente. In caso contrario, viene impostato l'errore esplicativo
        /// e il metodo restituisce false.
        /// </summary>
        /// <param name="id">l'identificativo generato in modo sicuro, oppure null in caso di errore</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se l'identificativo viene generato correttamente, altrimenti false</returns>
        /// <remarks>
        /// Se l'identificativo viene generato correttamente, l'oggetto dedicato all'eventuale errore viene impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo che lo
        /// identifica univocamente sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryGetRandomId(out string id, out ServiceFault error)
        {
            bool result;
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();

            try
            {
                byte[] randomBytes = new byte[16];
                rng.GetBytes(randomBytes);

                Guid guid = new Guid(randomBytes);

                id     = guid.ToString();
                error  = null;
                result = true;
            }
            catch (CryptographicException e)
            {
                HandleError(e.ToString(), ServiceFaultCode.TaskGenerateRequestIdFailed, out error);
                id     = null;
                result = false;
            }
            finally
            {
                rng.Dispose();
            }

            return(result);
        }
    /// <summary>
    /// Initializes the message with a service fault.
    /// </summary>
    public _NAME_ResponseMessage(ServiceFault ServiceFault)
    {
        this._NAME_Response = new _NAME_Response();

        if (ServiceFault != null)
        {
            this._NAME_Response.ResponseHeader = ServiceFault.ResponseHeader;
        }
    }
예제 #6
0
        protected override void InternalProcessRecord()
        {
            ITopologyConfigurationSession session = this.CreateSession();
            EhfTargetServerConfig         config  = Utils.CreateEhfTargetConfig(session, this.ConnectorId, this);

            using (EhfProvisioningService ehfProvisioningService = new EhfProvisioningService(config))
            {
                Exception ex = null;
                try
                {
                    this.InvokeWebService(session, config, ehfProvisioningService);
                }
                catch (FaultException <ServiceFault> faultException)
                {
                    ServiceFault detail = faultException.Detail;
                    if (detail.Id == FaultId.UnableToConnectToDatabase)
                    {
                        ex = new InvalidOperationException("ServiceFault: EHF is unable to connect to its database", faultException);
                    }
                    else
                    {
                        ex = faultException;
                    }
                }
                catch (MessageSecurityException ex2)
                {
                    switch (EhfProvisioningService.DecodeMessageSecurityException(ex2))
                    {
                    case EhfProvisioningService.MessageSecurityExceptionReason.DatabaseFailure:
                        ex = new InvalidOperationException("MessageSecurityException: EHF is unable to connect to its database", ex2.InnerException);
                        goto IL_A4;

                    case EhfProvisioningService.MessageSecurityExceptionReason.InvalidCredentials:
                        ex = new InvalidOperationException("MessageSecurityException: EHF connector contains invalid credentials", ex2.InnerException);
                        goto IL_A4;
                    }
                    ex = ex2;
                    IL_A4 :;
                }
                catch (CommunicationException ex3)
                {
                    ex = ex3;
                }
                catch (TimeoutException ex4)
                {
                    ex = ex4;
                }
                catch (EhfProvisioningService.ContractViolationException ex5)
                {
                    ex = ex5;
                }
                if (ex != null)
                {
                    base.WriteError(ex, ErrorCategory.InvalidOperation, null);
                }
            }
        }
예제 #7
0
        /// <summary>
        /// Genera un identificativo univoco per l'errore e lo associa ai dati specificati per poterne effettuare
        /// il logging tramite il logger di questa applicazione ed imposta in uscita l'errore esplicativo.
        /// </summary>
        /// <param name="errorDetails">le informazioni che descrivono l'errore verificatosi</param>
        /// <param name="errorCode">il codice che descrive l'errore verificatosi</param>
        /// <param name="error">l'errore esplicativo contenente identificativo e codice descrittivo</param>
        public void HandleError(string errorDetails, ServiceFaultCode errorCode, out ServiceFault error)
        {
            string errorId;

            HandleError(errorDetails, out errorId);
            error = new ServiceFault()
            {
                Id = errorId, Code = errorCode
            };
        }
예제 #8
0
        /// <summary>
        /// Permette il trasferimento dei dati relativi al task da elaborare ed imposta una stringa contenente
        /// l'identificativo univoco associato alla richiesta di elaborazione, necessario per ottenere in seguito
        /// i risultati dell'elaborazione.
        /// </summary>
        /// <param name="data">i dati relativi al task di cui si richiede l'elaborazione</param>
        /// <param name="id">l'identificativo associato alla richiesta di elaborazione</param>
        public void SubmitData(TaskData data, out string id)
        {
            m_Container.WriteToLog("SubmitData: receiving data, name = {0}.", data.Name);

            ServiceFault fault = null;

            // Genera un ID univoco da associare alla richiesta.
            string taskRequestId;

            if (!m_Container.TryGetRandomId(out taskRequestId, out fault))
            {
                throw new FaultException <ServiceFault>(fault);
            }

            m_Container.WriteToLog("SubmitData: task request id = {0}.", taskRequestId);

            string tdFilePath = m_Container.GetTaskDataFilePath();   // task data file path

            // Salva i dati ricevuti sul task da elaborare.
            if (!m_Container.TrySaveDataToFile(data.Contents, tdFilePath, out fault))
            {
                throw new FaultException <ServiceFault>(fault);
            }

            m_Container.WriteToLog("SubmitData: task request id = {0}, file saved to {1}.", taskRequestId, tdFilePath);

            // Verifica che la risorsa sia disponibile.
            string className, classVersion;

            if (!m_Container.TrySearchResource(tdFilePath, out className, out classVersion, out fault))
            {
                throw new FaultException <ServiceFault>(fault);
            }

            string trFilePath = m_Container.GetTaskResultsFilePath(); // task results file path

            // Prepara il task da elaborare.
            TaskMetadata tm = new TaskMetadata(className, classVersion, tdFilePath, trFilePath);

            tm.UpdateOnReady(DateTime.Now);

            // Inserisce il task in coda allo scheduler.
            if (!m_Container.TryQueueTask(tm, taskRequestId, out fault))
            {
                throw new FaultException <ServiceFault>(fault);
            }

            m_Container.WriteToLog("SubmitData: task scheduled with request id = {0}, target file = {1}.",
                                   taskRequestId, trFilePath);

            id = taskRequestId;
        }
예제 #9
0
        /// <summary>
        /// Creates a fault message.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>A fault message.</returns>
        protected static ServiceFault CreateFault(IServiceRequest request, Exception exception)
        {
            DiagnosticsMasks diagnosticsMask = DiagnosticsMasks.ServiceNoInnerStatus;

            ServiceFault fault = new ServiceFault();

            if (request != null)
            {
                fault.ResponseHeader.Timestamp     = DateTime.UtcNow;
                fault.ResponseHeader.RequestHandle = request.RequestHeader.RequestHandle;

                if (request.RequestHeader != null)
                {
                    diagnosticsMask = (DiagnosticsMasks)request.RequestHeader.ReturnDiagnostics;
                }
            }

            ServiceResult result = null;

            ServiceResultException sre = exception as ServiceResultException;

            if (sre != null)
            {
                result = new ServiceResult(sre);

                Utils.Trace(
                    Utils.TraceMasks.Service,
                    "Service Fault Occured. Reason={0}",
                    result);
            }
            else
            {
                result = new ServiceResult(exception, StatusCodes.BadUnexpectedError);
                Utils.Trace(exception, "SERVER - Unexpected Service Fault: {0}", exception.Message);
            }

            fault.ResponseHeader.ServiceResult = result.Code;

            StringTable stringTable = new StringTable();

            fault.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                result,
                diagnosticsMask,
                true,
                stringTable);

            fault.ResponseHeader.StringTable = stringTable.ToArray();

            return(fault);
        }
예제 #10
0
        /// <summary>
        /// Sends a fault response secured with the symmetric keys.
        /// </summary>
        protected void SendServiceFault(ChannelToken token, uint requestId, ServiceResult fault)
        {
            Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);

            BufferCollection buffers = null;

            try
            {
                // construct fault.
                ServiceFault response = new ServiceFault();

                response.ResponseHeader.ServiceResult = fault.Code;

                StringTable stringTable = new StringTable();

                response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                    fault,
                    DiagnosticsMasks.NoInnerStatus,
                    true,
                    stringTable);

                response.ResponseHeader.StringTable = stringTable.ToArray();

                // the limits should never be exceeded when sending a fault.
                bool limitsExceeded = false;

                // secure message.
                buffers = WriteSymmetricMessage(
                    TcpMessageType.Message,
                    requestId,
                    token,
                    response,
                    false,
                    out limitsExceeded);

                // send message.
                BeginWriteMessage(buffers, null);
                buffers = null;
            }
            catch (Exception e)
            {
                if (buffers != null)
                {
                    buffers.Release(BufferManager, "SendServiceFault");
                }

                ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error sending a service fault."));
            }
        }
        private object CreateFailedServiceReply(Type serviceReplyType, ServiceFault serviceFault)
        {
            if (!serviceReplyType.IsGenericType)
            {
                return new ServiceReply().Fail(serviceFault);
            }

            object instance = Activator.CreateInstance(serviceReplyType);
            PropertyInfo successPropInfo = instance.GetType().GetProperty("Success");
            successPropInfo.GetSetMethod().Invoke(instance, new object[] { false });
            PropertyInfo failureMessagePropInfo = instance.GetType().GetProperty("FailureDetails");
            failureMessagePropInfo.GetSetMethod().Invoke(instance, new object[] { serviceFault });

            return instance;
        }
예제 #12
0
        /// <summary>
        /// Sends a fault response secured with the asymmetric keys.
        /// </summary>
        protected void SendServiceFault(uint requestId, ServiceResult fault)
        {
            Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);

            BufferCollection chunksToSend = null;

            try
            {
                // construct fault.
                ServiceFault response = new ServiceFault();

                response.ResponseHeader.ServiceResult = fault.Code;

                StringTable stringTable = new StringTable();

                response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                    fault,
                    DiagnosticsMasks.NoInnerStatus,
                    true,
                    stringTable);

                response.ResponseHeader.StringTable = stringTable.ToArray();

                // serialize fault.
                byte[] buffer = BinaryEncoder.EncodeMessage(response, Quotas.MessageContext);

                // secure message.
                chunksToSend = WriteAsymmetricMessage(
                    TcpMessageType.Open,
                    requestId,
                    ServerCertificate,
                    ClientCertificate,
                    new ArraySegment <byte>(buffer, 0, buffer.Length));

                // write the message to the server.
                BeginWriteMessage(chunksToSend, null);
                chunksToSend = null;
            }
            catch (Exception e)
            {
                if (chunksToSend != null)
                {
                    chunksToSend.Release(BufferManager, "SendServiceFault");
                }

                ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error sending a service fault."));
            }
        }
예제 #13
0
		/**
		 * Metoda dodaje rekord u bazu \n
		 * 	ime - ime korisnika koji je resavao sudoku
		 */
		public void SnimiRekord (String ime)
		{
			long vreme = Vreme ();
			using (DataBase data = new DataBase ())
			{
				try
				{
					data.Open ();
					data.NoviRekord (ime, brojPokusaja, vreme);
				} catch (Exception ex)
				{
					ServiceFault fault = new ServiceFault ("Greska prilikom snimanja rekorda!");
					throw new FaultException<ServiceFault> (fault);
				}
			}
		}
예제 #14
0
		/**
		 * Metoda koja vraca zadatu rec (film) kao listu karaktera
		 */
		public char[] Resenje ()
		{
			char[] result;

			if (status == EStatusIgre.IGRA_AKTIVNA)
				status = EStatusIgre.IGRA_ZAVRSENA_PORAZ;
			result = film.Naziv.ToCharArray ();
			
			if(result.Length < 1)
			{
				ServiceFault fault = new ServiceFault ("Greska prilikom preuzimanja resenja!");
				throw new FaultException<ServiceFault> (fault);
			}

			return result;
		}
예제 #15
0
        public bool HandleException(Exception ex)
        {
            if (ex is FaultException <ServiceFault> )
            {
                ServiceFault fault = ((FaultException <ServiceFault>)ex).Detail;
                switch (fault.FaultType)
                {
                case FaultType.General:
                    FireEvent(ex.Message, "Error!");
                    break;

                case FaultType.Validation:
                    FireEvent(ex.Message, "Validierung auf dem Server fehlgeschlagen!");
                    break;

                case FaultType.Concurrency:
                    FireEvent("Eine andere Person hat diese Daten in der Zwischenzeit bearbeitet.", "Es ist ein Optimistic-Concurrency-Fehler aufgetreten!");
                    break;
                }
            }
            else if (ex is FaultException <ValidationFault> )
            {
                ValidationFault fault   = ((FaultException <ValidationFault>)ex).Detail;
                StringBuilder   builder = new StringBuilder();
                builder.AppendLine("Validierung auf dem Server fehlgeschlagen!");
                foreach (ValidationDetail result in fault.Details)
                {
                    builder.AppendLine(
                        string.Format(CultureInfo.CurrentCulture,
                                      "{0}: {1}",
                                      result.Key,
                                      result.Message));
                }
                FireEvent(builder.ToString(), "Error!");
            }
            else if (ex is UIException)
            {
                // Exception was already handled.
            }
            else
            {
                FireEvent(ex.Message, "Error!");
            }

            return(true);
        }
        /// <summary>
        /// To the web fault exception.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <returns></returns>
        public static WebFaultException <ServiceFault> ToWebFaultException(this Exception ex)
        {
            ex.Trace();
            var statusCode   = ex.GetStatusCode();
            var errorMessage = "Unknown Error";

            if (!string.IsNullOrWhiteSpace(ex.GetErrorCode()))
            {
                errorMessage = Msg.FromRes(ex.GetErrorCode());
            }

            var fault = new ServiceFault {
                Code = ex.GetErrorCode(), Message = errorMessage
            };

            return(new WebFaultException <ServiceFault>(fault, statusCode));
        }
예제 #17
0
        /// <summary>
        /// Creates a fault message.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>A fault message.</returns>
        protected static Exception CreateSoapFault(IServiceRequest request, Exception exception)
        {
            ServiceFault fault = CreateFault(request, exception);

            // get the error from the header.
            ServiceResult error = fault.ResponseHeader.ServiceResult;

            if (error == null)
            {
                error = ServiceResult.Create(StatusCodes.BadUnexpectedError, "An unknown error occurred.");
            }

            // construct the fault code and fault reason.
            string codeName = StatusCodes.GetBrowseName(error.Code);

            return(new ServiceResultException((uint)error.StatusCode, codeName, exception));
        }
예제 #18
0
            /// <summary cref="System.ServiceModel.Channels.RequestContext.Close(TimeSpan)" />
            public override void Close(TimeSpan timeout)
            {
                lock (m_lock)
                {
                    if (m_channel != null)
                    {
                        ServiceFault fault = new ServiceFault();

                        fault.ResponseHeader.Timestamp     = DateTime.UtcNow;
                        fault.ResponseHeader.ServiceResult = StatusCodes.BadInternalError;

                        // Utils.Trace("Reply Faulted: ChannelId={0}, RequestId={1}", this.m_channel.Id, m_requestId);
                        m_channel.SendResponse(m_requestId, fault);
                        m_channel = null;
                    }
                }
            }
예제 #19
0
        /// <summary>
        /// Dispatches an incoming binary encoded request.
        /// </summary>
        /// <param name="request">Request.</param>
        /// <returns>Invoke service response message.</returns>
        public virtual InvokeServiceResponseMessage InvokeService(InvokeServiceMessage request)
        {
            IServiceRequest  decodedRequest = null;
            IServiceResponse response       = null;

            // create context for request and reply.
            ServiceMessageContext context = MessageContext;

            try
            {
                // check for null.
                if (request == null || request.InvokeServiceRequest == null)
                {
                    throw new ServiceResultException(StatusCodes.BadDecodingError, Utils.Format("Null message cannot be processed."));
                }

                // decoding incoming message.
                decodedRequest =
                    BinaryDecoder.DecodeMessage(request.InvokeServiceRequest, null, context) as IServiceRequest;

                // invoke service.
                response = ProcessRequest(decodedRequest);

                // encode response.
                InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
                outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(response, context);
                return(outgoing);
            }
            catch (Exception e)
            {
                // create fault.
                ServiceFault fault = CreateFault(decodedRequest, e);

                // encode fault response.
                if (context == null)
                {
                    context = new ServiceMessageContext();
                }

                InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
                outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(fault, context);
                return(outgoing);
            }
        }
예제 #20
0
        /// <summary>
        /// Prova a salvare in locale su file la stringa in formato XML contenente i dati del task e restituisce
        /// true se la procedura viene completata correttamente. In caso contrario, restituisce false ed imposta
        /// l'errore esplicativo.
        /// </summary>
        /// <param name="contents">stringa in formato XML contenente i dati del task</param>
        /// <param name="targetFileName">il percorso completo sul server in cui salvare i dati ricevuti</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante la scrittura del file, altrimenti false</returns>
        /// <remarks>
        /// Se la stringa ricevuta viene scritta con successo, l'oggetto dedicato all'eventuale errore è impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo
        /// univoco sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TrySaveDataToFile(string contents, string targetFileName, out ServiceFault error)
        {
            bool result;

            try
            {
                File.WriteAllText(targetFileName, contents);

                error  = null;
                result = true;
            }
            catch (Exception e)
            {
                HandleError(e.ToString(), ServiceFaultCode.ReceiveTaskDataFailed, out error);
                result = false;
            }

            return(result);
        }
예제 #21
0
		/*
		 * Rekordi
		 */

		/**
		* Metoda vraca listu Rekordas \n
		* prima dva argumenta \n
		* br (int) - koji predstavlja broj
		* rekorda koje treba preuzeti, ako je null (default)
		* vraca sve rekorde \n
		* tipSortiranja (ETipSortiranja) - enumeracija
		* predstavlja tip sortiranja (default - NajboljiUkupno)
		*/
		public List<Rekord> PreuzmiRekorde (int? br = null,
			ETipSortiranja tipSortiranja = ETipSortiranja.NajboljiUkupno)
		{
			List<Rekord> rekordi;
			using (DataBase data = new DataBase ())
			{
				try
				{
					data.Open ();
					rekordi = data.PreuzmiRekorde (br, tipSortiranja);
				} catch (Exception ex)
				{
					ServiceFault fault = new ServiceFault ("Greska prilikom preuzimanja rekorda!");
					throw new FaultException<ServiceFault> (fault);
				}
			}

			return rekordi;
		}
예제 #22
0
        /// <summary>
        /// Dispatches an incoming binary encoded request.
        /// </summary>
        /// <param name="ar">The ar.</param>
        /// <returns></returns>
        public virtual InvokeServiceResponseMessage EndInvokeService(IAsyncResult ar)
        {
            try {
                // wait for the response.
                IServiceResponse response = ProcessRequestAsyncResult.WaitForComplete(ar, false);

                // encode the repsonse.
                InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
                outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(response, MessageContext);
                return(outgoing);
            } catch (Exception e) {
                // create fault.
                ServiceFault fault = CreateFault(ProcessRequestAsyncResult.GetRequest(ar), e);

                // encode the fault as a response.
                InvokeServiceResponseMessage outgoing = new InvokeServiceResponseMessage();
                outgoing.InvokeServiceResponse = BinaryEncoder.EncodeMessage(fault, MessageContext);
                return(outgoing);
            }
        }
예제 #23
0
        /// <summary>
        /// Creates a fault message.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>A fault message.</returns>
        protected static Exception CreateSoapFault(IServiceRequest request, Exception exception)
        {
            ServiceFault fault = CreateFault(request, exception);

            // get the error from the header.
            ServiceResult error = fault.ResponseHeader.ServiceResult;

            if (error == null)
            {
                error = ServiceResult.Create(StatusCodes.BadUnexpectedError, "An unknown error occurred.");
            }

            // construct the fault code and fault reason.
            string codeName = StatusCodes.GetBrowseName(error.Code);

            FaultCode   code   = null;
            FaultReason reason = null;

            if (!LocalizedText.IsNullOrEmpty(error.LocalizedText))
            {
                reason = new FaultReason(new FaultReasonText(Utils.Format("{0}", error.LocalizedText),
                                                             CultureInfo.InvariantCulture));
            }
            else
            {
                reason = new FaultReason(new FaultReasonText(codeName, CultureInfo.InvariantCulture));
            }

            if (!String.IsNullOrEmpty(error.SymbolicId))
            {
                FaultCode subcode = new FaultCode(error.SymbolicId, error.NamespaceUri);
                code = new FaultCode(codeName, Namespaces.OpcUa, subcode);
            }
            else
            {
                code = new FaultCode(codeName, Namespaces.OpcUa);
            }

            // throw the fault.
            return(new FaultException <ServiceFault>(fault, reason, code));
        }
예제 #24
0
        /// <summary>
        /// Creates a UA fault message from an exception.
        /// </summary>
        protected virtual Exception CreateSoapFault(RequestHeader requestHeader, Exception e)
        {
            ServiceFault fault = new ServiceFault();

            fault.ResponseHeader = CreateResponseHeader(requestHeader);

            // specify a code.
            StatusCodeException sce = e as StatusCodeException;

            if (sce != null)
            {
                fault.ResponseHeader.ServiceResult = new StatusCode(sce.Code);
            }
            else
            {
                fault.ResponseHeader.ServiceResult = new StatusCode(StatusCodes.BadUnexpectedError);
            }

            // return the message for the exception (add it to the string table first and store the index in the diagnostics).
            if ((requestHeader.ReturnDiagnostics & (uint)DiagnosticsMasks.ServiceLocalizedText) != 0)
            {
                fault.ResponseHeader.StringTable.Add(e.Message);
                fault.ResponseHeader.ServiceDiagnostics.LocalizedText = fault.ResponseHeader.StringTable.Count - 1;
            }

            // return the stack trace for the exception.
            // this is really handy for debugging but is a security risk and never should be done in a production system.
            if ((requestHeader.ReturnDiagnostics & (uint)DiagnosticsMasks.ServiceAdditionalInfo) != 0)
            {
                fault.ResponseHeader.ServiceDiagnostics.AdditionalInfo = e.StackTrace;
            }

            // construct the fault code and fault reason.
            FaultCode   code   = new FaultCode(StatusCodes.GetBrowseName(fault.ResponseHeader.ServiceResult.Code), Namespaces.OpcUa);
            FaultReason reason = new FaultReason(e.Message);;

            // return the fault.
            return(new FaultException <ServiceFault>(fault, reason, code));
        }
예제 #25
0
		/*
		 * Igra
		 */

		/**
		* Metoda koja pokrece igru \n
		* 	sve setuje na nulu i snima trenutno
		*	vreme
		*	na serveru
		*/
		public int[] PokreniIgru ()
		{
			brojPokusaja = 0;
			vremeStart = DateTime.Now;
			status = EStatusIgre.IGRA_AKTIVNA;
			List<int> result = new List<int> ();

			using (DataBase data = new DataBase ())
			{
				int brojFilmova;
				int rbFilma;
				Random random = new Random ();
				try
				{
					data.Open ();
					brojFilmova = data.BrojFilmova ();
					rbFilma = random.Next (brojFilmova);
					film = data.PreuzmiFilm (rbFilma);
					nazivFilma = film.Naziv.ToUpper ().ToCharArray ();
					nazivFilma = ZamenaKraktera (nazivFilma);
				} catch (Exception ex)
				{
					ServiceFault fault = new ServiceFault ("Greska prilikom preuzimanja filma iz baze!");
					throw new FaultException<ServiceFault> (fault);
				}
			}

			result.Add (nazivFilma.Length);
			for (int i = 0; i < nazivFilma.Length; i++)
				if (nazivFilma [i] == ' ')
				{
					result.Add (i);
					nazivFilma [i] = '\0';
				}

			return result.ToArray ();
		}
예제 #26
0
 public static void ShowErrorMessageDialogue(Exception ex)
 {
     if (ex is UserFacingException)
     {
         ShowErrorMessageDialogue((UserFacingException)ex);
     }
     else if (ex is FaultException <ValidationFault> )
     {
         ShowErrorMessageDialogue(ErrorCode.ValidationFault);
     }
     else if (ex is FaultException <ServiceFault> )
     {
         FaultException <ServiceFault> fex = (FaultException <ServiceFault>)ex;
         ServiceFault sex = fex.Detail;
         ShowErrorMessageDialogue(sex.ErrorCode.ToString(), sex.ErrorMessage);
     }
     else if (ex is FaultException <VersionFault> )
     {
         ShowErrorMessageDialogue(ErrorCode.VersionIncorrectFaultReasonMessage);
     }
     else if (ex is FaultException)
     {
         ShowErrorMessageDialogue(ErrorCode.ServiceFault);
     }
     else if (ex is CommunicationException)
     {
         ShowErrorMessageDialogue(ErrorCode.ServerUnavailableMsg);
     }
     else if (ex is TimeoutException)
     {
         ShowErrorMessageDialogue(ErrorCode.ServerTimedOutMsg);
     }
     else
     {
         ShowErrorMessageDialogue(ErrorCode.UnexpectedErrorMsg);
     }
 }
예제 #27
0
        void OnServiceFault(ServiceFault message)
        {
            _log.ErrorFormat("Fault on {0}: {1}", message.ServiceName, message.ToLogString());

            if (message.ServiceName == AppDomain.CurrentDomain.FriendlyName)
            {
                // we caught an unhandled exception, so what should we do? How about restarting all the services?

                if (_stopping == false)
                {
                    _actorCache.Each((name, x) => x.Send(new RestartService(name)));
                }
            }

            if (_stopping)
            {
                if (_actorCache.Has(message.ServiceName))
                {
                    _actorCache[message.ServiceName].Send(new UnloadService(message.ServiceName));
                }
            }

            EventChannel.Send(message);
        }
        /// <summary>
        /// Carica il file specificato contenente i dati da elaborare e prova ad estrarre le informazioni relative
        /// alla risorsa richiesta per la loro elaborazione. In caso di successo, verifica se tale risorsa è stata
        /// attivata su questo server e in caso affermativo restituisce true e imposta il nome e la versione della
        /// risorsa (il nome completo e la versione della classe che implementa la risorsa di elaborazione ).
        /// In caso contrario, se si verificano errori durante la lettura dei dati, oppure se la risorsa richiesta
        /// non è stata abilitata su questo server, il metodo restituisce false ed imposta un errore esplicativo.
        /// </summary>
        /// <param name="tdFilePath">il percorso completo del file da cui estrarre le informazioni</param>
        /// <param name="name">nome completo della classe che implementa la risorsa di elaborazione</param>
        /// <param name="version">versione della classe che implementa la risorsa di elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante la lettura del file, altrimenti false</returns>
        /// <remarks>
        /// Se le informazioni vengono lette correttamente, l'oggetto dedicato all'eventuale errore è impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo
        /// univoco sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TrySearchResource(string tdFilePath, out string name, out string version, out ServiceFault error)
        {
            bool result;

            try
            {
                XmlDocument document = new XmlDocument();
                document.Load(tdFilePath);

                XmlElement root = document.DocumentElement;
                XmlNodeList nodeList = root.SelectNodes("/task/component[@className and @classVersion]");
                XmlNode node = (nodeList.Count == 1 ? nodeList[0] : null);

                name = (node != null ? node.Attributes["className"].Value : string.Empty);
                version = (node != null ? node.Attributes["classVersion"].Value : string.Empty);

                if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(version))
                {
                    HandleError("TrySearchResource: unable to find the information about the requested processing resource.",
                        ServiceFaultCode.TaskDataFormatError, out error);
                    name = version = null;
                    result = false;
                }
                else if (IsResourceEnabled(name, version))
                {
                    error = null;
                    result = true;
                }
                else
                {
                    HandleError("TrySearchResource: the requested processing resource has not been enabled.",
                        ServiceFaultCode.ComponentUnavailable, out error);
                    name = version = null;
                    result = false;
                }
            }
            catch (Exception e)
            {
                HandleError(e.ToString(), ServiceFaultCode.InternalError, out error);
                name = version = null;
                result = false;
            }

            return result;
        }
예제 #29
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public ModifySubscriptionResponseMessage(ServiceFault ServiceFault)
        {
            this.ModifySubscriptionResponse = new ModifySubscriptionResponse();

            if (ServiceFault != null)
            {
                this.ModifySubscriptionResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #30
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public HistoryUpdateResponseMessage(ServiceFault ServiceFault)
        {
            this.HistoryUpdateResponse = new HistoryUpdateResponse();

            if (ServiceFault != null)
            {
                this.HistoryUpdateResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #31
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public TransferSubscriptionsResponseMessage(ServiceFault ServiceFault)
        {
            this.TransferSubscriptionsResponse = new TransferSubscriptionsResponse();

            if (ServiceFault != null)
            {
                this.TransferSubscriptionsResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #32
0
        private EhfCompanyRecord CreateEhfCompanyRecord(SyncedPerimeterConfig perimeterConfig)
        {
            EhfCompanyRecord result = null;
            Exception        ex     = null;

            try
            {
                Company company = null;
                int     companyId;
                if (!this.ehfService.TryGetCompanyByGuid(perimeterConfig.Guid, out company) && int.TryParse(perimeterConfig.PerimeterOrgId, out companyId))
                {
                    company = this.ehfService.GetCompany(companyId);
                }
                if (company != null)
                {
                    Domain[] allDomains = this.ehfService.GetAllDomains(company.CompanyId);
                    result = new EhfCompanyRecord(company, allDomains);
                }
            }
            catch (FaultException <ServiceFault> faultException)
            {
                ServiceFault detail = faultException.Detail;
                if (detail.Id == FaultId.UnableToConnectToDatabase)
                {
                    ex = new InvalidOperationException("ServiceFault: EHF is unable to connect to its database", faultException);
                }
                else
                {
                    if (detail.Id == FaultId.CompanyDoesNotExist)
                    {
                        return(null);
                    }
                    ex = faultException;
                }
            }
            catch (MessageSecurityException ex2)
            {
                switch (EhfProvisioningService.DecodeMessageSecurityException(ex2))
                {
                case EhfProvisioningService.MessageSecurityExceptionReason.DatabaseFailure:
                    ex = new InvalidOperationException("MessageSecurityException: EHF is unable to connect to its database", ex2.InnerException);
                    goto IL_E6;

                case EhfProvisioningService.MessageSecurityExceptionReason.InvalidCredentials:
                    ex = new InvalidOperationException("MessageSecurityException: EHF connector contains invalid credentials", ex2.InnerException);
                    goto IL_E6;
                }
                ex = ex2;
                IL_E6 :;
            }
            catch (CommunicationException ex3)
            {
                ex = ex3;
            }
            catch (TimeoutException ex4)
            {
                ex = ex4;
            }
            catch (EhfProvisioningService.ContractViolationException ex5)
            {
                ex = ex5;
            }
            if (ex != null)
            {
                base.WriteError(ex, ErrorCategory.InvalidOperation, null);
            }
            return(result);
        }
예제 #33
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public ModifyMonitoredItemsResponseMessage(ServiceFault ServiceFault)
        {
            this.ModifyMonitoredItemsResponse = new ModifyMonitoredItemsResponse();

            if (ServiceFault != null)
            {
                this.ModifyMonitoredItemsResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #34
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public CreateSubscriptionResponseMessage(ServiceFault ServiceFault)
        {
            this.CreateSubscriptionResponse = new CreateSubscriptionResponse();

            if (ServiceFault != null)
            {
                this.CreateSubscriptionResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #35
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public DeleteMonitoredItemsResponseMessage(ServiceFault ServiceFault)
        {
            this.DeleteMonitoredItemsResponse = new DeleteMonitoredItemsResponse();

            if (ServiceFault != null)
            {
                this.DeleteMonitoredItemsResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #36
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public UnregisterNodesResponseMessage(ServiceFault ServiceFault)
        {
            this.UnregisterNodesResponse = new UnregisterNodesResponse();

            if (ServiceFault != null)
            {
                this.UnregisterNodesResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #37
0
        /// <summary>
        /// Carica il file specificato contenente i dati da elaborare e prova ad estrarre le informazioni relative
        /// alla risorsa richiesta per la loro elaborazione. In caso di successo, verifica se tale risorsa è stata
        /// attivata su questo server e in caso affermativo restituisce true e imposta il nome e la versione della
        /// risorsa (il nome completo e la versione della classe che implementa la risorsa di elaborazione ).
        /// In caso contrario, se si verificano errori durante la lettura dei dati, oppure se la risorsa richiesta
        /// non è stata abilitata su questo server, il metodo restituisce false ed imposta un errore esplicativo.
        /// </summary>
        /// <param name="tdFilePath">il percorso completo del file da cui estrarre le informazioni</param>
        /// <param name="name">nome completo della classe che implementa la risorsa di elaborazione</param>
        /// <param name="version">versione della classe che implementa la risorsa di elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante la lettura del file, altrimenti false</returns>
        /// <remarks>
        /// Se le informazioni vengono lette correttamente, l'oggetto dedicato all'eventuale errore è impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo
        /// univoco sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TrySearchResource(string tdFilePath, out string name, out string version, out ServiceFault error)
        {
            bool result;

            try
            {
                XmlDocument document = new XmlDocument();
                document.Load(tdFilePath);

                XmlElement  root     = document.DocumentElement;
                XmlNodeList nodeList = root.SelectNodes("/task/component[@className and @classVersion]");
                XmlNode     node     = (nodeList.Count == 1 ? nodeList[0] : null);

                name    = (node != null ? node.Attributes["className"].Value : string.Empty);
                version = (node != null ? node.Attributes["classVersion"].Value : string.Empty);

                if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(version))
                {
                    HandleError("TrySearchResource: unable to find the information about the requested processing resource.",
                                ServiceFaultCode.TaskDataFormatError, out error);
                    name   = version = null;
                    result = false;
                }
                else if (IsResourceEnabled(name, version))
                {
                    error  = null;
                    result = true;
                }
                else
                {
                    HandleError("TrySearchResource: the requested processing resource has not been enabled.",
                                ServiceFaultCode.ComponentUnavailable, out error);
                    name   = version = null;
                    result = false;
                }
            }
            catch (Exception e)
            {
                HandleError(e.ToString(), ServiceFaultCode.InternalError, out error);
                name   = version = null;
                result = false;
            }

            return(result);
        }
예제 #38
0
        /// <summary>
        /// Creates a UA fault message from an exception.
        /// </summary>
        protected virtual Exception CreateSoapFault(RequestHeader requestHeader, Exception e)
        {
            ServiceFault fault = new ServiceFault();
            fault.ResponseHeader = CreateResponseHeader(requestHeader);

            // specify a code.
            StatusCodeException sce = e as StatusCodeException;

            if (sce != null)
            {
                fault.ResponseHeader.ServiceResult = new StatusCode(sce.Code);
            }
            else
            {
                fault.ResponseHeader.ServiceResult = new StatusCode(StatusCodes.BadUnexpectedError);
            }

            // return the message for the exception (add it to the string table first and store the index in the diagnostics).
            if ((requestHeader.ReturnDiagnostics & (uint)DiagnosticsMasks.ServiceLocalizedText) != 0)
            {
                fault.ResponseHeader.StringTable.Add(e.Message);
                fault.ResponseHeader.ServiceDiagnostics.LocalizedText = fault.ResponseHeader.StringTable.Count-1;
            }

            // return the stack trace for the exception.
            // this is really handy for debugging but is a security risk and never should be done in a production system.
            if ((requestHeader.ReturnDiagnostics & (uint)DiagnosticsMasks.ServiceAdditionalInfo) != 0)
            {
                fault.ResponseHeader.ServiceDiagnostics.AdditionalInfo = e.StackTrace;
            }
                
            // construct the fault code and fault reason.
            FaultCode code = new FaultCode(StatusCodes.GetBrowseName(fault.ResponseHeader.ServiceResult.Code), Namespaces.OpcUa);
            FaultReason reason = new FaultReason(e.Message);;

            // return the fault.
            return new FaultException<ServiceFault>(fault, reason, code);
        }
예제 #39
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public SetPublishingModeResponseMessage(ServiceFault ServiceFault)
        {
            this.SetPublishingModeResponse = new SetPublishingModeResponse();

            if (ServiceFault != null)
            {
                this.SetPublishingModeResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #40
0
        /// <summary>
        /// Sends a fault response secured with the asymmetric keys.
        /// </summary>
        private void SendServiceFault(uint requestId, ServiceResult fault)
        {   
            // Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);
         
            BufferCollection chunksToSend = null;

            try
            {
                // construct fault.
                ServiceFault response = new ServiceFault();
                
                response.ResponseHeader.ServiceResult = fault.Code;

                StringTable stringTable = new StringTable();

                response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                    fault, 
                    DiagnosticsMasks.NoInnerStatus, 
                    true, 
                    stringTable);

                response.ResponseHeader.StringTable = stringTable.ToArray();
                
                // serialize fault.
                byte[] buffer = BinaryEncoder.EncodeMessage(response, Quotas.MessageContext); 
                            
                // secure message.
                chunksToSend = WriteAsymmetricMessage(
                    TcpMessageType.Open,
                    requestId,
                    ServerCertificate,
                    ClientCertificate,
                    new ArraySegment<byte>(buffer, 0, buffer.Length));

                // write the message to the server.
                BeginWriteMessage(chunksToSend, Int32.MaxValue, null);
                chunksToSend = null;
            }
            catch (Exception e)
            {
                if (chunksToSend != null)
                {
                    chunksToSend.Release(BufferManager, "SendServiceFault");
                }

                ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error sending a service fault."));
            }
        }
예제 #41
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public QueryNextResponseMessage(ServiceFault ServiceFault)
        {
            this.QueryNextResponse = new QueryNextResponse();

            if (ServiceFault != null)
            {
                this.QueryNextResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #42
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public DeleteSubscriptionsResponseMessage(ServiceFault ServiceFault)
        {
            this.DeleteSubscriptionsResponse = new DeleteSubscriptionsResponse();

            if (ServiceFault != null)
            {
                this.DeleteSubscriptionsResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #43
0
        protected void InvokeProvisioningService(string operationName, EhfSynchronizer.ProvisioningServiceCall serviceCall, int numberOfEntries)
        {
            ExEventLog.EventTuple eventTuple = default(ExEventLog.EventTuple);
            Exception             ex         = null;

            EhfProvisioningService.MessageSecurityExceptionReason messageSecurityExceptionReason = EhfProvisioningService.MessageSecurityExceptionReason.Other;
            this.DiagSession.Tracer.TraceDebug <string>((long)this.DiagSession.GetHashCode(), "Executing EHF provisioning operation {0}", operationName);
            int  transientExceptionRetryCount = this.Config.EhfSyncAppConfig.TransientExceptionRetryCount;
            bool flag = true;

            do
            {
                if (ex != null)
                {
                    this.LogAndTraceException(operationName, ex, messageSecurityExceptionReason.ToString(), transientExceptionRetryCount + 1);
                }
                try
                {
                    Stopwatch stopwatch = new Stopwatch();
                    stopwatch.Start();
                    serviceCall();
                    stopwatch.Stop();
                    this.ehfConnection.PerfCounterHandler.OnOperationSuccessfullyCompleted(operationName, stopwatch.ElapsedMilliseconds, numberOfEntries);
                    this.DiagSession.LogAndTraceInfo(EdgeSyncLoggingLevel.High, "Successfully executed EHF provisioning operation {0}", new object[]
                    {
                        operationName
                    });
                    return;
                }
                catch (FaultException <ServiceFault> faultException)
                {
                    ex = faultException;
                    ServiceFault detail = faultException.Detail;
                    if (detail.Id == FaultId.UnableToConnectToDatabase)
                    {
                        eventTuple = EdgeSyncEventLogConstants.Tuple_EhfTransientFailure;
                        this.ehfConnection.PerfCounterHandler.OnOperationTransientFailure(operationName);
                    }
                    else
                    {
                        eventTuple = EdgeSyncEventLogConstants.Tuple_EhfCommunicationFailure;
                        this.ehfConnection.PerfCounterHandler.OnOperationCommunicationFailure(operationName);
                    }
                }
                catch (MessageSecurityException ex2)
                {
                    messageSecurityExceptionReason = EhfProvisioningService.DecodeMessageSecurityException(ex2);
                    switch (messageSecurityExceptionReason)
                    {
                    case EhfProvisioningService.MessageSecurityExceptionReason.DatabaseFailure:
                        ex         = ex2.InnerException;
                        eventTuple = EdgeSyncEventLogConstants.Tuple_EhfTransientFailure;
                        this.ehfConnection.PerfCounterHandler.OnOperationTransientFailure(operationName);
                        goto IL_186;

                    case EhfProvisioningService.MessageSecurityExceptionReason.InvalidCredentials:
                        ex         = ex2.InnerException;
                        eventTuple = EdgeSyncEventLogConstants.Tuple_EhfInvalidCredentials;
                        this.ehfConnection.PerfCounterHandler.OnOperationInvalidCredentialsFailure(operationName);
                        flag = false;
                        goto IL_186;
                    }
                    ex         = ex2;
                    eventTuple = EdgeSyncEventLogConstants.Tuple_EhfCommunicationFailure;
                    this.ehfConnection.PerfCounterHandler.OnOperationCommunicationFailure(operationName);
                    IL_186 :;
                }
                catch (CommunicationException ex3)
                {
                    ex         = ex3;
                    eventTuple = EdgeSyncEventLogConstants.Tuple_EhfCommunicationFailure;
                    this.ehfConnection.PerfCounterHandler.OnOperationCommunicationFailure(operationName);
                }
                catch (TimeoutException ex4)
                {
                    ex         = ex4;
                    eventTuple = EdgeSyncEventLogConstants.Tuple_EhfOperationTimedOut;
                    this.ehfConnection.PerfCounterHandler.OnOperationTimeoutFailure(operationName);
                    flag = false;
                }
                catch (EhfProvisioningService.ContractViolationException ex5)
                {
                    ex         = ex5;
                    eventTuple = EdgeSyncEventLogConstants.Tuple_EhfServiceContractViolation;
                    this.ehfConnection.PerfCounterHandler.OnOperationContractViolationFailure(operationName);
                    flag = false;
                }
            }while (flag && transientExceptionRetryCount-- > 0);
            if (ex != null)
            {
                this.EventLogAndTraceException(operationName, eventTuple, ex, messageSecurityExceptionReason.ToString());
                this.ehfConnection.AbortSyncCycle(ex);
            }
        }
예제 #44
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public WriteResponseMessage(ServiceFault ServiceFault)
        {
            this.WriteResponse = new WriteResponse();

            if (ServiceFault != null)
            {
                this.WriteResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #45
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public GetEndpointsResponseMessage(ServiceFault ServiceFault)
        {
            this.GetEndpointsResponse = new GetEndpointsResponse();

            if (ServiceFault != null)
            {
                this.GetEndpointsResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
        /// <summary>
        /// Prova a generare un identificativo di 16 byte sicuro dal punto di vista crittografico, restituendo true
        /// se la procedura viene completata correttamente. In caso contrario, viene impostato l'errore esplicativo
        /// e il metodo restituisce false.
        /// </summary>
        /// <param name="id">l'identificativo generato in modo sicuro, oppure null in caso di errore</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se l'identificativo viene generato correttamente, altrimenti false</returns>
        /// <remarks>
        /// Se l'identificativo viene generato correttamente, l'oggetto dedicato all'eventuale errore viene impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo che lo
        /// identifica univocamente sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryGetRandomId(out string id, out ServiceFault error)
        {
            bool result;
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();

            try
            {
                byte[] randomBytes = new byte[16];
                rng.GetBytes(randomBytes);

                Guid guid = new Guid(randomBytes);

                id = guid.ToString();
                error = null;
                result = true;
            }
            catch (CryptographicException e)
            {
                HandleError(e.ToString(), ServiceFaultCode.TaskGenerateRequestIdFailed, out error);
                id = null;
                result = false;
            }
            finally
            {
                rng.Dispose();
            }

            return result;
        }
예제 #47
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public SetTriggeringResponseMessage(ServiceFault ServiceFault)
        {
            this.SetTriggeringResponse = new SetTriggeringResponse();

            if (ServiceFault != null)
            {
                this.SetTriggeringResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
        /// <summary>
        /// Verifica che i metadati del task associato all'identificativo specificato siano esistenti ed eventualmente
        /// li copia in output e restituisce true. In caso contrario restituisce false ed imposta i metadati in output
        /// al valore null e un errore esplicativo.
        /// </summary>
        /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param>
        /// <param name="tm">la copia dei metadati relativi al task di cui è stata richiesta l'elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante il recupero dei metadati, altrimenti false</returns>
        /// <remarks>
        /// Se i metadati richiesti vengono trovati, l'oggetto dedicato all'eventuale errore è impostato al valore null,
        /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server, oltre
        /// ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryGetUserTask(string taskRequestId, out TaskMetadata tm, out ServiceFault error)
        {
            string taskProcId;
            if (!TryGetProcessingId(taskRequestId, out taskProcId))
            {
                string errorDetails = string.Format("TryGetUserTask: unable to find processing id for request id = {0}.", taskRequestId);
                HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error);

                tm = null;
                return false;
            }

            if (!m_TaskScheduler.TryGetUserTask(taskProcId, out tm))
            {
                string errorDetails = "TryGetUserTask: unable to find task for " +
                    string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId);
                HandleError(errorDetails, ServiceFaultCode.TaskResultsNotFound, out error);

                tm = null;
                return false;
            }

            error = null;
            return true;
        }
예제 #49
0
        /// <summary cref="IClientMessageInspector.AfterReceiveReply" />
        public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
        {
            // check for fault.
            if (reply.IsFault)
            {
                return;
            }

            // parse request parameters.
            object[] parameters = correlationState as object[];

            if (parameters == null || parameters.Length != 3)
            {
                throw new InvalidOperationException("Cannot decode request because the IClientMessageInspector not configured properly.");
            }

            // extract request parameters.
            MessageVersion  messageVersion = parameters[0] as MessageVersion;
            string          action         = parameters[1] as string;
            IServiceMessage request        = parameters[2] as IServiceMessage;

            object encodeable = null;

            if (!reply.Properties.TryGetValue(MessageProperties.UnencodedBody, out encodeable))
            {
                // extract binary encoded response from body.
                XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
                reader.MoveToStartElement("InvokeServiceResponse", Namespaces.OpcUaXsd);
                byte[] response = reader.ReadElementContentAsBase64();

                // decode body.
                try
                {
                    encodeable = BinaryDecoder.DecodeMessage(response, null, m_messageContext);
                }
                catch (Exception e)
                {
                    ServiceResult error = ServiceResult.Create(
                        e,
                        StatusCodes.BadDecodingError,
                        "Could not decoding incoming response message.");

                    ServiceFault fault = new ServiceFault();

                    fault.ResponseHeader.RequestHandle = request.GetRequest().RequestHeader.RequestHandle;
                    fault.ResponseHeader.Timestamp     = DateTime.UtcNow;
                    fault.ResponseHeader.ServiceResult = error.Code;

                    StringTable stringTable = new StringTable();

                    fault.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                        error,
                        DiagnosticsMasks.NoInnerStatus,
                        true,
                        stringTable);

                    fault.ResponseHeader.StringTable = stringTable.ToArray();

                    encodeable = fault;
                }
            }

            object unencodedBody = request.CreateResponse((IServiceResponse)encodeable);

            // create the unencoded reply message.
            Message unencodedReply = Message.CreateMessage(
                messageVersion,
                action + "Response",
                unencodedBody);

            unencodedReply.Headers.MessageId = reply.Headers.MessageId;
            unencodedReply.Headers.RelatesTo = reply.Headers.RelatesTo;

            unencodedReply.Properties.Add(MessageProperties.UnencodedBody, unencodedBody);

            // replace the incoming message.
            reply = unencodedReply;
        }
        /// <summary>
        /// Prova a mettere il task specificato in coda per l'elaborazione associandolo all'identificativo specificato
        /// e restituisce true se l'inserimento viene completate con successo. In caso contrario, restituisce false ed
        /// imposta l'errore esplicativo.
        /// </summary>
        /// <param name="tm">i metadati relativi al task di cui è stata richiesta l'elaborazione</param>
        /// <param name="taskRequestId">l'identificativo univoco della richiesta di elaborazione</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante l'accodamento del task, altrimenti false</returns>
        /// <remarks>
        /// Se il task viene accodato con successo, l'oggetto dedicato all'eventuale errore è impostato al valore null,
        /// altrimenti al suo interno vengono impostati il codice d'errore e un identificativo univoco sul server,
        /// oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TryQueueTask(TaskMetadata tm, string taskRequestId, out ServiceFault error)
        {
            bool result;

            string taskProcId;
            if (m_TaskScheduler.InsertUserTask(tm, out taskProcId))
            {
                if (TryInsertIdPair(taskRequestId, taskProcId))
                {
                    WriteToLog("TryQueueTask: task scheduled with request id = {0}, processing id = {1}.",
                        taskRequestId, taskProcId);
                    error = null;
                    result = true;
                }
                else
                {
                    string errorDetails = "TryQueueTask: unable to insert task identifiers within table: " +
                        string.Format("request id = {0}, processing id = {1}.", taskRequestId, taskProcId);
                    HandleError(errorDetails, ServiceFaultCode.InternalError, out error);
                    result = false;
                }
            }
            else
            {
                HandleError("TryQueueTask: unable to queue a new task.", ServiceFaultCode.InternalError, out error);
                result = false;
            }

            return result;
        }
예제 #51
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public CallResponseMessage(ServiceFault ServiceFault)
        {
            this.CallResponse = new CallResponse();

            if (ServiceFault != null)
            {
                this.CallResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
        /// <summary>
        /// Prova a salvare in locale su file la stringa in formato XML contenente i dati del task e restituisce
        /// true se la procedura viene completata correttamente. In caso contrario, restituisce false ed imposta
        /// l'errore esplicativo.
        /// </summary>
        /// <param name="contents">stringa in formato XML contenente i dati del task</param>
        /// <param name="targetFileName">il percorso completo sul server in cui salvare i dati ricevuti</param>
        /// <param name="error">l'eventuale errore impostato qualora si dovessero verificare dei problemi</param>
        /// <returns>true se non si verificano errori durante la scrittura del file, altrimenti false</returns>
        /// <remarks>
        /// Se la stringa ricevuta viene scritta con successo, l'oggetto dedicato all'eventuale errore è impostato
        /// al valore null, altrimenti al suo interno vengono impostati il codice d'errore e un identificativo
        /// univoco sul server, oltre ad effettuare il logging dell'errore.
        /// </remarks>
        public bool TrySaveDataToFile(string contents, string targetFileName, out ServiceFault error)
        {
            bool result;

            try
            {
                File.WriteAllText(targetFileName, contents);

                error = null;
                result = true;
            }
            catch (Exception e)
            {
                HandleError(e.ToString(), ServiceFaultCode.ReceiveTaskDataFailed, out error);
                result = false;
            }

            return result;
        }
 /// <summary>
 /// Genera un identificativo univoco per l'errore e lo associa ai dati specificati per poterne effettuare
 /// il logging tramite il logger di questa applicazione ed imposta in uscita l'errore esplicativo.
 /// </summary>
 /// <param name="errorDetails">le informazioni che descrivono l'errore verificatosi</param>
 /// <param name="errorCode">il codice che descrive l'errore verificatosi</param>
 /// <param name="error">l'errore esplicativo contenente identificativo e codice descrittivo</param>
 public void HandleError(string errorDetails, ServiceFaultCode errorCode, out ServiceFault error)
 {
     string errorId;
     HandleError(errorDetails, out errorId);
     error = new ServiceFault() { Id = errorId, Code = errorCode };
 }
예제 #54
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public PublishResponseMessage(ServiceFault ServiceFault)
        {
            this.PublishResponse = new PublishResponse();

            if (ServiceFault != null)
            {
                this.PublishResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #55
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public RegisterServer2ResponseMessage(ServiceFault ServiceFault)
        {
            this.RegisterServer2Response = new RegisterServer2Response();

            if (ServiceFault != null)
            {
                this.RegisterServer2Response.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #56
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public FindServersOnNetworkResponseMessage(ServiceFault ServiceFault)
        {
            this.FindServersOnNetworkResponse = new FindServersOnNetworkResponse();

            if (ServiceFault != null)
            {
                this.FindServersOnNetworkResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
예제 #57
0
        /// <summary>
        /// Sends a fault response secured with the symmetric keys.
        /// </summary>
        private void SendServiceFault(TcpChannelToken token, uint requestId, ServiceResult fault)
        {   
            // Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);
            
            BufferCollection buffers = null;

            try
            {
                // construct fault.
                ServiceFault response = new ServiceFault();
                
                response.ResponseHeader.ServiceResult = fault.Code;

                StringTable stringTable = new StringTable();

                response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                    fault, 
                    DiagnosticsMasks.NoInnerStatus, 
                    true, 
                    stringTable);

                response.ResponseHeader.StringTable = stringTable.ToArray();
                
                // the limits should never be exceeded when sending a fault.
                bool limitsExceeded = false;

                // secure message.
                buffers = WriteSymmetricMessage(
                    TcpMessageType.Message,
                    requestId,
                    token,
                    response,
                    false,
                    out limitsExceeded);

                // send message.
                BeginWriteMessage(buffers, Int32.MaxValue, null);
                buffers = null;
            }
            catch (Exception e)
            {
                if (buffers != null)
                {
                    buffers.Release(BufferManager, "SendServiceFault");
                }

                ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error sending a service fault."));
            }
        }
예제 #58
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public CloseSecureChannelResponseMessage(ServiceFault ServiceFault)
        {
            this.CloseSecureChannelResponse = new CloseSecureChannelResponse();

            if (ServiceFault != null)
            {
                this.CloseSecureChannelResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }
        /// <summary>
        /// Creates a fault message.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>A fault message.</returns>
        protected static ServiceFault CreateFault(IServiceRequest request, Exception exception)
        {
            DiagnosticsMasks diagnosticsMask = DiagnosticsMasks.ServiceNoInnerStatus;

            ServiceFault fault = new ServiceFault();

            if (request != null)
            {
                fault.ResponseHeader.Timestamp     = DateTime.UtcNow;
                fault.ResponseHeader.RequestHandle = request.RequestHeader.RequestHandle;

                if (request.RequestHeader != null)
                {
                    diagnosticsMask = (DiagnosticsMasks)request.RequestHeader.ReturnDiagnostics;
                }
            }

            ServiceResult result = null;

            ServiceResultException sre = exception as ServiceResultException;

            if (sre != null)
            {
                result = new ServiceResult(sre);

                Utils.Trace(
                    Utils.TraceMasks.Service, 
                    "Service Fault Occured. Reason={0}", 
                    result);
            }
            else
            {
                result = new ServiceResult(exception, StatusCodes.BadUnexpectedError);
                Utils.Trace(exception, "SERVER - Unexpected Service Fault: {0}", exception.Message);
            }                               

            fault.ResponseHeader.ServiceResult = result.Code;

            StringTable stringTable = new StringTable();

            fault.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
                result, 
                diagnosticsMask, 
                true, 
                stringTable);

            fault.ResponseHeader.StringTable = stringTable.ToArray();
 
            return fault;
        }
예제 #60
0
        /// <summary>
        /// Initializes the message with a service fault.
        /// </summary>
        public ActivateSessionResponseMessage(ServiceFault ServiceFault)
        {
            this.ActivateSessionResponse = new ActivateSessionResponse();

            if (ServiceFault != null)
            {
                this.ActivateSessionResponse.ResponseHeader = ServiceFault.ResponseHeader;
            }
        }