public async Task <bool> ResumeWorkflow(string workflowId)
{
if (LockProvider.AcquireLock(workflowId).Result)
{
bool requeue = false;
try
{
var wf = await PersistenceStore.GetWorkflowInstance(workflowId);
if (wf.Status == WorkflowStatus.Suspended)
{
wf.Status = WorkflowStatus.Runnable;
await PersistenceStore.PersistWorkflow(wf);
requeue = true;
return(true);
}
return(false);
}
finally
{
await LockProvider.ReleaseLock(workflowId);
if (requeue)
{
await QueueProvider.QueueForProcessing(workflowId);
}
}
}
return(false);
}
public async Task <bool> SuspendWorkflow(string workflowId)
{
if (await LockProvider.AcquireLock(workflowId, new CancellationToken()))
{
try
{
var wf = await PersistenceStore.GetWorkflowInstance(workflowId);
if (wf.Status == WorkflowStatus.Runnable)
{
wf.Status = WorkflowStatus.Suspended;
await PersistenceStore.PersistWorkflow(wf);
return(true);
}
return(false);
}
finally
{
await LockProvider.ReleaseLock(workflowId);
}
}
return(false);
}
public async Task PublishEvent(string eventName, string eventKey, object eventData, DateTime?effectiveDate = null)
{
if (_shutdown)
{
throw new Exception("Host is not running");
}
Logger.LogDebug("Creating event {0} {1}", eventName, eventKey);
Event evt = new Event();
if (effectiveDate.HasValue)
{
evt.EventTime = effectiveDate.Value.ToUniversalTime();
}
else
{
evt.EventTime = DateTime.Now.ToUniversalTime();
}
evt.EventData = eventData;
evt.EventKey = eventKey;
evt.EventName = eventName;
evt.IsProcessed = false;
string eventId = await PersistenceStore.CreateEvent(evt);
await QueueProvider.QueueWork(eventId, QueueType.Event);
}
public async Task IsUsernameRegisteredAsync_TestUser_Exists()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.Users.IsUsernameRegisteredAsync(TestBase.ValidUser.Username);
Assert.IsTrue(result);
}
public async Task IsUsernameRegisteredAsync_NonExistentUser_DoesNotExist()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.Users.IsUsernameRegisteredAsync(TestBase.ValidUser.Username + Guid.NewGuid().ToString());
Assert.IsFalse(result);
}
public async Task IsIdentityRegisteredAsync_NonexistentCredentialAndSecret_NoRecord()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.IsIdentityRegisteredAsync(ValidUserAuthentications.First().CredentialType, ValidUserAuthentications.First().Secret + " xyz");
Assert.IsFalse(result);
}
public async Task CreateAsync_ValidUser_GetsNewSession()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserSessions.CreateAsync(ValidUserId, DateTime.UtcNow);
Assert.AreEqual(TestBase.ValidUser.Id, result.UserId);
}
public async Task GetBySecretAsync_ValidCredentialAndSecret_GetsRecord()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.GetBySecretAsync(ValidUserAuthentications.First().CredentialType, ValidUserAuthentications.First().Secret);
Assert.IsNotNull(result);
}
public async Task GetByUserAsync_nonexistentId_NoRecord()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.GetAsync(Guid.NewGuid());
Assert.IsNull(result);
}
public async Task GetAsync_ValidId_GetsRecord()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.GetAsync(ValidUserAuthentications.First().Id);
Assert.IsNotNull(result);
}
public async Task GetByUserAsync_ValidUserEmptyCredential_GetsEmptyList()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.GetByUserAsync(CredentialType.Twitter, ValidUserId);
Assert.AreEqual(0, result.Count);
}
public async Task GetByUserAsync_ValidUserCredentialPair_GetsRecords()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.UserAuthentications.GetByUserAsync(ValidUserAuthentications.First().CredentialType, ValidUserId);
Assert.AreEqual(ValidUserAuthentications.Count(), result.Count);
}
public async Task GetAsync_TestCustomer_GetsCustomerRecord()
{
var database = new PersistenceStore(ConnectionString);
var result = await database.Customers.GetAsync(TestBase.ValidCustomerId);
Assert.AreEqual(TestBase.ValidCustomer.Id, result.Id);
Assert.AreEqual(TestBase.ValidCustomer.DisplayName, result.DisplayName);
}
public async Task SubscribeEvent(string workflowId, int stepId, string eventName, string eventKey)
{
Logger.LogDebug("Subscribing to event {0} {1} for workflow {2} step {3}", eventName, eventKey, workflowId, stepId);
EventSubscription subscription = new EventSubscription();
subscription.WorkflowId = workflowId;
subscription.StepId = stepId;
subscription.EventName = eventName;
subscription.EventKey = eventKey;
await PersistenceStore.CreateEventSubscription(subscription);
}
public void Start()
{
_shutdown = false;
PersistenceStore.EnsureStoreExists();
QueueProvider.Start().Wait();
LockProvider.Start().Wait();
Logger.LogInformation("Starting backgroud tasks");
foreach (var task in _backgroundTasks)
{
task.Start();
}
}
private async Task StashUnpublishedEvents()
{
if (!_shutdown)
{
var pub = await QueueProvider.DequeueForPublishing();
while (pub != null)
{
await PersistenceStore.CreateUnpublishedEvent(pub);
pub = await QueueProvider.DequeueForPublishing();
}
}
}
public async Task GetAsync_CreateViewAsync_ProducesNewView()
{
var database = new PersistenceStore(ConnectionString);
string originalAccessKey = "abc-123";
var view = new ViewDTO(null, ValidCustomerId, originalAccessKey, new ViewCustomizationDTO("url", "logo", "title", new List <ViewCustomizationHeaderLinkDTO>(), "copyright"), new List <ViewColumnDTO>()
{
});
var result = await database.Views.CreateNewAsync(view);
Assert.AreEqual(originalAccessKey, result.AccessKey);
Assert.AreNotEqual(originalAccessKey, view.AccessKey);
Assert.AreEqual(view.CustomerId, result.CustomerId);
Assert.IsNotNull(result.Id);
}
public async Task <string> StartWorkflow <TData>(string workflowId, int?version, TData data = null)
where TData : class
{
if (_shutdown)
{
throw new InvalidOperationException("Host is not running");
}
var def = Registry.GetDefinition(workflowId, version);
if (def == null)
{
throw new WorkflowNotRegisteredException(workflowId, version);
}
var wf = new WorkflowInstance
{
WorkflowDefinitionId = workflowId,
Version = def.Version,
Data = data,
Description = def.Description,
NextExecution = 0,
CreateTime = DateTime.Now.ToUniversalTime(),
Status = WorkflowStatus.Runnable
};
if ((def.DataType != null) && (data == null))
{
wf.Data = def.DataType.GetConstructor(new Type[] { }).Invoke(null);
}
wf.ExecutionPointers.Add(new ExecutionPointer
{
Id = Guid.NewGuid().ToString(),
StepId = 0,
Active = true,
StepName = def.Steps.First(x => x.Id == 0).Name
});
string id = await PersistenceStore.CreateNewWorkflow(wf);
await QueueProvider.QueueWork(id, QueueType.Workflow);
return(id);
}
public async Task <string> StartWorkflow <TData>(string workflowId, int?version, TData data = null)
where TData : class
{
if (_shutdown)
{
throw new Exception("Host is not running");
}
var def = Registry.GetDefinition(workflowId, version);
if (def == null)
{
throw new Exception(String.Format("Workflow {0} version {1} is not registered", workflowId, version));
}
var wf = new WorkflowInstance();
wf.WorkflowDefinitionId = workflowId;
wf.Version = def.Version;
wf.Data = data;
wf.Description = def.Description;
wf.NextExecution = 0;
wf.CreateTime = DateTime.Now.ToUniversalTime();
wf.Status = WorkflowStatus.Runnable;
if ((def.DataType != null) && (data == null))
{
wf.Data = def.DataType.GetConstructor(new Type[] { }).Invoke(null);
}
wf.ExecutionPointers.Add(new ExecutionPointer()
{
Id = Guid.NewGuid().ToString(),
StepId = def.InitialStep,
Active = true,
ConcurrentFork = 1,
StepName = def.Steps.First(x => x.Id == def.InitialStep).Name
});
string id = await PersistenceStore.CreateNewWorkflow(wf);
await QueueProvider.QueueForProcessing(id);
return(id);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_shutdown = false;
PersistenceStore.EnsureStoreExists();
await QueueProvider.Start();
await LockProvider.Start();
await _lifeCycleEventHub.Start();
await _searchIndex.Start();
Logger.LogInformation("Starting background tasks");
foreach (var task in _backgroundTasks)
{
task.Start();
}
}
public async Task <bool> TerminateWorkflow(string workflowId)
{
if (LockProvider.AcquireLock(workflowId).Result)
{
try
{
var wf = await PersistenceStore.GetWorkflowInstance(workflowId);
wf.Status = WorkflowStatus.Terminated;
await PersistenceStore.PersistWorkflow(wf);
return(true);
}
finally
{
await LockProvider.ReleaseLock(workflowId);
}
}
return(false);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_shutdown = false;
PersistenceStore.EnsureStoreExists();
await QueueProvider.Start();
await LockProvider.Start();
await _lifeCycleEventHub.Start();
await _searchIndex.Start();
// Event subscriptions are removed when stopping the event hub.
// Add them when starting.
AddEventSubscriptions();
Logger.LogInformation("Starting background tasks");
foreach (var task in _backgroundTasks)
{
task.Start();
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var activity = WorkflowActivity.StartHost();
try
{
_shutdown = false;
PersistenceStore.EnsureStoreExists();
await QueueProvider.Start();
await LockProvider.Start();
await _lifeCycleEventHub.Start();
await _searchIndex.Start();
// Event subscriptions are removed when stopping the event hub.
// Add them when starting.
AddEventSubscriptions();
Logger.LogInformation("Starting background tasks");
foreach (var task in _backgroundTasks)
{
task.Start();
}
}
catch (Exception ex)
{
activity.RecordException(ex);
throw;
}
finally
{
activity?.Dispose();
}
}
public async Task PublishEvent(string eventName, string eventKey, object eventData)
{
if (_shutdown)
{
throw new Exception("Host is not running");
}
Logger.LogDebug("Publishing event {0} {1}", eventName, eventKey);
var subs = await PersistenceStore.GetSubcriptions(eventName, eventKey);
foreach (var sub in subs.ToList())
{
EventPublication pub = new EventPublication();
pub.Id = Guid.NewGuid();
pub.EventData = eventData;
pub.EventKey = eventKey;
pub.EventName = eventName;
pub.StepId = sub.StepId;
pub.WorkflowId = sub.WorkflowId;
await QueueProvider.QueueForPublishing(pub);
await PersistenceStore.TerminateSubscription(sub.Id);
}
}
private static CacheManager GetCacheManager(PersistenceStore store)
{
return CacheFactory.GetCacheManager(Enum.GetName(typeof(PersistenceStore), store)) as CacheManager;
}
/// <summary>
/// Construct a new index term for the specified persistence store.
/// </summary>
/// <param name="PersistenceStore">Store to add index term to.</param>
public MeshIndexTerm(PersistenceStore PersistenceStore) {
this.PersistenceStore = PersistenceStore;
UserProfilesByAccount = PersistenceStore.GetIndex(KeyUserProfile);
IndexUniqueID = PersistenceStore.GetIndex(UniqueID);
}
/// <summary>
/// 캐시를 지원하는 <c>IDacHelper</c>를 구현하는 클래스의 새 인스턴스를 돌려줍니다.
/// </summary>
/// <param name="dbHelper">쿼리를 수행하는데 사용되는 <c>SqlDbHelper</c>입니다.</param>
/// <param name="connectionStringName">연결문자열입니다.</param>
/// <param name="store">캐시 저장 메카니즘의 종류 입니다.</param>
/// <param name="slidingExpiration">캐시의 폐기 시간 입니다.</param>
/// <returns>캐시를 지원하는 <c>IDacHelper</c>를 구현하는 클래스의 새 인스턴스입니다.</returns>
public static IDacHelper CreateCacheable(SqlDbHelper dbHelper, string connectionStringName, PersistenceStore store, TimeSpan slidingExpiration)
{
return new CacheableDacHelper(dbHelper, connectionStringName, GetCacheManager(store), slidingExpiration);
}
/// <summary>
/// Construct a persistence store for the specified domain, with the
/// specified store and portal stores.
/// </summary>
/// <param name="Domain">Domain name of the service</param>
/// <param name="Store">store name for the profile persistence store.</param>
/// <param name="Portal">Store name for the portal persistence store.</param>
public Mesh(string Domain, string Store, string Portal) {
this.Domain = Domain;
MeshStore = new LogPersistenceStore(Store, StoreType, StoreComment);
PortalStore = new LogPersistenceStore(Portal, PortalType, PortalComment);
//Accounts are kept in the portal store and indexed by
//the account
PortalByPrimary = PortalStore.ObjectIndex;
//Profiles are kept in the Mesh and are indexed by the UDF of the
//master signature key.
IndexUniqueID = MeshStore.ObjectIndex;
}