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 DefaultEmailingProcessor(
IMailSender sender,
IMessageBuilder messageBuilder)
{
_sender = sender;
_messageBuilder = messageBuilder;
}
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());
}
}
