public void TestMethod1()
{
var initialInventory = new RealTimeInventory("ticketsections-100", 10, 0, 0);
var serverOptions = new InventoryServerOptions()
{
InitialInventory = initialInventory,
InventoryActorAddress = "akka.tcp://InventoryService-Server@localhost:10000/user/InventoryActor",
ServerEndPoint = "http://*:10088/",
StorageType = typeof(InMemory),
ServerActorSystemName = "InventoryService-Server",
ServerActorSystemConfig = @"
akka.actor{provider= ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""}
akka.remote.helios.tcp {
transport-class =""Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote""
port = 10000
transport-protocol = tcp
hostname = ""localhost""
}
"
};
using (var server = new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), serverOptions))
{
var mySystem = Akka.Actor.ActorSystem.Create("mySystem", ConfigurationFactory.ParseString(@"
akka.actor{provider= ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""}
akka.remote.helios.tcp {
transport-class =""Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote""
port = 0
transport-protocol = tcp
hostname = ""localhost""
}
"));
var inventoryActor = mySystem.ActorSelection(serverOptions.InventoryActorAddress);
var result =
server.inventoryActor.Ask <IInventoryServiceCompletedMessage>(new ReserveMessage(
initialInventory.ProductId, 20));
result.ConfigureAwait(false);
Task.WaitAll(result);
if (result.Result.Successful)
{
Console.WriteLine(result.Result.RealTimeInventory);
}
else
{
Console.WriteLine(result.Result.RealTimeInventory);
}
}
}
public void TestMethod2()
{
var serverOptions = new InventoryServerOptions()
{
InventoryActorAddress = "akka.tcp://InventoryService-Server@localhost:10000/user/InventoryActor",
ServerEndPoint = "http://*:10088/",
StorageType = typeof(InMemory),
ServerActorSystemName = "InventoryService-Server",
ServerActorSystemConfig = @"
akka.actor{provider= ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""}
akka.remote.helios.tcp {
transport-class =""Akka.Remote.Transport.Helios.HeliosTcpTransport, Akka.Remote""
port = 10000
transport-protocol = tcp
hostname = ""localhost""
}
"
};
var InventoryserviceServer = new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), serverOptions);
var res = InventoryserviceServer.inventoryActor.Path;
var res2 = InventoryserviceServer.inventoryActor.Ask(new GetInventoryMessage("sample")).Result;
}
private RealTimeInventory RunSomeInventoryOperationUsingEventsAsync(List <Tuple <int, RealTimeInventory, int> > events, InventoryServiceServer testHelper)
{
var operations2 = InventoryServiceSpecificationHelper.GetOperations(testHelper);
Task <IInventoryServiceCompletedMessage> currentInventoryAfterLastOperationResult = null;
foreach (var @event in events)
{
currentInventoryAfterLastOperationResult = operations2[@event.Item1](@event.Item2, @event.Item3);
}
var currentInventoryAfterLastOperation = currentInventoryAfterLastOperationResult.WaitAndGetOperationResult().RealTimeInventory;
return(currentInventoryAfterLastOperation as RealTimeInventory);
}
public static Dictionary <int, Func <RealTimeInventory, int, Task <IInventoryServiceCompletedMessage> > > GetOperations(InventoryServiceServer testHelper)
{
var operations = new Dictionary <int, Func <RealTimeInventory, int, Task <IInventoryServiceCompletedMessage> > >
{
{
1, (product, update) =>
{
var reservationResult = testHelper.ReserveAsync(product, update);
return(reservationResult);
}
},
{
2, (product, update) =>
{
var reservationResult = testHelper.UpdateQuantityAsync(product, update);
return(reservationResult);
}
},
{
3, (product, update) =>
{
var reservationResult = testHelper.PlaceHoldAsync(product, update);
return(reservationResult);
}
},
{
4, (product, update) =>
{
var reservationResult = testHelper.UpdateQuantityAndHoldAsync(product, update);
return(reservationResult);
}
},
{
5, (product, update) =>
{
var reservationResult = testHelper.PurchaseAsync(product, update);
return(reservationResult);
}
},
{
6, (product, update) =>
{
var reservationResult = testHelper.PurchaseFromHoldsAsync(product, update);
return(reservationResult);
}
}
};
return(operations);
}
private void btnExecute_Click(object sender, EventArgs e)
{
try
{
var productName = "productName";
var inventory = new RealTimeInventory(
productName,
Convert.ToInt32(InitialQuantity.Text),
Convert.ToInt32(InitialReservation.Text),
Convert.ToInt32(InitialHold.Text));
InventoryServiceServer helper = new InventoryServiceServer(new TestPerformanceService(), new NullBackUp(), new InventoryServerOptions()
{
StorageType = typeof(Storage.InMemoryLib.InMemory),
InitialInventory = inventory,
ClientActorSystem = ActorSystem
});
var t = helper.ReserveAsync(ActorSystem.ActorSelection(textBox1.Text), 1);
var task = ActorSystem.ActorSelection(textBox1.Text).ResolveOne(TimeSpan.FromSeconds(5));
// task.ConfigureAwait(false);
task.ContinueWith(r =>
{
IInventoryServiceCompletedMessage result = null;
var newUpdate = Convert.ToInt32(NewQuantity.Text);
switch (cmbOoperation.SelectedItem.ToString())
{
case "ReadInventory":
result = helper.GetInventoryAsync(productName).WaitAndGetOperationResult();
break;
case "Reserve":
result = helper.ReserveAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "UpdateQuantity":
result = helper.UpdateQuantityAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "UpdateQuantityAndHold":
result = helper.UpdateQuantityAndHoldAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "PlaceHold":
result = helper.PlaceHoldAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "Purchase":
result = helper.PurchaseAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
case "PurchaseFromHolds":
result = helper.PurchaseFromHoldsAsync(inventory, newUpdate).WaitAndGetOperationResult();
break;
}
if (result != null)
{
ResultQuantity.Text = result.RealTimeInventory.Quantity.ToString();
ResultHold.Text = result.RealTimeInventory.Holds.ToString();
ResultReservation.Text = result.RealTimeInventory.Reserved.ToString();
if (!result.Successful)
{
var errorMessage = result as InventoryOperationErrorMessage;
var list = new List <string>();
var aggregateException = errorMessage?.Error;
if (aggregateException != null)
{
list.Add(aggregateException.ErrorMessage);
}
richTextBox1.Text = errorMessage?.Error?.ErrorMessage + " - " + string.Join(" ", list);
}
else
{
richTextBox1.Text = "";
}
}
});
}
catch (Exception ex)
{
richTextBox1.Text = ex.Message + ex?.InnerException?.Message;
}
}
