protected AbstractMsmqListener( IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMessageSerializer messageSerializer, IEndpointRouter endpointRouter, TransactionalOptions transactional, IMessageBuilder<Message> messageBuilder) { this.queueStrategy = queueStrategy; this.messageSerializer = messageSerializer; this.endpointRouter = endpointRouter; this.endpoint = endpoint; this.threadCount = threadCount; threads = new Thread[threadCount]; switch (transactional) { case TransactionalOptions.Transactional: this.transactional = true; break; case TransactionalOptions.NonTransactional: this.transactional = false; break; case TransactionalOptions.FigureItOut: this.transactional = null; break; default: throw new ArgumentOutOfRangeException("transactional"); } this.messageBuilder = messageBuilder; this.messageBuilder.Initialize(Endpoint); }
public InstanceContextFactory(InstanceMode instanceMode, IMessageBuilder msgBuilder, ILoggerFactory loggerFactory) { _instanceMode = instanceMode; _msgBuilder = msgBuilder; _loggerFactory = loggerFactory; _logger = _loggerFactory.CreateLogger("InstanceContextFactory"); }
public DuplicateMessageSender( string senderName, IMessageBuilder messageBuilder, IMessageReceiver messageReceiver) : base(senderName, messageBuilder, messageReceiver) { }
public static void Unsubscribe(this IMessageBuilder messageBuilder, string context) { messageBuilder .WithAction(Constants.UnsubscribeAction) .AddHeader(new IdentifierHeader(context), true) .SendAndGetResponse(); }
public static PullResponse PullNextBatch(this IMessageBuilder messageBuilder, string context, int maxElements) { var requestMessage = messageBuilder .WithAction(Enumeration.Constants.PullAction) .AddBody(new PullRequest { MaxTime = new MaxTime(TimeSpan.FromSeconds(1)), EnumerationContext = new EnumerationContextKey(context), MaxElements = new MaxElements(maxElements) }); try { var responseMessage = requestMessage.SendAndGetResponse(); return(responseMessage.GetPayload <PullResponse>()); } catch (FaultException ex) { if (new TimedOutFaultException().Equals(ex)) { return(new PullResponse { EnumerationContext = new EnumerationContextKey(context) }); } throw; } }
public RhinoQueuesOneWayBus(MessageOwner[] messageOwners, IMessageSerializer messageSerializer, string path, bool enablePerformanceCounters, IMessageBuilder<MessagePayload> messageBuilder, QueueManagerConfiguration queueManagerConfiguration) : base(NullEndpoint, new EndpointRouter(), messageSerializer, 1, path, IsolationLevel.ReadCommitted, 5, enablePerformanceCounters, messageBuilder, queueManagerConfiguration) { this.messageOwners = new MessageOwnersSelector(messageOwners, new EndpointRouter()); Start(); }
public MessageStateMachine(IMusicTrackDatabase musicDatabase) { this.messageRegister = new MessageRegister(); this.messageBuilder = new MessageBuilder(musicDatabase); this.messageHistory = new MessageHistory(); this.statisticsManager = new StatisticsManager(); }
private void Process_Address(string address, string expectedParsedAddress, StandardSmtpResponseCode expectedResponse) { Mocks mocks = new Mocks(); Mock <IMessageBuilder> message = new Mock <IMessageBuilder>(); IMessageBuilder currentMessage = null; mocks.Connection.Setup(c => c.NewMessage()).Returns(() => { currentMessage = message. Object; return (currentMessage); } ); mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(() => currentMessage); MailFromVerb mailFromVerb = new MailFromVerb(); mailFromVerb.Process(mocks.Connection.Object, new SmtpCommand("FROM " + address)); mocks.VerifyWriteResponse(expectedResponse); message.VerifySet(m => m.From = expectedParsedAddress); }
public static IEnumerable <EndpointReference> EnumerateEPR(this IMessageBuilder messageBuilder, Filter filter, int maxElements, bool optimize) { IMessageBuilder nextMessageBuilder; var response = messageBuilder .StartEnumeration(filter, EnumerationMode.EnumerateEPR, optimize, out nextMessageBuilder); if (response.Items != null) { foreach (var item in response.Items) { yield return(item.EPRValue); } } var context = response.EnumerationContext; var endOfSequence = response.EndOfSequence != null; while (!endOfSequence) { var pullResponse = nextMessageBuilder .PullNextBatch(context, maxElements, out nextMessageBuilder); foreach (var item in pullResponse.Items) { yield return(item.EPRValue); } endOfSequence = pullResponse.EndOfSequence != null; context = pullResponse.EnumerationContext; } }
public RhinoFilesTransport(Uri endpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string path, IsolationLevel queueIsolationLevel, int numberOfRetries, bool enablePerformanceCounters, IMessageBuilder<MessagePayload> messageBuilder, QueueManagerConfiguration queueManagerConfiguration) { _endpoint = endpoint; _queueIsolationLevel = queueIsolationLevel; _numberOfRetries = numberOfRetries; _enablePerformanceCounters = enablePerformanceCounters; _messageBuilder = messageBuilder; _queueManagerConfiguration = queueManagerConfiguration; _endpointRouter = endpointRouter; _messageSerializer = messageSerializer; _threadCount = threadCount; _path = path; _queueName = endpoint.GetQueueName(); _threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events in order to successfully handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(Endpoint); }
public MessagingManager(ICommunicationDispatcher <IMessage> messageCommunicationDispatcher, IRecipientManager recipientManager, IMessageBuilder messageBuilder, IUserProfileManager userProfileManager) { this._messageCommunicationDispatcher = messageCommunicationDispatcher; this._recipientManager = recipientManager; this._messageBuilder = messageBuilder; this._userProfileManager = userProfileManager; }
/// <summary> /// 补充百科内容 /// </summary> /// <param name="message"></param> /// <param name="senderId"></param> /// <param name="builder"></param> public void AddWiki(IMessageBase[] message, long senderId, IMessageBuilder builder, ref bool isReply) { string question; if (listenCache.TryGetValue(senderId, out question)) { List <MsgModel> answer = new List <MsgModel>(); for (int i = 1; i < message.Length; i++) { if (message[i].Type == PlainMessage.MsgType) { answer.Add(new MsgModel() { type = message[i].Type, content = message[i].ToString() }); } else if (message[i].Type == ImageMessage.MsgType) { answer.Add(new MsgModel() { type = message[i].Type, content = (message[i] as ImageMessage).Url }); } } SetWiki(question, answer); //添加欢迎信息 builder.AddPlainMessage(string.Format(_command["WikiCommand:Thanks"], _command["BotName"])); //从监听数组里移除掉 listenCache.Remove(senderId); } else { isReply = false; } }
public HttpRequestMessage Build(IMessageBuilder messageBuilder) { var message = messageBuilder.Build(); var request = new HttpRequestMessage(message.Method, message.RequestUri); var body = string.Empty; if ((message.Method == HttpMethod.Post || message.Method == HttpMethod.Post) && !string.IsNullOrEmpty(message.Content)) { body = message.Content; request.Content = new StringContent(body); } var timestamp = Timestamp; var nonce = Nonce; var url = new Uri(Configuration.ApiUrl, request.RequestUri); var signature = _signer.Sign(_secret, request.Method.Method, url.ToString(), body, nonce, timestamp); request.Headers.TryAddWithoutValidation("Authorization", _clientKey + ':' + signature); request.Headers.Add("X-Auth-Timestamp", timestamp); request.Headers.Add("X-Auth-Nonce", nonce); request.Headers.TryAddWithoutValidation("Content-Type", "application/json"); return(request); }
public SqlQueuesTransport(Uri queueEndpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string connectionString, int numberOfRetries, IMessageBuilder <MessagePayload> messageBuilder) { this.queueEndpoint = queueEndpoint; this.numberOfRetries = numberOfRetries; this.messageBuilder = messageBuilder; this.endpointRouter = endpointRouter; this.messageSerializer = messageSerializer; this.threadCount = threadCount; this.connectionString = connectionString; queueName = queueEndpoint.GetQueueName(); threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events // in order to successfuly handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(Endpoint); }
public SendSmsHandler(IMessageBuilder messageBuilder, IMessageHttpService messageHttpService, RouteConfiguration routeConfiguration) { _messageBuilder = messageBuilder; _messageHttpService = messageHttpService; _routeConfiguration = routeConfiguration; }
internal DuplexClientConnection(ISocket socket, IMessageBuilder msgBuilder, IInstanceContextFactory instanceContextFactory) : base(socket, msgBuilder) { _instanceContextFactory = instanceContextFactory; }
internal DuplexClientConnection(ITransport transport, IMessageBuilder msgBuilder, IInstanceContextFactory instanceContextFactory) : base(transport, msgBuilder) { _instanceContextFactory = instanceContextFactory; }
public RhinoQueuesTransport(Uri endpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string path, IsolationLevel queueIsolationLevel, int numberOfRetries, bool enablePerformanceCounters, IMessageBuilder<MessagePayload> messageBuilder) { this.endpoint = endpoint; this.queueIsolationLevel = queueIsolationLevel; this.numberOfRetries = numberOfRetries; this.enablePerformanceCounters = enablePerformanceCounters; this.messageBuilder = messageBuilder; this.endpointRouter = endpointRouter; this.messageSerializer = messageSerializer; this.threadCount = threadCount; this.path = path; queueName = endpoint.GetQueueName(); threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events // in order to successfully handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(this.Endpoint); }
public DefaultEmailingProcessor( IMailSender sender, IMessageBuilder messageBuilder) { _sender = sender; _messageBuilder = messageBuilder; }
protected AbstractFileListener( IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMessageSerializer messageSerializer, IEndpointRouter endpointRouter, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder) { this.queueStrategy = queueStrategy; this.messageSerializer = messageSerializer; this.endpointRouter = endpointRouter; this.endpoint = endpoint; this.threadCount = threadCount; threads = new Thread[threadCount]; switch (transactional) { case TransactionalOptions.Transactional: this.transactional = true; break; case TransactionalOptions.NonTransactional: this.transactional = false; break; case TransactionalOptions.FigureItOut: this.transactional = null; break; default: throw new ArgumentOutOfRangeException("transactional"); } this.messageBuilder = messageBuilder; this.messageBuilder.Initialize(Endpoint); }
public SqlQueuesTransport(Uri queueEndpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string connectionString, int numberOfRetries, IMessageBuilder<MessagePayload> messageBuilder) { this.queueEndpoint = queueEndpoint; this.numberOfRetries = numberOfRetries; this.messageBuilder = messageBuilder; this.endpointRouter = endpointRouter; this.messageSerializer = messageSerializer; this.threadCount = threadCount; this.connectionString = connectionString; queueName = queueEndpoint.GetQueueName(); threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events // in order to successfuly handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(Endpoint); }
public RhinoQueuesTransport(Uri endpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string path, IsolationLevel queueIsolationLevel, int numberOfRetries, bool enablePerformanceCounters, IMessageBuilder <MessagePayload> messageBuilder, QueueManagerConfiguration queueManagerConfiguration, ITransactionStrategy transactionStrategy) { this.endpoint = endpoint; this.queueIsolationLevel = queueIsolationLevel; this.numberOfRetries = numberOfRetries; this.enablePerformanceCounters = enablePerformanceCounters; this.messageBuilder = messageBuilder; this.queueManagerConfiguration = queueManagerConfiguration; this.transactionStrategy = transactionStrategy; this.endpointRouter = endpointRouter; this.messageSerializer = messageSerializer; this.threadCount = threadCount; this.path = path; queueName = endpoint.GetQueueName(); threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events // in order to successfully handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(this.Endpoint); }
public static void Delete(this IMessageBuilder messageBuilder, string resourceUri, IEnumerable <Selector> selectors) { messageBuilder .WithResourceUri(resourceUri) .WithSelectors(selectors) .Delete(); }
public TransactionValidator(IOptions <ValidationRules> validationRules, IMessageBuilder errorMessageHelper, IServiceProvider serviceProvider) { _validationRules = validationRules.Value; _errorMessageHelper = errorMessageHelper; _serviceProvider = serviceProvider; }
/// <summary> /// Initializes a new instance of the <see cref="MessagingClientContext" /> class. /// </summary> /// <param name="readBuffer">The read buffer.</param> /// <param name="formatterFactory">Used to format messages </param> public MessagingClientContext(IBufferSlice readBuffer, IMessageFormatterFactory formatterFactory) : base(readBuffer) { if (formatterFactory == null) throw new ArgumentNullException("formatterFactory"); _formatterFactory = formatterFactory; _messageBuilder = _formatterFactory.CreateBuilder(); }
/// <summary> /// The Process_AddressAsync /// </summary> /// <param name="address">The address<see cref="string"/></param> /// <param name="expectedParsedAddress">The expectedParsedAddress<see cref="string"/></param> /// <param name="expectedResponse">The expectedResponse<see cref="StandardSmtpResponseCode"/></param> /// <returns>A <see cref="Task{T}"/> representing the async operation</returns> private async Task Process_AddressAsync(string address, string expectedParsedAddress, StandardSmtpResponseCode expectedResponse, bool asException = false, bool eightBitMessage = false) { TestMocks mocks = new TestMocks(); Mock <IMessageBuilder> message = new Mock <IMessageBuilder>(); message.SetupGet(m => m.EightBitTransport).Returns(eightBitMessage); IMessageBuilder currentMessage = null; mocks.Connection.Setup(c => c.NewMessage()).ReturnsAsync(() => { currentMessage = message.Object; return(currentMessage); }); mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(() => currentMessage); MailFromVerb mailFromVerb = new MailFromVerb(); if (!asException) { await mailFromVerb.Process(mocks.Connection.Object, new SmtpCommand("FROM " + address)).ConfigureAwait(false); mocks.VerifyWriteResponse(expectedResponse); } else { SmtpServerException e = await Assert.ThrowsAsync <SmtpServerException>(() => mailFromVerb.Process(mocks.Connection.Object, new SmtpCommand("FROM " + address))); Assert.Equal((int)expectedResponse, e.SmtpResponse.Code); } if (expectedParsedAddress != null) { message.VerifySet(m => m.From = expectedParsedAddress); } }
public ContactUsController( IEmailSender emailSender, IMessageBuilder messageBuilder) { _emailSender = emailSender; _messageBuilder = messageBuilder; }
public ContestController(IContestRepository contestRepository, IUserContestRepository userContestRepository, IProblemContestRepository problemContestRepository, ISubmisionContestRepository submisionContestRepository, IAnnouncementRepository announcementRepository, IProblemRepository problemRepository, ISubmisionRepository submisionRepository, IMessageBuilder emailSender, UserManager <User> userManager, IConfiguration configuration, ITestsRepository testsRepository, SubmissionHub submissionHub, IHubContext <SubmissionHub> hubContext, ISerializeTests serializeTests, IEvaluationRepository evaluationRepository, IUserInformationRepository userInformation) { _contestRepository = contestRepository; _userContestRepository = userContestRepository; _problemContestRepository = problemContestRepository; _submisionContestRepository = submisionContestRepository; _announcementRepository = announcementRepository; _problemRepository = problemRepository; _submisionRepository = submisionRepository; _compilers = Compilator.Compilers; _emailSender = emailSender; _userManager = userManager; _configuration = configuration; _testRepository = testsRepository; _submissionHub = submissionHub; _evaluationRepository = evaluationRepository; _hubContext = hubContext; _serializeTests = serializeTests; _userInformation = userInformation; //intialize compilation and running api _compilationApi = _configuration.GetSection("Api")["CompilationApi"]; _executionApi = _configuration.GetSection("Api")["ExecutionApi"]; }
public IncomingMessage SendAndGetResponse(out IMessageBuilder nextMessageBuilder) { var response = _soapClient.SendRequest(_outgoingMessage); nextMessageBuilder = new MessageBuilder(_soapClient); return(response); }
public CommunicationParser(IMessageBuilder messageBuilder, IMessageProcessor messageProcessor, IEncodingAdapter encodingAdapter, ILogger logger, IMessageWriter messageWriter) { this._messageBuilder = messageBuilder; this._messageProcessor = messageProcessor; this._encodingAdapter = encodingAdapter; this._logger = logger; this._messageWriter = messageWriter; }
public static IMessageBuilder AddUsers(this IMessageBuilder builder, IEnumerable <MailRecipient> recipients) { foreach (var recipient in recipients.WhereNotNull().Distinct()) { builder.AddToRecipient(recipient.User.ToRecipient()); } return(builder); }
internal static void ContructAddMessage(this HostEntry hostEntry, IMessageBuilder builder) { builder .WriteLine("Added Host Entry") .IncreaseIndent() .WriteLine("Host Name: {0}", hostEntry.HostName) .WriteLine("IP: {0}", hostEntry.IpAddress); }
internal static void ContructAddMessage(this VirtualDirectory virtualDirectory, IMessageBuilder builder) { builder .WriteLine("Adding Virtual Directory") .IncreaseIndent() .WriteLine("Alias: {0}", virtualDirectory.Path) .WriteLine("Physical Path {0}", virtualDirectory.PhysicalPath); }
public static T Put <T>(this IMessageBuilder messageBuilder, string resourceUri, string fragmentTransferExpression, object payload, IEnumerable <Selector> selectors) { return(messageBuilder .WithResourceUri(resourceUri) .WithSelectors(selectors) .AddHeader(new FragmentTransferHeader(fragmentTransferExpression), true) .Put <T>(payload)); }
public MsmqReadyForWorkListener(IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMessageSerializer messageSerializer, IEndpointRouter endpointRouter, TransactionalOptions transactional, IMessageBuilder<Message> messageBuilder) : base(queueStrategy, endpoint, threadCount, messageSerializer, endpointRouter, transactional, messageBuilder) {}
/// <returns>An asynchronous task context.</returns> /// <inheritdoc cref="IMailClient.BulkSendAsync(IMessageBuilder, IDataReader, IEnumerable{IMessageMutator}, IFormatProvider, CancellationToken)"/> public static Task BulkSendAllAsync(this IMailClient client, IMessageBuilder messageBuilder, IDataReader reader, IEnumerable <IMessageMutator>?messageMutators = null, IFormatProvider?formatProvider = null, CancellationToken cancellationToken = default) { _ = client ?? throw new ArgumentNullException(nameof(client)); _ = messageBuilder ?? throw new ArgumentNullException(nameof(messageBuilder)); _ = reader ?? throw new ArgumentNullException(nameof(reader)); return(client.BulkSendAsync(messageBuilder, reader, messageMutators, formatProvider, cancellationToken).ConsumeAsync()); }
public SqlQueuesOneWayBus(MessageOwner[] messageOwners, IMessageSerializer messageSerializer, string connectionString, IMessageBuilder<MessagePayload> messageBuilder) : base(NullEndpoint, new EndpointRouter(), messageSerializer, 0, connectionString, 5, messageBuilder) { this.messageOwners = new MessageOwnersSelector(messageOwners, new EndpointRouter()); internalStart(); internalPostStart(); }
public JObject GetGelfJson(LogEvent logEvent) { IMessageBuilder builder = logEvent.Exception != null ? _messageBuilders[BuilderType.Exception].Value : _messageBuilders[BuilderType.Message].Value; return(builder.Build(logEvent)); }
/// <inheritdoc/> public MimeMessage?Send(IMessageBuilder messageBuilder, IDataRecord record, IEnumerable <IMessageMutator>?messageMutators = null, IFormatProvider?formatProvider = null) { _ = messageBuilder ?? throw new ArgumentNullException(nameof(messageBuilder)); _ = record ?? throw new ArgumentNullException(nameof(record)); messageMutators ??= Array.Empty <IMessageMutator>(); return(SendImpl(messageBuilder, record, messageMutators, formatProvider ?? CultureInfo.InvariantCulture, 0, 1, out _)); }
/// <summary> /// Processes the context. /// </summary> /// <param name="context">The context.</param> /// <param name="builder">The Message Builder</param> public void Process(IEmailContext context, IMessageBuilder builder) { var message = builder.BuildMessage(context, _repository); if (message != null) { _sender.Send(message); } }
/// <summary> /// Initializes a new instance of the <see cref="ControlProcessor"/> class. /// </summary> /// <param name="identification">The identification.</param> /// <param name="inputGateway">The input gateway.</param> /// <param name="outputGateway">The output gateway.</param> /// <param name="handlerRepository">The handler repository.</param> /// <param name="messageBuilder">The message builder.</param> /// <param name="reinjectionEngine">The reinjection engine.</param> internal ControlProcessor(Identification identification, IInputGateway <IControlMessage, MessageHeader> inputGateway, IOutputGateway <IControlMessage> outputGateway, IHandlerRepository handlerRepository, IMessageBuilder messageBuilder, IReinjectionEngine reinjectionEngine) : base(identification, inputGateway, handlerRepository, messageBuilder, reinjectionEngine) { OutputGateway = outputGateway; }
/// <inheritdoc/> public Task <MimeMessage?> SendAsync(IMessageBuilder messageBuilder, IDataRecord record, IEnumerable <IMessageMutator>?messageMutators = null, IFormatProvider?formatProvider = null, CancellationToken cancellationToken = default) { _ = messageBuilder ?? throw new ArgumentNullException(nameof(messageBuilder)); _ = record ?? throw new ArgumentNullException(nameof(record)); messageMutators ??= Array.Empty <IMessageMutator>(); return(SendAsyncImpl(messageBuilder, record, messageMutators, formatProvider ?? CultureInfo.InvariantCulture, 0, 1, cancellationToken).ContinueWith(x => x.Result.Message)); }
internal static void ContructAddMessage(this Application application, IMessageBuilder builder) { builder .WriteLine("Adding Application") .IncreaseIndent() .WriteLine("Alias: {0}", application.Path) .WriteLine("Physical Path {0}", application.VirtualDirectory().PhysicalPath) .WriteLine("Application Pool: {0}", application.ApplicationPoolName); }
internal static void ContructAlterMessage(this Site site, IMessageBuilder builder) { builder .WriteLine("Altering Website") .IncreaseIndent() .WriteLine("Name: {0}", site.Name) .WriteLine("Id: {0}", site.Id) .WriteLine("Application Pool: {0}", site.Application().ApplicationPoolName); }
private async Task<HttpResponseMessage> SendAsync(IMessageBuilder messageBuilder) { if (messageBuilder == null) throw new ArgumentNullException("messageBuilder"); var message = messageBuilder.Build(); var request = new HttpRequestMessage(message.Method, message.RequestUri); return await CreateClient().SendAsync(request).ConfigureAwait(false); }
internal static void ContructRemoveMessage(this ApplicationPool applicationPool, IMessageBuilder builder) { builder .WriteLine("Removing Application Pool") .IncreaseIndent() .WriteLine("Name: {0}", applicationPool.Name) .WriteLine("Managed Pipe Line Mode: {0}", applicationPool.ManagedPipelineMode) .WriteLine("Runtime version: {0}", applicationPool.ManagedRuntimeVersion); }
public AvrmcHandler(IAvrmcParser parser, ILogger logger, IEventTypeParser eventTypeParser, IMessageBuilder messageBuilder, IMessageWriter messageWriter) { this._parser = parser; this._logger = logger; this._eventTypeParser = eventTypeParser; this._messageBuilder = messageBuilder; this._messageWriter = messageWriter; }
public void TestInitialize() { _context = new DbTestContext(Settings.Default.MainConnectionString); _fixture = new Fixture(); _serializer = new Serializer(); _builder = CompositionJobsHelper.GetApplicationMessageBuilder(_context.Connection, Settings.Default.MainConnectionString, Settings.Default.FilesConnectionString); }
internal static void ContructAddMessage(this Site site, IMessageBuilder builder) { builder .WriteLine("Adding Website") .IncreaseIndent() .WriteLine("Name: {0}", site.Name) .WriteLine("Id: {0}", site.Id) .WriteLine("Physical Path {0}", site.Application().VirtualDirectory().PhysicalPath) .WriteLine("Application Pool: {0}", site.Application().ApplicationPoolName); }
private void ConvertHeaders(IMessageReader input, IMessageBuilder output) { var headerCount = input.ItemCount; output.BeginHeaders(headerCount); for (; headerCount > 0; headerCount--) { input.Read(); output.WriteHeader(input.PropertyName, input.StringValue); } output.EndHeaders(); }
public MsmqLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, int threadCount, Uri secondaryLoadBalancer, TransactionalOptions transactional, IMessageBuilder<Message> messageBuilder) : this(serializer, queueStrategy, endpointRouter, endpoint, threadCount, transactional, messageBuilder) { this.secondaryLoadBalancer = secondaryLoadBalancer; }
public MsmqLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, int threadCount, TransactionalOptions transactional, IMessageBuilder<Message> messageBuilder) : base(queueStrategy, endpoint, threadCount, serializer, endpointRouter, transactional, messageBuilder) { heartBeatTimer = new Timer(SendHeartBeatToSecondaryServer); this.queueStrategy = queueStrategy; }
/// <summary> /// Processes the context batch. /// </summary> /// <param name="batch">The batch.</param> /// <param name="builder">The Message Builder</param> public void ProcessBatch(IEnumerable<IEmailContext> batch, IMessageBuilder builder) { var messages = new List<MailMessage>(); foreach (var context in batch) { var message = builder.BuildMessage(context, _repository); if (message != null) { messages.Add(message); } } _sender.SendBatch(messages); }
public static PullResponse PullNextBatch(this IMessageBuilder messageBuilder, EnumerationContextKey context, int maxElements, out IMessageBuilder nextMessageBuilder) { var responseMessage = messageBuilder .WithAction(Constants.PullAction) .AddBody(new PullRequest { EnumerationContext = context, MaxElements = new MaxElements(maxElements) }) .SendAndGetResponse(out nextMessageBuilder); return responseMessage.GetPayload<PullResponse>(); }
public static EnumerateResponse StartEnumeration(this IMessageBuilder messageBuilder, Filter filter, EnumerationMode enumerationMode, bool optimize, out IMessageBuilder nextMessageBuilder) { var responseMessage = messageBuilder .WithAction(Constants.EnumerateAction) .AddBody(new EnumerateRequest { EnumerationMode = enumerationMode, OptimizeEnumeration = optimize ? new OptimizeEnumeration() : null, Filter = filter, }) .SendAndGetResponse(out nextMessageBuilder); return responseMessage.GetPayload<EnumerateResponse>(); }
/// <summary> /// Initializes a new instance of the <see cref="RouterControlProcessor" /> class. /// </summary> /// <param name="identification">The identification.</param> /// <param name="inputGateway">The input gateway.</param> /// <param name="handlerRepository">The handler repository.</param> /// <param name="subscriptonsHelper">The subscriptors helper.</param> /// <param name="messageBuilder">The message builder.</param> internal RouterControlProcessor(Identification identification, IInputGateway<IControlMessage, MessageHeader> inputGateway, IHandlerRepository handlerRepository, ISubscriptorsHelper subscriptonsHelper, IMessageBuilder messageBuilder) { ConfigureStateMachine(); _identification = identification; _inputGateway = inputGateway; _inputGateway.OnMessage += MessageReceived; _handlerRepository = handlerRepository; _subscriptonsHelper = subscriptonsHelper; _subscriptonsHelper.Controller = this; _messageBuilder = messageBuilder; }
public MsmqSecondaryLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, Uri primaryLoadBalancer, int threadCount, TransactionalOptions transactional, IMessageBuilder<Message> messageBuilder) : base(serializer, queueStrategy, endpointRouter, endpoint, threadCount, transactional, messageBuilder) { TimeoutForHeartBeatFromPrimary = TimeSpan.FromSeconds(10); this.primaryLoadBalancer = primaryLoadBalancer; tookOverWork = false; }
public MsmqTransport(IMessageSerializer serializer, IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMsmqTransportAction[] transportActions, IEndpointRouter endpointRouter, IsolationLevel queueIsolationLevel, TransactionalOptions transactional, bool consumeInTransaction, IMessageBuilder<Message> messageBuilder) : base(queueStrategy, endpoint, threadCount, serializer, endpointRouter, transactional, messageBuilder) { this.transportActions = transportActions; this.queueIsolationLevel = queueIsolationLevel; this.consumeInTransaction = consumeInTransaction; }
internal static void ContructAddMessage(this Binding binding, IMessageBuilder builder) { var bindingInformation = binding.ToBindingInformation(); builder .WriteLine("Adding Binding") .IncreaseIndent() .WriteLine("Protocol: {0}", binding.Protocol) .WriteLine("Port: {0}", bindingInformation.Port) .WriteLine("IP: {0}", bindingInformation.IpAddress) .WriteLine("Host Name: {0}", bindingInformation.HostName); if (binding.Protocol.Equals("https", StringComparison.InvariantCultureIgnoreCase)) { builder.WriteLine("Certificate Thumbprint: {0}", binding.GetCertificateThumbprint()); } }