public async Task startTest()
{
IStreamProvider _provider = base.GetStreamProvider("CollectionStreamProvider");
var distributedCollection = GetRandomDistributedCollection <int>();
await distributedCollection.SetNumberOfNodes(4);
var l = Enumerable.Range(0, 20000).ToList();
var references = await distributedCollection.BatchAdd(l);
ActorModel.Assert(!(references.Any(item => item == null)), "Batch add failed!!");
var consumer = new MultiStreamListConsumer <ContainerHostedElement <int> >(_provider);
//Modified: split a statement with 2 awaits (AwaitRewriter must be fixed)
var getStrIds = await distributedCollection.GetStreamIdentities();
Console.WriteLine(" ====== COUNT: " + getStrIds.Count);
//await consumer.SetInput(getStrIds);
//var tid = await distributedCollection.EnumerateToStream();
//await consumer.TransactionComplete(tid);
//////CollectionAssert.AreEquivalent(l, consumer.Items.Select(x => x.Item).ToList());
////TODO Rashmi: Write equivalent Assert.
}
public async Task StartTransaction()
{
var sender = GrainClient.GrainFactory.GetGrain <ISender>(0);
ActorModel.Assert(sender != null, "sender proxy is null");
await sender.Dummy();
this.State = 0;
await this.WriteStateAsync();
}
public async Task TryToStealMoney()
{
int numOfPeople = await this.StateManager.GetStateAsync <int>("PeopleInside");
bool isSafeOpen = await this.StateManager.GetStateAsync <bool>("IsSafeOpen");
ActorModel.Log("[LOG] Thief is searching for money. Room has {0} people", numOfPeople);
ActorModel.Assert(!isSafeOpen || numOfPeople > 0, "Thief stole the money.");
}
private Event WaitOnEvent()
{
MachineId mid = ActorModel.Runtime.GetCurrentMachineId();
Console.WriteLine("Inside WaitOnEvent: " + mid);
ActorModel.Runtime.Log($"<ActorModelLog> Machine '{mid.Name}' is " +
"waiting to receive a result.");
ActorModel.Runtime.SendEvent(this.ActorCompletionMachine,
new ActorCompletionMachine.GetResultRequest(mid));
Event resultEvent = null;
bool receivedResult = false;
while (!receivedResult)
{
resultEvent = ActorModel.Runtime.Receive(
Tuple.Create <Type, Func <Event, bool> >(typeof(ActorCompletionMachine.GetResultResponse), (Event e) =>
{
if ((e as ActorCompletionMachine.GetResultResponse).Source.Equals(this.ActorCompletionMachine))
{
return(true);
}
return(false);
}),
Tuple.Create <Type, Func <Event, bool> >(typeof(ActorMachine.ActorEvent), (Event e) =>
{
if (ActorModel.Configuration.AllowReentrantCalls &&
ActorModel.ReentrantActors.ContainsKey(mid) &&
ActorModel.ReentrantActors[mid])
{
return(true);
}
ActorModel.Assert(!(e as ActorMachine.ActorEvent).ExecutionContext.Contains(mid),
$"Deadlock detected. {mid.Name} is not reentrant.");
return(false);
}));
if (resultEvent is ActorCompletionMachine.GetResultResponse)
{
receivedResult = true;
}
else
{
var handler = ActorModel.GetReentrantActionHandler(mid);
handler(resultEvent as ActorMachine.ActorEvent);
}
}
return(resultEvent);
}
//IGrainReminder myReminder;
//public override async Task OnActivateAsync()
//{
//var reminderTask = this.RegisterOrUpdateReminder("helloReminder", TimeSpan.FromSeconds(2),
// TimeSpan.FromSeconds(0));
//ActorModel.Wait(reminderTask);
//myReminder = ActorModel.GetResult<IGrainReminder>(reminderTask);
////this.Timer = this.RegisterTimer(HandleTimeout, null,
//// TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(0));
// await base.OnActivateAsync();
//}
public async Task DoSomething(int numberOfItems)
{
var receiver = GrainClient.GrainFactory.GetGrain <IReceiver>(1);
await receiver.StartTransaction();
for (int i = 0; i < numberOfItems; i++)
{
await receiver.TransmitData(new TransactionItems("xyz" + i));
}
int transmitted = await receiver.GetCurrentCount();
ActorModel.Assert(transmitted <= numberOfItems, "Items sent: " + numberOfItems + "; Transmitted: " + transmitted);
}
public Task DoSomething(int numberOfItems)
{
var receiverProxy = ActorProxy.Create <IReceiver>(new ActorId(1), "ReceiverProxy");
receiverProxy.StartTransaction();
for (int i = 0; i < numberOfItems; i++)
{
receiverProxy.TransmitData("xyz" + i);
}
int transmitted = ActorModel.GetResult <int>(receiverProxy.GetCurrentCount());
ActorModel.Assert(transmitted <= numberOfItems, "Items sent: " + numberOfItems + "; Transmitted: " + transmitted);
return(Task.FromResult(true));
}
/// <summary>
/// Gets the actor type from the specified
/// interface and assembly path.
/// </summary>
/// <param name="interfaceType">Type</param>
/// <param name="assemblyPath">Assembly path</param>
/// <returns>Type</returns>
private Type GetActorType(Type interfaceType, string assemblyPath)
{
List <Assembly> allAssemblies = new List <Assembly>();
allAssemblies.AddRange(this.GetAllAssemblies(assemblyPath, "exe"));
allAssemblies.AddRange(this.GetAllAssemblies(assemblyPath, "dll"));
var types = new List <Type>();
foreach (var asm in allAssemblies)
{
try
{
types.AddRange(asm.GetTypes());
}
catch
{
continue;
}
}
IEnumerable <Type> actorTypes = null;
if (interfaceType.IsGenericType)
{
var potentialTypes = types.Where(p => !p.IsInterface);
foreach (var pType in potentialTypes)
{
foreach (var potentialInterfaceType in pType.GetInterfaces())
{
if (potentialInterfaceType.IsGenericType && potentialInterfaceType.GetGenericTypeDefinition() == interfaceType.GetGenericTypeDefinition())
{
return(pType);
}
}
}
}
else
{
actorTypes = types.Where(p => interfaceType.IsAssignableFrom(p) && !p.IsInterface);
}
ActorModel.Assert(actorTypes.Any(), "No implementation found for actor " +
$"type '{interfaceType}'.");
return(actorTypes.First());
}
/// <summary>
/// Unregisters the specified reminder.
/// </summary>
/// <param name="reminder">IActorReminder</param>
/// <returns>Task</returns>
protected Task UnregisterReminderAsync(IActorReminder reminder)
{
ActorModel.Assert(reminder != null, "Cannot unregister a 'null' reminder.");
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminderToBeRemoved = reminders.SingleOrDefault(val
=> ((ActorReminder)val).Name.Equals(reminder.Name));
if (reminderToBeRemoved != null)
{
reminderToBeRemoved.Dispose();
}
var task = new ActorCompletionTask <object>();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(true));
return(task);
}
/// <summary>
/// Serializes the specified payload.
/// </summary>
/// <param name="payload">Payload</param>
/// <returns>Serialized payload</returns>
public static object[] Serialize(params object[] payload)
{
object[] serializedPayload = new object[payload.Length];
for (int idx = 0; idx < payload.Length; idx++)
{
Type type = payload[idx].GetType();
//if (type.GetCustomAttribute(typeof(SerializableAttribute), false) != null)
//{
// MemoryStream stream = new MemoryStream();
// BinaryFormatter bf = new BinaryFormatter();
// bf.Serialize(stream, payload[idx]);
// stream.Seek(0, SeekOrigin.Begin);
// serializedPayload[idx] = bf.Deserialize(stream);
//}
if (type.GetInterfaces().Any(val => val == typeof(ICloneable)))
{
serializedPayload[idx] = ((ICloneable)payload[idx]).Clone();
}
else
{
try
{
serializedPayload[idx] = Serialization.DeepClone(payload[idx]);
}
catch
{
ActorModel.Assert(false, $"Payload of type '{type}' " +
"cannot be serialized.");
}
}
}
return(serializedPayload);
}
