/// <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("===================================");
}
