protected override void Execute(CodeActivityContext activityContext)
{
QueryPartitionBase queryPartition = QueryPartition.Get(activityContext);
switch (queryPartition.Query.ExecutionMode)
{
case ExecutionMode.SingleServer:
queryPartition.InitializeQueryObject(null, null, true);
break;
case ExecutionMode.Graywulf:
using (var context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
var scheduler = activityContext.GetExtension <IScheduler>();
//queryPartition.DatabaseVersionName = queryPartition.Query.SourceDatabaseVersionName; TODO: delete
queryPartition.InitializeQueryObject(context, scheduler, false);
var dss = queryPartition.FindRequiredDatasets();
// Check if there are any Graywulf datasets referenced in the query
var assignmydb = (dss.Values.FirstOrDefault(ds => !ds.IsSpecificInstanceRequired) == null);
// *** TODO: replace this whole thing to use JOIN graphs
// If no graywulf datasets are used, use the server containing myDB,
// otherwise ask the scheduler for an appropriate server
if (dss.Count == 0 || assignmydb)
{
// use MyDB's server
var ef = new EntityFactory(context);
var federation = queryPartition.FederationReference.Value;
var user = ef.LoadEntity <User>(context.UserGuid);
var di = federation.MyDBDatabaseVersion.GetUserDatabaseInstance(user);
queryPartition.AssignedServerInstance = di.ServerInstance;
}
else
{
// Assign new server instance
var si = new ServerInstance(context);
si.Guid = scheduler.GetNextServerInstance(
dss.Values.Where(x => !x.IsSpecificInstanceRequired).Select(x => x.DatabaseDefinition.Guid).ToArray(),
queryPartition.Query.SourceDatabaseVersionName,
null);
si.Load();
queryPartition.AssignedServerInstance = si;
}
queryPartition.InitializeQueryObject(context, scheduler, true);
EntityGuid.Set(activityContext, queryPartition.AssignedServerInstance.Guid);
}
break;
}
}
protected override void Execute(CodeActivityContext activityContext)
{
Guid databaseinstanceguid = DatabaseInstanceGuid.Get(activityContext);
using (Context context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
DatabaseInstance di = new DatabaseInstance(context);
di.Guid = databaseinstanceguid;
di.Load();
di.Attach();
}
EntityGuid.Set(activityContext, databaseinstanceguid);
}
protected override void Execute(CodeActivityContext activityContext)
{
Guid databaseinstanceguid = SourceDatabaseInstanceGuid.Get(activityContext);
using (Context context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
DatabaseInstance di = new DatabaseInstance(context);
di.Guid = databaseinstanceguid;
di.Load();
di.LoadFileGroups(false);
// Files will be sorted by logical volume to allow parallel copies
Dictionary <Guid, List <Guid> > guids = new Dictionary <Guid, List <Guid> >();
// Append files
foreach (DatabaseInstanceFileGroup fg in di.FileGroups.Values)
{
fg.LoadFiles(false);
foreach (DatabaseInstanceFile f in fg.Files.Values)
{
if (!guids.ContainsKey(f.DiskVolume.Guid))
{
guids.Add(f.DiskVolume.Guid, new List <Guid>());
}
guids[f.DiskVolume.Guid].Add(f.Guid);
}
}
// Append logfiles
/* *** TODO: delete
* foreach (DatabaseInstanceFile f in di.Files.Values)
* {
* if (!guids.ContainsKey(f.DiskVolume.Guid))
* {
* guids.Add(f.DiskVolume.Guid, new List<Guid>());
* }
*
* guids[f.DiskVolume.Guid].Add(f.Guid);
* }*/
SourceDatabaseInstanceFileGuids.Set(activityContext, guids);
}
EntityGuid.Set(activityContext, databaseinstanceguid);
}
protected override void Execute(CodeActivityContext activityContext)
{
QueryBase query = Query.Get(activityContext);
using (Context context = query.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
int partitionCount;
Guid assignedServerInstanceGuid;
query.DeterminePartitionCount(context, activityContext.GetExtension <IScheduler>(), out partitionCount, out assignedServerInstanceGuid);
EntityGuid.Set(activityContext, assignedServerInstanceGuid);
query.GeneratePartitions(partitionCount);
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext activityContext, AsyncCallback callback, object state)
{
Guid sourcefileguid = SourceFileGuid.Get(activityContext);
Guid destinationdatabaseinstanceguid = DestinationDatabaseInstanceGuid.Get(activityContext);
FileCopyDirection filecopydirection = FileCopyDirection.Get(activityContext);
string sourcefilename, destinationfilename;
string hostname;
// Load files
using (Context context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
// Load destination database instance
DatabaseInstance di = new DatabaseInstance(context);
di.Guid = destinationdatabaseinstanceguid;
di.Load();
di.LoadFileGroups(false);
EntityGuid.Set(activityContext, di.Guid);
// Load database instance from the schema database
DatabaseInstanceFile df;
DatabaseInstanceFile sf = new DatabaseInstanceFile(context);
sf.Guid = sourcefileguid;
sf.Load();
EntityGuidFrom.Set(activityContext, sourcefileguid);
sourcefilename = sf.GetFullUncFilename();
DatabaseInstanceFileGroup fg = di.FileGroups[sf.DatabaseInstanceFileGroup.Name];
fg.LoadFiles(false);
df = fg.Files[sf.Name];
EntityGuidTo.Set(activityContext, df.Guid);
destinationfilename = df.GetFullUncFilename();
DatabaseInstanceFile ssf = filecopydirection == Jhu.Graywulf.Registry.FileCopyDirection.Push ? sf : df;
hostname = ssf.DatabaseInstanceFileGroup.DatabaseInstance.ServerInstance.Machine.HostName.ResolvedValue;
}
Guid workflowInstanceGuid = activityContext.WorkflowInstanceId;
string activityInstanceId = activityContext.ActivityInstanceId;
return(EnqueueAsync(_ => OnAsyncExecute(workflowInstanceGuid, activityInstanceId, hostname, sourcefilename, destinationfilename), callback, state));
}
protected override void Execute(CodeActivityContext activityContext)
{
// get/init workflow arguments
string databaseVersionName = DatabaseVersionName.Get(activityContext);
Queue <Guid> sourceDatabaseInstanceGuids = new Queue <Guid>();
Queue <Guid> destinationDatabaseInstanceGuids = new Queue <Guid>();
using (Context context = ContextManager.Instance.CreateContext(this, activityContext, ConnectionMode.AutoOpen, TransactionMode.AutoCommit))
{
EntityFactory ef = new EntityFactory(context);
DatabaseVersion dv = ef.LoadEntity <DatabaseVersion>(databaseVersionName);
EntityGuid.Set(activityContext, dv.Guid);
dv.DatabaseDefinition.LoadDatabaseInstances(false);
foreach (DatabaseInstance di in dv.DatabaseDefinition.DatabaseInstances.Values)
{
if (Entity.StringComparer.Compare(di.DatabaseVersion.Name, dv.Name) == 0)
{
if (di.ServerInstance.Machine.RunningState == RunningState.Running)
{
if (di.DeploymentState == DeploymentState.Deployed && di.RunningState == RunningState.Attached)
{
sourceDatabaseInstanceGuids.Enqueue(di.Guid);
}
else if (di.DeploymentState == DeploymentState.New || di.DeploymentState == DeploymentState.Undeployed)
{
destinationDatabaseInstanceGuids.Enqueue(di.Guid);
}
}
}
}
}
SourceDatabaseInstanceGuids.Set(activityContext, sourceDatabaseInstanceGuids);
DestinationDatabaseInstanceGuids.Set(activityContext, destinationDatabaseInstanceGuids);
if (sourceDatabaseInstanceGuids.Count == 0 ||
destinationDatabaseInstanceGuids.Count == 0)
{
throw new InvalidOperationException(ExceptionMessages.NoDatabasesToCopy);
}
}
