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