public IFactoryBroker ApplyConfiguration(IFactoryBroker broker)
{
if (Brokers != null)
{
if (Brokers.Servers != null)
{
foreach (var server in Brokers.Servers)
{
broker.Add(server);
}
}
if (Brokers.Publishers != null)
{
foreach (var publisher in Brokers.Publishers)
{
broker.Add(publisher);
}
}
if (Brokers.Subscribers != null)
{
foreach (var subscriber in Brokers.Subscribers)
{
broker.Add(subscriber);
}
}
}
return(broker);
}
public static RabbitMqAppender Initialize(IFactoryBroker self, string name, string rabbitPublisherName, bool reformat = true, int appendLogsIntervalSeconds = 2, params string[] restrictedTracks)
{
if (string.IsNullOrEmpty(rabbitPublisherName))
{
throw new Bb.Exceptions.InvalidConfigurationException(nameof(rabbitPublisherName));
}
var ex = self.CheckPublisher(rabbitPublisherName);
if (ex != null)
{
throw ex;
}
var logger = new RabbitMqAppender(self, appendLogsIntervalSeconds)
{
Name = name,
PublisherName = rabbitPublisherName,
Reformat = reformat
//TraceOutputOptions = TraceOptions.
};
if (restrictedTracks.Length > 0)
{
logger.RestrictedTracks = new HashSet <string>(restrictedTracks);
}
System.Diagnostics.Trace.Listeners.Add(logger);
return(logger);
}
public static IFactoryBroker Initialize(this IFactoryBroker brokers)
{
foreach (string serverName in brokers.GetServerBrokerNames())
{
var broker = brokers.CreateServerBroker(serverName);
Trace.WriteLine($"test to connect to {serverName}");
if (!broker.CheckConnection())
{
}
}
foreach (string subscriberName in brokers.GetSubscriberNames())
{
Trace.WriteLine($"Check to subscribe {subscriberName}");
var e = brokers.CheckSubscription(subscriberName);
if (e != null)
{
throw e;
}
}
foreach (string publisherName in brokers.GetPublisherNames())
{
Trace.WriteLine($"Check publisher {publisherName}");
var e = brokers.CheckPublisher(publisherName);
if (e != null)
{
throw e;
}
}
return(brokers);
}
/// <summary>
/// Load configuration for rabbit
/// </summary>
/// <param name="selfPath"></param>
/// <param name="factoryBroker"></param>
/// <param name="serverPatternExtension"></param>
/// <param name="publisherPatternExtension"></param>
/// <param name="subscriberPatternExtension"></param>
/// <returns>true if the directory exists</returns>
public static bool LoadFolderFromJson(this string selfPath,
IFactoryBroker factoryBroker,
string serverPatternExtension = "*.rabbit.server",
string publisherPatternExtension = "*.rabbit.publisher",
string subscriberPatternExtension = "*.rabbit.subscriber")
{
DirectoryInfo dir = new DirectoryInfo(selfPath);
dir.Refresh();
if (dir.Exists)
{
foreach (var file in dir.GetFiles(serverPatternExtension, SearchOption.TopDirectoryOnly))
{
factoryBroker.Add(LoadFromJSon <ServerBrokerConfiguration>(File.ReadAllText(file.FullName)));
}
foreach (var file in dir.GetFiles(publisherPatternExtension, SearchOption.TopDirectoryOnly))
{
factoryBroker.Add(LoadFromJSon <BrokerPublishParameter>(File.ReadAllText(file.FullName)));
}
foreach (var file in dir.GetFiles(subscriberPatternExtension, SearchOption.TopDirectoryOnly))
{
factoryBroker.Add(LoadFromJSon <BrokerSubscriptionParameter>(File.ReadAllText(file.FullName)));
}
return(true);
}
return(false);
}
public void ApplyConfiguration(IFactoryBroker broker)
{
if (Servers != null)
{
foreach (var server in Servers)
{
broker.Add(server);
}
}
if (Publishers != null)
{
foreach (var publisher in Publishers)
{
broker.Add(publisher);
}
}
if (Subscribers != null)
{
foreach (var subscriber in Subscribers)
{
broker.Add(subscriber);
}
}
}
public SubcriptionIncomingBusAction(IFactoryBroker brokers, ActionBusConfiguration configuration, ActionRunner <ActionBusContext> action)
: base("Service consume incoming adapter broker queue")
{
_action = action;
Subscription = brokers.CreateSubscription(configuration.ActionBusBrokerConfiguration.ActionBusQueue, context => Callback(context));
_acknowledgeQueue = brokers.CreatePublisher(configuration.ActionBusBrokerConfiguration.AcknowledgeExchange);
_deadQueue = brokers.CreatePublisher(configuration.ActionBusBrokerConfiguration.DeadQueueAction);
}
public static IFactoryBroker Test(this IFactoryBroker brokers, out bool successfullInitialized, int timeOutInSecond = 10)
{
HashSet <string> cache = new HashSet <string>();
using (var subs = new SubscriptionInstances(brokers))
{
Task callback(IBrokerContext ctx)
{
string key = ctx.Utf8Data;
Trace.WriteLine($"Depiled message {key}");
if (cache.Contains(key))
{
cache.Remove(ctx.Utf8Data);
ctx.Commit();
}
else
{
ctx.Reject();
}
return(Task.CompletedTask);
}
foreach (string subscriberName in brokers.GetSubscriberNames())
{
Trace.WriteLine($"test to subsribe {subscriberName}");
subs.AddSubscription(subscriberName, subscriberName, callback);
}
foreach (string publisherName in brokers.GetPublisherNames())
{
using (var broker = brokers.CreatePublisher(publisherName))
{
Trace.WriteLine($"test to push test message to {publisherName}");
var currentGuid = Guid.NewGuid().ToString();
cache.Add(currentGuid);
broker.Publish(currentGuid);
}
}
DateTime d = DateTime.Now.AddSeconds(timeOutInSecond);
while (cache.Count > 0)
{
Thread.Yield();
if (d < DateTime.Now)
{
break;
}
}
}
successfullInitialized = cache.Count == 0;
return(brokers);
}
public SubcriptionIncomingEvent(IFactoryBroker brokers, EngineGeneratorConfiguration configuration, WebEngineProvider provider, KilledGracefulInterceptor killed)
: base("Service consume incoming event.")
{
_provider = provider;
_domainHeader = configuration.EngineGeneratorModel.DomainHeader;
Subscription = brokers.CreateSubscription(configuration.EngineGeneratorModel.WorkflowQueue, context => Callback(context));
_deadQueue = brokers.CreatePublisher(configuration.EngineGeneratorModel.PublishDeadQueueWorkflow);
_killed = killed;
_killed.StopAction = this.PrepareStop;
}
private RabbitMqAppender(IFactoryBroker factory, int appendLogsIntervalSeconds)
{
ass1 = GetType().Assembly;
ass2 = typeof(TraceListener).Assembly;
AppendLogsIntervalSeconds = appendLogsIntervalSeconds;
_factoryBrocker = factory;
_bag = new List <Task>();
_timer = new Timer(AppendAsync, null, AppendLogsIntervalSeconds * 1000, AppendLogsIntervalSeconds * 1000);
}
public static IServiceProvider RegisterResponsesReminder(this IServiceProvider services)
{
ReminderService reminder = services.GetService(typeof(IReminderRequest)) as ReminderService;
//ReminderConfiguration configuration = services.GetService(typeof(ReminderConfiguration)) as ReminderConfiguration;
IFactoryBroker factory = services.GetService(typeof(IFactoryBroker)) as IFactoryBroker;
reminder.AddResponses(
new ReminderResponseBroker(factory)
);
return(services);
}
public static IFactoryBroker AddDirect(this IFactoryBroker brokers, string serverName
, string publisherName
, string subscriberName
, string exchangeName
, string queueName
)
{
var e = brokers.CheckServerBroker(serverName);
if (e != null)
{
throw e;
}
BrokerPublishParameter publisher = brokers.GetConfigurationPublisher(publisherName) as BrokerPublishParameter;
if (publisher == null)
{
brokers.Add(publisher = new BrokerPublishParameter()
{
Name = publisherName,
ServerName = serverName,
ExchangeType = ExchangeType.DIRECT,
ExchangeName = exchangeName,
DefaultRountingKey = queueName
});
}
else
{
}
BrokerSubscriptionParameter subscriber = brokers.GetConfigurationSubscriber(publisherName) as BrokerSubscriptionParameter;
if (subscriber == null)
{
brokers.Add(subscriber = new BrokerSubscriptionParameter()
{
Name = subscriberName,
ServerName = serverName,
ExchangeType = ExchangeType.DIRECT,
ExchangeName = exchangeName,
StorageQueueName = queueName,
}.AddRoutingKeys(queueName)
);
}
return(brokers);
}
public static IServiceProvider RegisterListeners(this IServiceProvider serviceProvider)
{
SubscriptionInstances subscriptions = serviceProvider.GetService(typeof(SubscriptionInstances)) as SubscriptionInstances;
IFactoryBroker brokers = serviceProvider.GetService(typeof(IFactoryBroker)) as IFactoryBroker;
IConfiguration configuration = serviceProvider.GetService(typeof(IConfiguration)) as IConfiguration;
ActionRepositories actionRepositories = serviceProvider.GetService(typeof(ActionRepositories)) as ActionRepositories;
var subscriberName = configuration.GetValue <string>("listener");
Subcription1 sub = new Subcription1("Actions", brokers, subscriberName, actionRepositories)
{
_acknowledgeQueue = brokers.CreatePublisher(configuration.GetValue <string>("AcknowledgeQueue")),
_deadQueue = brokers.CreatePublisher(configuration.GetValue <string>("DeadQueue")),
};
subscriptions.AddSubscription(sub);
return(serviceProvider);
}
public static void RegisterLogToBrokers(this List <object> _instances)
{
IServiceCollection services = _instances.First(c => (c is IServiceCollection)) as IServiceCollection;
IConfiguration configuration = _instances.First(c => (c is IConfiguration)) as IConfiguration;
IFactoryBroker brokers = _instances.First(c => (c is IFactoryBroker)) as IFactoryBroker;
var loggers = Collectkeys(configuration, "Loggers");
foreach (string item in loggers)
{
RabbitBrokerLog p = new RabbitBrokerLog();
if (!ConnectionStringHelper.Map <RabbitBrokerLog>(p, item, false))
{
throw new Bb.Exceptions.InvalidConfigurationException($"parameters can't be mapped from '{item}'");
}
var appender = Bb.LogAppender.RabbitMqAppender.Initialize(brokers, p.Name, p.PublisherName, p.Reformat, p.AppendLogsIntervalSeconds, p.Tracks.ToArray());
Trace.WriteLine($"Logger {appender.Name} initialized");
}
}
public ActionBusConfiguration(ActionBusBrokerConfiguration actionBusBrokerConfiguration, IFactoryBroker brokerConfiguration)
{
this.ActionBusBrokerConfiguration = actionBusBrokerConfiguration;
this.Broker = brokerConfiguration;
}
public Subcription1(string name, IFactoryBroker brokers, string subscriberName, ActionRepositories actionRepositories)
: base(name)
{
_actionRepositories = actionRepositories;
Subscription = brokers.CreateSubscription(subscriberName, context => Callback(context));
}
/// <summary>
/// Adds the server from connection string.
/// </summary>
/// <param name="self">The self.</param>
/// <param name="payload">The payload.</param>
/// <returns></returns>
public static IFactoryBroker AddServerFromConnectionString(this IFactoryBroker self, string payload)
{
self.Add(payload.LoadServerFromConnectionString());
return(self);
}
public EngineGeneratorConfiguration(EngineGeneratorModel engineGeneratorModel, IFactoryBroker broker, EngineConfigurationModel engineConfiguration, IServiceProvider services)
{
this.EngineGeneratorModel = engineGeneratorModel;
this.Broker = broker;
this.EngineConfiguration = engineConfiguration;
this.Services = services;
}
public SubscriptionInstances(IFactoryBroker borkers)
{
_brokers = borkers;
_items = new List <SubscriptionInstance>();
}
public static CommandLineApplication CommandPushworkflow(this CommandLineApplication app)
{
var cmd = app.Command("workflow", config =>
{
config.Description = "push a message on workflow server";
config.HelpOption(HelpFlag);
});
var cmd2 = cmd.Command("http", config =>
{
config.Description = "push a message on workflow server using http";
config.HelpOption(HelpFlag);
var validator = new GroupArgument(config, false);
var serverName = validator.Argument("server",
"Url server of the workflow server. (this argument is required)"
, ValidatorExtension.EvaluateRequired
);
var domain = validator.Argument("domain",
"target domain workflow (this argument is required)"
, ValidatorExtension.EvaluateRequired
);
var content = validator.Argument("content",
"content that you want to push on the workflow server"
, ValidatorExtension.EvaluateRequired
);
config.OnExecute(() =>
{
if (validator.Evaluate() > 0)
{
return(2);
}
string model = GetContent(content.Value);
var client = new BbClientHttp(new Uri(serverName.Value));
var result = client.Post <RootResultModel <object> >($"api/workflowProcessor/Push/{domain.Value}", model /*, GetToken() */);
result.Wait();
Output.WriteLine("item successfully pushed on workflow server.");
Result = Helper.Parameters.ServerUrl;
return(0);
});
});
var cmd3 = cmd.Command("broker", config =>
{
config.Description = "push a message on workflow server using http";
config.HelpOption(HelpFlag);
var validator = new GroupArgument(config, false);
var configBroker = validator.Argument("config",
"broker configuration (this argument is required)"
, ValidatorExtension.EvaluateRequired
);
var publisher = validator.Argument("publisher",
"server connection string (this argument is required)"
, ValidatorExtension.EvaluateRequired
);
var domain = validator.Argument("domain",
"target domain workflow (this argument is required)"
, ValidatorExtension.EvaluateRequired
);
var content = validator.Argument("content",
"content that you want to push on the workflow server"
, ValidatorExtension.EvaluateRequired
);
config.OnExecute(() =>
{
if (validator.Evaluate() > 0)
{
return(2);
}
string configRabbit = GetContent(configBroker.Value);
var result = Newtonsoft.Json.JsonConvert.DeserializeObject <ConfigurationBroker>(configRabbit);
var publisherItem = result.Brokers.Publishers.First(c => c.Name == publisher.Value);
string model = GetContent(content.Value);
IFactoryBroker brokers = result.ApplyConfiguration(new RabbitFactoryBrokers())
.Initialize();
using (var publisherInstance = brokers.CreatePublisher(publisher.Value))
using (var trans = publisherInstance.BeginTransaction())
{
publisherInstance.Publish(publisherItem.DefaultRountingKey, model, new { domain = domain.Value });
publisherInstance.Commit();
}
Output.WriteLine("item successfully pushed on workflow server.");
return(0);
});
});
return(app);
}
