/// <summary>
/// Generates and feeds data to the space
/// </summary>
private void Feed()
{
try
{
//Create a proxy to the remote service which provide processing statistics
ExecutorRemotingProxyBuilder <IProcessorStatisticsProvider> builder = new ExecutorRemotingProxyBuilder <IProcessorStatisticsProvider>(_proxy);
IProcessorStatisticsProvider processorStatisticsProvider = builder.CreateProxy();
int iteration = 0;
Random random = new Random();
string stages = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456989";
while (_started)
{
//Create a new data object with random info and random type
String key = "AA-12345";
Data data = new Data(key, random.Next(DataTypesCount));
//data.FlightLegStatus = stages[random.Next(stages.Length)];
data.FlightLegStatus = stages[iteration % stages.Length];
data.FlightOrigDate = System.DateTime.Now;
data.AirlineCode = "AA1";
data.FlightNumber = "1865";
data.DepatureStation = "JFK";
data.DuplicateDepartureStationNumber = 0;
data.DuplicateArrivalStationNumber = 0;
Console.WriteLine("Added data object with key {0} and type {1}", data.Key, data.Type);
//Feed the data into the cluster
_proxy.Write(data);
Thread.Sleep(_feedDelay);
//Check if should print statistics
if (++iteration % PrintStatisticIterCount == 0)
{
Console.WriteLine("Asking processor of type " + data.Type.Value + " how many objects of that type it has processed");
int processedTypes = processorStatisticsProvider.GetProcessObjectCount(data.Type.Value);
Console.WriteLine("Received total processed object of type " + data.Type.Value + " is " + processedTypes);
}
}
}
catch (SpaceException e)
{
Console.WriteLine("Space Error has occured - " + e);
}
catch (Exception e)
{
Console.WriteLine("Error has occured - " + e);
}
}
/// <summary>
/// Initializes the composer with its required dependencies from the provided container
/// </summary>
/// <param name="container"></param>
/// <param name="systemId">The integer identifier of this system</param>
protected Composer(IContainer container, int systemId)
{
_systemId = systemId;
_instanceId = Guid.NewGuid();
try
{
_dependencyResolver = container;
_actorManager = container.Resolve <IActorManager>();
_statisticsProvider = container.Resolve <IProcessorStatisticsProvider>();
_connectionFactory = container.Resolve <IConnectionProvider>();
// There may not be any external dependencies for this system
_externalDependencies = container.IsRegistered <IEnumerable <IExternalDependency> >() ? container.Resolve <IEnumerable <IExternalDependency> >() : new List <IExternalDependency>();
}
catch (Exception ex)
{
EventLog.WriteEntry(GetType().Name, "Fatal exception encountered during start-up: \n" + ex, EventLogEntryType.Error);
}
}
public void Init()
{
_statisticsProvider = Stubs.BareMock <IProcessorStatisticsProvider>();
}
internal static int GetNumWorkersRequiredToClearQueue(IQueueConfiguration configuration, IProcessorStatisticsProvider statisticsProvider, int messageCount)
{
// Since we're storing message resolution time in floating point, if we're faster than 100 ns, we get zero - not good
var meanMessageResolutionTime = Math.Max(statisticsProvider.GetQueueStatistics(configuration.QueueIdentifier).MeanMessageResolutionTime, 0.0000001);
// units: seconds / (worker * seconds / message)
var numMessagesResolvedInTargetTimePerWorker = configuration.TargetTimeToClearQueue / meanMessageResolutionTime;
// Take the ceiling here to err on the side of faster dequeuing and to ensure that we act on very slow queues with low message counts
var numWorkersRequired = (int)Math.Ceiling(messageCount / numMessagesResolvedInTargetTimePerWorker);
// Never create more workers than there are messages
return(numWorkersRequired > messageCount ? messageCount : numWorkersRequired);
}
