public Task AddASameTypeStatelessOperatorToTopology(Guid guid)
{
var unit = topology.GetUnit(guid);
if (unit.OperatorType == OperatorType.Stateless)
{
var newUnit = new TopologyUnit(OperatorType.Stateless, Guid.NewGuid());
//To Add a new operator, we need connect it with all the upper stream units
//and lower stream unit
var upperStreamUnits = unit.GetUpperStreamUnits();
var downsStreamUnits = unit.GetdownStreamUnits();
var newStatelessOp = GrainFactory.GetGrain <IStatelessOperator>(newUnit.PrimaryKey, Constants.Stateless_Operator_Prefix);
//Add down stream by this unit
newStatelessOp.AddCustomDownStreamOperators(downsStreamUnits.Values.ToList());
foreach (var op in upperStreamUnits)
{
if (op.Value.OperatorType == OperatorType.Source)
{
var source = GrainFactory.GetGrain <IStreamSource>(op.Key);
source.AddCustomDownStreamOperator(newStatelessOp);
}
}
}
else
{
throw new ArgumentException("The guid is not a stateless operator!");
}
return(Task.CompletedTask);
}
public override Task OnActivateAsync()
{
batchTracker = GrainFactory.GetGrain <IBatchTracker>(Constants.Tracker);
operatorSettings.operatorType = OperatorType.Stateless;
topologyManager = GrainFactory.GetGrain <ITopology>(Constants.Topology_Manager);
topologyUnit = new TopologyUnit(OperatorType.Stateless, this.GetPrimaryKey());
topologyManager.AddUnit(topologyUnit);
return(base.OnActivateAsync());
}
public override Task OnActivateAsync()
{
var streamProvider = GetStreamProvider(Constants.FaultTolerantStreamProvider);
stream = streamProvider.GetStream <StreamMessage>(Guid.NewGuid(), Constants.FaultTolerantStreamNameSpace);
SetUpBatchManager();
SetUpBatchTracker();
currentBatchID = 0;
topologyManager = GrainFactory.GetGrain <ITopology>(Constants.Topology_Manager);
topologyUnit = new TopologyUnit(OperatorType.Source, this.GetPrimaryKey());
topologyManager.AddUnit(topologyUnit);
return(base.OnActivateAsync());
}
public override Task OnActivateAsync()
{
//Add a initial state for testing usage
currentBatchID = 0;
//Generate random file name
var name = @"D:\grainStates\grain" + Guid.NewGuid().ToString() + ".dat";
batchTracker = GrainFactory.GetGrain <IBatchTracker>(Constants.Tracker);
batchCoordinator = GrainFactory.GetGrain <IBatchCoordinator>(Constants.Coordinator);
operatorSettings.incrementalLogAddress = name;
operatorSettings.operatorType = OperatorType.Stateful;
topologyManager = GrainFactory.GetGrain <ITopology>(Constants.Topology_Manager);
topologyUnit = new TopologyUnit(OperatorType.Stateful, this.GetPrimaryKey());
topologyManager.AddUnit(topologyUnit);
topologyManager.UpdateOperatorSettings(topologyUnit.PrimaryKey, operatorSettings);
return(Task.CompletedTask);
}
public async Task <Task> ReplaceTheOldOperator(Guid oldGuid)
{
var oldUnit = topology.GetUnit(oldGuid);
var newUnit = new TopologyUnit(oldUnit.OperatorType, Guid.NewGuid());
var newGuid = newUnit.PrimaryKey;
//Only the stateful load the settings
if (newUnit.OperatorType == OperatorType.Stateful)
{
IStatefulOperator statefulOp = GrainFactory.GetGrain <IStatefulOperator>(newUnit.PrimaryKey, Constants.Stateful_Operator_Prefix);
await statefulOp.MarkOperatorAsFailed();
await statefulOp.LoadSettings(oldUnit.GetSettings());
}
//Disconnect the old and connect new
var upperStreamUnits = oldUnit.GetUpperStreamUnits();
var downsStreamUnits = oldUnit.GetdownStreamUnits();
PrettyConsole.Line("Number of upperStream : " + upperStreamUnits.Count);
PrettyConsole.Line("Number of downStream : " + downsStreamUnits.Count);
//Handle Upper Stream
if (upperStreamUnits.Count > 0)
{
var keyList = upperStreamUnits.Keys.ToList();
int index = 0;
foreach (var item in upperStreamUnits.Values.ToList())
{
await DisConnectUnits(item.PrimaryKey, oldGuid);
IOperator op;
var unitList = new List <TopologyUnit>();
unitList.Add(newUnit);
if (item.OperatorType == OperatorType.Stateless)
{
op = GrainFactory.GetGrain <IOperator>(keyList[index], Constants.Stateless_Operator_Prefix);
await op.AddCustomDownStreamOperators(unitList);
await op.RemoveCustomDownStreamOperator(oldGuid);
}
else if (item.OperatorType == OperatorType.Stateful)
{
op = GrainFactory.GetGrain <IOperator>(keyList[index], Constants.Stateful_Operator_Prefix);
await op.AddCustomDownStreamOperators(unitList);
await op.RemoveCustomDownStreamOperator(oldGuid);
}
else if (item.OperatorType == OperatorType.Source)
{
var source = GrainFactory.GetGrain <IStreamSource>(item.PrimaryKey);
await source.AddCustomDownStreamOperators(unitList);
await source.RemoveCustomDownStreamOperator(oldGuid);
}
index++;
}
}
//Handle Down Stream
if (downsStreamUnits.Count > 0)
{
var units = downsStreamUnits.Values.ToList();
IOperator newOp;
if (newUnit.OperatorType == OperatorType.Stateless)
{
newOp = GrainFactory.GetGrain <IStatelessOperator>(newGuid, Constants.Stateless_Operator_Prefix);
await newOp.AddCustomDownStreamOperators(units);
}
else if (newUnit.OperatorType == OperatorType.Stateful)
{
newOp = GrainFactory.GetGrain <IStatefulOperator>(newGuid, Constants.Stateful_Operator_Prefix);
await newOp.AddCustomDownStreamOperators(units);
}
else
{
throw new ArgumentException("Source cannot be down stream operator");
}
}
//Remove the old
await RemoveUnit(oldGuid);
//Start Recovery
var batchCoordinator = GrainFactory.GetGrain <IBatchCoordinator>(Constants.Coordinator);
batchCoordinator.StartRecovery();
return(Task.CompletedTask);
}
public Task AddUnit(TopologyUnit unit)
{
topology.AddUnit(unit);
return(Task.CompletedTask);
}
