/// <summary>
/// Get a worker by name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static Worker Get(string name)
{
Worker worker;
if (string.IsNullOrWhiteSpace(name))
{
name = string.Empty;
}
if (!_Instances.TryGetValue(name, out worker))
{
try
{
var workersConfig = Configuration.Roque.Settings.Workers;
if (workersConfig == null)
{
throw new Exception("No workers found in configuration");
}
var workerConfig = workersConfig[name];
if (workerConfig == null)
{
throw new Exception("Worker not found: " + name);
}
worker = new Worker(workerConfig.Name, Queue.Get(workerConfig.Queue), workerConfig.TooManyErrors, workerConfig.TooManyErrorsRetrySeconds);
worker.AutoStart = workerConfig.AutoStart;
}
catch (Exception ex)
{
RoqueTrace.Source.Trace(TraceEventType.Error, "Error creating worker {0}: {1}", name, ex.Message, ex);
throw;
}
}
return(worker);
}
public void RegisterSubscriber(object subscriber, string sourceQueue = null, string queue = null)
{
var suscribeMethods = subscriber.GetType().GetMethods().Where(m => m.Name.StartsWith("Subscribe")).ToArray();
foreach (var suscribeMethod in suscribeMethods)
{
List <object> parameters = new List <object>();
foreach (var paramInfo in suscribeMethod.GetParameters())
{
try
{
var instance = GetTarget(paramInfo.ParameterType.AssemblyQualifiedName, true).Instance;
parameters.Add(instance);
if (instance is EventProxyGenerator.IEventProxy)
{
((EventProxyGenerator.IEventProxy)instance).BeginTrackingSubscriptions();
}
}
catch (Exception ex)
{
if (RoqueTrace.Switch.TraceError)
{
Trace.TraceError(string.Format("Error injecting subscriber parameter: {0}. Method: {1}, Parameter: {2}, Expected Type: {3}", ex.Message, suscribeMethod.Name, paramInfo.Name, paramInfo.ParameterType.FullName), ex);
}
throw;
}
}
suscribeMethod.Invoke(subscriber, parameters.ToArray());
if (!string.IsNullOrWhiteSpace(sourceQueue) && !string.IsNullOrWhiteSpace(queue))
{
foreach (var paramInfo in suscribeMethod.GetParameters())
{
var instance = GetTarget(paramInfo.ParameterType.AssemblyQualifiedName, true).Instance;
if (instance is EventProxyGenerator.IEventProxy)
{
string[] eventNames = ((EventProxyGenerator.IEventProxy)instance).GetEventsWithNewSubscriptions();
foreach (string eventName in eventNames)
{
Queue.Get(queue).ReportEventSubscription(sourceQueue, paramInfo.ParameterType.FullName, eventName);
}
if (RoqueTrace.Switch.TraceVerbose)
{
Trace.TraceInformation(string.Format("Reported event subscriptions. Events: {0}:{1}, Source Queue: {2}, Queue: {3}", paramInfo.ParameterType.FullName, string.Join(",", eventNames), sourceQueue, queue));
}
}
}
}
}
}
/// <summary>
/// Get a worker by name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static Worker Get(string name)
{
Worker worker;
if (string.IsNullOrWhiteSpace(name))
{
name = string.Empty;
}
if (!_Instances.TryGetValue(name, out worker))
{
try
{
var workersConfig = Configuration.Roque.Settings.Workers;
if (workersConfig == null)
{
throw new Exception("No workers found in configuration");
}
var workerConfig = workersConfig[name];
if (workerConfig == null)
{
throw new Exception("Worker not found: " + name);
}
worker = new Worker(workerConfig.Name, Queue.Get(workerConfig.Queue), workerConfig.TooManyErrors, workerConfig.TooManyErrorsRetrySeconds);
_Instances[worker.Name] = worker;
}
catch (Exception ex)
{
if (RoqueTrace.Switch.TraceError)
{
Trace.TraceError(ex.Message, ex);
}
throw;
}
}
return(worker);
}
/// <summary>
/// Create a new event broadcaster
/// </summary>
/// <param name="queueName">target queue for this broadcaster, by default "_events"</param>
public RoqueEventBroadcaster(string queueName = Queue.DefaultEventQueueName)
: this(Queue.Get(queueName))
{
}
/// <summary>
/// Creates a new proxy for <typeparamref name="T"/> class, all methods will be intercepted and enqueued for async execution
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queueName">the queue to send all invocations</param>
/// <param name="enqueueAsync">if true enqueueing will be done async</param>
/// <returns>the transparent proxy which enqueues all invocations for async execution</returns>
public static T Create <T>(string queueName, bool enqueueAsync = false)
where T : class
{
return(Create <T>(Queue.Get(queueName), enqueueAsync));
}
