DataActionResult <string> GetFilePath(ExecutableServicesTypes key)
{
string path;
lock (_servicesData)
{
path = _servicesData[key].FilePathCache;
if (path == null || !File.Exists(path))
{
DataActionResult <FilePathData[]> pathsSearchResult =
SearchBinDirectoryForFilePaths();
if (pathsSearchResult.Status.Failure())
{
return(DataActionResult <string> .Failed(
pathsSearchResult.Status
));
}
DataActionResult <string> newServicePathResult =
FindServicePath(
_servicesData[key].StrSearchKey,
pathsSearchResult.Result
);
if (newServicePathResult.Status.Failure())
{
return(DataActionResult <string> .Failed(
newServicePathResult.Status
));
}
_servicesData[key].FilePathCache = newServicePathResult.Result;
path = newServicePathResult.Result;
}
}
return(DataActionResult <string> .Successful(path));
}
public async Task <DataActionResult <string> > GetCwsBoundingString(
int nodeId,
int cwsId
)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <string> .Failed(nodeIdValidationStatus));
}
StatusMessage cwsIdValidationStatus =
(await GetCwsParamNumber(cwsId)).Status;
if (cwsIdValidationStatus.Failure())
{
return(DataActionResult <string> .Failed(cwsIdValidationStatus));
}
StatusMessage cwsBindingExistsStatus =
await FailIfCWSBinding_DOES_NOT_Exist(nodeId, cwsId);
if (cwsBindingExistsStatus.Failure())
{
return(DataActionResult <string> .Failed(cwsBindingExistsStatus));
}
return(await Repo.GetCwsBoundingString(nodeId, cwsId));
}
public async Task <DataActionResult <NtwkNode> > CreateNodeWithParent(
NtwkNode node,
int parentId
)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(parentId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeIdValidationStatus));
}
StatusMessage nodeValidationStatus = _validator.Validate(node);
if (nodeValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeValidationStatus));
}
StatusMessage nameExistsStatus = await FailIfNodeNameExists(node.Name);
if (nameExistsStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nameExistsStatus));
}
return(FailOrConvert(
await Repo.CreateNodeWithParent(_viewToEfConverter.Convert(node), parentId),
n => _efToViewConverter.Convert(n)
));
}
static DataActionResult <FilePathData[]> SearchBinDirectoryForFilePaths()
{
FilePathData[] files;
try
{
files = Directory.GetFiles(Directory.GetCurrentDirectory() + @"/bin")
.Select(f => new FilePathData()
{
FullPath = f,
Filename = Path.GetFileName(f)
})
.ToArray();
}
catch (UnauthorizedAccessException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.NotEnoughOsRightsToSearchForExecServices
));
}
catch (DirectoryNotFoundException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.CouldNotFindBinDirectoryWhileSearchingForExecutableServices
));
}
catch (IOException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.UnknownIoErrorWhileTryingToFindExecutableServices
));
}
return(DataActionResult <FilePathData[]> .Successful(files));
}
public async Task <DataActionResult <IEnumerable <PingTestData> > > TestConnectionListAsync(
IEnumerable <IPAddress> ips
)
{
IEnumerable <IPAddress> ipAddresses = ips as IPAddress[] ?? ips.ToArray();
int len = ipAddresses.Count();
var results = new DataActionResult <PingTestData> [len];
int index = 0;
DataActionResult <PingTestData> firstFailed = null;
foreach (var ip in ipAddresses)
{
results[index] = await TestConnectionAsync(ip);
if (results[index].Status.Failure())
{
firstFailed = results[index];
break;
}
index++;
}
return(firstFailed != null
? DataActionResult <IEnumerable <PingTestData> >
.Failed(firstFailed.Status)
: DataActionResult <IEnumerable <PingTestData> >
.Successful(results.Select(r => r.Result)));
}
protected DataActionResult <TModelOut> FailOrConvert <TModelIn, TModelOut>(
DataActionResult <TModelIn> input,
Func <TModelIn, TModelOut> convert
)
{
return(input.Status.Failure()
? DataActionResult <TModelOut> .Failed(input.Status)
: DataActionResult <TModelOut> .Successful(convert(input.Result)));
}
public async Task <DataActionResult <TagFilterData> > GetProfileMonitorTagFilterData(int profileId)
{
StatusMessage profileIdValidationStatus = await ValidateProfileId(profileId);
if (profileIdValidationStatus.Failure())
{
return(DataActionResult <TagFilterData> .Failed(profileIdValidationStatus));
}
return(await Repo.GetProfileMonitorTagFilterData(profileId));
}
protected async Task <DataActionResult <int> > GetCwsParamNumber(int cwsId)
{
DataActionResult <int> paramNumResult =
await Repo.GetCwsParamNumber(cwsId);
return(paramNumResult.Status.Failure()
? DataActionResult <int> .Failed(StatusMessage.ErrorWhileCheckingCwsParamNumberInDatabase)
: paramNumResult.Result == -1
? DataActionResult <int> .Failed(StatusMessage.InvalidWebServiceId)
: paramNumResult);
}
public async Task <DataActionResult <IEnumerable <IPAddress> > > GetNodesIPs(
IEnumerable <int> nodesIDs
)
{
var results = await Task.WhenAll(nodesIDs.Select(GetNodeIp));
var firstFailure = results.FirstOrDefault(r => r.Status.Failure());
return(firstFailure != null
? DataActionResult <IEnumerable <IPAddress> > .Failed(firstFailure.Status)
: DataActionResult <IEnumerable <IPAddress> > .Successful(results.Select(r => r.Result)));
}
public async Task <DataActionResult <IEnumerable <int> > > GetTaggedNodesIDs(
int tagId
)
{
StatusMessage tagIdValidationStatus = await ValidateTagId(tagId);
if (tagIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <int> > .Failed(tagIdValidationStatus));
}
return(await Repo.GetTaggedNodesIDs(tagId));
}
public async Task <DataActionResult <Profile> > RemoveProfile(int profileId)
{
StatusMessage profileIdValidationStatus = await ValidateProfileId(profileId);
if (profileIdValidationStatus.Failure())
{
return(DataActionResult <Profile> .Failed(profileIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveProfile(profileId),
p => _efToViewConverter.Convert(p)
));
}
public async Task <DataActionResult <NtwkNode> > RemoveNode(int nodeId)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveNode(nodeId),
n => _efToViewConverter.Convert(n)
));
}
public async Task <DataActionResult <NodeTag> > RemoveTag(int tagId)
{
StatusMessage tagIdValidationStatus = await ValidateTagId(tagId);
if (tagIdValidationStatus.Failure())
{
return(DataActionResult <NodeTag> .Failed(tagIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveTag(tagId),
t => _efToViewConverter.Convert(t)
));
}
public async Task <DataActionResult <IPAddress> > GetNodeIp(int nodeId)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <IPAddress> .Failed(nodeIdValidationStatus));
}
return(FailOrConvert(
await Repo.GetNodeIp(nodeId),
nIp => new IPAddress(nIp)
));
}
public async Task <DataActionResult <CustomWebService> > RemoveCustomWebService(
int cwsId
)
{
StatusMessage idExistsStatus =
(await GetCwsParamNumber(cwsId)).Status;
if (idExistsStatus.Failure())
{
return(DataActionResult <CustomWebService> .Failed(idExistsStatus));
}
return(FailOrConvert(
await Repo.RemoveCustomWebService(cwsId),
cws => _efToViewConverter.Convert(cws)
));
}
public async Task <DataActionResult <IEnumerable <MonitoringSession> > > GetSessionsForProfile(int profileId)
{
StatusMessage profIdValidationStatus =
await ValidateProfileId(profileId);
if (profIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <MonitoringSession> > .Failed(
profIdValidationStatus
));
}
return(FailOrConvert(
await Repo.GetSessionsForProfile(profileId),
sessions => sessions.Select(s => _efToViewConverter.Convert(s))
));
}
public async Task <DataActionResult <MonitoringSession> > GetNewSession(
int profileId
)
{
StatusMessage profIdValidationStatus =
await ValidateProfileId(profileId);
if (profIdValidationStatus.Failure())
{
return(DataActionResult <MonitoringSession> .Failed(profIdValidationStatus));
}
return(FailOrConvert(
await Repo.GetNewSession(profileId),
session => _efToViewConverter.Convert(session)
));
}
//includes messages
public async Task <DataActionResult <IEnumerable <MonitoringPulseResult> > > GetSessionReport(
int monitoringSessionId)
{
StatusMessage sessionIdValidationStatus =
await ValidateSessionId(monitoringSessionId);
if (sessionIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <MonitoringPulseResult> > .Failed(
sessionIdValidationStatus
));
}
return(FailOrConvert(
await Repo.GetSessionReport(monitoringSessionId),
pulses => pulses.Select(ConvertPulseResult)
));
}
public async Task <DataActionResult <PingTestData> > TestConnectionAsync(
IPAddress ip
)
{
List <PingTestData> pingReplies = new List <PingTestData>();
for (int i = 0; i < _maxRetry; i++)
{
DataActionResult <PingTestData> pingResult = await PingAsync(
_ping,
ip,
_timeout,
_buffer,
_options
);
if (pingResult.Status.Failure())
{
return(DataActionResult <PingTestData> .Failed(pingResult.Status));
}
pingReplies.Add(pingResult.Result);
if (pingResult.Result.Avg < 50 && pingResult.Result.Failed == 0)
{
break;
}
}
PingTestData result = pingReplies.Aggregate((current, next) =>
{
current.Num += next.Num;
current.Avg += next.Avg;
current.Failed += next.Failed;
return(current);
});
int successful = result.Num - result.Failed;
if (successful != 0)
{
result.Avg /= successful;
}
return(DataActionResult <PingTestData> .Successful(result));
}
public async Task <DataActionResult <Profile> > CreateProfile(Profile profile)
{
StatusMessage profileValidationStatus = _validator.Validate(profile);
if (profileValidationStatus.Failure())
{
return(DataActionResult <Profile> .Failed(profileValidationStatus));
}
StatusMessage nameExistsStatus = await FailIfProfileNameExists(profile.Name);
if (nameExistsStatus.Failure())
{
return(DataActionResult <Profile> .Failed(nameExistsStatus));
}
return(FailOrConvert(
await Repo.CreateProfile(_viewToEfConverter.Convert(profile)),
p => _efToViewConverter.Convert(p)
));
}
public async Task <DataActionResult <NodeTag> > CreateTag(NodeTag tag)
{
StatusMessage tagValidationStatus = _validator.Validate(tag);
if (tagValidationStatus.Failure())
{
return(DataActionResult <NodeTag> .Failed(tagValidationStatus));
}
StatusMessage nameExistsStatus = await FailIfTagNameExists(tag.Name);
if (nameExistsStatus.Failure())
{
return(DataActionResult <NodeTag> .Failed(nameExistsStatus));
}
return(FailOrConvert(
await Repo.CreateTag(_viewToEfConverter.Convert(tag)),
t => _efToViewConverter.Convert(t)
));
}
static async Task <DataActionResult <PingTestData> > PingAsync(
Ping ping,
IPAddress ip,
int timeout,
byte[] buffer,
PingOptions options
)
{
try
{
long tripTime = -1;
PingTestData result = new PingTestData()
{
Num = 1
};
var reply = await ping.SendPingAsync(ip, timeout, buffer, options);
if (reply.Status == IPStatus.Success)
{
tripTime = reply.RoundtripTime;
}
if (tripTime == -1)
{
result.Avg = 0;
result.Failed = 1;
}
else
{
result.Avg = tripTime;
}
return(DataActionResult <PingTestData> .Successful(result));
}
catch (PingException)
{
return(DataActionResult <PingTestData> .Failed(
StatusMessage.PingExecutionServiceError
));
}
}
async Task <DataActionResult <T> > PerformDataOperationOrLogExceptions <T>(
Func <Task <T> > getter
)
{
try
{
return(DataActionResult <T> .Successful(await getter()));
}
catch (AggregateException aggregateException)
{
aggregateException.Handle(ex =>
{
_logger.LogException(ex);
return(true);
});
return(DataActionResult <T> .Failed(StatusMessage.DatabaseInternalError));
}
catch (Exception ex)
{
_logger.LogException(ex);
return(DataActionResult <T> .Failed(StatusMessage.DatabaseInternalError));
}
}
static DataActionResult <string> FindServicePath(
string strKey,
FilePathData[] paths
)
{
IEnumerable <FilePathData> candidates = paths
.Where(f => f.Filename.Contains(strKey))
.ToArray();
if (!candidates.Any())
{
return(DataActionResult <string> .Failed(
StatusMessage.NoSpecifiedExecServiceFoundInBinDirectory
));
}
else if (candidates.Count() > 1)
{
return(DataActionResult <string> .Failed(
StatusMessage.TooManyCandidatesForSpecefiedExecServiceInBinDirectory
));
}
return(DataActionResult <string> .Successful(candidates.Single().FullPath));
}
public async Task <DataActionResult <MonitoringPulseResult> > SavePulseResult(
int sessionId,
MonitoringPulseResult pulseResult,
IEnumerable <MonitoringMessage> messages
)
{
StatusMessage sessionIdValidationStatus =
await ValidateSessionId(sessionId);
if (sessionIdValidationStatus.Failure())
{
return(DataActionResult <MonitoringPulseResult> .Failed(sessionIdValidationStatus));
}
IEnumerable <MonitoringMessage> monitoringMessages = messages as MonitoringMessage[] ?? messages.ToArray();
foreach (MonitoringMessage message in monitoringMessages)
{
StatusMessage messageValidationStatus = _validator.Validate(message);
if (messageValidationStatus.Failure())
{
return(DataActionResult <MonitoringPulseResult> .Failed(
messageValidationStatus
));
}
}
EFDbModel.MonitoringPulseResult convertedPulseResult =
_viewToEfConverter.Convert(pulseResult);
IEnumerable <EFDbModel.MonitoringMessage> convertedMessages = monitoringMessages
.Select(m => _viewToEfConverter.Convert(m));
return(FailOrConvert(
await Repo.SavePulseResult(sessionId, convertedPulseResult, convertedMessages),
ConvertPulseResult
));
}
public async Task <DataActionResult <CustomWebService> > CreateCustomWebService(
CustomWebService cws
)
{
StatusMessage validationStatus = _validator.Validate(cws);
if (validationStatus.Failure())
{
return(DataActionResult <CustomWebService> .Failed(validationStatus));
}
StatusMessage nameExistsStatus =
await FailIfCwsNameExists(cws.Name);
if (nameExistsStatus.Failure())
{
return(DataActionResult <CustomWebService> .Failed(nameExistsStatus));
}
return(FailOrConvert(
await Repo.CreateCustomWebService(_viewToEfConverter.Convert(cws)),
created => _efToViewConverter.Convert(created)
));
}
