public void HostInboundService()
{
ConnectedModuleManager.Instance.RegisterModulesForIoC(Environment.Test);
//Select message queueu entities
_messageStorage = IoCManager.Instance.ResolveIfRegistered <IMessageStorage>();// new FakeStorage(); //_messageStorage = new MessageQueueStorage();
////Resolve Configuration DB Repository
//IConnectedConfDBRepository connectedConfDBRepository = IoCManager.Instance.Resolve<IConnectedConfDBRepository>();
//Host Inbound service
//_service = new InboundService(_messageStorage, connectedConfDBRepository);
//Host Inbound service
_service = IoCManager.Instance.ResolveIfRegistered <InboundService>();
//TODO : Implement wcf service call function for Inbound service
//TODO : them host service here, call this instance
//try
//{
// ServiceHost serviceHost = new ServiceHost(_service);
// serviceHost.Open();
//}
//catch (Exception ex)
//{
// throw ex;
//}
}
public ChatContext(string serverId, IConfig config, IDatabaseBackend databaseBackend, IDataProvider dataProvider)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
DatabaseWrapper db = new DatabaseWrapper(databaseBackend ?? throw new ArgumentNullException(nameof(databaseBackend)));
IMessageStorage msgStore = db.IsNullBackend
? new MemoryMessageStorage()
: new ADOMessageStorage(db);
DataProvider = dataProvider ?? throw new ArgumentNullException(nameof(dataProvider));
Sessions = new SessionManager(this, serverId, config.ScopeTo(@"sessions"));
Messages = new MessageManager(this, msgStore, config.ScopeTo(@"messages"));
Users = new UserManager(this);
Channels = new ChannelManager(this, config, Bot);
ChannelUsers = new ChannelUserRelations(this, Channels, Users, Sessions, Messages);
RateLimiter = new RateLimiter(config.ScopeTo(@"flood"));
Channels.UpdateChannels();
// Should probably not rely on Timers in the future
BumpTimer = new Timer(e => {
Logger.Write(@"Bumping last online times...");
IEnumerable <IUser> users = null;
Sessions.GetActiveSessions(s => users = s.Select(s => s.User));
DataProvider.UserBumpClient.SubmitBumpUsers(Sessions, users);
}, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
}
protected override void OnStart(string[] args)
{
try
{
//Select message queueu entities
IMessageStorage messageStorage = IoCManager.Instance.ResolveIfRegistered <IMessageStorage>();// new FakeStorage(); //_messageStorage = new MessageQueueStorage();
//Resolve Configuration DB Repository
IConnectedConfDBRepository connectedConfDBRepository = IoCManager.Instance.ResolveIfRegistered <IConnectedConfDBRepository>();
_routeFinderService = new RouteFinder.RouteFinderService(messageStorage, connectedConfDBRepository);
_routeFinderService.StartRouteFinderService();
_loger.WriteLog(
"Connected Route Finder Service Started. ",
global::Common.Enums.LogType.Info, "Connected Route Finder Service");
}
catch (Exception exception)
{
_loger.WriteLog(
"Connected Route Finder Service couldn't started. Error message : " + exception.Message +
(!string.IsNullOrEmpty(exception.InnerException.Message)
? ", Inner exception : " + exception.InnerException.Message
: ""),
global::Common.Enums.LogType.Error, "Connected Route Finder Service");
throw;
}
}
public void StartListener(IMessageStorage storage, IMessageParser parser)
{
bool done = false;
UdpClient listener = new UdpClient(_port);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, _port);
try
{
while (!done)
{
byte[] bytes = listener.Receive(ref endPoint);
if (bytes.Length > MaxMessageLength)
{
continue;
}
var rawmessage = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
storage.Add(parser.Parse(rawmessage, endPoint.Address));
}
}
catch (Exception ex)
{
}
finally
{
listener.Close();
}
}
public void StartListener(IMessageStorage storage, IMessageParser parser)
{
bool done = false;
UdpClient listener = new UdpClient(_port);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, _port);
try
{
while (!done)
{
byte[] bytes = listener.Receive(ref endPoint);
if (bytes.Length > MaxMessageLength)
continue;
var rawmessage = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
storage.Add(parser.Parse(rawmessage, endPoint.Address));
}
}
catch (Exception ex)
{
}
finally
{
listener.Close();
}
}
private ResendMessagesChannelModule GetTarget(
bool setEstablishedState = true,
Mock <IChannel> channel = null,
IMessageStorage messageStorage = null,
IDeadMessageHandler deadMessageHandler = null,
Event[] eventsToRemovePendingMessage = null)
{
if (channel == null)
{
channel = _channel;
}
var target =
ResendMessagesChannelModule.CreateAndRegister(channel.Object, _resendMessageTryCount,
_resendMessageInterval, messageStorage, deadMessageHandler: deadMessageHandler, eventsToRemovePendingMessage: eventsToRemovePendingMessage);
channel
.Setup(c => c.SendMessageAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Returns((Message m, CancellationToken c) => ((IChannelModule <Message>)target).OnSendingAsync(m, _cancellationToken));
if (setEstablishedState)
{
target.OnStateChanged(SessionState.Established);
}
_targets.Add(target);
return(target);
}
public MessageManager(IEventDispatcher dispatcher, IMessageStorage storage, IConfig config)
{
Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
Storage = storage ?? throw new ArgumentNullException(nameof(storage));
Config = config ?? throw new ArgumentNullException(nameof(config));
TextMaxLengthValue = Config.ReadCached(@"maxLength", DEFAULT_LENGTH_MAX);
}
public MessageBus(
IChannelPool channelPool,
ILogger <MessageBus> logger,
IMessageStorage storage = null)
{
_channelPool = channelPool;
_logger = logger;
_storage = storage;
}
public static void ConfigureServices(string remoteHost, int remotePort, int localPort)
{
ConnectionBuilder connBuilder = new ConnectionBuilder();
ConnServ = connBuilder.
ConfigureLocal(localPort)
.ConfigureRemote(remoteHost, remotePort)
.Build();
MessageStorage = new FileStorage($@"{remoteHost}{remotePort}.txt");
MessageServ = new MessageService.MessageService(MessageStorage);
}
public void Initialize(HttpContext context)
{
lock (this.m_Lock)
{
string[] strArray = Utility.GetConfig().AppSettings.Settings["MessageStorageImpl"].Value.Split(new char[] { ' ' });
ConstructorInfo constructor = Assembly.Load(strArray[0]).GetType(strArray[1]).GetConstructor(new Type[0]);
this.m_IMessageStorage = constructor.Invoke(new object[0]) as IMessageStorage;
this.m_MaxKey = this.m_IMessageStorage.GetMaxKey();
this.m_MaxCreatedTime = this.m_IMessageStorage.GetCreatedTime();
}
}
public InboundService(IMessageStorage messageStorage, IConnectedConfDBRepository connectedConfDBRepository)
{
MessageStorage = messageStorage;
ConnectedConfDBRepository = connectedConfDBRepository;
_messageTypes = ConnectedConfDBRepository.GetMessageTypes();
_sendAdapters = ConnectedConfDBRepository.GetSendAdapters();
_registrations = ConnectedConfDBRepository.GetAdapterMessageTypes();
//Decorator Pattern Test
IMessageStorage loggedMessageStorage = new Connected.MessageStorage.LoggedMessagesDecorator(messageStorage);
}
public CommandReceiver(
IServiceScopeFactory scopeFactory,
IConnection connection,
ILogger <CommandReceiver> logger,
IReadOnlyCollection <CommandModule> modules,
IMessageStorage storage = null)
{
_scopeFactory = scopeFactory;
_connection = connection;
_logger = logger;
_modules = modules;
_storage = storage;
}
public EventSubscriber(
IServiceScopeFactory scopeFactory,
IConnection connection,
ILogger <EventSubscriber> logger,
IReadOnlyCollection <EventModule> modules,
IMessageStorage storage = null)
{
_scopeFactory = scopeFactory;
_connection = connection;
_logger = logger;
_modules = modules;
_storage = storage;
}
public MainWindowViewModel(IMailService mailService,
IServerStorage serverStorage, ISenderStorage senderStorage, IRecipientStorage recipientStorage, IMessageStorage messageStorage)
{
_MailService = mailService;
_serverStorage = serverStorage;
_senderStorage = senderStorage;
_recipientStorage = recipientStorage;
_messageStorage = messageStorage;
_timer = new Timer(100);
_timer.Elapsed += OnTimerElapsed;
_timer.AutoReset = true;
_timer.Enabled = true;
}
/// <summary>
/// Constructs the step with the given saga storage
/// </summary>
public LoadMessageDataStep(IMessageStorage messageStorage, ITransport transport, IRebusLoggerFactory rebusLoggerFactory)
{
if (messageStorage == null)
{
throw new ArgumentNullException(nameof(messageStorage));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
_msgStorage = messageStorage;
_log = rebusLoggerFactory.GetLogger <LoadMessageDataStep>();
}
public static SMSProviderBase GetProvider(IMessageStorage storage, SMSProviderType type)
{
switch (type)
{
case SMSProviderType.Thread:
return(new SMSProviderThread(storage));
case SMSProviderType.Task:
return(new SMSProviderTask(storage));
default:
throw new NotImplementedException($"Not implemented logic for {type.ToString()} in {nameof(SMSProviderType)}");
}
}
public SMSProviderBase(IMessageStorage storage)
{
this.storage = storage;
lock_obj = new object();
users = new string[]
{
"+308751566825",
"+308865211124",
"+301111111111",
"+307777777777",
"+308333333333",
};
usersIndexRnd = new Random();
generatorDelaRnd = new Random();
}
public ReliableChatRoomHub(
ILogger <ReliableChatRoomHub> logger,
IUserHandler userHandler,
IMessageStorage messageStorage,
IMessageFactory messageFactory,
IClientAckHandler clientAckHandler,
INotificationHandler notificationHandler)
{
_logger = logger;
_userHandler = userHandler;
_messageStorage = messageStorage;
_messageFactory = messageFactory;
_clientAckHandler = clientAckHandler;
_notificationHandler = notificationHandler;
}
public RouteFinderService(IMessageStorage messageStorage, IConnectedConfDBRepository connectedConfDBRepository)
{
//Task cancellation token
_ts = new CancellationTokenSource();
_ct = _ts.Token;
//TODO : Get this from app config or constructor
//TODO : Set this a higher value
_messageLimitToBoEnriched = 10;
MessageStorage = messageStorage;
ConnectedConfDBRepository = connectedConfDBRepository;
_messageTypes = ConnectedConfDBRepository.GetMessageTypes();
_messageSubscriptionDetails = ConnectedConfDBRepository.GetMessageSubscriptionDetails();
}
/// <summary>
/// Constructs the step
/// </summary>
public IdempotentMessageIncomingStep(ITransport transport, IMessageStorage messageStorage, IRebusLoggerFactory rebusLoggerFactory)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (messageStorage == null)
{
throw new ArgumentNullException(nameof(messageStorage));
}
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
_transport = transport;
_msgStorage = messageStorage;
_log = rebusLoggerFactory.GetLogger <IdempotentMessageIncomingStep>();
}
/// <summary>
/// Initializes a new instance of MailerQ MIME message storage
/// </summary>
/// <param name="options"></param>
public MessageStorage(IOptions <MailerQConfiguration> options)
{
var uri = options.Value.MessageStorageUrl;
var schemeSeparatorIndex = uri.IndexOf(@"://");
if (schemeSeparatorIndex <= 0)
{
throw new ArgumentException($"{nameof(MailerQConfiguration.MessageStorageUrl)} has invalid value");
}
var scheme = uri.Remove(schemeSeparatorIndex);
if (!Enum.TryParse(scheme, ignoreCase: true, out StorageEngines storageScheme))
{
throw new ArgumentException($"{nameof(MailerQConfiguration.MessageStorageUrl)} value does not correspond to a supported storage engine");
}
storageEngine = CreateConcretStorage(storageScheme, uri);
}
public Context(IConfig config, IDatabaseBackend databaseBackend, IDataProvider dataProvider)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
ServerId = RNG.NextString(ID_LENGTH); // maybe read this from the cfg instead
Created = DateTimeOffset.Now; // read this from config definitely
DatabaseWrapper db = new DatabaseWrapper(databaseBackend ?? throw new ArgumentNullException(nameof(databaseBackend)));
IMessageStorage msgStore = db.IsNullBackend
? new MemoryMessageStorage()
: new ADOMessageStorage(db);
DataProvider = dataProvider ?? throw new ArgumentNullException(nameof(dataProvider));
Sessions = new SessionManager(this, Users, config.ScopeTo(@"sessions"), ServerId);
Messages = new MessageManager(this, msgStore, config.ScopeTo(@"messages"));
Users = new UserManager(this);
Channels = new ChannelManager(this, config, Bot);
ChannelUsers = new ChannelUserRelations(this, Channels, Users, Sessions, Messages);
RateLimiter = new RateLimiter(config.ScopeTo(@"flood"));
WelcomeMessage = new WelcomeMessage(config.ScopeTo(@"welcome"));
AddEventHandler(Sessions);
AddEventHandler(Users);
AddEventHandler(Channels);
AddEventHandler(ChannelUsers);
AddEventHandler(Messages);
Channels.UpdateChannels();
// Should probably not rely on Timers in the future
BumpTimer = new Timer(e => {
Logger.Write(@"Nuking dead sessions and bumping online times...");
Sessions.CheckTimeOut();
IEnumerable <IUser> users = null;
Sessions.GetActiveSessions(s => users = s.Select(s => s.User));
DataProvider.UserBumpClient.SubmitBumpUsers(Sessions, users);
}, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
}
public DispatcherService(IMessageStorage messageStorage, IConnectedConfDBRepository connectedConfDBRepository)
{
//Task cancellation token
_ts = new CancellationTokenSource();
_ct = _ts.Token;
//TODO : Get this from app config or constructor
//TODO : Set this a higher value
_messageLimitToBoMoved = 10;
_messageLimitToBeDispatched = 10;
MessageStorage = messageStorage;
ConnectedConfDBRepository = connectedConfDBRepository;
//Get receive adapters
_receiveAdaptersWithDetails = ConnectedConfDBRepository.GetReceiveAdaptersWithDetails();
//TODO : Get this from app config
//Set waiting list limit
_waitingListLimit = 25;
}
public static ResendMessagesChannelModule CreateAndRegister(
IChannel channel,
int maxResendCount,
TimeSpan resendWindow,
IMessageStorage messageStorage = null,
IKeyProvider keyProvider = null,
IDeadMessageHandler deadMessageHandler = null,
Event[] eventsToRemovePendingMessage = null)
{
var resendMessagesChannelModule = new ResendMessagesChannelModule(
channel,
messageStorage ?? new MemoryMessageStorage(),
keyProvider ?? KeyProvider.Instance,
deadMessageHandler ?? DiscardDeadMessageHandler.Instance,
maxResendCount,
resendWindow,
eventsToRemovePendingMessage);
resendMessagesChannelModule.RegisterTo(channel);
return(resendMessagesChannelModule);
}
public ResendMessagesChannelModule(
IChannel channel,
IMessageStorage messageStorage,
IKeyProvider keyProvider,
IDeadMessageHandler deadMessageHandler,
int maxResendCount,
TimeSpan resendWindow,
Event[] eventsToRemovePendingMessage = null)
{
_channel = channel ?? throw new ArgumentNullException(nameof(channel));
_messageStorage = messageStorage ?? throw new ArgumentNullException(nameof(messageStorage));
_keyProvider = keyProvider ?? throw new ArgumentNullException(nameof(keyProvider));
_deadMessageHandler = deadMessageHandler ?? throw new ArgumentNullException(nameof(deadMessageHandler));
_maxResendCount = maxResendCount;
_resendWindow = resendWindow;
if (eventsToRemovePendingMessage != null && eventsToRemovePendingMessage.Length == 0)
{
throw new ArgumentException("At least one event must be provided", nameof(eventsToRemovePendingMessage));
}
_eventsToRemovePendingMessage = eventsToRemovePendingMessage;
}
public MessageLogic(IMessageStorage messageStorage)
{
this.messageStorage = messageStorage;
}
public StoragePrinter(IMessageStorage Storage)
{
_Storage = Storage;
}
public BoardController(IUUIDProvider uuidProvider, IUserStorage userStorage, IMessageStorage messageStorage)
{
this.uuidProvider = uuidProvider;
this.userStorage = userStorage;
this.messageStorage = messageStorage;
}
public static void ConfigureStorage(string remoteHost, int remotePort)
{
MessageStorage = new FileStorage(remoteHost);
MessageServ = new MessageService.MessageService(MessageStorage);
}
public static void EnableIdempotentMessages(this OptionsConfigurer configurer, IMessageStorage messageStorage)
{
configurer.Decorate <IPipeline>(c =>
{
var transport = c.Get <ITransport>();
var pipeline = c.Get <IPipeline>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var incomingStep = new IdempotentMessageIncomingStep(transport, messageStorage, rebusLoggerFactory);
var loadMessageDataStep = new LoadMessageDataStep(messageStorage, transport, rebusLoggerFactory);
var outgoingStep = new IdempotentMessageOutgoingStep(rebusLoggerFactory);
var injector = new PipelineStepInjector(pipeline)
.OnReceive(loadMessageDataStep, PipelineRelativePosition.Before, typeof(DispatchIncomingMessageStep))
.OnReceive(incomingStep, PipelineRelativePosition.Before, typeof(DispatchIncomingMessageStep))
.OnSend(outgoingStep, PipelineRelativePosition.After, typeof(SendOutgoingMessageStep));
return(injector);
});
}
public Messenger(IMessageStorage MessageStorage)
{
Storage = MessageStorage;
Messages = Storage.Read().ToList();
}
public Messenger(IMessageStorage MessageStorage)
{
Storage = MessageStorage;
Messages = Storage.Read().ToList();
}
public void Initialize(HttpContext context)
{
lock (m_Lock)
{
if (m_MessageStorageImpl == null)
{
string accStorage = System.Web.Configuration.WebConfigurationManager.AppSettings["MessageStorageImpl"];
String[] accStorageInfo = accStorage.Split(new char[] { ' ' });
Type type = Assembly.Load(accStorageInfo[0]).GetType(accStorageInfo[1]);
ConstructorInfo ctor = type.GetConstructor(new Type[] { });
m_MessageStorageImpl = ctor.Invoke(new object[] { }) as IMessageStorage;
m_MaxKey = MessageStorageImpl.GetMaxKey();
m_MaxCreatedTime = MessageStorageImpl.GetCreatedTime();
}
}
}
