public void Receive(byte[] data, IHeaders headers, IMessageCallback callback) { var envelope = new Envelope(data, headers, callback); Received.Add(envelope); envelope.Callback.MarkSuccessful(); }
private static void AddGeneralProperties(IHeaders props, XmlElement item) { string prop; var ownerDocument = item.OwnerDocument; if (ownerDocument == null) { throw new ArgumentNullException(nameof(item)); } if (props.TryGetValue("DateO", out prop)) { var e = ownerDocument.CreateElement("dc", "date", NS_DC); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Genre", out prop)) { var e = ownerDocument.CreateElement("upnp", "genre", NS_UPNP); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Description", out prop)) { var e = ownerDocument.CreateElement("dc", "description", NS_DC); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Artist", out prop)) { var e = ownerDocument.CreateElement("upnp", "artist", NS_UPNP); e.SetAttribute("role", "AlbumArtist"); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Performer", out prop)) { var e = ownerDocument.CreateElement("upnp", "artist", NS_UPNP); e.SetAttribute("role", "Performer"); e.InnerText = prop; item.AppendChild(e); e = ownerDocument.CreateElement("dc", "creator", NS_DC); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Album", out prop)) { var e = ownerDocument.CreateElement("upnp", "album", NS_UPNP); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Track", out prop)) { var e = ownerDocument.CreateElement( "upnp", "originalTrackNumber", NS_UPNP); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Creator", out prop)) { var e = ownerDocument.CreateElement("dc", "creator", NS_DC); e.InnerText = prop; item.AppendChild(e); } if (props.TryGetValue("Director", out prop)) { var e = ownerDocument.CreateElement("upnp", "director", NS_UPNP); e.InnerText = prop; item.AppendChild(e); } }
public void Send(byte[] data, IHeaders headers) { var payload = new MessagePayload {Data = data, Headers = headers.ToNameValues()}; var scope = _queueManager.BeginTransactionalScope(); scope.Send(Address, payload); scope.Commit(); }
/// <summary> /// Initializes a new instance of the <see cref="QueueProducerConfiguration" /> class. /// </summary> /// <param name="transportConfiguration">The transport configuration.</param> /// <param name="headers">The headers.</param> /// <param name="additionalConfiguration">The additional configuration.</param> /// <param name="timeConfiguration">The time configuration.</param> public QueueProducerConfiguration(TransportConfigurationSend transportConfiguration, IHeaders headers, IConfiguration additionalConfiguration, BaseTimeConfiguration timeConfiguration) : base(transportConfiguration, headers, additionalConfiguration, timeConfiguration) { }
/// <summary> /// Initializes a new instance of the <see cref="RedisHeaders" /> class. /// </summary> /// <param name="messageContextDataFactory">The message context data factory.</param> /// <param name="headers">The headers.</param> public RedisHeaders(IMessageContextDataFactory messageContextDataFactory, IHeaders headers) { Guard.NotNull(() => messageContextDataFactory, messageContextDataFactory); Guard.NotNull(() => headers, headers); Headers = headers; IncreaseQueueDelay = messageContextDataFactory.Create("IncreaseQueueDelay", new RedisQueueDelay(TimeSpan.Zero)); CorelationId = messageContextDataFactory.Create<RedisQueueCorrelationIdSerialized>("CorelationId", null); }
// TODO -- do routing slip tracking later public Envelope(IHeaders headers) { Headers = headers; if (CorrelationId.IsEmpty()) { CorrelationId = Guid.NewGuid().ToString(); } }
internal static SQLiteCommand CreateMetaDataRecord(TimeSpan? delay, TimeSpan expiration, SQLiteConnection connection, IMessage message, IAdditionalMessageData data, TableNameHelper tableNameHelper, IHeaders headers, SqLiteMessageQueueTransportOptions options, IGetTime getTime) { var command = new SQLiteCommand(connection); BuildMetaCommand(command, tableNameHelper, headers, data, message, 0, options, delay, expiration, getTime.GetCurrentUtcDate()); return command; }
/// <summary> /// Initializes a new instance of the <see cref="QueueRpcConfiguration" /> class. /// </summary> /// <param name="transportConfigurationReceive">The transport configuration receive.</param> /// <param name="transportConfigurationSend">The transport configuration send.</param> /// <param name="messageExpirationConfiguration">The message expiration configuration.</param> /// <param name="headers">The headers.</param> public QueueRpcConfiguration(TransportConfigurationReceive transportConfigurationReceive, TransportConfigurationSend transportConfigurationSend, IMessageExpirationConfiguration messageExpirationConfiguration, IHeaders headers) : base(transportConfigurationSend, transportConfigurationReceive, headers) { Guard.NotNull(() => messageExpirationConfiguration, messageExpirationConfiguration); MessageExpiration = messageExpirationConfiguration; }
public void Send(byte[] data, IHeaders headers) { var envelope = new EnvelopeToken { Data = data, Headers = headers }; _queue.Enqueue(envelope); }
public HttpRequestAuthParameters(IHeaders headers, IPEndPoint endPoint) { if (headers != null) { headers.TryGetValue("User-Agent", out _userAgent); } if (endPoint != null) { _address = endPoint.Address; _mac = IP.GetMAC(_address); } }
public bool Authorize(IHeaders headers, IPEndPoint endPoint, string mac) { var addr = endPoint?.Address; if (addr == null) { return false; } var rv = ips.ContainsKey(addr); DebugFormat(!rv ? "Rejecting {0}. Not in IP whitelist" : "Accepted {0} via IP whitelist", addr); return rv; }
public bool Authorize(IHeaders headers, IPEndPoint endPoint, string mac) { if (string.IsNullOrEmpty(mac)) { return false; } var rv = macs.ContainsKey(mac); DebugFormat(!rv ? "Rejecting {0}. Not in MAC whitelist" : "Accepted {0} via MAC whitelist", mac); return rv; }
/// <summary> /// Initializes a new instance of the <see cref="QueueConfigurationRpc" /> class. /// </summary> /// <param name="transportConfigurationSend">The transport configuration send.</param> /// <param name="transportConfigurationReceive">The transport configuration receive.</param> /// <param name="headerNames">The header names.</param> public QueueConfigurationRpc(TransportConfigurationSend transportConfigurationSend, TransportConfigurationReceive transportConfigurationReceive, IHeaders headerNames) { Guard.NotNull(() => transportConfigurationSend, transportConfigurationSend); Guard.NotNull(() => transportConfigurationReceive, transportConfigurationReceive); Guard.NotNull(() => headerNames, headerNames); TransportConfigurationSend = transportConfigurationSend; TransportConfigurationReceive = transportConfigurationReceive; HeaderNames = headerNames; }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessagesDecorator" /> class. /// </summary> /// <param name="metrics">The metrics factory.</param> /// <param name="headers">The headers.</param> /// <param name="getTime">The get time.</param> /// <param name="handler">The handler.</param> /// <param name="connectionInformation">The connection information.</param> public ReceiveMessagesDecorator(IMetrics metrics, IHeaders headers, IGetTimeFactory getTime, IReceiveMessages handler, IConnectionInformation connectionInformation) { var name = handler.GetType().Name; _meter = metrics.Meter($"{connectionInformation.QueueName}.{name}.ReceiveMessageMeter", Units.Items); _waitTimer = metrics.Timer($"{connectionInformation.QueueName}.{name}.WaitForDeQueueMeter", Units.None); _handler = handler; _getTime = getTime; _headers = headers; }
/// <summary> /// Initializes a new instance of the <see cref="QueueConfigurationSend" /> class. /// </summary> /// <param name="transportConfiguration">The transport configuration.</param> /// <param name="headerNames">The header names.</param> /// <param name="configuration">The configuration.</param> /// <param name="timeConfiguration">The time configuration.</param> public QueueConfigurationSend(TransportConfigurationSend transportConfiguration, IHeaders headerNames, IConfiguration configuration, BaseTimeConfiguration timeConfiguration) { Guard.NotNull(() => transportConfiguration, transportConfiguration); Guard.NotNull(() => headerNames, headerNames); Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => timeConfiguration, timeConfiguration); TransportConfiguration = transportConfiguration; HeaderNames = headerNames; AdditionalConfiguration = configuration; TimeConfiguration = timeConfiguration; }
public MessageDeQueue(IHeaders headers, IMessageFactory messageFactory, IReceivedMessageFactory receivedMessageFactory, ICompositeSerialization serialization) { Guard.NotNull(() => serialization, serialization); Guard.NotNull(() => headers, headers); Guard.NotNull(() => messageFactory, messageFactory); Guard.NotNull(() => receivedMessageFactory, receivedMessageFactory); _messageFactory = messageFactory; _headers = headers; _serialization = serialization; _receivedMessageFactory = receivedMessageFactory; }
public void Receive(byte[] data, IHeaders headers, IMessageCallback callback) { if (data == null) throw new ArgumentNullException("data"); if (headers == null) throw new ArgumentNullException("headers"); if (callback == null) throw new ArgumentNullException("callback"); var envelope = new Envelope(data, headers, callback) { ReceivedAt = _address }; envelope.ContentType = envelope.ContentType ?? _node.DefaultContentType ?? _graph.DefaultContentType; _pipeline.Receive(envelope); }
public bool Authorize(IHeaders headers, IPEndPoint ep, string mac) { if (string.IsNullOrEmpty(mac)) { return false; } var rv = macs.ContainsKey(mac); if (!rv) { DebugFormat("Rejecting {0}. Not in MAC whitelist", mac ?? "<UNKNOWN>"); } else { DebugFormat("Accepted {0} via MAC whitelist", mac); } return rv; }
public void Send(byte[] data, IHeaders headers) { var messagePayload = new MessagePayload { Data = data, Headers = headers.ToNameValues() }; var sendingScope = _queueManager.BeginTransactionalScope(); var id = sendingScope.Send(_address, messagePayload); // TODO -- do we grab this? //data.CorrelationId = id.MessageIdentifier; sendingScope.Commit(); }
public bool Authorize(IHeaders headers, IPEndPoint endPoint, string mac) { if (headers == null) { throw new ArgumentNullException(nameof(headers)); } string ua; if (!headers.TryGetValue("User-Agent", out ua)) { return false; } if (string.IsNullOrEmpty(ua)) { return false; } var rv = userAgents.ContainsKey(ua); DebugFormat(!rv ? "Rejecting {0}. Not in User-Agent whitelist" : "Accepted {0} via User-Agent whitelist", ua); return rv; }
public void Send(byte[] data, IHeaders headers) { var messagePayload = new MessagePayload { Data = data, Headers = headers.ToNameValues() }; //TODO Maybe expose something to modify transport specific payloads? messagePayload.TranslateHeaders(); var sendingScope = _queueManager.BeginTransactionalScope(); var id = sendingScope.Send(_address, messagePayload); // TODO -- do we grab this? //data.CorrelationId = id.MessageIdentifier; sendingScope.Commit(); }
/// <summary> /// Initializes a new instance of the <see cref="WorkerNotification" /> class. /// </summary> /// <param name="headerNames">The header names.</param> /// <param name="cancelWork">The cancel work.</param> /// <param name="configuration">The configuration.</param> /// <param name="log">The log.</param> /// <param name="metrics">The metrics factory.</param> public WorkerNotification(IHeaders headerNames, IQueueCancelWork cancelWork, TransportConfigurationReceive configuration, ILogFactory log, IMetrics metrics) { Guard.NotNull(() => headerNames, headerNames); Guard.NotNull(() => cancelWork, cancelWork); Guard.NotNull(() => configuration, configuration); Guard.NotNull(() => log, log); Guard.NotNull(() => metrics, metrics); HeaderNames = headerNames; WorkerStopping = cancelWork; TransportSupportsRollback = configuration.MessageRollbackSupported; Log = log.Create(); Metrics = metrics; }
public bool Authorize(IHeaders headers, IPEndPoint ep, string mac) { if (methods.Count == 0) { return true; } try { foreach (var m in methods) { if (m.Authorize(headers, ep, mac)) { return true; } } return false; } catch (Exception ex) { Error("Failed to authorize", ex); return false; } }
/// <summary> /// Initializes a new instance of the <see cref="QueueConsumerConfiguration" /> class. /// </summary> /// <param name="transportConfiguration">The transport configuration.</param> /// <param name="workerConfiguration">The worker configuration.</param> /// <param name="heartBeatConfiguration">The heart beat configuration.</param> /// <param name="messageExpirationConfiguration">The message expiration configuration.</param> /// <param name="headers">The headers.</param> /// <param name="additionalConfiguration">The additional configuration.</param> /// <param name="timeConfiguration">The time configuration.</param> public QueueConsumerConfiguration(TransportConfigurationReceive transportConfiguration, IWorkerConfiguration workerConfiguration, IHeartBeatConfiguration heartBeatConfiguration, IMessageExpirationConfiguration messageExpirationConfiguration, IHeaders headers, IConfiguration additionalConfiguration, BaseTimeConfiguration timeConfiguration) : base(transportConfiguration, headers, additionalConfiguration, timeConfiguration) { Guard.NotNull(() => workerConfiguration, workerConfiguration); Guard.NotNull(() => heartBeatConfiguration, heartBeatConfiguration); Guard.NotNull(() => messageExpirationConfiguration, messageExpirationConfiguration); Worker = workerConfiguration; HeartBeat = heartBeatConfiguration; MessageExpiration = messageExpirationConfiguration; _routes = new List<string>(); }
public bool Authorize(IHeaders headers, IPEndPoint ep, string mac) { if (ep == null) { return false; } var addr = ep.Address; if (addr == null) { return false; } var rv = ips.ContainsKey(addr); if (!rv) { DebugFormat("Rejecting {0}. Not in IP whitelist", addr); } else { DebugFormat("Accepted {0} via IP whitelist", addr); } return rv; }
internal static void BuildMetaCommand(NpgsqlCommand command, TableNameHelper tableNameHelper, IHeaders headers, IAdditionalMessageData data, IMessage message, long id, PostgreSqlMessageQueueTransportOptions options, TimeSpan? delay, TimeSpan expiration, DateTime currentDateTime) { var sbMeta = new StringBuilder(); sbMeta.AppendLine("Insert into " + tableNameHelper.MetaDataName); sbMeta.Append("(QueueID, CorrelationID, QueuedDateTime "); //add configurable columns - queue options.AddBuiltInColumns(sbMeta); AddHeaderColumns(sbMeta, message, headers); //close the column list sbMeta.AppendLine(") "); //add standard values that are always present sbMeta.Append("VALUES ("); sbMeta.Append("@QueueID, @CorrelationID, now() at time zone 'utc' "); //add the values for built in fields options.AddBuiltInColumnValues(delay, expiration, currentDateTime, sbMeta); AddHeaderValues(sbMeta, message, headers); sbMeta.Append(")"); //close the VALUES command.CommandText = sbMeta.ToString(); options.AddBuiltInColumnsParams(command, data); AddHeaderColumnParams(command, message, headers); command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint, 8).Value = id; command.Parameters.Add("@CorrelationID", NpgsqlDbType.Uuid, 16).Value = data.CorrelationId.Id.Value; }
/// <summary> /// Initializes a new instance of the <see cref="RedisQueueReceiveMessages" /> class. /// </summary> /// <param name="workSubFactory">The work sub factory.</param> /// <param name="receiveMessage">The receive message.</param> /// <param name="handleMessage">The handle message.</param> /// <param name="headers">The headers.</param> /// <param name="cancelWork">The cancel work.</param> /// <param name="receiveMessageAsync">The receive message asynchronous.</param> public RedisQueueReceiveMessages(IRedisQueueWorkSubFactory workSubFactory, IQueryHandler<ReceiveMessageQuery, RedisMessage> receiveMessage, HandleMessage handleMessage, IHeaders headers, IQueueCancelWork cancelWork, IQueryHandler<ReceiveMessageQueryAsync, Task<RedisMessage>> receiveMessageAsync) { Guard.NotNull(() => workSubFactory, workSubFactory); Guard.NotNull(() => receiveMessage, receiveMessage); Guard.NotNull(() => handleMessage, handleMessage); Guard.NotNull(() => headers, headers); Guard.NotNull(() => cancelWork, cancelWork); Guard.NotNull(() => receiveMessageAsync, receiveMessageAsync); _receiveMessage = receiveMessage; _handleMessage = handleMessage; _headers = headers; _cancelWork = cancelWork; _receiveMessageAsync = receiveMessageAsync; _workSubFactory = workSubFactory; }
public static TimeSpan GetExpiration(SendMessageCommand commandSend, IHeaders headers) { //there are three possible locations for a message expiration. The user data and the header / internal headers //grab it from the internal header var expiration = commandSend.MessageToSend.GetInternalHeader(headers.StandardHeaders.RpcTimeout).Timeout; //if the header value is zero, check the message expiration if (expiration == TimeSpan.Zero) { //try the message header expiration = commandSend.MessageToSend.GetHeader(headers.StandardHeaders.RpcTimeout).Timeout; } //if the header value is zero, check the message expiration if (expiration == TimeSpan.Zero && commandSend.MessageData.GetExpiration().HasValue) { // ReSharper disable once PossibleInvalidOperationException expiration = commandSend.MessageData.GetExpiration().Value; } return expiration; }
internal static SQLiteCommand GetMainCommand(SendMessageCommand commandSend, SQLiteConnection connection, SqLiteCommandStringCache commandCache, IHeaders headers, ICompositeSerialization serializer) { var command = connection.CreateCommand(); command.CommandText = commandCache.GetCommand(SqLiteCommandStringTypes.InsertMessageBody); var serialization = serializer.Serializer.MessageToBytes(new MessageBody { Body = commandSend.MessageToSend.Body }); command.Parameters.Add("@body", DbType.Binary, -1); command.Parameters["@body"].Value = serialization.Output; commandSend.MessageToSend.SetHeader(headers.StandardHeaders.MessageInterceptorGraph, serialization.Graph); command.Parameters.Add("@headers", DbType.Binary, -1); command.Parameters["@headers"].Value = serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers); return command; }
internal static void BuildStatusCommand(SQLiteCommand command, TableNameHelper tableNameHelper, IHeaders headers, IAdditionalMessageData data, IMessage message, long id, SqLiteMessageQueueTransportOptions options, DateTime currentDateTime) { var builder = new StringBuilder(); builder.AppendLine("Insert into " + tableNameHelper.StatusName); builder.Append("(QueueID, Status, CorrelationID "); //add configurable columns - user AddUserColumns(builder, data); //close the column list builder.AppendLine(") "); //add standard values that are always present builder.Append("VALUES ("); builder.Append($"@QueueID, {Convert.ToInt32(QueueStatuses.Waiting)}, @CorrelationID"); //add configurable column value - user AddUserColumnsValues(builder, data); builder.Append(")"); //close the VALUES command.CommandText = builder.ToString(); options.AddBuiltInColumnsParams(command, data, null, TimeSpan.Zero, currentDateTime); command.Parameters.Add("@QueueID", DbType.Int64, 8).Value = id; command.Parameters.Add("@CorrelationID", DbType.StringFixedLength, 38).Value = data.CorrelationId.Id.Value.ToString(); //add configurable column command params - user AddUserColumnsParams(command, data); AddHeaderColumnParams(command, message, headers); }
internal static void BuildStatusCommand(NpgsqlCommand command, TableNameHelper tableNameHelper, IHeaders headers, IAdditionalMessageData data, IMessage message, long id, PostgreSqlMessageQueueTransportOptions options) { var builder = new StringBuilder(); builder.AppendLine("Insert into " + tableNameHelper.StatusName); builder.Append("(QueueID, Status, CorrelationID "); //add configurable columns - user AddUserColumns(builder, data); //close the column list builder.AppendLine(") "); //add standard values that are always present builder.Append("VALUES ("); builder.Append($"@QueueID, {Convert.ToInt32(QueueStatuses.Waiting)}, @CorrelationID"); //add configurable column value - user AddUserColumnsValues(builder, data); builder.Append(")"); //close the VALUES command.CommandText = builder.ToString(); options.AddBuiltInColumnsParams(command, data); command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint, 8).Value = id; command.Parameters.Add("@CorrelationID", NpgsqlDbType.Uuid, 16).Value = data.CorrelationId.Id.Value; //add configurable column command params - user AddUserColumnsParams(command, data); }
/// <summary> /// Loads html page by http get request /// </summary> /// <param name="uri">URL of page for loading</param> /// <param name="headers">Http headers</param> /// <returns>AngleSharp.IDocument</returns> public virtual async Task <IDocument> LoadPage(Uri uri, IHeaders headers) { if (uri == null) { throw new ArgumentNullException(nameof(uri)); } if (headers == null) { throw new ArgumentNullException(nameof(headers)); } var requester = new HttpRequester(); requester.Headers["User-Agent"] = headers.UserAgent; requester.Headers["Accept"] = headers.Accept; var config = Configuration.Default .WithDefaultLoader(requesters: new IRequester[] { requester }) .WithJavaScript() .WithCss(); return(await BrowsingContext.New(config).OpenAsync(uri.ToString())); }
internal static void BuildMetaCommand(SqlCommand command, ITableNameHelper tableNameHelper, IHeaders headers, IAdditionalMessageData data, IMessage message, long id, SqlServerMessageQueueTransportOptions options, TimeSpan?delay, TimeSpan expiration) { var sbMeta = new StringBuilder(); sbMeta.AppendLine("Insert into " + tableNameHelper.MetaDataName); sbMeta.Append("(QueueID, CorrelationID, QueuedDateTime "); //add configurable columns - queue options.AddBuiltInColumns(sbMeta); //close the column list sbMeta.AppendLine(") "); //add standard values that are always present sbMeta.Append("VALUES ("); sbMeta.Append("@QueueID, @CorrelationID, GetUTCDate() "); //add the values for built in fields options.AddBuiltInColumnValues(delay, expiration, sbMeta); sbMeta.Append(")"); //close the VALUES command.CommandText = sbMeta.ToString(); options.AddBuiltInColumnsParams(command, data); command.Parameters.Add("@QueueID", SqlDbType.BigInt, 8).Value = id; command.Parameters.Add("@CorrelationID", SqlDbType.UniqueIdentifier, 16).Value = data.CorrelationId.Id.Value; }
/// <summary> /// Initializes a new instance of the <see cref="SendMessageCommandHandler" /> class. /// </summary> /// <param name="tableNameHelper">The table name helper.</param> /// <param name="serializer">The serializer.</param> /// <param name="optionsFactory">The options factory.</param> /// <param name="headers">The headers.</param> /// <param name="commandCache">The command cache.</param> /// <param name="configurationSend">The configuration send.</param> /// <param name="getTimeFactory">The get time factory.</param> /// <param name="dbFactory">The database factory.</param> /// <param name="sendJobStatus">The send job status.</param> /// <param name="jobExistsHandler">The job exists handler.</param> /// <param name="jobSchedulerMetaData">The job scheduler meta data.</param> /// <param name="databaseExists">The database exists.</param> public SendMessageCommandHandler(TableNameHelper tableNameHelper, ICompositeSerialization serializer, ISqLiteMessageQueueTransportOptionsFactory optionsFactory, IHeaders headers, IDbCommandStringCache commandCache, TransportConfigurationSend configurationSend, IGetTimeFactory getTimeFactory, IDbFactory dbFactory, ICommandHandler <SetJobLastKnownEventCommand <IDbConnection, IDbTransaction> > sendJobStatus, RelationalDatabase.IQueryHandler <DoesJobExistQuery <IDbConnection, IDbTransaction>, QueueStatuses> jobExistsHandler, IJobSchedulerMetaData jobSchedulerMetaData, DatabaseExists databaseExists) { Guard.NotNull(() => tableNameHelper, tableNameHelper); Guard.NotNull(() => serializer, serializer); Guard.NotNull(() => optionsFactory, optionsFactory); Guard.NotNull(() => headers, headers); Guard.NotNull(() => commandCache, commandCache); Guard.NotNull(() => configurationSend, configurationSend); Guard.NotNull(() => getTimeFactory, getTimeFactory); Guard.NotNull(() => sendJobStatus, sendJobStatus); Guard.NotNull(() => jobExistsHandler, jobExistsHandler); Guard.NotNull(() => databaseExists, databaseExists); Guard.NotNull(() => dbFactory, dbFactory); _tableNameHelper = tableNameHelper; _serializer = serializer; _options = new Lazy <SqLiteMessageQueueTransportOptions>(optionsFactory.Create); _headers = headers; _commandCache = commandCache; _configurationSend = configurationSend; _getTime = getTimeFactory.Create(); _dbFactory = dbFactory; _sendJobStatus = sendJobStatus; _jobExistsHandler = jobExistsHandler; _jobSchedulerMetaData = jobSchedulerMetaData; _databaseExists = databaseExists; }
public bool Authorize(IHeaders headers, IPEndPoint endPoint, string mac) { if (endPoint == null) { return(false); } var addr = endPoint.Address; if (addr == null) { return(false); } var rv = ips.ContainsKey(addr); if (!rv) { DebugFormat("Rejecting {0}. Not in IP whitelist", addr); } else { DebugFormat("Accepted {0} via IP whitelist", addr); } return(rv); }
public void Receive(byte[] data, IHeaders headers, IMessageCallback callback) { if (data == null) { throw new ArgumentNullException("data"); } if (headers == null) { throw new ArgumentNullException("headers"); } if (callback == null) { throw new ArgumentNullException("callback"); } var envelope = new Envelope(data, headers, callback) { ReceivedAt = _address }; envelope.ContentType = envelope.ContentType ?? _node.DefaultContentType ?? _graph.DefaultContentType; _pipeline.Receive(envelope); }
internal override IDictionary <string, string> GetSignature(HttpRequest request, HttpContext context, IHeaders iheaders) { CommonUtil.AddHeader(request, iheaders.ContentSha256Header(), ContentSha256); IDictionary <string, string> tempDict = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in request.Headers) { if (string.IsNullOrEmpty(entry.Key)) { continue; } tempDict.Add(entry.Key.Trim().ToLower(), entry.Value); } List <string> signedHeadersList = V4Signer.GetSignedHeaderList(tempDict); string signedHeaders = V4Signer.GetSignedHeaders(signedHeadersList); IDictionary <string, string> dateDict = V4Signer.GetLongDateAndShortDate(request, iheaders); string signature = GetTemporarySignature(request, context, iheaders, dateDict, signedHeaders, tempDict, signedHeadersList, ContentSha256); IDictionary <string, string> ret = new Dictionary <string, string>(); ret.Add("Signature", signature); ret.Add("ShortDate", dateDict["ShortDate"]); ret.Add("SignedHeaders", signedHeaders); return(ret); }
private IEnumerable <KeyValuePair <string, string> > HandleBrowse( IRequest request, IHeaders sparams) { var key = Prefix + sparams.HeaderBlock; AttributeCollection rv; if (soapCache.TryGetValue(key, out rv)) { return(rv); } var id = sparams["ObjectID"]; var flag = sparams["BrowseFlag"]; var requested = 20; var provided = 0; var start = 0; try { if (int.TryParse(sparams["RequestedCount"], out requested) && requested <= 0) { requested = 20; } if (int.TryParse(sparams["StartingIndex"], out start) && start <= 0) { start = 0; } } catch (Exception ex) { Debug("Not all params provided", ex); } var root = GetItem(id) as IMediaFolder; if (root == null) { throw new ArgumentException("Invalid id"); } var result = new XmlDocument(); var didl = result.CreateElement(string.Empty, "DIDL-Lite", NS_DIDL); didl.SetAttribute("xmlns:dc", NS_DC); didl.SetAttribute("xmlns:dlna", NS_DLNA); didl.SetAttribute("xmlns:upnp", NS_UPNP); didl.SetAttribute("xmlns:sec", NS_SEC); result.AppendChild(didl); if (flag == "BrowseMetadata") { Browse_AddFolder(result, root); provided++; } else { provided = BrowseFolder_AddItems( request, result, root, start, requested); } var resXML = result.OuterXml; rv = new AttributeCollection { { "Result", resXML }, { "NumberReturned", provided.ToString() }, { "TotalMatches", root.ChildCount.ToString() }, { "UpdateID", systemID.ToString() } }; soapCache[key] = rv; return(rv); }
public IHeaders <TKey, TValue> Add(IHeaders <TKey, TValue> headers) { throw ReadOnlyException; }
private CreateTemporarySignatureResponse CreateTemporarySignature(HttpRequest httpRequest, long expires, IHeaders iheaders) { DateTime dt1970 = new DateTime(1970, 1, 1, 0, 0, 0, 0); string expiresValue = ((DateTime.UtcNow.Ticks - dt1970.Ticks) / 10000000 + expires).ToString(); httpRequest.Headers[Constants.CommonHeaders.Date] = expiresValue; HttpContext context = new HttpContext(this.sp, this.ObsConfig); IDictionary <string, string> SinerReturn = this.httpClient.GetSigner(new HttpContext(this.sp, this.ObsConfig)).GetSignature(httpRequest, context, iheaders); string signature = CommonUtil.UrlEncode(SinerReturn["Signature"]); CreateTemporarySignatureResponse response = new CreateTemporarySignatureResponse(); response.SignUrl = this.ObsConfig.Endpoint.StartsWith("https", StringComparison.OrdinalIgnoreCase) ? "https://" : "http://"; response.SignUrl += httpRequest.GetHost(this.ObsConfig.Endpoint); if (this.ObsConfig.PathStyle && !string.IsNullOrEmpty(httpRequest.BucketName)) { response.SignUrl += "/" + CommonUtil.UrlEncode(httpRequest.BucketName); } if (!string.IsNullOrEmpty(httpRequest.ObjectKey)) { response.SignUrl += "/" + CommonUtil.UrlEncode(httpRequest.ObjectKey, null, "/"); } string accessKeyIdPrefix = this.ObsConfig.AuthType == AuthTypeEnum.OBS ? "AccessKeyId=" : "AWSAccessKeyId="; response.SignUrl += "?" + accessKeyIdPrefix + this.sp.Ak + "&Expires=" + expiresValue; foreach (KeyValuePair <string, string> entry in httpRequest.Params) { response.SignUrl += "&"; response.SignUrl += CommonUtil.UrlEncode(entry.Key); response.SignUrl += "="; response.SignUrl += CommonUtil.UrlEncode(entry.Value); } response.SignUrl += "&Signature=" + signature; foreach (KeyValuePair <string, string> entry in httpRequest.Headers) { if (!entry.Key.Equals(Constants.CommonHeaders.Date)) { response.ActualSignedRequestHeaders.Add(entry.Key, entry.Value); } } return(response); }
public ContentHeader(IHeaders headers) { this.headers = headers; }
public new static IConvertor GetInstance(IHeaders iheaders) { return(new ObsConvertor(iheaders)); }
internal override IDictionary <string, string> GetSignature(HttpRequest request, HttpContext context, IHeaders iheaders) { StringBuilder stringToSign = new StringBuilder(); stringToSign.Append(request.Method.ToString()).Append("\n"); string dateHeader = Constants.CommonHeaders.Date.ToLower(); string contentTypeHeader = Constants.CommonHeaders.ContentType.ToLower(); string contentMd5Header = Constants.CommonHeaders.ContentMd5.ToLower(); string headerPrefix = iheaders.HeaderPrefix(); string headerMetaPrefix = iheaders.HeaderMetaPrefix(); IDictionary <string, string> tempDict = new Dictionary <string, string>(); if (request.Headers.Count > 0) { foreach (KeyValuePair <string, string> entry in request.Headers) { if (string.IsNullOrEmpty(entry.Key)) { continue; } string key = entry.Key.Trim().ToLower(); if (key.StartsWith(headerPrefix) || key.Equals(contentTypeHeader) || key.Equals(contentMd5Header)) { tempDict.Add(key, entry.Value); } } } if (request.Headers.ContainsKey(dateHeader)) { tempDict.Add(dateHeader, request.Headers[dateHeader]); } else { tempDict.Add(dateHeader, ""); } if (!tempDict.ContainsKey(contentMd5Header)) { tempDict.Add(contentMd5Header, ""); } if (!tempDict.ContainsKey(contentTypeHeader)) { tempDict.Add(contentTypeHeader, ""); } List <KeyValuePair <string, string> > kvlist = new List <KeyValuePair <string, string> >(tempDict); tempDict.Clear(); kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y) { return(string.Compare(x.Key, y.Key, StringComparison.Ordinal)); }); foreach (KeyValuePair <string, string> kv in kvlist) { if (kv.Key.StartsWith(headerMetaPrefix)) { stringToSign.Append(kv.Key).Append(":").Append(kv.Value.Trim()); } else if (kv.Key.StartsWith(headerPrefix)) { stringToSign.Append(kv.Key).Append(":").Append(kv.Value); } else { stringToSign.Append(kv.Value); } stringToSign.Append("\n"); } kvlist.Clear(); stringToSign.Append("/"); if (!string.IsNullOrEmpty(request.BucketName)) { stringToSign.Append(CommonUtil.UrlEncode(request.BucketName)); if (!request.PathStyle) { stringToSign.Append("/"); } if (!string.IsNullOrEmpty(request.ObjectKey)) { if (request.PathStyle) { stringToSign.Append("/"); } stringToSign.Append(CommonUtil.UrlEncode(request.ObjectKey, null, "/")); } } if (request.Params.Count > 0) { foreach (KeyValuePair <string, string> entry in request.Params) { if (string.IsNullOrEmpty(entry.Key)) { continue; } if (Constants.AllowedResourceParameters.Contains(entry.Key.ToLower()) || entry.Key.ToLower().StartsWith(iheaders.HeaderPrefix())) { tempDict.Add(entry.Key, entry.Value); } } } kvlist = new List <KeyValuePair <string, string> >(tempDict); tempDict.Clear(); kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y) { return(string.Compare(x.Key, y.Key, StringComparison.Ordinal)); }); if (kvlist.Count > 0) { bool isFirst = true; foreach (KeyValuePair <string, string> kv in kvlist) { if (isFirst) { stringToSign.Append("?"); isFirst = false; } else { stringToSign.Append("&"); } stringToSign.Append(kv.Key); if (kv.Value != null) { stringToSign.Append("=").Append(kv.Value); } } } if (LoggerMgr.IsDebugEnabled) { LoggerMgr.Debug("StringToSign: ******"); } IDictionary <string, string> ret = new Dictionary <string, string>(); ret.Add("Signature", Convert.ToBase64String(CommonUtil.HmacSha1(context.SecurityProvider.Sk, stringToSign.ToString()))); return(ret); }
public void Send(byte[] data, IHeaders headers) { _queueManager.Send(data, headers, Address); }
/// <summary> /// Initializes a new instance of the <see cref="SendMessageCommandHandlerAsyncDecorator"/> class. /// </summary> /// <param name="handler">The handler.</param> /// <param name="tracer">The tracer.</param> /// <param name="headers">The headers.</param> /// <param name="connectionInformation">The connection information.</param> public SendMessageCommandHandlerAsyncDecorator(ICommandHandlerWithOutputAsync <SendMessageCommand, int> handler, ActivitySource tracer, IHeaders headers, IConnectionInformation connectionInformation) { _handler = handler; _tracer = tracer; _headers = headers; _connectionInformation = connectionInformation; }
public static void ParseObsWebServiceResponse(HttpResponse httpResponse, ObsWebServiceResponse response, IHeaders iheaders) { response.StatusCode = httpResponse.StatusCode; if (httpResponse.Headers.ContainsKey(iheaders.RequestIdHeader())) { response.RequestId = httpResponse.Headers[iheaders.RequestIdHeader()]; } if (httpResponse.Headers.ContainsKey(Constants.CommonHeaders.ContentLength)) { response.ContentLength = Convert.ToInt64(httpResponse.Headers[Constants.CommonHeaders.ContentLength]); } foreach (KeyValuePair <string, string> header in httpResponse.Headers) { string key = header.Key; if (key.StartsWith(iheaders.HeaderMetaPrefix())) { key = key.Substring(iheaders.HeaderMetaPrefix().Length); } else if (key.StartsWith(iheaders.HeaderPrefix())) { key = key.Substring(iheaders.HeaderPrefix().Length); } else if (key.StartsWith(Constants.ObsHeaderMetaPrefix)) { key = key.Substring(Constants.ObsHeaderMetaPrefix.Length); } else if (key.StartsWith(Constants.ObsHeaderPrefix)) { key = key.Substring(Constants.ObsHeaderPrefix.Length); } response.Headers.Add(key, header.Value); } }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> public HeadersDictionary(IHeaders headers) { this.headers = headers; }
/// <summary> /// Initializes a new instance of the <see cref="AddStandardMessageHeaders"/> class. /// </summary> /// <param name="headers">The headers.</param> /// <param name="getFirstMessageDeliveryTime">The get first message delivery time.</param> public AddStandardMessageHeaders(IHeaders headers, IGetFirstMessageDeliveryTime getFirstMessageDeliveryTime) { _headers = headers; _getFirstMessageDeliveryTime = getFirstMessageDeliveryTime; }
/// <summary> /// Initializes a new instance of the <see cref="MessageHandlerAsyncDecorator"/> class. /// </summary> /// <param name="handler">The handler.</param> /// <param name="tracer">The tracer.</param> /// <param name="headers">The headers.</param> public MessageHandlerAsyncDecorator(IMessageHandlerAsync handler, ITracer tracer, IHeaders headers) { _handler = handler; _tracer = tracer; _headers = headers; }
protected ObsConvertor(IHeaders iheaders) : base(iheaders) { }
private CreateTemporarySignatureResponse CreateV4TemporarySignature(HttpRequest httpRequest, long expires, IHeaders iheaders) { IDictionary <string, string> dateDict = V4Signer.GetLongDateAndShortDate(httpRequest, iheaders); string host = httpRequest.GetHost(this.ObsConfig.Endpoint); CommonUtil.AddHeader(httpRequest, Constants.CommonHeaders.Host, host); IDictionary <string, string> tempDict = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in httpRequest.Headers) { if (string.IsNullOrEmpty(entry.Key)) { continue; } tempDict.Add(entry.Key.Trim().ToLower(), entry.Value); } List <string> signedHeadersList = V4Signer.GetSignedHeaderList(tempDict); string signedHeaders = V4Signer.GetSignedHeaders(signedHeadersList); CommonUtil.AddParam(httpRequest, "X-Amz-Algorithm", V4Signer.Algorithm); CommonUtil.AddParam(httpRequest, "X-Amz-Credential", this.sp.Ak + "/" + dateDict["ShortDate"] + V4Signer.ScopeSuffix); CommonUtil.AddParam(httpRequest, "X-Amz-Date", dateDict["LongDate"]); CommonUtil.AddParam(httpRequest, "X-Amz-Expires", expires.ToString()); CommonUtil.AddParam(httpRequest, "X-Amz-SignedHeaders", signedHeaders); HttpContext context = new HttpContext(this.sp, this.ObsConfig); string signature = CommonUtil.UrlEncode(V4Signer.GetTemporarySignature(httpRequest, context, iheaders, dateDict, signedHeaders, tempDict, signedHeadersList, null)); CreateTemporarySignatureResponse response = new CreateTemporarySignatureResponse(); response.SignUrl = this.ObsConfig.Endpoint.StartsWith("https", StringComparison.OrdinalIgnoreCase) ? "https://" : "http://"; response.SignUrl += host; if (this.ObsConfig.PathStyle && !string.IsNullOrEmpty(httpRequest.BucketName)) { response.SignUrl += "/" + CommonUtil.UrlEncode(httpRequest.BucketName); } if (!string.IsNullOrEmpty(httpRequest.ObjectKey)) { response.SignUrl += "/" + CommonUtil.UrlEncode(httpRequest.ObjectKey, null, "/"); } bool isFirst = true; foreach (KeyValuePair <string, string> entry in httpRequest.Params) { if (isFirst) { response.SignUrl += "?"; isFirst = false; } else { response.SignUrl += "&"; } response.SignUrl += CommonUtil.UrlEncode(entry.Key); response.SignUrl += "="; response.SignUrl += CommonUtil.UrlEncode(entry.Value); } if (!string.IsNullOrEmpty(this.sp.Token)) { response.SignUrl += "&" + iheaders.SecurityTokenHeader() + "=" + this.sp.Token; } response.SignUrl += "&X-Amz-Signature=" + signature; foreach (KeyValuePair <string, string> entry in httpRequest.Headers) { if (!entry.Key.Equals(Constants.CommonHeaders.Date)) { response.ActualSignedRequestHeaders.Add(entry.Key, entry.Value); } } return(response); }
public Envelope(byte[] data, IHeaders headers, IMessageCallback callback) : this(headers) { Data = data; Callback = callback; }
public void Send(byte[] data, IHeaders headers) { }
internal static IDictionary <string, string> GetLongDateAndShortDate(HttpRequest request, IHeaders iheaders) { string longDate; if (request.Headers.ContainsKey(iheaders.DateHeader())) { longDate = request.Headers[iheaders.DateHeader()]; } else if (request.Headers.ContainsKey(Constants.CommonHeaders.Date)) { longDate = DateTime.ParseExact(request.Headers[Constants.CommonHeaders.Date], Constants.RFC822DateFormat, Constants.CultureInfo) .ToString(Constants.LongDateFormat, Constants.CultureInfo); } else { longDate = DateTime.UtcNow.ToString(Constants.LongDateFormat, Constants.CultureInfo); } string shortDate = longDate.Substring(0, longDate.IndexOf("T")); IDictionary <string, string> tempDict = new Dictionary <string, string>(); tempDict.Add("LongDate", longDate); tempDict.Add("ShortDate", shortDate); return(tempDict); }
public new static IParser GetInstance(IHeaders iheaders) { return(new ObsParser(iheaders)); }
/// <summary> /// Generate parameters for a temporary authentication request. /// </summary> /// <param name="request">Request parameters</param> /// <returns>Response</returns> public CreateTemporarySignatureResponse CreateTemporarySignature(CreateTemporarySignatureRequest request) { HttpRequest httpRequest = new HttpRequest(); httpRequest.PathStyle = this.ObsConfig.PathStyle; httpRequest.BucketName = request.BucketName; httpRequest.ObjectKey = request.ObjectKey; httpRequest.Method = request.Method; IHeaders iheaders = this.httpClient.GetIHeaders(new HttpContext(this.sp, this.ObsConfig)); if (!string.IsNullOrEmpty(this.sp.Token) && !request.Parameters.ContainsKey(iheaders.SecurityTokenHeader())) { request.Parameters.Add(iheaders.SecurityTokenHeader(), this.sp.Token.Trim()); } foreach (KeyValuePair <string, string> entry in request.Headers) { CommonUtil.AddHeader(httpRequest, entry.Key, entry.Value); } foreach (KeyValuePair <string, string> entry in request.Parameters) { CommonUtil.AddParam(httpRequest, entry.Key, entry.Value); } if (request.SubResource.HasValue) { SubResourceEnum value = request.SubResource.Value; if (value == SubResourceEnum.StoragePolicy && this.ObsConfig.AuthType == AuthTypeEnum.OBS) { value = SubResourceEnum.StorageClass; } else if (value == SubResourceEnum.StorageClass && this.ObsConfig.AuthType != AuthTypeEnum.OBS) { value = SubResourceEnum.StoragePolicy; } CommonUtil.AddParam(httpRequest, EnumAdaptor.GetStringValue(value), null); } foreach (KeyValuePair <string, string> entry in request.Metadata.KeyValuePairs) { if (string.IsNullOrEmpty(entry.Key)) { continue; } string _key = entry.Key; if (!entry.Key.StartsWith(iheaders.HeaderMetaPrefix(), StringComparison.OrdinalIgnoreCase) && !entry.Key.StartsWith(Constants.ObsHeaderMetaPrefix, StringComparison.OrdinalIgnoreCase)) { _key = iheaders.HeaderMetaPrefix() + _key; } CommonUtil.AddHeader(httpRequest, _key, entry.Value); } long expires = 300; if (request.Expires.HasValue && request.Expires.Value > 0) { expires = request.Expires.Value; } return(this.ObsConfig.AuthType == AuthTypeEnum.V4 ? this.CreateV4TemporarySignature(httpRequest, expires, iheaders) : this.CreateTemporarySignature(httpRequest, expires, iheaders)); }
internal static string GetTemporarySignature(HttpRequest request, HttpContext context, IHeaders iheaders, IDictionary <string, string> dateDict, string signedHeaders, IDictionary <string, string> headerDict, List <string> signedHeaderList, string payload) { StringBuilder canonicalRequest = new StringBuilder(); canonicalRequest.Append(request.Method).Append("\n"); // Canonical URI canonicalRequest.Append("/"); if (!string.IsNullOrEmpty(request.BucketName)) { if (request.PathStyle) { canonicalRequest.Append(CommonUtil.UrlEncode(request.BucketName)); } if (!string.IsNullOrEmpty(request.ObjectKey)) { if (request.PathStyle) { canonicalRequest.Append("/"); } canonicalRequest.Append(CommonUtil.UrlEncode(request.ObjectKey, null, "/")); } } canonicalRequest.Append("\n"); //CanonicalQueryString IDictionary <string, string> tempDict = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in request.Params) { if (string.IsNullOrEmpty(entry.Key)) { continue; } tempDict.Add(entry.Key, entry.Value); } List <KeyValuePair <string, string> > kvlist = new List <KeyValuePair <string, string> >(tempDict); tempDict.Clear(); kvlist.Sort(delegate(KeyValuePair <string, string> x, KeyValuePair <string, string> y) { return(string.Compare(x.Key, y.Key, StringComparison.Ordinal)); }); canonicalRequest.Append(CommonUtil.ConvertParamsToCanonicalQueryString(kvlist)); canonicalRequest.Append("\n"); if (headerDict == null) { // Canonical Headers headerDict = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in request.Headers) { if (string.IsNullOrEmpty(entry.Key)) { continue; } headerDict.Add(entry.Key.Trim().ToLower(), entry.Value); } } foreach (string key in signedHeaderList) { canonicalRequest.Append(key).Append(":").Append(headerDict[key]).Append("\n"); } canonicalRequest.Append("\n"); // SignedHeaders canonicalRequest.Append(signedHeaders); canonicalRequest.Append("\n"); // Hashed Payload canonicalRequest.Append(string.IsNullOrEmpty(payload)? UnsignedPayload : payload); if (LoggerMgr.IsDebugEnabled) { LoggerMgr.Debug("CanonicalRequest:" + canonicalRequest); } StringBuilder stringToSign = new StringBuilder(Algorithm).Append("\n") .Append(dateDict["LongDate"]).Append("\n") .Append(dateDict["ShortDate"]).Append(ScopeSuffix).Append("\n") .Append(CommonUtil.HexSha256(canonicalRequest.ToString())); if (LoggerMgr.IsDebugEnabled) { LoggerMgr.Debug("StringToSign:" + stringToSign.ToString()); } return(CaculateSignature(stringToSign.ToString(), dateDict["ShortDate"], context.SecurityProvider.Sk)); }
internal HttpAuthorizationEventArgs(IHeaders headers, IPEndPoint remoteEndpoint) { Headers = headers; RemoteEndpoint = remoteEndpoint; }
private ObsParser(IHeaders iheaders) : base(iheaders) { }