public FormMain(IClientMainService service, IClientService cService, IProductService pService, IReportService rService, IBackUpService backUpService)
{
InitializeComponent();
this.service = service;
this.cService = cService;
this.pService = pService;
this.rService = rService;
this.backUpService = backUpService;
order = new OrderBindingModel();
order.OrderProducts = new List <OrderProductBindingModel>();
}
public InventoryActor(IInventoryStorage inventoryStorage, IPerformanceService performanceService, IBackUpService backUpService, bool withCache = true)
{
if (backUpService == null)
{
throw new ArgumentNullException(nameof(backUpService));
}
BackUpService = backUpService;
PerformanceService = performanceService;
PerformanceService.Init();
Logger.Debug("Starting Inventory Actor ....");
InventoryStorage = inventoryStorage;
_withCache = withCache;
Become(Initializing);
}
public void StartServer(IPerformanceService performanceService, IBackUpService backUpService, Action <IActorRef, ActorSystem> onReady = null, Type storageType = null, string serverActorSystemName = null,
ActorSystem serverActorSystem = null, string serverActorSystemConfig = null)
{
Log.Debug("Initializing ...");
IActorRef inventoryActor = null;
if (storageType == null)
{
// var message = "Unable to initialize storage. No storage specified" ;
// Log.Debug(message);
var storageSettings = ConfigurationManager.AppSettings["Storage"];
if (string.IsNullOrEmpty(storageSettings))
{
const string message = "Could not find Storage setup in config";
Log.Debug(message);
throw new Exception(message);
}
else
{
storageType = Type.GetType(storageSettings);
}
}
if (storageType == null)
{
const string message = "Could not create storage type";
Log.Debug(message);
throw new Exception(message);
}
var inventoryStorage = (IInventoryStorage)Activator.CreateInstance(storageType);
Log.Debug("Starting Server");
ActorSystemFactory.CreateOrSetUpActorSystem(serverActorSystemName: serverActorSystemName,
actorSystem: serverActorSystem, actorSystemConfig: serverActorSystemConfig);
inventoryActor =
ActorSystemFactory.InventoryServiceActorSystem.ActorOf(
Props.Create(() => new InventoryActor(inventoryStorage, performanceService, backUpService, true)),
typeof(InventoryActor).Name);
if (inventoryActor == null || inventoryActor.IsNobody())
{
const string message = "Unable to create actor";
Log.Debug(message);
throw new Exception(message);
}
ActorSystem = ActorSystemFactory.InventoryServiceActorSystem;
onReady?.Invoke(inventoryActor, ActorSystem);
}
public InventoryServiceServer(IPerformanceService performanceService, IBackUpService backUpService, InventoryServerOptions options = null)
{
Options = options ?? new InventoryServerOptions();
if (Options.DontUseActorSystem)
{
DontUseActorSystem = Options.DontUseActorSystem;
TestInventoryStorage = Options.StorageType != null
? (IInventoryStorage)Activator.CreateInstance(Options.StorageType)
: new Storage.InMemoryLib.InMemory();
if (Options.InitialInventory != null)
{
TestInventoryStorage.WriteInventoryAsync(Options.InitialInventory);
}
}
else
{
Sys = Options.ClientActorSystem;
InventoryServiceApplication = new InventoryServiceApplication();
if (string.IsNullOrEmpty(Options.InventoryActorAddress))
{
Options.InventoryActorAddress = ConfigurationManager.AppSettings["RemoteInventoryActorAddress"];
}
InventoryServiceApplication.Start(performanceService, backUpService, Options.OnInventoryActorSystemReady, Options.StorageType,
serverEndPoint: Options.ServerEndPoint, serverActorSystemName: Options.ServerActorSystemName,
serverActorSystem: Options.ServerActorSystem,
serverActorSystemConfig: Options.ServerActorSystemConfig);
Sys = Sys ?? InventoryServiceApplication.InventoryServiceServerApp.ActorSystem;
var selection = Sys.ActorSelection(Options.InventoryActorAddress);
inventoryActor = TryResolveActorSelection(selection);
var serverEndPoint = Options.ServerEndPoint;//ConfigurationManager.AppSettings["ServerEndPoint"];
if (!string.IsNullOrEmpty(serverEndPoint))
{
OwinRef = WebApp.Start <Startup>(url: serverEndPoint);
}
if (Options.InitialInventory != null)
{
InitializeWithInventorydata(Options);
}
}
}
public void Start(IPerformanceService performanceService, IBackUpService backUpService, Action <IActorRef, ActorSystem> onReady = null,
Type storageType = null
, string serverEndPoint = null
, string serverActorSystemName = null
, ActorSystem serverActorSystem = null
, string serverActorSystemConfig = null
)
{
try
{
InventoryServiceServerApp = new InventoryServiceServerApp();
InventoryServiceServerApp.StartServer(performanceService, backUpService, onReady, storageType, serverActorSystemName: serverActorSystemName, serverActorSystem: serverActorSystem, serverActorSystemConfig: serverActorSystemConfig);
}
catch (Exception e)
{
Log.Error(e, "Unable to start inventory service");
throw;
}
//
}
public BackupController(IBackUpService context, IToolTypeService contextToolTypes, IToolTypeSearchService contextToolTypesSearch)
{
_context = context;
_contextToolTypes = contextToolTypes;
_contextToolTypesSearch = contextToolTypesSearch;
}
public InventoryQueryActor(IBackUpService backUpService)
{
if (backUpService == null)
{
throw new ArgumentNullException(nameof(backUpService));
}
BackUpService = backUpService;
var lastUpadteTime = DateTime.UtcNow;
Subscribers = new List <Tuple <string, IActorRef> >();
LastReceivedServerMessage = "System started at " + DateTime.UtcNow;
RealTimeInventories = new Dictionary <string, IRealTimeInventory>();
Logger.Debug(LastReceivedServerMessage);
Receive <string>(message =>
{
LastReceivedServerMessage = string.IsNullOrEmpty(message) ? LastReceivedServerMessage : message;
Logger.Debug(LastReceivedServerMessage);
});
Receive <BackUpAllInventoryMessage>(message =>
{
try
{
var inventories = RealTimeInventories.Select(x => x.Value as RealTimeInventory).ToList();
var csv = inventories.ToDelimitedText(",", true);
backUpService.BackUp(("inventory-service-backup-" + $"{DateTime.UtcNow:dddd MMMM d yyyy HH-mm-ss}" + ".csv").ToLower(), csv);
Sender.Tell(new BackUpAllInventoryCompletedMessage());
}
catch (Exception e)
{
Sender.Tell(new BackUpAllInventoryFailedMessage(e.Message + " : " + e.InnerException?.Message));
}
});
Receive <ExportAllInventoryMessage>(message =>
{
try
{
var inventories = RealTimeInventories.Select(x => x.Value as RealTimeInventory).ToList();
var csv = inventories.ToDelimitedText(",", true);
Sender.Tell(new ExportAllInventoryCompletedMessage(csv));
}
catch (Exception)
{
Sender.Tell(new ExportAllInventoryCompletedMessage(null));
}
});
Receive <QueryInventoryListMessage>(message =>
{
NotifySubscribersAndRemoveStaleSubscribers(RealTimeInventories);
});
Receive <RealTimeInventoryChangeMessage>(message =>
{
RealTimeInventories[message.RealTimeInventory.ProductId] = message.RealTimeInventory;
// because delivery may be out of order . probably this line is not needed
//LastEtag = LastEtag.IsMostRecentThan(message.RealTimeInventory.ETag) ? LastEtag: message.RealTimeInventory.ETag;
NotifySubscribersAndRemoveStaleSubscribers(message);
Logger.Debug("total inventories in inventory service : " + RealTimeInventories.Count);
});
Receive <GetAllInventoryListMessage>(message =>
{
Sender.Tell(new QueryInventoryCompletedMessage(RealTimeInventories.Select(x => x.Value).ToList(), 0, 0));
});
Receive <IRequestMessage>(message =>
{
NotifySubscribersAndRemoveStaleSubscribers(message);
Logger.Debug("received by inventory Actor - " + message.GetType().Name + " - " + message);
MessageCount++;
var secondsPast = (int)(DateTime.UtcNow - lastUpadteTime).TotalSeconds;
if (secondsPast <= 1)
{
return;
}
MessageSpeed = MessageCount / secondsPast;
PeakMessageSpeed = (PeakMessageSpeed > MessageSpeed) ? PeakMessageSpeed : MessageSpeed;
lastUpadteTime = DateTime.UtcNow;
MessageCount = 0;
});
Receive <Terminated>(t =>
{
Logger.Error("Removing subscriber " + t.ActorRef.Path.ToStringWithUid() + " because no ActorAliveMessage was received over time ....");
Self.Tell(new UnSubScribeToNotificationMessage(t.ActorRef.Path.ToStringWithUid()));
});
Receive <SubScribeToNotificationMessage>(message =>
{
if (Sender.IsNobody())
{
Logger.Error("No subscriber specified or subscriber is nobody");
}
else
{
var id = Sender.Path.ToStringWithUid();
Subscribers.Add(new Tuple <string, IActorRef>(id, Sender));
ActorAliveList = ActorAliveList ?? new HashSet <string>();
ActorAliveList.Add(id);
Context.Watch(Sender);
Sender.Tell(new SubScribeToNotificationCompletedMessage(id));
Logger.Debug("Successfully subscribed . Subscription id : " + id + " and subscriber is : " + Sender.Path);
}
});
Receive <UnSubScribeToNotificationMessage>(message =>
{
if (!Subscribers.Exists(x => x.Item1 == message.SubscriptionId))
{
Logger.Error("Unable to unsubscribe : No subscriber specified or subscriber is nobody");
Sender.Tell(new SubScribeToNotificationFailedMessage("Subscription doesn't exists"));
}
else
{
Logger.Debug("Unsubscribing subscriber " + message.SubscriptionId + " .... ");
Subscribers.Remove(Subscribers.Find(x => x.Item1 == message.SubscriptionId));
Sender.Tell(new UnSubScribeToNotificationCompletedMessage());
}
Subscribers.Remove(Subscribers.Find(x => string.IsNullOrEmpty(x?.Item1.ToString())));
});
Receive <CheckIfNotificationSubscriptionExistsMessage>(message =>
{
var subscriptionExists = Subscribers.Exists(x => x.Item1 == message.SubscriptionId);
Sender.Tell(new CheckIfNotificationSubscriptionExistsCompletedMessage(subscriptionExists));
});
Context.System.Scheduler.ScheduleTellRepeatedly(TimeSpan.Zero, TimeSpan.FromHours(1), Self, new BackUpAllInventoryMessage(), Self);
}
public ReportController(IReportService service, IBackUpService backUpService)
{
_service = service;
_backUpService = backUpService;
}
