/// <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)); }