/// <summary>
/// Search AvailableElementData By TargetAddress (By Element, MissionOperatorCode, or MissionId)
/// </summary>
/// <param name="targetAddress">Target address.</param>
/// <param name="lstAvailableElementData">[out] Information describing the list available element.</param>
/// <returns>List of AvailableElementData matching TargetAddress criteria.</returns>
public T2GManagerErrorEnum GetAvailableElementDataByTargetAddress(TargetAddressType targetAddress, out ElementList <AvailableElementData> lstAvailableElementData)
{
T2GManagerErrorEnum lReturn = T2GManagerErrorEnum.eFailed;
lstAvailableElementData = new ElementList <AvailableElementData>();
if (targetAddress != null && !string.IsNullOrEmpty(targetAddress.Id))
{
// Resolve target elements
switch (targetAddress.Type)
{
case AddressTypeEnum.Element:
AvailableElementData element = new AvailableElementData();
lReturn = GetAvailableElementDataByElementNumber(targetAddress.Id, out element);
if (lReturn == T2GManagerErrorEnum.eSuccess)
{
lstAvailableElementData.Add(element);
}
break;
case AddressTypeEnum.MissionOperatorCode:
lReturn = GetAvailableElementDataListByMissionOperatorCode(targetAddress.Id, out lstAvailableElementData);
break;
case AddressTypeEnum.MissionCode:
lReturn = GetAvailableElementDataListByMissionCode(targetAddress.Id, out lstAvailableElementData);
break;
}
}
return(lReturn);
}
/// <summary>
/// This function allows the GroundApp to request from the ground PIS the list of available
/// elements. This list includes also missions that are running for each element, and the
/// versions of the LMT and PIS Base data packages.
/// </summary>
/// <param name="sessionId">Identifier for the session.</param>
/// <returns>
/// The code “request accepted” when the command is valid and the list of elements, or and error
/// code when the command is rejected.
/// </returns>
RealTimeAvailableElementListResult IRealTimeService.GetAvailableElementList(Guid sessionId)
{
var result = new RealTimeAvailableElementListResult();
result.ResultCode = RealTimeServiceErrorEnum.ElementListNotAvailable;
result.ElementList = null;
if (_sessionManager.IsSessionValid(sessionId))
{
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataList(out result.ElementList);
if (rqstResult == T2GManagerErrorEnum.eSuccess)
{
result.ResultCode = RealTimeServiceErrorEnum.RequestAccepted;
}
else
{
result.ResultCode = RealTimeServiceErrorEnum.ElementListNotAvailable;
}
}
else
{
result.ResultCode = RealTimeServiceErrorEnum.ErrorInvalidSessionId;
}
return(result);
}
/// <summary>Search AvailableElementData By MissionOperatorCode.</summary>
/// <param name="missionOperatorCode">Mission Operator code.</param>
/// <param name="elementDataList">[out] Information describing the list available element.</param>
/// <returns>ElementList of AvailableElementData.</returns>
public T2GManagerErrorEnum GetAvailableElementDataListByMissionOperatorCode(string missionOperatorCode, out ElementList <AvailableElementData> elementDataList)
{
if (LogManager.IsTraceActive(TraceType.INFO))
{
LogManager.WriteLog(TraceType.INFO, "GetAvailableElementDataListByMissionOperatorCode called for mission operator code: '" + missionOperatorCode ?? string.Empty + "'.", "PIS.Ground.Core.T2G.T2GManager.GetAvailableElementDataByElementNumber", null, EventIdEnum.GroundCore);
}
elementDataList = new ElementList <AvailableElementData>(); // always return an object
T2GManagerErrorEnum result = T2GManagerErrorEnum.eFailed;
if (T2GServerConnectionStatus)
{
elementDataList = _localDataStorage.GetAvailableElementDataListByMissionOperatorCode(missionOperatorCode);
if (elementDataList.Count > 0)
{
result = T2GManagerErrorEnum.eSuccess;
}
else
{
result = T2GManagerErrorEnum.eElementNotFound;
}
}
else
{
result = T2GManagerErrorEnum.eT2GServerOffline;
}
return(result);
}
/// <summary>Search AvailableElementData By ElementNumber.</summary>
/// <param name="elementNumber">element number.</param>
/// <param name="objAvailableElementData">[out] Information describing the object available element.</param>
/// <returns>The success of the operation. Possible values are:
/// <list type="table">
/// <listheader><term>Error code</term><description>Description</description></listheader>
/// <item><term>T2GManagerErrorEnum.eSuccess</term><description>Queryed element found.</description></item>
/// <item><term>T2GManagerErrorEnum.eElementNotFound</term><description>Queried element is unknown.</description></item>
/// <item><term>T2GManagerErrorEnum.eT2GServerOffline</term><description>T2G services are down.</description></item>
/// </list>
/// </returns>
public T2GManagerErrorEnum GetAvailableElementDataByElementNumber(string elementNumber, out AvailableElementData objAvailableElementData)
{
if (LogManager.IsTraceActive(TraceType.INFO))
{
LogManager.WriteLog(TraceType.INFO, "GetAvailableElementDataByElementNumber called for element '" + elementNumber ?? string.Empty + "'.", "PIS.Ground.Core.T2G.T2GManager.GetAvailableElementDataByElementNumber", null, EventIdEnum.GroundCore);
}
T2GManagerErrorEnum result = T2GManagerErrorEnum.eFailed;
if (T2GServerConnectionStatus)
{
AvailableElementData elementData = _localDataStorage.GetAvailableElementDataByElementNumber(elementNumber);
if (elementData != null)
{
objAvailableElementData = elementData; // copy reference
result = T2GManagerErrorEnum.eSuccess;
}
else
{
objAvailableElementData = new AvailableElementData(); // always return an object
result = T2GManagerErrorEnum.eElementNotFound;
}
}
else
{
objAvailableElementData = new AvailableElementData(); // always return an object
result = T2GManagerErrorEnum.eT2GServerOffline;
}
return(result);
}
/// <summary>Verify if a system is online or not.</summary>
/// <param name="elementNumber">The system identifier to query.</param>
/// <param name="IsOnline">[out] Online status on the train. In case of error, value is forced to false.</param>
/// <returns>The success of the operation. Possible values are:
/// <list type="table">
/// <listheader><term>Error code</term><description>Description</description></listheader>
/// <item><term>T2GManagerErrorEnum.eSuccess</term><description>Service retrieved successfully and it is available</description></item>
/// <item><term>T2GManagerErrorEnum.eElementNotFound</term><description>Queried system is unknown.</description></item>
/// <item><term>T2GManagerErrorEnum.eT2GServerOffline</term><description>T2G services are down.</description></item>
/// </list>
/// </returns>
public T2GManagerErrorEnum IsElementOnline(string elementNumber, out bool isOnline)
{
T2GManagerErrorEnum lReturn = T2GManagerErrorEnum.eFailed;
isOnline = false;
if (T2GServerConnectionStatus)
{
// Get connection status of element first to improve speed when system is online.
// Then, check if the element exist.
isOnline = _localDataStorage.IsElementOnline(elementNumber);
if (isOnline || _localDataStorage.ElementExists(elementNumber))
{
lReturn = T2GManagerErrorEnum.eSuccess;
}
else
{
lReturn = T2GManagerErrorEnum.eElementNotFound;
}
}
else
{
lReturn = T2GManagerErrorEnum.eT2GServerOffline;
}
return(lReturn);
}
/// <summary>Process the mission data sending.</summary>
/// <param name="elementId">Identifier for the element.</param>
/// <param name="missionCode">The mission code.</param>
private static void ProcessMissionDataSending(string elementId, string missionCode)
{
ServiceInfo serviceInfo = null;
T2GManagerErrorEnum t2gResult = _t2gManager.GetAvailableServiceData(elementId, (int)eServiceID.eSrvSIF_RealTimeServer, out serviceInfo);
if (t2gResult == T2GManagerErrorEnum.eSuccess)
{
string endpoint = "http://" + serviceInfo.ServiceIPAddress + ":" + serviceInfo.ServicePortNumber;
try
{
// Call RealTime train service and send the request.
using (Train.RealTime.RealTimeTrainServiceClient lTrainClient = new Train.RealTime.RealTimeTrainServiceClient("RealTimeTrainEndpoint", endpoint))
{
try
{
Train.RealTime.DelayType rtinfoDelay = null;
Train.RealTime.WeatherType rtinfoWeather = null;
RealTimeUtils.ConvertGroundMissionDataToTrainMissionData(
_rtpisDataStore.GetMissionRealTimeInformation(missionCode),
out rtinfoDelay,
out rtinfoWeather);
Train.RealTime.SetMissionRealTimeRequest request = new Train.RealTime.SetMissionRealTimeRequest(
missionCode,
rtinfoDelay != null ? Train.RealTime.ActionTypeEnum.Set : Train.RealTime.ActionTypeEnum.Delete,
rtinfoDelay,
rtinfoWeather != null ? Train.RealTime.ActionTypeEnum.Set : Train.RealTime.ActionTypeEnum.Delete,
rtinfoWeather);
Train.RealTime.SetMissionRealTimeResponse response = ((Train.RealTime.IRealTimeTrainService)lTrainClient).SetMissionRealTime(request);
ProcessCommandResultList(elementId, missionCode, response.ResultList);
}
catch (Exception ex)
{
LogManager.WriteLog(TraceType.EXCEPTION, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_FAILED_SEND_REQUEST_TO_EMBEDDED, elementId), "PIS.Ground.RealTime.RealTimeService.ProcessMissionDataSending", ex, EventIdEnum.RealTime);
}
finally
{
if (lTrainClient.State == CommunicationState.Faulted)
{
lTrainClient.Abort();
}
}
}
}
catch (Exception ex)
{
LogManager.WriteLog(TraceType.EXCEPTION, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_FAILED_SEND_REQUEST_TO_EMBEDDED, elementId), "PIS.Ground.RealTime.RealTimeService.ProcessMissionDataSending", ex, EventIdEnum.RealTime);
}
}
else if (t2gResult == T2GManagerErrorEnum.eElementNotFound)
{
LogManager.WriteLog(TraceType.WARNING, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_GET_SERVICE_DATA_FOR_ELEMENT, elementId, t2gResult), "PIS.Ground.RealTime.RealTimeService.ProcessMissionDataSending", null, EventIdEnum.RealTime);
}
else if (LogManager.IsTraceActive(TraceType.DEBUG))
{
LogManager.WriteLog(TraceType.DEBUG, string.Format(CultureInfo.CurrentCulture, Logs.DEBUG_GET_SERVICE_DATA_FOR_ELEMENT, elementId, t2gResult), "PIS.Ground.RealTime.RealTimeService.ProcessMissionDataSending", null, EventIdEnum.RealTime);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public InfotainmentJournalingElementListResponse GetAvailableElementList(Guid sessionId)
{
InfotainmentJournalingElementListResponse result = new InfotainmentJournalingElementListResponse();
result.ResultCode = ResultCodeEnum.InternalError;
if (_sessionManager.IsSessionValid(sessionId))
{
T2GManagerErrorEnum lResult = _t2gManager.GetAvailableElementDataList(out result.ElementList);
if (lResult == T2GManagerErrorEnum.eSuccess)
{
result.ResultCode = ResultCodeEnum.RequestAccepted;
}
else
{
result.ResultCode = ResultCodeEnum.ElementListNotAvailable;
}
}
else
{
result.ResultCode = ResultCodeEnum.InvalidSessionId;
}
return(result);
}
private static void SendStartStreamingCommandToProperStatusElements(string url)
{
try
{
// Get the list of all currently available trains
ElementList <AvailableElementData> elements = new ElementList <AvailableElementData>();
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataList(out elements);
switch (rqstResult)
{
case T2GManagerErrorEnum.eSuccess:
// Send notification to all clients
LiveVideoControlService.SendNotificationToGroundApp(
Guid.Empty,
PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlAutomaticMode,
url);
// Send a start command to each train that is online and in mission
foreach (AvailableElementData element in elements)
{
TargetAddressType target = new TargetAddressType();
target.Type = AddressTypeEnum.Element;
target.Id = element.ElementNumber;
_dicVideoHistory[target] = url;
_dicVideoHistorySentService[target] = null;
if (element.OnlineStatus == true && element.MissionState == MissionStateEnum.MI)
{
ServiceInfo availableService;
if (_t2gManager.GetAvailableServiceData(element.ElementNumber, (int)eServiceID.eSrvSIF_LiveVideoControlServer, out availableService) == T2GManagerErrorEnum.eSuccess)
{
_dicVideoHistorySentService[target] = availableService;
}
SendStartStreamingCommand(Guid.Empty, target, url);
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LogManager.WriteLog(TraceType.ERROR, "T2G Server: Offline",
"PIS.Ground.LiveVideoControl.LiveVideoControlService.ProcessAutomaticMode",
null, EventIdEnum.LiveVideoControl);
break;
default:
LogManager.WriteLog(TraceType.ERROR, "Element not found",
"PIS.Ground.LiveVideoControl.LiveVideoControlService.ProcessAutomaticMode", null, EventIdEnum.LiveVideoControl);
break;
}
}
catch (System.Exception exception)
{
LogManager.WriteLog(TraceType.EXCEPTION, exception.Message,
"PIS.Ground.LiveVideoControl.LiveVideoControlService.ProcessAutomaticMode", exception, EventIdEnum.LiveVideoControl);
}
}
public void GetAvailableElementListNotAvailable()
{
ElementList <AvailableElementData> elementList = new ElementList <AvailableElementData>();
T2GManagerErrorEnum returns = T2GManagerErrorEnum.eElementNotFound;
Guid sessionId = Guid.NewGuid();
_sessionManagerMock.Setup(x => x.IsSessionValid(sessionId)).Returns(true);
_train2groundClientMock.Setup(y => y.GetAvailableElementDataList(out elementList)).Returns(returns);
MissionServiceElementListResult result = _missionService.GetAvailableElementList(sessionId);
_train2groundClientMock.Verify(w => w.GetAvailableElementDataList(out elementList), Times.Once());
Assert.AreEqual(MissionErrorCode.ElementListNotAvailable, result.ResultCode);
}
public void GetAvailableElementListRequestAccepted()
{
ElementList <AvailableElementData> elementList = new ElementList <AvailableElementData>();
T2GManagerErrorEnum returns = T2GManagerErrorEnum.eSuccess;
this._sessionManagerMock.Setup(x => x.IsSessionValid(It.IsAny <Guid>())).Returns(true);
this._train2groundClientMock.Setup(x => x.GetAvailableElementDataList(out elementList)).Returns(returns);
MissionAvailableElementListResult result = this._missionService.GetAvailableElementList(Guid.NewGuid());
this._train2groundClientMock.Verify(w => w.GetAvailableElementDataList(out elementList), Times.Once());
Assert.AreEqual(MissionServiceErrorCodeEnum.RequestAccepted, result.ResultCode);
}
/// <summary>Sends a video streaming status request.</summary>
/// <param name="requestId">Request ID for the corresponding request.</param>
private static void SendVideoStreamingStatusRequest(Guid requestId)
{
ElementList <AvailableElementData> availableElementData = new ElementList <AvailableElementData>();
T2GManagerErrorEnum result = _t2gManager.GetAvailableElementDataList(out availableElementData);
switch (result)
{
case T2GManagerErrorEnum.eSuccess:
foreach (AvailableElementData element in availableElementData)
{
ServiceInfo serviceInfo;
result = _t2gManager.GetAvailableServiceData(element.ElementNumber, (int)eServiceID.eSrvSIF_LiveVideoControlServer, out serviceInfo);
switch (result)
{
case T2GManagerErrorEnum.eSuccess:
ProcessSendVideoStreamingStatusRequestContext request = new ProcessSendVideoStreamingStatusRequestContext(
element.ElementNumber,
requestId,
serviceInfo);
_requestProcessor.AddRequest(request);
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlElementNotFound, element.ElementNumber);
break;
case T2GManagerErrorEnum.eServiceInfoNotFound:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlServiceNotFound, element.ElementNumber);
break;
default:
break;
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
default:
break;
}
}
public void InitializeMissionNewMissionRequestAccepted()
{
AvailableElementData elementData = InitTrainElement();
Guid requestId = Guid.NewGuid();
File.Copy(this._dbSourcePath, Path.Combine(this._dbWorkingPath, "file.db"));
List <string> inputStationList = InitStationList(StationListTypeEnum.VALID_ONLY);
MissionParams missionParams = InitMissionParams(
this._sessionId,
this._newMissionCode,
this._elementId,
inputStationList,
1);
ServiceInfo serviceInfo = this.InitServiceInfo();
this._sessionManagerMock.Setup(x => x.IsSessionValid(It.IsAny <Guid>())).Returns(true);
this._sessionManagerMock.Setup(x => x.GenerateRequestID(It.IsAny <Guid>(), out requestId)).Returns(string.Empty);
this._train2groundClientMock.Setup(y => y.GetAvailableElementDataByElementNumber(missionParams.ElementId, out elementData)).Returns(T2GManagerErrorEnum.eSuccess);
this._remoteDataStoreFactoryMock.Setup(z => z.GetRemoteDataStoreInstance()).Returns(new RemoteDataStoreSimulator.RemoteDataStore(this._dbWorkingPath, "3.0.13.0"));
T2GManagerErrorEnum rslt = T2GManagerErrorEnum.eSuccess;
this._train2groundClientMock.Setup(x => x.GetAvailableServiceData(
missionParams.ElementId,
(int)eServiceID.eSrvSIF_MissionServer,
out serviceInfo)).Returns(rslt);
MissionInitializeMissionResult result = this._missionService.InitializeMission(
missionParams.SessionId,
missionParams.MissionCode,
missionParams.ElementId,
missionParams.StationList,
missionParams.Timeout);
Assert.AreEqual(MissionServiceErrorCodeEnum.RequestAccepted, result.ResultCode);
Assert.AreEqual(result.RequestId, requestId);
Assert.AreEqual(result.MissionCode, this._newMissionCode);
}
/// <summary>Get the information on a specific service on a specific train. Service shall be available.</summary>
/// <param name="systemId">The system identifier to retrieve the information.</param>
/// <param name="serviceId">The service identifier to retrieve information on</param>
/// <param name="serviceDataResult">[out] Information on the service retrieve. It's never null.</param>
/// <returns>The success of the operation. Possible values are:
/// <list type="table">
/// <listheader><term>Error code</term><description>Description</description></listheader>
/// <item><term>T2GManagerErrorEnum.eSuccess</term><description>Service retrieved successfully and it is available</description></item>
/// <item><term>T2GManagerErrorEnum.eServiceInfoNotFound</term><description>Service is unknown or it is not available..</description></item>
/// <item><term>T2GManagerErrorEnum.eElementNotFound</term><description>Queried system is unknown.</description></item>
/// <item><term>T2GManagerErrorEnum.eT2GServerOffline</term><description>T2G services are down.</description></item>
/// </list>
/// </returns>
public T2GManagerErrorEnum GetAvailableServiceData(string systemId, int serviceId, out ServiceInfo serviceDataResult)
{
T2GManagerErrorEnum lReturn = T2GManagerErrorEnum.eFailed;
serviceDataResult = null;
if (T2GServerConnectionStatus)
{
// By default, assume that system exist to speed up expected behavior
ServiceInfo service = _localDataStorage.GetAvailableServiceData(systemId, serviceId);
if (object.ReferenceEquals(service, null))
{
lReturn = _localDataStorage.ElementExists(systemId) ? T2GManagerErrorEnum.eServiceInfoNotFound : T2GManagerErrorEnum.eElementNotFound;
}
else if (service.IsAvailable)
{
serviceDataResult = service; // Copy reference, service info immutable
lReturn = T2GManagerErrorEnum.eSuccess;
}
else
{
lReturn = T2GManagerErrorEnum.eServiceInfoNotFound;
}
}
else
{
lReturn = T2GManagerErrorEnum.eT2GServerOffline;
}
if (lReturn != T2GManagerErrorEnum.eSuccess)
{
// Always return a valid object.
serviceDataResult = new ServiceInfo();
}
return(lReturn);
}
public void CancelMissionRequestAccepted()
{
AvailableElementData elementData = null;
Guid requestId = Guid.NewGuid();
MissionParams missionParams = InitMissionParams(
this._sessionId,
this._existingMissionCode,
this._elementId,
null,
1);
ServiceInfo serviceInfo = this.InitServiceInfo();
T2GManagerErrorEnum rslt = T2GManagerErrorEnum.eSuccess;
this._train2groundClientMock.Setup(x => x.GetAvailableServiceData(
missionParams.ElementId,
(int)eServiceID.eSrvSIF_MissionServer,
out serviceInfo)).Returns(rslt);
this._sessionManagerMock.Setup(x => x.IsSessionValid(It.IsAny <Guid>())).Returns(true);
this._sessionManagerMock.Setup(x => x.GenerateRequestID(It.IsAny <Guid>(), out requestId)).Returns(string.Empty);
this._train2groundClientMock.Setup(y => y.GetAvailableElementDataByElementNumber(missionParams.ElementId, out elementData)).Returns(T2GManagerErrorEnum.eSuccess);
this._remoteDataStoreFactoryMock.Setup(z => z.GetRemoteDataStoreInstance()).Returns(new RemoteDataStoreSimulator.RemoteDataStore(this._dbWorkingPath, "3.0.13.0"));
MissionCancelMissionResult result = this._missionService.CancelMission(
missionParams.SessionId,
missionParams.MissionCode,
missionParams.ElementId,
missionParams.Timeout);
Assert.AreEqual(MissionServiceErrorCodeEnum.RequestAccepted, result.ResultCode);
Assert.AreEqual(result.RequestId, requestId);
Assert.AreEqual(result.MissionCode, this._existingMissionCode);
}
/// <summary>Process the station data sending.</summary>
/// <param name="elementId">Identifier for the element.</param>
/// <param name="stationCodeList">List of station codes.</param>
private static void ProcessStationDataSending(string elementId, KeyValuePair <string, List <string> > stationCodeList)
{
List <RealTimeStationStatusType> stationDataList = _rtpisDataStore.GetStationRealTimeInformation(stationCodeList.Key, stationCodeList.Value);
if (stationDataList == null)
{
stationDataList = new List <RealTimeStationStatusType>();
}
if (stationDataList.Count == 0)
{
RealTimeRetrieveStationListResult result = new RealTimeRetrieveStationListResult();
AvailableElementData elementData = null;
T2GManagerErrorEnum t2gTmpResult = _t2gManager.GetAvailableElementDataByElementNumber(elementId, out elementData);
if (t2gTmpResult == T2GManagerErrorEnum.eSuccess)
{
RealTimeService.GetStationListFromLMTDataBase(stationCodeList.Key, elementId, elementData, ref result);
if (result.ResultCode == RealTimeServiceErrorEnum.RequestAccepted)
{
stationDataList.Capacity = result.StationList.Count;
foreach (var station in result.StationList)
{
stationDataList.Add(new RealTimeStationStatusType()
{
StationID = station
});
}
}
else
{
LogManager.WriteLog(TraceType.ERROR, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_ACCESSING_STATIONLIST_FOR_ELEMENT, elementId, "GetStationListFromLMTDataBase", result.ResultCode), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", null, EventIdEnum.RealTime);
}
}
else
{
LogManager.WriteLog(TraceType.ERROR, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_ACCESSING_STATIONLIST_FOR_ELEMENT, elementId, "GetAvailableElementDataByElementNumber", t2gTmpResult), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", null, EventIdEnum.RealTime);
}
}
// Updating the train is important only when the data of at least one station need to be updated.
if (stationDataList.Count != 0)
{
ServiceInfo serviceInfo = null;
T2GManagerErrorEnum t2gResult = _t2gManager.GetAvailableServiceData(elementId, (int)eServiceID.eSrvSIF_RealTimeServer, out serviceInfo);
if (t2gResult == T2GManagerErrorEnum.eSuccess)
{
string endpoint = "http://" + serviceInfo.ServiceIPAddress + ":" + serviceInfo.ServicePortNumber;
try
{
// Call RealTime train service and send the request.
using (Train.RealTime.RealTimeTrainServiceClient lTrainClient = new Train.RealTime.RealTimeTrainServiceClient("RealTimeTrainEndpoint", endpoint))
{
try
{
Train.RealTime.ListOfStationDataType stationDataListType = null;
RealTimeUtils.ConvertGroundStationDataToTrainStationData(
stationDataList,
out stationDataListType);
Train.RealTime.SetStationRealTimeRequest request = new Train.RealTime.SetStationRealTimeRequest(stationCodeList.Key, stationDataListType);
Train.RealTime.SetStationRealTimeResponse response = ((Train.RealTime.IRealTimeTrainService)lTrainClient).SetStationRealTime(request);
ProcessCommandResultList(elementId, stationCodeList.Key, response.ResultList);
}
catch (Exception ex)
{
LogManager.WriteLog(TraceType.EXCEPTION, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_FAILED_SEND_REQUEST_TO_EMBEDDED, elementId), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", ex, EventIdEnum.RealTime);
}
finally
{
if (lTrainClient.State == CommunicationState.Faulted)
{
lTrainClient.Abort();
}
}
}
}
catch (Exception ex)
{
LogManager.WriteLog(TraceType.EXCEPTION, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_FAILED_SEND_REQUEST_TO_EMBEDDED, elementId), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", ex, EventIdEnum.RealTime);
}
}
else if (t2gResult == T2GManagerErrorEnum.eElementNotFound)
{
LogManager.WriteLog(TraceType.WARNING, string.Format(CultureInfo.CurrentCulture, Logs.ERROR_GET_SERVICE_DATA_FOR_ELEMENT, elementId, t2gResult), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", null, EventIdEnum.RealTime);
}
else if (LogManager.IsTraceActive(TraceType.DEBUG))
{
LogManager.WriteLog(TraceType.DEBUG, string.Format(CultureInfo.CurrentCulture, Logs.DEBUG_GET_SERVICE_DATA_FOR_ELEMENT, elementId, t2gResult), "PIS.Ground.RealTime.RealTimeService.ProcessStationDataSending", null, EventIdEnum.RealTime);
}
}
}
/// <summary>Transmit request to embedded system.</summary>
/// <param name="request">The request to send to embedded.</param>
private static void TransmitRequest(RequestContext request)
{
bool requestIsTransmitted = false;
ServiceInfo serviceInfo;
// Check if target element is online
bool elementIsOnline;
T2GManagerErrorEnum rqstResult = _train2groundManager.IsElementOnline(request.ElementId, out elementIsOnline);
switch (rqstResult)
{
case T2GManagerErrorEnum.eSuccess:
if (elementIsOnline == true)
{
T2GManagerErrorEnum result = _train2groundManager.GetAvailableServiceData(request.ElementId, (int)eServiceID.eSrvSIF_LiveVideoControlServer, out serviceInfo);
switch (result)
{
case T2GManagerErrorEnum.eSuccess:
{
string endpoint = "http://" + serviceInfo.ServiceIPAddress + ":" + serviceInfo.ServicePortNumber;
try
{
// Call LiveVideoControl train service
using (LiveVideoControlServiceClient trainClient = new LiveVideoControlServiceClient("LiveVideoControlEndpoint", endpoint))
{
try
{
if (request is ProcessStopVideoStreamingCommandRequestContext)
{
RequestProcessor.TransmitStopVideoStreamingCommandRequest(trainClient, request as ProcessStopVideoStreamingCommandRequestContext);
}
else if (request is ProcessStartVideoStreamingCommandRequestContext)
{
RequestProcessor.TransmitStartVideoStreamingCommandRequest(trainClient, request as ProcessStartVideoStreamingCommandRequestContext);
}
else if (request is ProcessSendVideoStreamingStatusRequestContext)
{
RequestProcessor.TransmitSendVideoStreamingStatusRequest(trainClient, request as ProcessSendVideoStreamingStatusRequestContext);
}
else
{
// No other request type supported
}
requestIsTransmitted = true;
}
catch (Exception ex)
{
if (!RequestProcessor.ShouldContinueOnTransmissionError(ex))
{
// Assume transmitted (no reason to retry)
requestIsTransmitted = true;
}
}
finally
{
if (trainClient.State == CommunicationState.Faulted)
{
trainClient.Abort();
}
}
}
}
catch (Exception ex)
{
if (!RequestProcessor.ShouldContinueOnTransmissionError(ex))
{
// Assume transmitted (no reason to retry)
requestIsTransmitted = true;
}
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlElementNotFound, request.ElementId);
break;
case T2GManagerErrorEnum.eServiceInfoNotFound:
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlServiceNotFound, request.ElementId);
break;
default:
break;
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
requestIsTransmitted = true;
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlElementNotFound, request.ElementId);
break;
default:
break;
}
request.TransmissionStatus = requestIsTransmitted;
if (request.State == RequestState.WaitingRetry && request.TransferAttemptsDone == 1)
{
// first attempt failed, send notification
RequestProcessor.SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlDistributionWaitingToSend, request.ElementId);
}
}
/// <summary>LiveVideoControlService web service method "GetAvailableElementList".</summary>
/// <param name="sessionId">The session identifier.</param>
/// <returns>Response <see cref="LiveVideoControlElementListResult"/>.</returns>
LiveVideoControlElementListResult ILiveVideoControlService.GetAvailableElementList(Guid sessionId)
{
LiveVideoControlElementListResult lResult = new LiveVideoControlElementListResult();
lResult.ResultCode = LiveVideoControlErrorEnum.ElementListNotAvailable;
if (LiveVideoControlService._sessionManager.IsSessionValid(sessionId))
{
// Get the list of all trains
//
ElementList <AvailableElementData> lElementList;
T2GManagerErrorEnum lT2GResult = _t2gManager.GetAvailableElementDataList(out lElementList);
if (lT2GResult == T2GManagerErrorEnum.eSuccess)
{
var lLiveVideoServiceElementList = new ElementList <AvailableElementData>();
ServiceInfo lServiceInfo;
bool lT2GDisconnection = false;
// For each train...
//
foreach (AvailableElementData lElement in lElementList)
{
// ...get information related to the live video streaming service
//
lT2GResult = _t2gManager.GetAvailableServiceData(lElement.ElementNumber,
(int)eServiceID.eSrvSIF_LiveVideoControlServer, out lServiceInfo);
switch (lT2GResult)
{
case T2GManagerErrorEnum.eSuccess:
// If the streaming service is provided...
//
if (lServiceInfo.IsAvailable)
{
// ...add the train to the streaming service elements list
lLiveVideoServiceElementList.Add(lElement);
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
lT2GDisconnection = true;
break;
default:
break;
}
// Since we need T2G to build the list of streaming service elements...
if (lT2GDisconnection)
{
// ...stop wasting time and return immediately
lResult.ResultCode = LiveVideoControlErrorEnum.T2GServerOffline;
break;
}
}
if (!lT2GDisconnection)
{
// In case of success, return the list of train(s) that provide video steaming service
//
lResult.ElementList = lLiveVideoServiceElementList;
lResult.ResultCode = LiveVideoControlErrorEnum.RequestAccepted;
}
else
{
lResult.ResultCode = LiveVideoControlErrorEnum.T2GServerOffline;
}
}
else
{
lResult.ResultCode = LiveVideoControlErrorEnum.ElementListNotAvailable;
}
if (false == LiveVideoControlService._statusRequestedSessions.Contains(sessionId))
{
LiveVideoControlService._statusRequestedSessions.Add(sessionId);
LiveVideoControlService._delegate(sessionId);
}
}
else
{
lResult.ResultCode = LiveVideoControlErrorEnum.InvalidSessionId;
}
return(lResult);
}
/// <summary>
/// The function commands the retreival of the station list from an addressee. If a mission code
/// is provided, only the stations of that mission are returned. By default, all the station list
/// from the database are returned.
/// </summary>
/// <param name="sessionId">Identifier for the session.</param>
/// <param name="missionCode">The mission code.</param>
/// <param name="elementId">Identifier for the element.</param>
/// <returns>
/// The code “request accepted” when the command is valid and the list of stations for the given
/// mission code/element id, or and error code when the command is rejected.
/// </returns>
RealTimeRetrieveStationListResult IRealTimeService.RetrieveStationList(Guid sessionId, string missionCode, string elementId)
{
var result = new RealTimeRetrieveStationListResult();
result.RequestId = Guid.Empty;
result.ResultCode = RealTimeServiceErrorEnum.ErrorInvalidSessionId;
result.MissionCode = missionCode;
result.ElementID = elementId;
result.StationList = null;
if (_sessionManager.IsSessionValid(sessionId))
{
string error = _sessionManager.GenerateRequestID(sessionId, out result.RequestId);
if (string.IsNullOrEmpty(error))
{
AvailableElementData elementData;
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataByElementNumber(elementId, out elementData);
switch (rqstResult)
{
case T2GManagerErrorEnum.eSuccess:
{
try
{
GetStationListFromLMTDataBase(missionCode, elementId, elementData, ref result);
}
catch (TimeoutException)
{
result.ResultCode = RealTimeServiceErrorEnum.ErrorRemoteDatastoreUnavailable;
}
catch (CommunicationException)
{
result.ResultCode = RealTimeServiceErrorEnum.ErrorRemoteDatastoreUnavailable;
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
result.ResultCode = RealTimeServiceErrorEnum.T2GServerOffline;
break;
case T2GManagerErrorEnum.eElementNotFound:
default:
result.ResultCode = RealTimeServiceErrorEnum.ErrorInvalidElementId;
break;
}
}
else
{
result.ResultCode = RealTimeServiceErrorEnum.ErrorRequestIdGeneration;
}
}
else
{
result.ResultCode = RealTimeServiceErrorEnum.ErrorInvalidSessionId;
}
return(result);
}
/// <summary>Sends a start streaming command.</summary>
/// <param name="sessionId">The session identifier.</param>
/// <param name="targetAddress">Addressee information.</param>
/// <param name="url">The streaming URL to be used.</param>
/// <returns>Response <see cref="LiveVideoControlElementListResult"/>.</returns>
private static LiveVideoControlResult SendStartStreamingCommand(
Guid sessionId,
TargetAddressType targetAddress,
string url)
{
LiveVideoControlResult result = new LiveVideoControlResult();
result.RequestId = Guid.Empty;
result.ResultCode = LiveVideoControlErrorEnum.InternalError;
Guid requestId = Guid.Empty;
string error;
if (sessionId != Guid.Empty)
{
error = _sessionManager.GenerateRequestID(sessionId, out requestId);
}
else
{
error = _sessionManager.GenerateRequestID(out requestId);
}
if (requestId != Guid.Empty)
{
ElementList <AvailableElementData> elements;
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataByTargetAddress(targetAddress, out elements);
switch (rqstResult)
{
case T2GManagerErrorEnum.eSuccess:
Guid notificationRequestId = requestId;
List <RequestContext> newRequests = new List <RequestContext>();
foreach (AvailableElementData element in elements)
{
if (_dicVideoHistorySentService.ContainsKey(targetAddress))
{
ServiceInfo availableService;
if (_t2gManager.GetAvailableServiceData(element.ElementNumber, (int)eServiceID.eSrvSIF_LiveVideoControlServer, out availableService) == T2GManagerErrorEnum.eSuccess)
{
_dicVideoHistorySentService[targetAddress] = availableService;
}
}
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlDistributionProcessing, element.ElementNumber);
ProcessStartVideoStreamingCommandRequestContext request = new ProcessStartVideoStreamingCommandRequestContext(
element.ElementNumber,
requestId,
sessionId,
url);
newRequests.Add(request);
}
_requestProcessor.AddRequestRange(newRequests);
result.RequestId = requestId;
result.ResultCode = LiveVideoControlErrorEnum.RequestAccepted;
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LogManager.WriteLog(TraceType.ERROR, "T2G Offline", "PIS.Ground.LiveVideoControl.LiveVideoControlService.SendStartStreamingCommand", null, EventIdEnum.LiveVideoControl);
result.ResultCode = LiveVideoControlErrorEnum.T2GServerOffline;
break;
case T2GManagerErrorEnum.eElementNotFound:
LogManager.WriteLog(TraceType.ERROR, "Element not found", "PIS.Ground.LiveVideoControl.LiveVideoControlService.SendStartStreamingCommand", null, EventIdEnum.LiveVideoControl);
result.ResultCode = LiveVideoControlService.GetInvalidTargetAddressResponse(targetAddress);
break;
default:
LogManager.WriteLog(TraceType.ERROR, "Problem looking for an element. T2GClient returned: " + rqstResult.ToString(),
"PIS.Ground.LiveVideoControl.LiveVideoControlService.SendStartStreamingCommand", null, EventIdEnum.LiveVideoControl);
result.ResultCode = LiveVideoControlErrorEnum.InternalError;
break;
}
}
else
{
LogManager.WriteLog(TraceType.ERROR, error, "PIS.Ground.LiveVideoControl.LiveVideoControlService.SendStartStreamingCommand", null, EventIdEnum.LiveVideoControl);
result.ResultCode = LiveVideoControlErrorEnum.InvalidRequestID;
}
return(result);
}
private static void TransmitNotifyReportRetrievedRequest(NotifyReportRetrievedRequestContext request)
{
bool lTransmitted = false;
ServiceInfo serviceInfo;
T2GManagerErrorEnum lRqstResult = _t2gManager.GetAvailableServiceData(request.ElementId, (int)eServiceID.eSrvSIF_ReportExchangeServer, out serviceInfo);
switch (lRqstResult)
{
case T2GManagerErrorEnum.eSuccess:
String lEndpoint = "http://" + serviceInfo.ServiceIPAddress + ":" + serviceInfo.ServicePortNumber;
// Check if target element is online
bool lIsElementOnline;
lRqstResult = _t2gManager.IsElementOnline(request.ElementId, out lIsElementOnline);
switch (lRqstResult)
{
case T2GManagerErrorEnum.eSuccess:
if (lIsElementOnline)
{
// Call Report Exchange train service
using (ReportExchange.ReportExchangeServiceClient client = new ReportExchange.ReportExchangeServiceClient("ReportExchangeEndpoint", lEndpoint))
{
try
{
String requestIdStr = request.RequestId.ToString();
// Call onboard train Report Exchange Web service
ReportExchange.ResultType result = client.NotifyInfotainmentJournalRetrieved(
ref requestIdStr, request.FolderId);
switch (result)
{
case ReportExchange.ResultType.ServiceInhibited:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentDownloadInhibited, request.ElementId);
break;
case ReportExchange.ResultType.Failure:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.Failed, request.ElementId);
break;
case ReportExchange.ResultType.Success:
lTransmitted = true;
break;
default:
LogManager.WriteLog(TraceType.ERROR,
String.Format("Unexpected return value from WebService client: {0}", result),
"PIS.Ground.Infotainment.Journaling.JournalingService.TransmitGetReportRequest",
null, EventIdEnum.InfotainmentJournaling);
break;
}
}
catch (Exception ex)
{
LogManager.WriteLog(TraceType.ERROR,
String.Format("Unexpected error from WebService client: {0}", ex.Message),
"PIS.Ground.Infotainment.Journaling.JournalingService.TransmitNotifyReportRetrievedRequest",
ex, EventIdEnum.InfotainmentJournaling);
}
finally
{
if (client.State == CommunicationState.Faulted)
{
client.Abort();
}
}
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentT2GServerOffline, String.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentDownloadElementNotFound, request.ElementId);
break;
default:
LogManager.WriteLog(TraceType.ERROR,
String.Format("T2G method IsElementOnline failed with error code: {0}", lRqstResult),
"PIS.Ground.Infotainment.Journaling.JournalingService.TransmitGetReportRequest",
null, EventIdEnum.InfotainmentJournaling);
break;
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentT2GServerOffline, String.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentDownloadElementNotFound, request.ElementId);
break;
case T2GManagerErrorEnum.eServiceInfoNotFound:
SendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentDownloadServiceNotFound, eServiceID.eSrvSIF_ReportExchangeServer.ToString());
break;
default:
LogManager.WriteLog(TraceType.INFO, "Failed to obtain service data from T2G", "PIS.Ground.Infotainment.Journaling.JournalingService.TransmitGetVersionFileRequest", null, EventIdEnum.InfotainmentJournaling);
break;
}
request.TransmissionStatus = lTransmitted;
}
/// <summary>
///
/// </summary>
/// <param name="sessionId"></param>
/// <param name="targetAddress"></param>
/// <param name="requestTimeout"></param>
/// <returns></returns>
public GetReportResponse GetReport(Guid sessionId, TargetAddressType targetAddress, uint requestTimeout)
{
GetReportResponse result = new GetReportResponse();
result.RequestId = Guid.Empty;
result.ResultCode = ResultCodeEnum.InternalError;
if (requestTimeout <= MAX_REQUEST_TIMEOUT)
{
if (_sessionManager.IsSessionValid(sessionId))
{
Guid requestId = Guid.Empty;
_sessionManager.GenerateRequestID(sessionId, out requestId);
if (requestId != Guid.Empty) // TODO requires modification to method GenerateRequestID
{
ElementList <AvailableElementData> elements;
T2GManagerErrorEnum lRqstResult = _t2gManager.GetAvailableElementDataByTargetAddress(targetAddress, out elements);
switch (lRqstResult)
{
case T2GManagerErrorEnum.eSuccess:
// Queue to request list
foreach (AvailableElementData element in elements)
{
SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.InfotainmentDownloadProcessing, element.ElementNumber);
GetReportRequestContext request = new GetReportRequestContext(element.ElementNumber, requestId, sessionId, requestTimeout);
lock (_lock)
{
_newRequests.Add(request);
}
}
// Signal thread and start transmitting
_transmitEvent.Set();
result.RequestId = requestId;
result.ResultCode = ResultCodeEnum.RequestAccepted;
break;
case T2GManagerErrorEnum.eT2GServerOffline:
result.ResultCode = ResultCodeEnum.T2GServerOffline;
break;
case T2GManagerErrorEnum.eElementNotFound:
switch (targetAddress.Type)
{
case AddressTypeEnum.Element:
result.ResultCode = ResultCodeEnum.UnknownElementId;
break;
case AddressTypeEnum.MissionCode:
result.ResultCode = ResultCodeEnum.UnknownMissionId;
break;
case AddressTypeEnum.MissionOperatorCode:
result.ResultCode = ResultCodeEnum.UnknownMissionId;
break;
}
break;
default:
break;
}
}
else
{
result.ResultCode = ResultCodeEnum.InvalidSessionId;
}
}
else
{
result.ResultCode = ResultCodeEnum.InvalidSessionId;
}
}
else
{
result.ResultCode = ResultCodeEnum.InvalidRequestTimeout;
}
return(result);
}
/// <summary>
/// LiveVideoControlService Web service method "StopVideoStreamingCommand" that cancels all
/// predefined and free-text messages at addressee.
/// </summary>
/// <param name="sessionId">The session identifier.</param>
/// <param name="targetAddress">Addressee information.</param>
/// <returns>Response <see cref="LiveVideoControlResult"/>.</returns>
LiveVideoControlResult ILiveVideoControlService.StopVideoStreamingCommand(
Guid sessionId,
TargetAddressType targetAddress)
{
LiveVideoControlResult result = new LiveVideoControlResult();
result.RequestId = Guid.Empty;
result.ResultCode = LiveVideoControlErrorEnum.RequestAccepted;
_dicVideoHistory.Remove(targetAddress);
_dicVideoHistorySentService.Remove(targetAddress);
if (_sessionManager.IsSessionValid(sessionId))
{
string automaticModeURL;
if (GetAutomaticMode(out automaticModeURL) == false)
{
Guid requestId = Guid.Empty;
string error = _sessionManager.GenerateRequestID(sessionId, out requestId);
if (requestId != Guid.Empty)
{
ElementList <AvailableElementData> elements;
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataByTargetAddress(targetAddress, out elements);
switch (rqstResult)
{
case T2GManagerErrorEnum.eSuccess:
{
List <RequestContext> newRequests = new List <RequestContext>();
foreach (AvailableElementData element in elements)
{
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlDistributionProcessing, element.ElementNumber);
ProcessStopVideoStreamingCommandRequestContext request = new ProcessStopVideoStreamingCommandRequestContext(
element.ElementNumber,
requestId,
sessionId);
newRequests.Add(request);
}
_requestProcessor.AddRequestRange(newRequests);
result.RequestId = requestId;
result.ResultCode = LiveVideoControlErrorEnum.RequestAccepted;
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
result.ResultCode = LiveVideoControlErrorEnum.T2GServerOffline;
break;
case T2GManagerErrorEnum.eElementNotFound:
result.ResultCode = LiveVideoControlService.GetInvalidTargetAddressResponse(targetAddress);
break;
default:
break;
}
}
else
{
LogManager.WriteLog(TraceType.ERROR, error, "PIS.Ground.LiveVideoControl.LiveVideoControlService.StopVideoStreamingCommand", null, EventIdEnum.LiveVideoControl);
result.ResultCode = LiveVideoControlErrorEnum.InvalidRequestID;
}
}
else
{
result.Url = automaticModeURL;
result.ResultCode = LiveVideoControlErrorEnum.AutomaticModeActivated;
}
}
else
{
result.ResultCode = LiveVideoControlErrorEnum.InvalidSessionId;
}
return(result);
}
/// <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);
}
/// <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;
}
}
}
/// <summary>Rtpis data store changed.</summary>
/// <param name="sender">Source of the event.</param>
/// <param name="e">Rtpis data store event information.</param>
private static void RTPISDataStoreChanged(object sender, RTPISDataStoreEventArgs e)
{
ElementList <AvailableElementData> elementList = null;
if (e != null)
{
// Skip the processing if PIS-Ground does not communicate with T2G.
if (_t2gManager.T2GServerConnectionStatus)
{
if (!string.IsNullOrEmpty(e.MissionCode))
{
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataListByMissionCode(e.MissionCode, out elementList);
if (rqstResult == T2GManagerErrorEnum.eSuccess)
{
if (elementList != null)
{
foreach (var element in elementList)
{
ProcessMissionDataSending(element.ElementNumber, e.MissionCode);
}
}
}
else
{
if (LogManager.IsTraceActive(TraceType.INFO))
{
LogManager.WriteLog(TraceType.INFO, string.Format(CultureInfo.CurrentCulture, Logs.INFO_NO_ELEMENTS_FOR_MISSION, e.MissionCode), "PIS.Ground.RealTime.RealTimeService.RTPISDataStoreChanged", null, EventIdEnum.RealTime);
}
}
}
string missionCode;
if (e.StationCodeList.HasValue &&
!string.IsNullOrEmpty((missionCode = e.StationCodeList.Value.Key)) &&
e.StationCodeList.Value.Value.Count > 0)
{
if (elementList == null)
{
T2GManagerErrorEnum rqstResult = _t2gManager.GetAvailableElementDataListByMissionCode(missionCode, out elementList);
if (rqstResult != T2GManagerErrorEnum.eSuccess && LogManager.IsTraceActive(TraceType.INFO))
{
LogManager.WriteLog(TraceType.INFO, string.Format(CultureInfo.CurrentCulture, Logs.INFO_NO_ELEMENTS_FOR_MISSION, missionCode), "PIS.Ground.RealTime.RealTimeService.RTPISDataStoreChanged", null, EventIdEnum.RealTime);
}
}
if (elementList != null)
{
foreach (var element in elementList)
{
ProcessStationDataSending(element.ElementNumber, e.StationCodeList.Value);
}
}
}
}
else if (LogManager.IsTraceActive(TraceType.DEBUG))
{
LogManager.WriteLog(TraceType.DEBUG, Logs.SKIP_NOTIFICATION_RTPISDATASTORECHANGED_T2G_OFFLINE, "PIS.Ground.RealTime.RealTimeService.RTPISDataStoreChanged", null, EventIdEnum.RealTime);
}
}
}
