/// <summary> /// Stops the data package service. /// </summary> protected void StopDataPackageService() { if (_datapackageServiceStub != null) { _datapackageServiceStub.Dispose(); _datapackageServiceStub = null; } if (_requestManager != null) { _requestManager.Dispose(); _requestManager = null; } DataPackageService.Uninitialize(); if (_baselineStatusUpdater != null) { _baselineStatusUpdater.Dispose(); _baselineStatusUpdater = null; } if (_t2gManager != null) { _t2gManager.Dispose(); _t2gManager = null; } T2GManagerContainer.T2GManager = null; _sessionManager = null; _requestFactory = null; }
public SendNotificationResponse SendNotification(SendNotificationRequest pNotification) { Guid requestId; try { int endPos = pNotification.RequestId.IndexOf('|'); if (endPos != -1) { requestId = new Guid(pNotification.RequestId.Substring(0, endPos)); } else if (pNotification.RequestId.Length != 0) { requestId = new Guid(pNotification.RequestId); } else { requestId = Guid.Empty; } } catch (System.Exception ex) { DataPackageService.mWriteLog(TraceType.WARNING, "PIS.Ground.DataPackage.Notification.SendNotification", ex, Logs.WARNING_CANNOT_CONVERT_GUID_NOTIFICATION_REQUEST, pNotification.RequestId, pNotification.NotificationId, pNotification.ElementId); requestId = Guid.Empty; } DataPackageService.sendElementIdNotificationToGroundApp(requestId, (PIS.Ground.GroundCore.AppGround.NotificationIdEnum)pNotification.NotificationId, pNotification.ElementId); return(new SendNotificationResponse()); // Always an empty response }
public RequestBaselineResponse RequestBaseline(RequestBaselineRequest request) { RequestBaselineResponse lResponse = new RequestBaselineResponse(); DataPackageService lDataPackageService = new DataPackageService(); DataPackageErrorEnum lResult = lDataPackageService.distributeTargetedBaseline(request.ElementId, request.Version, request.ActivationDate, request.ExpirationDate); switch (lResult) { case DataPackageErrorEnum.REQUEST_ACCEPTED: lResponse.Result = ResultEnumType.Success; break; case DataPackageErrorEnum.REMOTEDATASTORE_NOT_ACCESSIBLE: lResponse.Result = ResultEnumType.RemoteDataStoreNotAccessible; break; case DataPackageErrorEnum.ELEMENT_ID_NOT_FOUND: lResponse.Result = ResultEnumType.InvalidElementId; break; case DataPackageErrorEnum.BASELINE_NOT_FOUND: lResponse.Result = ResultEnumType.BaselineNotFound; break; case DataPackageErrorEnum.DATA_PACKAGE_NOT_FOUND: lResponse.Result = ResultEnumType.PackageNotFound; break; default: lResponse.Result = ResultEnumType.Failure; break; } return(lResponse); }
public void updateBaselineAssignmentStatus(Guid pReqID, Notification.NotificationIdEnum pStatus, string pElementId, string pBLVersion) { List <string> lParamList = new List <string>(2); lParamList.Add(pElementId); lParamList.Add(pBLVersion); DataPackageService.sendNotificationToGroundApp(pReqID, (PIS.Ground.GroundCore.AppGround.NotificationIdEnum)pStatus, FormatNotificationParameter(lParamList)); }
/// <summary> /// Initializes a new instance of the <see cref="DataPackageCallbackService"/> class. /// </summary> public DataPackageCallbackService() { if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "DataPackageCallbackService"; } DataPackageService.Initialize(); }
/// <summary> /// Initializes a new instance of the <see cref="NotificationGroundService"/> class. /// </summary> public NotificationGroundService() { if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "DataPkg.NotificationGroundService"; } DataPackageService.Initialize(); }
public void updatePackageUploadStatus(Guid pReqID, Notification.NotificationIdEnum pStatus, Dictionary <string, string> pDPCharsList) { List <string> CharacteristicsList = new List <string>(2 * pDPCharsList.Count); // Put dictionary entries into the CharacteristicsList foreach (KeyValuePair <string, string> dicEntry in pDPCharsList) { CharacteristicsList.Add(dicEntry.Key.ToString()); CharacteristicsList.Add(dicEntry.Value); } DataPackageService.sendNotificationToGroundApp(pReqID, (PIS.Ground.GroundCore.AppGround.NotificationIdEnum)pStatus, FormatNotificationParameter(CharacteristicsList)); }
public void missingDataPackageNotification(Guid pReqID, Dictionary <string, string> pDPCharsList) { List <string> CharacteristicsList = new List <string>(2 * pDPCharsList.Count); // Put dictionary entries into the CharacteristicsList foreach (KeyValuePair <string, string> dicEntry in pDPCharsList) { CharacteristicsList.Add(dicEntry.Key); CharacteristicsList.Add(dicEntry.Value); } DataPackageService.sendNotificationToGroundApp(pReqID, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageMissing, FormatNotificationParameter(CharacteristicsList)); }
protected void TearDown() { if (_testedInstance != null) { _testedInstance.Dispose(); } if (_baselineStatusUpdater != null) { _baselineStatusUpdater.Dispose(); } DataPackageService.Uninitialize(); }
/// <summary>Sends a notification to Ground App.</summary> /// <param name="requestId">Request ID for the corresponding request.</param> /// <param name="status">Processing status.</param> /// <param name="parameter">The generic notification parameter.</param> private void SendNotificationToGroundApp( Guid requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum status, string parameter) { try { if (_notificationSender != null) { _notificationSender.SendNotification(status, parameter, requestId); } else { DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_UNDEFINED_NOTIFICATION_SENDER, EventIdEnum.DataPackage); } } catch (Exception ex) { DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, ex.Message, EventIdEnum.DataPackage); } }
/// <summary>Executes the transmit event action.</summary> private void OnTransmitEvent() { try { List <IRequestContext> currentRequests = new List <IRequestContext>(); while (!_stopTransmitThread) { if (currentRequests.Count == 0) { _TransmitEvent.WaitOne(); } lock (_lock) { if (_newRequests.Count > 0) { currentRequests.AddRange(_newRequests); _newRequests.Clear(); currentRequests.RemoveAll(c => c == null); } } ProcessRequests(currentRequests); if (!_stopTransmitThread) { Thread.Sleep(100); } } } catch (ThreadAbortException) { // No logic to apply } catch (System.Exception exception) { DataPackageService.mWriteLog(TraceType.EXCEPTION, System.Reflection.MethodBase.GetCurrentMethod().Name, exception, exception.Message, EventIdEnum.DataPackage); } }
/// <summary>Adds a request.</summary> /// <exception cref="ArgumentNullException">Thrown when a value was unexpectedly null.</exception> /// <param name="requestContext">Context for the request.</param> public virtual void AddRequest(PIS.Ground.Core.Data.IRequestContext requestContext) { if (requestContext != null) { BaselineDistributingRequestContext processBaselineDistributingRequest = requestContext as BaselineDistributingRequestContext; if (null != processBaselineDistributingRequest) { DataPackageService.saveBaselineDistributingRequest(processBaselineDistributingRequest); } lock (_lock) { _newRequests.Add(requestContext); } _TransmitEvent.Set(); } else { throw new ArgumentNullException("requestContext"); } }
public RequestBaselineVersionResponse RequestBaselineVersion(RequestBaselineVersionRequest request) { RequestBaselineVersionResponse lResponse = new RequestBaselineVersionResponse(); DataPackageService lDataPackageService = new DataPackageService(); DataPackageErrorEnum lResult = lDataPackageService.requestBaselineVesion(request.ElementId, request.PisBaseVersion, request.PisMissionVersion, request.PisInfotainmentVersion, request.LmtVersion); switch (lResult) { case DataPackageErrorEnum.REQUEST_ACCEPTED: lResponse.Result = ResultEnumType.Success; break; case DataPackageErrorEnum.REMOTEDATASTORE_NOT_ACCESSIBLE: lResponse.Result = ResultEnumType.RemoteDataStoreNotAccessible; break; default: lResponse.Result = ResultEnumType.Failure; break; } return(lResponse); }
public void updateBaselineDefinitionStatus(Guid pReqID, string pBLVersion, Notification.NotificationIdEnum pStatus) { DataPackageService.sendNotificationToGroundApp(pReqID, (PIS.Ground.GroundCore.AppGround.NotificationIdEnum)pStatus, FormatNotificationParameter(pBLVersion)); }
/// <summary>Process the force request described by request.</summary> /// <exception cref="NotSupportedException">Thrown when the requested operation is not supported.</exception> /// <param name="request">The request.</param> private void ProcessForceRequest(IRequestContext request) { BaselineForcingRequestContext requestContext = request as BaselineForcingRequestContext; if (requestContext == null) { throw new NotSupportedException("Can't process forcing baseline with a invalid request context."); } try { using (PIS.Ground.DataPackage.DataPackageTrainServiceClient lTrainDataPackageClient = new PIS.Ground.DataPackage.DataPackageTrainServiceClient("DataPackageEndpoint", requestContext.Endpoint)) { try { string requestIdStr = requestContext.RequestId.ToString(); bool validCommand = true; switch (requestContext.CommandType) { case BaselineCommandType.FORCE_FUTURE: lTrainDataPackageClient.ForceFutureBaseline(requestIdStr); break; case BaselineCommandType.FORCE_ARCHIVED: lTrainDataPackageClient.ForceArchivedBaseline(requestIdStr); break; case BaselineCommandType.CLEAR_FORCING: lTrainDataPackageClient.CancelBaselineForcing(requestIdStr); break; default: validCommand = false; break; } if (validCommand) { if (requestContext.CommandType == BaselineCommandType.CLEAR_FORCING) { DataPackageService.sendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineClearForcingSent, request.ElementId); } else { DataPackageService.sendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineForcingSent, request.ElementId); } requestContext.TransmissionStatus = true; requestContext.CompletionStatus = true; } } catch (Exception ex) { if (false == requestContext.OnCommunicationError(ex)) { requestContext.CompletionStatus = true; } } finally { if (lTrainDataPackageClient.State == CommunicationState.Faulted) { lTrainDataPackageClient.Abort(); } } } } catch (Exception ex) { if (false == requestContext.OnCommunicationError(ex)) { requestContext.CompletionStatus = true; } } }
/// <summary>Gets baseline files urls.</summary> /// <param name="requestId">Identifier for the request.</param> /// <param name="elementId">Identifier for the element.</param> /// <param name="baselineVersion">The baseline version.</param> /// <param name="isIncremental">True if this object is incremental.</param> /// <param name="notifyGroundApp">True to notify ground application.</param> /// <param name="packagesURLs">[Out] The packages ur ls.</param> /// <param name="packagesParams">[Out] Options for controlling the packages.</param> /// <returns>True if it succeeds, false if it fails.</returns> private bool GetBaselineFilesURLs( Guid requestId, string elementId, string baselineVersion, bool isIncremental, bool notifyGroundApp, out List <string> packagesURLs, out List <PackageParams> packagesParams) { bool result = false; packagesParams = new List <PackageParams>(); packagesURLs = new List <string>(); BaselineDefinition baselineDefinition = null; List <string> parametersList = new List <string>() { elementId, baselineVersion }; using (StringWriter stringWriter = new StringWriter()) { _stringListXmlSerializer.Serialize(stringWriter, parametersList); if (!string.IsNullOrEmpty(baselineVersion)) { try { using (IRemoteDataStoreClient remoteDataStore = _remoteDataStoreFactory.GetRemoteDataStoreInstance()) { if (remoteDataStore.checkIfBaselineExists(baselineVersion)) { baselineDefinition = DataTypeConversion.fromDataContainerToBaselineDefinition(remoteDataStore.getBaselineDefinition(baselineVersion)); } if (baselineDefinition == null) { DataPackageService.sendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailedMissingDataPackage, stringWriter.ToString()); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_INVALID_BASELINE_VERSION, baselineVersion); result = false; } else if (remoteDataStore.checkIfDataPackageExists(DataPackageType.PISBASE.ToString(), baselineDefinition.PISBaseDataPackageVersion) == false || remoteDataStore.checkIfDataPackageExists(DataPackageType.PISMISSION.ToString(), baselineDefinition.PISMissionDataPackageVersion) == false || remoteDataStore.checkIfDataPackageExists(DataPackageType.PISINFOTAINMENT.ToString(), baselineDefinition.PISInfotainmentDataPackageVersion) == false || remoteDataStore.checkIfDataPackageExists(DataPackageType.LMT.ToString(), baselineDefinition.LMTDataPackageVersion) == false) { if (notifyGroundApp) { DataPackageService.sendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailedMissingDataPackage, stringWriter.ToString()); } DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_INVALID_BASELINE_VERSION, baselineVersion); result = false; } else { AvailableElementData elementData; T2GManagerErrorEnum requestResult = _trainToGroundManager.GetAvailableElementDataByElementNumber(elementId, out elementData); if (requestResult == T2GManagerErrorEnum.eT2GServerOffline) { DataPackageService.sendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageT2GServerOffline, string.Empty); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_T2G_SERVER_OFFLINE); } else if (requestResult == T2GManagerErrorEnum.eElementNotFound) { DataPackageService.sendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionUnknowElementId, stringWriter.ToString()); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_ELEMENT_NOT_FOUND, elementId); } Dictionary <DataPackageType, string> uploadPackagesList = new Dictionary <DataPackageType, string>(); BaselineDefinition embeddedBaselineDefinition = null; if (elementData.PisBaselineData != null && !string.IsNullOrEmpty(elementData.PisBaselineData.CurrentVersionOut) && elementData.PisBaselineData.CurrentVersionOut != "0.0.0.0") { if (remoteDataStore.checkIfBaselineExists(elementData.PisBaselineData.CurrentVersionOut)) { embeddedBaselineDefinition = DataTypeConversion.fromDataContainerToBaselineDefinition(remoteDataStore.getBaselineDefinition(elementData.PisBaselineData.CurrentVersionOut)); } else { string message = string.Format(CultureInfo.CurrentCulture, "Baseline version '{0}' installed on element '{1}' is unknown. Full baseline distribution will be performed.", elementData.PisBaselineData.CurrentVersionOut, elementData.ElementNumber); DataPackageService.mWriteLog(TraceType.WARNING, System.Reflection.MethodBase.GetCurrentMethod().Name, null, message); } if (embeddedBaselineDefinition != null) { if (baselineDefinition.PISBaseDataPackageVersion != embeddedBaselineDefinition.PISBaseDataPackageVersion) { uploadPackagesList.Add(DataPackageType.PISBASE, baselineDefinition.PISBaseDataPackageVersion); } if (baselineDefinition.PISMissionDataPackageVersion != embeddedBaselineDefinition.PISMissionDataPackageVersion) { uploadPackagesList.Add(DataPackageType.PISMISSION, baselineDefinition.PISMissionDataPackageVersion); } if (baselineDefinition.PISInfotainmentDataPackageVersion != embeddedBaselineDefinition.PISInfotainmentDataPackageVersion) { uploadPackagesList.Add(DataPackageType.PISINFOTAINMENT, baselineDefinition.PISInfotainmentDataPackageVersion); } if (baselineDefinition.LMTDataPackageVersion != embeddedBaselineDefinition.LMTDataPackageVersion) { uploadPackagesList.Add(DataPackageType.LMT, baselineDefinition.LMTDataPackageVersion); } } } if (embeddedBaselineDefinition == null) { uploadPackagesList.Add(DataPackageType.PISBASE, baselineDefinition.PISBaseDataPackageVersion); uploadPackagesList.Add(DataPackageType.PISMISSION, baselineDefinition.PISMissionDataPackageVersion); uploadPackagesList.Add(DataPackageType.PISINFOTAINMENT, baselineDefinition.PISInfotainmentDataPackageVersion); uploadPackagesList.Add(DataPackageType.LMT, baselineDefinition.LMTDataPackageVersion); } if (isIncremental == false || embeddedBaselineDefinition == null) { foreach (KeyValuePair <DataPackageType, string> lDP in uploadPackagesList) { DataPackagesCharacteristics packageCharacteristics = DataTypeConversion.fromDataContainerToDataPackagesCharacteristics(remoteDataStore.getDataPackageCharacteristics(lDP.Key.ToString(), lDP.Value)); packagesURLs.Add(ConfigurationSettings.AppSettings["RemoteDataStoreUrl"] + "/" + packageCharacteristics.DataPackagePath); packagesParams.Add(new PackageParams(lDP.Key, lDP.Value)); } result = true; } else { foreach (KeyValuePair <DataPackageType, string> packageToUpload in uploadPackagesList) { string embeddedBaselineVersion = string.Empty; switch (packageToUpload.Key) { case DataPackageType.PISBASE: embeddedBaselineVersion = embeddedBaselineDefinition.PISBaseDataPackageVersion; break; case DataPackageType.PISMISSION: embeddedBaselineVersion = embeddedBaselineDefinition.PISMissionDataPackageVersion; break; case DataPackageType.PISINFOTAINMENT: embeddedBaselineVersion = embeddedBaselineDefinition.PISInfotainmentDataPackageVersion; break; case DataPackageType.LMT: embeddedBaselineVersion = embeddedBaselineDefinition.LMTDataPackageVersion; break; default: break; } bool isEmbPackageOnGround = remoteDataStore.checkIfDataPackageExists(packageToUpload.Key.ToString(), embeddedBaselineVersion); if (!isEmbPackageOnGround) { string message = string.Format(CultureInfo.CurrentCulture, "{0}'s data package version '{1}' associated to baseline '{2}' is unknown. Distribution the element '{3}' will receive a complete update for that data package.", packageToUpload.Key.ToString(), embeddedBaselineVersion, packageToUpload.Value, elementData.ElementNumber); DataPackageService.mWriteLog(TraceType.WARNING, System.Reflection.MethodBase.GetCurrentMethod().Name, null, message); DataPackagesCharacteristics packageCharacteristics = DataTypeConversion.fromDataContainerToDataPackagesCharacteristics(remoteDataStore.getDataPackageCharacteristics(packageToUpload.Key.ToString(), packageToUpload.Value)); packagesURLs.Add(ConfigurationSettings.AppSettings["RemoteDataStoreUrl"] + "/" + packageCharacteristics.DataPackagePath); packagesParams.Add(new PackageParams(packageToUpload.Key, packageToUpload.Value)); } else { // Store the current operational timeout. TimeSpan oldOperationTimeOut = remoteDataStore.OperationTimeout; try { // Set the operational timeout to 10minutes because the getDiffDataPackageUrl can take a long time (Zip operation) remoteDataStore.OperationTimeout = TimeSpan.FromMinutes(10); string differentialPackagePath = remoteDataStore.getDiffDataPackageUrl(requestId, elementId, packageToUpload.Key.ToString(), embeddedBaselineVersion, packageToUpload.Value); if (null != differentialPackagePath && !string.IsNullOrEmpty(differentialPackagePath)) { packagesURLs.Add(ConfigurationSettings.AppSettings["RemoteDataStoreUrl"] + "/" + differentialPackagePath); packagesParams.Add(new PackageParams(packageToUpload.Key, packageToUpload.Value)); } } finally { // restore the operation timeout. remoteDataStore.OperationTimeout = oldOperationTimeOut; } } result = true; } } } } } catch (Exception ex) { DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_REMOTEDATASTORE_NOT_ACCESSIBLE, baselineVersion); result = false; } } else { result = false; } } return(result); }
public RequestAssignedBaselineResponse RequestAssignedBaseline(RequestAssignedBaselineRequest request) { RequestAssignedBaselineResponse lResponse = new RequestAssignedBaselineResponse(); lResponse.Result = ResultEnumType.Failure; lResponse.Version = ""; try { using (RemoteDataStoreProxy lRemDSProxy = new RemoteDataStoreProxy()) { try { DataContainer baselinesDef = lRemDSProxy.getElementBaselinesDefinitions(request.ElementId); ElementDescription elemDescr = DataTypeConversion.fromDataContainerToElementDescription(baselinesDef); if (request.Current) { lResponse.Version = lRemDSProxy.getAssignedCurrentBaselineVersion(request.ElementId); lResponse.ActivationDate = DateTime.Now; lResponse.ExpirationDate = elemDescr.AssignedCurrentBaselineExpirationDate; } else { lResponse.Version = lRemDSProxy.getAssignedFutureBaselineVersion(request.ElementId); lResponse.ActivationDate = elemDescr.AssignedFutureBaselineActivationDate; lResponse.ExpirationDate = elemDescr.AssignedFutureBaselineExpirationDate; } lResponse.Result = ResultEnumType.Success; DataPackageService lDataPackageService = new DataPackageService(); DataPackageErrorEnum lResult = lDataPackageService.distributeTargetedBaseline(request.ElementId, lResponse.Version, lResponse.ActivationDate, lResponse.ExpirationDate); switch (lResult) { case DataPackageErrorEnum.REQUEST_ACCEPTED: lResponse.Result = ResultEnumType.Success; break; case DataPackageErrorEnum.REMOTEDATASTORE_NOT_ACCESSIBLE: lResponse.Result = ResultEnumType.RemoteDataStoreNotAccessible; break; case DataPackageErrorEnum.ELEMENT_ID_NOT_FOUND: lResponse.Result = ResultEnumType.InvalidElementId; break; case DataPackageErrorEnum.BASELINE_NOT_FOUND: lResponse.Result = ResultEnumType.BaselineNotFound; break; case DataPackageErrorEnum.DATA_PACKAGE_NOT_FOUND: lResponse.Result = ResultEnumType.PackageNotFound; break; default: lResponse.Result = ResultEnumType.Failure; break; } } catch (FaultException fe) { if (fe.Code.Name == "UNKNOWN_ELEMENT_ID" || fe.Code.Name == "INVALID_ELEMENT_ID") { lResponse.Result = ResultEnumType.InvalidElementId; } else { PIS.Ground.Core.LogMgmt.LogManager.WriteLog(PIS.Ground.Core.Data.TraceType.EXCEPTION, "Element ID : " + request.ElementId + ". Error Code : " + fe.Code.Name + ". Error Message : " + fe.Message , "PIS.Ground.DataPackage.DataPackageSyncGroundService.RequestAssignedbaseline" , fe, PIS.Ground.Core.Data.EventIdEnum.DataPackage); lResponse.Result = ResultEnumType.Failure; } } finally { if (lRemDSProxy.State == CommunicationState.Faulted) { lRemDSProxy.Abort(); } } } } catch (TimeoutException) { lResponse.Result = ResultEnumType.RemoteDataStoreNotAccessible; } catch (CommunicationException) { lResponse.Result = ResultEnumType.RemoteDataStoreNotAccessible; } return(lResponse); }
/// <summary> /// Processes the requests. /// </summary> /// <param name="currentRequests">The request to process.</param> protected virtual void ProcessRequests(List <IRequestContext> requests) { BaselineDistributingRequestContext processBaselineDistributingRequest = null; for (int i = 0; i < requests.Count && !_stopTransmitThread; ++i) { IRequestContext request = requests[i]; switch (request.State) { case RequestState.Created: Predicate <IRequestContext> comparisonPredicate; if (request is BaselineDistributingRequestContext) { comparisonPredicate = c => { return(c is BaselineDistributingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); }; } else if (request is BaselineForcingRequestContext) { comparisonPredicate = c => { return(c is BaselineForcingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); }; } else { comparisonPredicate = c => { return(c is BaselineSettingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); }; } for (int j = requests.Count - 1; j >= 0; --j) { if (comparisonPredicate(requests[j])) { requests.RemoveAt(j); if (j <= i) { --i; } } } break; case RequestState.ReadyToSend: break; case RequestState.WaitingRetry: break; case RequestState.Expired: BaselineForcingRequestContext processBaselineCommandRequest = request as BaselineForcingRequestContext; if (null != processBaselineCommandRequest) { if (processBaselineCommandRequest.CommandType == BaselineCommandType.CLEAR_FORCING) { SendNotificationToGroundApp( request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineClearForcingTimedOut, FormatNotificationParameter(processBaselineCommandRequest.ElementId)); } else { SendNotificationToGroundApp( request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineForcingTimedOut, FormatNotificationParameter(processBaselineCommandRequest.ElementId)); } } else { processBaselineDistributingRequest = request as BaselineDistributingRequestContext; if (null != processBaselineDistributingRequest) { DataPackageService.deleteBaselineDistributingRequest(processBaselineDistributingRequest.ElementId); SendNotificationToGroundApp( request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionTimedOut, FormatNotificationParameter(processBaselineDistributingRequest.ElementId, processBaselineDistributingRequest.BaselineVersion)); } } break; case RequestState.Transmitted: request.CompletionStatus = true; processBaselineDistributingRequest = request as BaselineDistributingRequestContext; if (null != processBaselineDistributingRequest) { DataPackageService.deleteBaselineDistributingRequest(processBaselineDistributingRequest.ElementId); SendNotificationToGroundApp( request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionTransferred, FormatNotificationParameter(processBaselineDistributingRequest.ElementId, processBaselineDistributingRequest.BaselineVersion)); processBaselineDistributingRequest.CompletionStatus = true; } break; case RequestState.AllRetriesExhausted: break; case RequestState.Completed: break; case RequestState.Error: break; } } if (!_stopTransmitThread) { requests.RemoveAll(c => c.IsStateFinal); } }
/// <summary>Process the distribute request described by request.</summary> /// <exception cref="NotSupportedException">Thrown when the requested operation is not supported.</exception> /// <param name="request">The request.</param> private void ProcessDistributeRequest(IRequestContext request) { BaselineDistributingRequestContext requestContext = request as BaselineDistributingRequestContext; if (requestContext == null) { throw new ArgumentException(Logs.ERROR_INVALID_BASELINE_DISTRIBUTE_REQUEST_CONTEXT, "request"); } List <string> parametersList = new List <string>() { requestContext.ElementId, requestContext.BaselineVersion }; using (StringWriter stringWriter = new StringWriter()) { _stringListXmlSerializer.Serialize(stringWriter, parametersList); if (requestContext.TransferAttemptsDone == 1) { DataPackageService.sendNotificationToGroundApp( request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionPending, stringWriter.ToString()); } if (_trainToGroundManager.IsElementOnlineAndPisBaselineUpToDate(requestContext.ElementId)) { ServiceInfo serviceInfo; if (T2GManagerErrorEnum.eSuccess == _trainToGroundManager.GetAvailableServiceData(requestContext.ElementId, (int)Core.Common.eServiceID.eSrvSIF_DataPackageServer, out serviceInfo)) { // Rebuild the url of the service in case that it has changed since the last invocation. requestContext.Endpoint = "http://" + serviceInfo.ServiceIPAddress + ":" + serviceInfo.ServicePortNumber; try { using (PIS.Ground.DataPackage.DataPackageTrainServiceClient lTrainDataPackageClient = new PIS.Ground.DataPackage.DataPackageTrainServiceClient("DataPackageEndpoint", requestContext.Endpoint)) { try { List <RecipientId> recipients = new List <RecipientId>() { new RecipientId() { ApplicationId = ConfigurationSettings.AppSettings["ApplicationId"], SystemId = requestContext.ElementId, MissionId = string.Empty } }; DataPackageService.mWriteLog(TraceType.INFO, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.INFO_FUTURE_BASELINE, requestContext.ElementId, requestContext.BaselineVersion); if (!string.IsNullOrEmpty(requestContext.BaselineVersion)) { List <PackageParams> packagesParamsList; List <string> filesUrlsList; if (GetBaselineFilesURLs(requestContext.RequestId, requestContext.ElementId, requestContext.BaselineVersion, requestContext.IsIncremental, true, out filesUrlsList, out packagesParamsList)) { try { using (IRemoteDataStoreClient remoteDataStore = _remoteDataStoreFactory.GetRemoteDataStoreInstance()) { filesUrlsList.Add(ConfigurationSettings.AppSettings["RemoteDataStoreUrl"] + remoteDataStore.createBaselineFile( requestContext.RequestId, requestContext.ElementId, requestContext.BaselineVersion, requestContext.BaselineActivationDate.ToString(), requestContext.BaselineExpirationDate.ToString())); } } catch (Exception ex) { DataPackageService.mWriteLog(TraceType.EXCEPTION, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_REMOTEDATASTORE_FAULTED); } if (filesUrlsList.Count > 0) { UploadFileDistributionRequest uploadFilesRequestContext = new UploadFileDistributionRequest( requestContext.RequestId, requestContext.RequestId.ToString(), requestContext.DistributionAttributes.transferExpirationDate, filesUrlsList, requestContext.DistributionAttributes.fileCompression, recipients, requestContext.DistributionAttributes.transferDate, "Distribute baseline for element " + requestContext.ElementId, requestContext.DistributionAttributes.TransferMode, requestContext.DistributionAttributes.priority, new EventHandler <FileDistributionStatusArgs>(DataPackageService.OnFileDistributeNotification), new EventHandler <FileDistributionTaskCreatedArgs>(_baselineStatusUpdater.OnFileDistributionTaskCreated)); DataPackageService.sendNotificationToGroundApp(requestContext.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageFutureBaselineDefinition, stringWriter.ToString()); string logMessage = "Distribute baseline for element " + requestContext.ElementId; logMessage += ". Files to upload : "; foreach (string file in filesUrlsList) { logMessage += file + ", "; } logMessage = logMessage.Substring(0, logMessage.Length - 2); DataPackageService.mWriteLog(TraceType.INFO, System.Reflection.MethodBase.GetCurrentMethod().Name, null, logMessage); AvailableElementData elementData; T2GManagerErrorEnum lRqstResult = _trainToGroundManager.GetAvailableElementDataByElementNumber(requestContext.ElementId, out elementData); if (lRqstResult == T2GManagerErrorEnum.eSuccess && elementData != null && elementData.PisBaselineData != null) { _baselineStatusUpdater.ProcessDistributeBaselineRequest( elementData.ElementNumber, requestContext.RequestId, elementData.OnlineStatus, elementData.PisBaselineData.CurrentVersionOut, elementData.PisBaselineData.FutureVersionOut, requestContext.BaselineVersion); } else { DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_ELEMENT_INFO, requestContext.ElementId); } DataPackageService.mAddBaselineVersionToDictionary(requestContext.RequestId, requestContext.ElementId, requestContext.BaselineVersion); DataPackageService.mAddPackagesToUsedPackagesList(packagesParamsList); _trainToGroundManager.T2GFileDistributionManager.AddUploadRequest(uploadFilesRequestContext); requestContext.TransmissionStatus = true; DataPackageService.mRemovePackagesFromUsedPackagesList(packagesParamsList); } } else { requestContext.CompletionStatus = true; DataPackageService.sendNotificationToGroundApp(requestContext.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailed, stringWriter.ToString()); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, Logs.ERROR_GETTING_URL_LIST); } } else { requestContext.CompletionStatus = true; DataPackageService.sendNotificationToGroundApp(requestContext.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailed, stringWriter.ToString()); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED_UNKNOW_BASELINE_VERSION, requestContext.ElementId); } } catch (Exception ex) { if (false == requestContext.OnCommunicationError(ex)) { requestContext.CompletionStatus = true; DataPackageService.sendNotificationToGroundApp(requestContext.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailedRejectedByElement, stringWriter.ToString()); DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, ex.Message); } else { DataPackageService.mWriteLog(TraceType.DEBUG, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, ex.Message); } } finally { if (lTrainDataPackageClient.State == CommunicationState.Faulted) { lTrainDataPackageClient.Abort(); } } } } catch (Exception ex) { if (false == requestContext.OnCommunicationError(ex)) { requestContext.CompletionStatus = true; DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, ex.Message); DataPackageService.sendNotificationToGroundApp(requestContext.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionFailed, stringWriter.ToString()); } else { DataPackageService.mWriteLog(TraceType.DEBUG, System.Reflection.MethodBase.GetCurrentMethod().Name, ex, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, ex.Message); } } } else { DataPackageService.mWriteLog(TraceType.ERROR, System.Reflection.MethodBase.GetCurrentMethod().Name, null, Logs.ERROR_DISTRIBUTE_BASELINE_FAILED, requestContext.BaselineVersion, requestContext.ElementId, "Cannot get embedded DataPackage service data."); requestContext.TransmissionStatus = false; } } else { requestContext.TransmissionStatus = false; } } }
public void TearDown() { if (_datapackageServiceStub != null) { _datapackageServiceStub.Dispose(); _datapackageServiceStub = null; } if (_requestManager != null) { _requestManager.Dispose(); _requestManager = null; } foreach (ServiceHost service in new ServiceHost[] { _hostVehicleInfoService, _hostFileTransferService, _hostIdentificationService, _hostNotificationService, _hostTrainDataPackageService }) { if (service == null) { continue; } if (service.State == CommunicationState.Faulted) { service.Abort(); } service.Close(); } if (_vehicleInfoServiceStub != null) { _vehicleInfoServiceStub.Dispose(); } if (_baselineStatusUpdater != null) { _baselineStatusUpdater.Dispose(); } _hostIdentificationService = null; _hostFileTransferService = null; _hostVehicleInfoService = null; _hostNotificationService = null; _hostTrainDataPackageService = null; _fileTransferServiceStub = null; _identificationServiceStub = null; _vehicleInfoServiceStub = null; _notificationServiceStub = null; _trainDataPackageServiceStub = null; _baselineStatusUpdater = null; DataPackageService.Uninitialize(); T2GManagerContainer.T2GManager = null; _t2gManager = null; _sessionManager = null; _requestFactory = null; if (_dataStoreServiceStub != null) { _dataStoreServiceStub.Dispose(); _dataStoreServiceStub = null; } _remoteDataStoreFactoryMock = null; TestContext currentContext = TestContext.CurrentContext; Console.Out.WriteLine("==================================="); Console.Out.WriteLine("END TEST {0}", currentContext.Test.Name); Console.Out.WriteLine("==================================="); }