public void Execute(Fileset fileset)
{
_activityLogService.Log(fileset.Id, "Executing manual copy");
foreach (var item in fileset.Includes)
{
var fileName = Path.GetFileName(item.RelativePath);
var filePath = FilesetItem.GetFullPath(fileset.SourcePath, item.RelativePath);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
if (fileset.Excludes.Any())
{
var relativePath = fileset.Excludes.FirstOrDefault().RelativePath;
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, relativePath);
var directoryName = Path.GetDirectoryName(fullPath);
if (!string.IsNullOrEmpty(directoryName))
{
IEnumerable <string> files = Directory.GetFiles(directoryName);
files = files.Except(fileset.Excludes.Select(f =>
{
return(FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath));
}));
foreach (var file in files)
{
var fileName = Path.GetFileName(file);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = file,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
}
}
}
private void OnItemCopied(ReplicationItem item)
{
var title = GetBalloonTipTitle(item.Fileset);
_taskbarIcon.HideBalloonTip();
_taskbarIcon.ShowBalloonTip(
title,
item.FileName + " copied",
BalloonIcon.Info);
_lastActiveFilesets.Remove(item.Fileset);
_lastActiveFilesets.Insert(0, item.Fileset);
if (_lastActiveFilesets.Count > 5)
{
_lastActiveFilesets.RemoveAt(_lastActiveFilesets.Count - 1);
}
}
public NewCardResults RequestNewCard(string password)
{
if (!Thread.CurrentPrincipal.IsInRole("Clients"))
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
ExtractUsernameFromFullName(Thread.CurrentPrincipal.Identity.Name),
"Request for new card failed client isn't in client's role.",
EventLogEntryType.FailureAudit));
});
throw new SecurityException("Principal isn't part of Clients role.");
}
try
{
var clientName = ExtractUsernameFromFullName(Thread.CurrentPrincipal.Identity.Name);
Console.WriteLine($"Client {clientName} requested new card.");
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Request for new card!",
EventLogEntryType.Information));
});
if (CertificateManager.Instance.GetCertificateFromStore(
StoreLocation.LocalMachine,
StoreName.My,
clientName) != null)
{
throw new InvalidOperationException("You already have issued card.");
}
RevokeCertificate(clientName);
var CACertificate = CertificateManager.Instance.GetCACertificate();
CertificateManager.Instance.CreateAndStoreNewCertificate(
clientName,
password,
CACertificate,
BankAppConfig.BankTransactionServiceCertificatePath);
var cert = CertificateManager.Instance.GetCertificateFromStore(
StoreLocation.LocalMachine,
StoreName.My,
clientName);
if (cert == null)
{
throw new ArgumentNullException(nameof(cert));
}
var resultData = new NewCardResults
{
PinCode = GenerateRandomPin()
};
var client = BankCache.GetClientFromCache(_bankCache, clientName);
client.ResetPin(null, resultData.PinCode);
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Successfully created a card!",
EventLogEntryType.Information));
});
_bankCache.StoreData();
var replicationData = new ReplicationItem(
client,
ReplicationType.UserData | ReplicationType.CertificateData,
cert);
_replicatorProxy.ReplicateData(replicationData);
return(resultData);
}
catch (ArgumentNullException ane)
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
Thread.CurrentPrincipal.Identity.Name,
ane.Message,
EventLogEntryType.Error));
});
throw new FaultException <CustomServiceException>(new CustomServiceException(ane.Message + "was null!"));
}
}
public bool ExtendCard(string password)
{
var clientName = ExtractUsernameFromFullName(Thread.CurrentPrincipal.Identity.Name);
if (!Thread.CurrentPrincipal.IsInRole("Clients"))
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
$"({nameof(BankServiceApp)}) [BankMasterCardService] Client isn't part of Clients group.",
EventLogEntryType.FailureAudit));
});
throw new SecurityException("Principal isn't part of Clients role.");
}
try
{
Console.WriteLine($"Client {clientName} requested extension.");
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Requested extension.",
EventLogEntryType.Information));
});
RevokeCertificate(clientName);
var CACertificate = CertificateManager.Instance.GetCACertificate();
CertificateManager.Instance.CreateAndStoreNewCertificate(
clientName,
password,
CACertificate,
BankAppConfig.BankTransactionServiceCertificatePath);
var newCert = CertificateManager.Instance.GetCertificateFromStore(
StoreLocation.LocalMachine,
StoreName.My,
clientName);
if (newCert == null)
{
return(false);
}
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Successfully extended the card.",
EventLogEntryType.Information));
});
var replicationItem = new ReplicationItem(null, ReplicationType.CertificateData, newCert);
_replicatorProxy.ReplicateData(replicationItem);
return(true);
}
catch (ArgumentNullException ane)
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
Thread.CurrentPrincipal.Identity.Name,
ane.Message,
EventLogEntryType.Error));
});
throw new FaultException <CustomServiceException>(new CustomServiceException(ane.Message + "was null!"),
$"{ane.Message} was null!");
}
}
public bool RevokeExistingCard(string pin)
{
if (!Thread.CurrentPrincipal.IsInRole("Clients"))
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
ExtractUsernameFromFullName(Thread.CurrentPrincipal.Identity.Name),
"Request for new card failed client isn't in client's role.",
EventLogEntryType.FailureAudit));
});
throw new SecurityException("Client isn't in required role.");
}
try
{
// Check if client exists
var clientName = ExtractUsernameFromFullName(Thread.CurrentPrincipal.Identity.Name);
var client = default(IClient);
client = BankCache.GetClientFromCache(_bankCache, clientName);
if (client == null)
{
return(false);
}
// if he exists in the system, authorize him
if (client.CheckPin(pin))
{
Console.WriteLine($"Client {clientName} requested card revocation.");
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Requested card revocation.",
EventLogEntryType.Information));
});
var cert = CertificateManager.Instance.GetCertificateFromStore(
StoreLocation.LocalMachine,
StoreName.My,
clientName);
if (cert == null)
{
return(false);
}
var revoked = RevokeCertificate(clientName);
if (revoked)
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Successfully revoked the card.",
EventLogEntryType.Information));
});
client.Pin = null;
_bankCache.StoreData();
// We also replicate client data since pin wa removed
var replicationData = new ReplicationItem(
client,
ReplicationType.UserData | ReplicationType.CertificateData |
ReplicationType.RevokeCertificate,
cert);
_replicatorProxy.ReplicateData(replicationData);
}
return(revoked);
}
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
clientName,
"Invalid pin.",
EventLogEntryType.FailureAudit));
});
throw new SecurityException("Invalid pin.");
}
catch (ArgumentNullException ane)
{
Task.Run(() =>
{
ProxyPool.GetProxy <IBankAuditService>().Log(new EventLogData(
_applicationName,
Thread.CurrentPrincipal.Identity.Name,
ane.Message,
EventLogEntryType.Error));
});
throw;
}
}
private void ReplicationRun()
{
try
{
foreach (var item in _replicationQueue.GetConsumingEnumerable(_cts.Token))
{
ReplicationItem currentItem = item;
ScriptScope scope = _scriptEngine.CreateScope();
scope.SetVariable("fileInfo", currentItem);
scope.SetVariable("fileset", currentItem.Fileset);
scope.SetVariable("retryCopy", new Action(() =>
{
currentItem.IncrementRetries();
_replicationQueue.Add(currentItem);
}));
scope.SetVariable("log", new Action <string>(message =>
{
_activityLogService.Log(currentItem.Fileset.Id, message);
}));
if (File.Exists(_copyEventScriptFile))
{
try
{
ExecuteScripts(_scriptEngine, scope, currentItem.Fileset.OnCopyScripts);
ExecuteScripts(_scriptEngine, scope, currentItem.Fileset.OnCopySuccessScripts);
_eventAggregator.GetEvent <CopiedEvent>().Publish(currentItem);
}
catch (Exception e)
{
try
{
scope.SetVariable("exception", e);
ExecuteScripts(_scriptEngine, scope, currentItem.Fileset.OnCopyErrorScripts);
}
catch (Exception exception)
{
Trace.WriteLine(exception);
}
_eventAggregator.GetEvent <CopyErrorEvent>().Publish(Tuple.Create(currentItem, e));
}
finally
{
try
{
ExecuteScripts(_scriptEngine, scope, currentItem.Fileset.OnCopyFinallyScripts);
}
catch (Exception e)
{
Trace.WriteLine(e);
}
}
}
}
}
catch (OperationCanceledException oce)
{
Trace.WriteLine(oce);
}
}
private void ActivateFileset(Fileset fileset)
{
List <IDisposable> watchers;
if (!_watchers.TryGetValue(fileset, out watchers))
{
watchers = new List <IDisposable>();
_watchers.TryAdd(fileset, watchers);
}
DeactivateFileset(fileset);
var distinctIncludeFolders = fileset.Includes.Select(f =>
{
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath);
return(new FileInfo(fullPath).DirectoryName);
}).Distinct();
var distinctExcludeFolders = fileset.Excludes.Select(f =>
{
var fullPath = FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath);
return(new FileInfo(fullPath).DirectoryName);
}).Distinct();
var foldersToWatch = distinctIncludeFolders.Union(distinctExcludeFolders);
foreach (var folderToWatch in foldersToWatch)
{
if (Directory.Exists(folderToWatch))
{
IDisposable observable = GetObservable(folderToWatch)
.Buffer(TimeSpan.FromSeconds(2))
.Subscribe(t =>
{
if (t.Any())
{
var fileNames = t.Distinct();
foreach (var filePath in fileNames)
{
var relativePath = FilesetItem.GetRelativePath(fileset.SourcePath, filePath);
if (fileset.Includes.Any(f => f.RelativePath == relativePath))
{
var fileName = Path.GetFileName(filePath);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
if (fileset.Excludes.Any())
{
string directoryName = Path.GetDirectoryName(filePath);
if (!string.IsNullOrEmpty(directoryName))
{
IEnumerable <string> files = Directory.GetFiles(directoryName);
files = files.Except(fileset.Excludes.Select(f =>
{
return(FilesetItem.GetFullPath(fileset.SourcePath, f.RelativePath));
}));
foreach (var file in files)
{
var fileName = Path.GetFileName(file);
var replicationItem = new ReplicationItem
{
Fileset = fileset,
FileName = fileName,
FullSourcePath = filePath,
FullDestinationPath = Path.Combine(fileset.DestinationPath, fileName)
};
replicationItem.Data.LockingProcesses = new string[0];
_replicationQueue.TryAdd(replicationItem);
}
}
}
}
}
});
watchers.Add(observable);
}
}
}
