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