private Task <TResp> SendRequest <TReq, TResp>(TReq request, CancellationToken token) where TResp : IResponse, new() where TReq : IRequest { request.Timestamp = DateTimeOffset.UtcNow; request.RequestId = Guid.NewGuid(); _logger.LogTrace("Handling {RequestType} with request id {RequestId}", typeof(TReq).Name, request.RequestId); S3Config config = _options.Value; Stream? requestStream = _marshaller.MarshalRequest(request, config); _validator.ValidateAndThrow(request); StringBuilder sb = StringBuilderPool.Shared.Rent(200); RequestHelper.AppendScheme(sb, config); int schemeLength = sb.Length; RequestHelper.AppendHost(sb, config, request); request.SetHeader(HttpHeaders.Host, sb.ToString(schemeLength, sb.Length - schemeLength)); request.SetHeader(AmzHeaders.XAmzDate, request.Timestamp, DateTimeFormat.Iso8601DateTime); if (requestStream != null) { foreach (IRequestStreamWrapper wrapper in _requestStreamWrappers) { if (wrapper.IsSupported(request)) { requestStream = wrapper.Wrap(requestStream, request); } } } if (!request.Headers.TryGetValue(AmzHeaders.XAmzContentSha256, out string contentHash)) { if (config.PayloadSignatureMode == SignatureMode.Unsigned) { contentHash = "UNSIGNED-PAYLOAD"; } else { contentHash = requestStream == null ? "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" : CryptoHelper.Sha256Hash(requestStream, true).HexEncode(); } request.SetHeader(AmzHeaders.XAmzContentSha256, contentHash); } _logger.LogDebug("ContentSha256 is {ContentSha256}", contentHash); //We add the authorization header here because we need ALL other headers to be present when we do _authBuilder.BuildAuthorization(request); RequestHelper.AppendUrl(sb, config, request); RequestHelper.AppendQueryParameters(sb, request); string url = sb.ToString(); StringBuilderPool.Shared.Return(sb); return(HandleResponse <TReq, TResp>(request, url, requestStream, token)); }
public void Setup() { { S3Config config = new S3Config(); config.Region = AwsRegion.EuWest1; config.Credentials = new StringAccessKey("keyidkeyidkeyidkeyid", "accesskeyacceskey123accesskeyacceskey123"); IOptions <S3Config> options = Options.Create(config); SigningKeyBuilder signingKeyBuilder = new SigningKeyBuilder(options, NullLogger <SigningKeyBuilder> .Instance); ScopeBuilder scopeBuilder = new ScopeBuilder(options); SignatureBuilder signatureBuilder = new SignatureBuilder(signingKeyBuilder, scopeBuilder, NullLogger <SignatureBuilder> .Instance, options); _builder = new HeaderAuthorizationBuilder(options, scopeBuilder, signatureBuilder, NullLogger <HeaderAuthorizationBuilder> .Instance); _request = new DummyRequest(); _request.SetHeader(AmzHeaders.XAmzContentSha256, "UNSIGNED-PAYLOAD"); } { _request2 = new HttpRequestMessage(System.Net.Http.HttpMethod.Get, "https://dummyurl"); _credentials = new ImmutableCredentials("keyidkeyidkeyidkeyid", "accesskeyacceskey123accesskeyacceskey123", null); // Add required headers _request2.AddHeader(HeaderKeys.XAmzDateHeader, DateTime.UtcNow.ToIso8601BasicDateTime()); // Add conditional headers _request2.AddHeaderIf(_credentials.UseToken, HeaderKeys.XAmzSecurityTokenHeader, _credentials.Token); _request2.AddHeaderIf(!_request2.Headers.Contains(HeaderKeys.HostHeader), HeaderKeys.HostHeader, _request2.RequestUri.Host); } }
public static void AppendHost <TReq>(StringBuilder sb, S3Config config, TReq request) where TReq : IRequest { string?bucketName = null; if (request is IHasBucketName bn) { bucketName = bn.BucketName; } Uri?endpoint = config.Endpoint; if (endpoint != null) { sb.Append(endpoint.Host); if (!endpoint.IsDefaultPort) { sb.Append(':').Append(endpoint.Port); } } else if (bucketName != null && config.NamingMode == NamingMode.VirtualHost) { sb.Append(bucketName).Append(".s3.").Append(ValueHelper.EnumToString(config.Region)).Append(".amazonaws.com"); } else { sb.Append("s3.").Append(ValueHelper.EnumToString(config.Region)).Append(".amazonaws.com"); } }
internal RootConfig() { Logging = new LoggingConfig(); DynamoDB = new DynamoDBConfig(); S3 = new S3Config(); EC2 = new EC2Config(); Proxy = new ProxyConfig(); EndpointDefinition = AWSConfigs._endpointDefinition; Region = AWSConfigs._awsRegion; ProfileName = AWSConfigs._awsProfileName; ProfilesLocation = AWSConfigs._awsAccountsLocation; #if !WIN_RT && !WINDOWS_PHONE //var root = AWSConfigs.GetSection<AWSSection>(_rootAwsSectionName); // Logging.Configure(root.Logging); // DynamoDB.Configure(root.DynamoDB); // S3.Configure(root.S3); // EC2.Configure(root.EC2); // Proxy.Configure(root.Proxy); // // EndpointDefinition = Choose(EndpointDefinition, root.EndpointDefinition); // Region = Choose(Region, root.Region); // ProfileName = Choose(ProfileName, root.ProfileName); // ProfilesLocation = Choose(ProfilesLocation, root.ProfilesLocation); #endif }
public S3Client(S3Config config, HttpMessageHandler messageHandler) { ServiceCollection services = new ServiceCollection(); services.AddSingleton(x => Options.Create(config)); IS3ClientBuilder builder = services.AddSimpleS3Core(); IHttpClientBuilder httpBuilder = builder.UseHttpClientFactory(); if (messageHandler != null) { httpBuilder.ConfigurePrimaryHttpMessageHandler(x => messageHandler); } httpBuilder.SetHandlerLifetime(TimeSpan.FromMinutes(5)); Random random = new Random(); // Policy is: // Retries: 3 // Timeout: 2^attempt seconds (2, 4, 8 seconds) + -100 to 100 ms jitter httpBuilder.AddTransientHttpErrorPolicy(p => p.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)) + TimeSpan.FromMilliseconds(random.Next(-100, 100)))); _provider = services.BuildServiceProvider(); _objectClient = _provider.GetRequiredService <IS3ObjectClient>(); _bucketClient = _provider.GetRequiredService <IS3BucketClient>(); _serviceClient = _provider.GetRequiredService <IS3ServiceClient>(); }
public ActionResult Index() { var config = new S3Config { // Unique Policy ID and duration Uuid = Guid.NewGuid(), ExpirationTime = TimeSpan.FromHours(1), // Authentication AccessKey = "YOUR_ACCESS_KEY", SecretAccessKey = "YOUR_SECRET_KEY", // Bucket name and key prefix (folder) Bucket = "YOUR_BUCKET", BucketUrl = "http://YOUR_BUCKET.s3.amazonaws.com/", KeyPrefix = "YOUR_UPLOAD_ROOT/", // See http://docs.aws.amazon.com/AmazonS3/latest/dev/ACLOverview.html#CannedACL Acl = "private", // Mime type prefix ContentTypePrefix = "image/", // Fully qualified URL of an "empty document" in the same origin // Required for IE < 10 SuccessUrl = "http://localhost:62629/home/success" }; ViewBag.Policy = Policy(config); ViewBag.PolicySignature = Sign(ViewBag.Policy, config.SecretAccessKey); ViewBag.S3Config = config; return(View()); }
public PatreonOauthTokenProvider(IOptions <PatreonConfig> config, S3ClientProvider <S3Config> s3ClientProvider, S3Config s3Config, ILogger <PatreonOauthTokenProvider> logger) { _s3Client = s3ClientProvider.S3Client; _s3Config = s3Config; _logger = logger; _config = config.Value; }
public string SignRequest <TReq>(TReq request, TimeSpan expiresIn) where TReq : IRequest { request.Timestamp = DateTimeOffset.UtcNow; request.RequestId = Guid.NewGuid(); _logger.LogTrace("Handling {RequestType} with request id {RequestId}", typeof(TReq).Name, request.RequestId); S3Config config = _options.Value; _marshaller.MarshalRequest(request, config); _validator.ValidateAndThrow(request); StringBuilder sb = StringBuilderPool.Shared.Rent(200); RequestHelper.AppendScheme(sb, config); int schemeLength = sb.Length; RequestHelper.AppendHost(sb, config, request); request.SetHeader(HttpHeaders.Host, sb.ToString(schemeLength, sb.Length - schemeLength)); string scope = _scopeBuilder.CreateScope("s3", request.Timestamp); request.SetQueryParameter(AmzParameters.XAmzAlgorithm, SigningConstants.AlgorithmTag); request.SetQueryParameter(AmzParameters.XAmzCredential, _options.Value.Credentials.KeyId + '/' + scope); request.SetQueryParameter(AmzParameters.XAmzDate, request.Timestamp.ToString(DateTimeFormats.Iso8601DateTime, DateTimeFormatInfo.InvariantInfo)); request.SetQueryParameter(AmzParameters.XAmzExpires, expiresIn.TotalSeconds.ToString(NumberFormatInfo.InvariantInfo)); request.SetQueryParameter(AmzParameters.XAmzSignedHeaders, string.Join(";", SigningConstants.FilterHeaders(request.Headers).Select(x => x.Key))); //Copy all headers to query parameters foreach (KeyValuePair <string, string> header in request.Headers) { if (header.Key == HttpHeaders.Host) { continue; } request.SetQueryParameter(header.Key, header.Value); } _authBuilder.BuildAuthorization(request); //Clear sensitive material from the request if (request is IContainSensitiveMaterial sensitive) { sensitive.ClearSensitiveMaterial(); } RequestHelper.AppendUrl(sb, config, request); RequestHelper.AppendQueryParameters(sb, request); string url = sb.ToString(); StringBuilderPool.Shared.Return(sb); return(url); }
public static (FakeHttpHandler handler, S3Client client) CreateFakeClient() { S3Config config = new S3Config(new StringAccessKey("ExampleKeyId00000000", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"), AwsRegion.USEast1); FakeHttpHandler fakeHandler = new FakeHttpHandler(); S3Client client = new S3Client(config, fakeHandler); return(fakeHandler, client); }
public static (FakeNetworkDriver driver, S3Client client) CreateFakeClient() { S3Config config = new S3Config(new StringAccessKey("ExampleKeyId00000000", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); FakeNetworkDriver fakeNetworkDriver = new FakeNetworkDriver(); S3Client client = new S3Client(Options.Create(config), fakeNetworkDriver, NullLoggerFactory.Instance); return(fakeNetworkDriver, client); }
public CanonicalRequestFileTests() { S3Config config = new S3Config(new StringAccessKey("KeyIdExampleExampleE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); IOptions <S3Config> options = Options.Create(config); ISigningKeyBuilder keyBuilder = new SigningKeyBuilder(options, NullLogger <SigningKeyBuilder> .Instance); _scopeBuilder = new ScopeBuilder(options); _sigBuilder = new SignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <SignatureBuilder> .Instance, options); }
public PreSignedUrlTests() { //See https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html S3Config config = new S3Config(new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); _options = Options.Create(config); SigningKeyBuilder keyBuilder = new SigningKeyBuilder(_options, NullLogger <SigningKeyBuilder> .Instance); _scopeBuilder = new ScopeBuilder(_options); _sigBuilder = new SignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <SignatureBuilder> .Instance, _options); }
public CanonicalRequestFileTests() { S3Config config = new S3Config(new StringAccessKey("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"), AwsRegion.USEast1); IOptions <S3Config> options = Options.Create(config); S3ConfigNullCredentialProvider nullCredsProvider = new S3ConfigNullCredentialProvider(options); ISigningKeyBuilder keyBuilder = new SigningKeyBuilder(options, nullCredsProvider, new NullLogger <SigningKeyBuilder>()); _scopeBuilder = new ScopeBuilder(options); _sigBuilder = new SignatureBuilder(keyBuilder, _scopeBuilder, new NullLogger <SignatureBuilder>()); }
public static S3Client Create() { //Public minio playground credentials StringAccessKey key = new StringAccessKey("Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"); //Minio expect the region to always be USEast1 S3Config config = new S3Config(key, AwsRegion.UsEast1); //We have to set the endpoint to point to the Minio Playground server config.Endpoint = new Uri("https://play.min.io:9000/"); return(new S3Client(config)); }
public static void AppendScheme(StringBuilder sb, S3Config config) { if (config.Endpoint == null) { sb.Append(config.UseTLS ? "https" : "http"); } else { sb.Append(config.Endpoint.Scheme); } sb.Append("://"); }
public ChunkedSignatureTests() { S3Config config = new S3Config(new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); _options = Options.Create(config); SigningKeyBuilder keyBuilder = new SigningKeyBuilder(_options, NullLogger <SigningKeyBuilder> .Instance); _scopeBuilder = new ScopeBuilder(_options); _sigBuilder = new SignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <SignatureBuilder> .Instance, _options); _chunkedSigBuilder = new ChunkedSignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <ChunkedSignatureBuilder> .Instance); _authHeaderBuilder = new AuthorizationHeaderBuilder(_options, _scopeBuilder, _sigBuilder, NullLogger <AuthorizationHeaderBuilder> .Instance); }
public IActionResult S3Signature() { S3Config config = new S3Config { Bucket = Environment.GetEnvironmentVariable("AWS_BUCKET"), Region = Environment.GetEnvironmentVariable("AWS_REGION"), KeyStart = Environment.GetEnvironmentVariable("AWS_KEY_START"), Acl = Environment.GetEnvironmentVariable("AWS_ACL"), AccessKey = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY"), SecretKey = Environment.GetEnvironmentVariable("AWS_SECRET_KEY") }; return(Json(FroalaEditor.S3.GetHash(config))); }
public static string BuildFullUrl <TReq>(S3Config config, TReq request) where TReq : IRequest { StringBuilder sb = StringBuilderPool.Shared.Rent(200); AppendScheme(sb, config); AppendHost(sb, config, request); AppendUrl(sb, config, request); AppendQueryParameters(sb, request); string url = sb.ToString(); StringBuilderPool.Shared.Return(sb); return(url); }
public static void AppendUrl <TReq>(StringBuilder sb, S3Config config, TReq request) where TReq : IRequest { sb.Append('/'); if (config.NamingMode == NamingMode.PathStyle && request is IHasBucketName bn) { sb.Append(bn.BucketName).Append('/'); } if (request is IHasObjectKey ok) { sb.Append(UrlHelper.UrlPathEncode(ok.ObjectKey)); } }
public ChunkedSignatureTests() { S3Config config = new S3Config(new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); //The tests here have signatures built using path style config.NamingMode = NamingMode.PathStyle; _options = Options.Create(config); SigningKeyBuilder keyBuilder = new SigningKeyBuilder(_options, NullLogger <SigningKeyBuilder> .Instance); _scopeBuilder = new ScopeBuilder(_options); _sigBuilder = new SignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <SignatureBuilder> .Instance, _options); _chunkedSigBuilder = new ChunkedSignatureBuilder(keyBuilder, _scopeBuilder, NullLogger <ChunkedSignatureBuilder> .Instance); _authBuilder = new HeaderAuthorizationBuilder(_options, _scopeBuilder, _sigBuilder, NullLogger <HeaderAuthorizationBuilder> .Instance); }
private string Policy(S3Config config) { var policyJson = JsonConvert.SerializeObject(new { expiration = DateTime.UtcNow.Add(config.ExpirationTime).ToString("yyyy-MM-ddTHH:mm:ssZ"), conditions = new object[] { new { bucket = config.Bucket }, new [] { "starts-with", "$key", config.KeyPrefix }, new { acl = config.Acl }, new [] { "starts-with", "$success_action_redirect", "" }, new [] { "starts-with", "$Content-Type", config.ContentTypePrefix }, new Dictionary <string, string> { { "x-amz-meta-uuid", config.Uuid.ToString() } } } }); return(Convert.ToBase64String(Encoding.UTF8.GetBytes(policyJson))); }
private void ConfigureS3(S3Config config) { //Set the configuration from the config file _configRoot.Bind(config); StringAccessKey secret = new StringAccessKey(_configRoot[nameof(StringAccessKey.KeyId)], _configRoot[nameof(StringAccessKey.AccessKey)]); if (string.IsNullOrWhiteSpace(secret.KeyId)) { throw new Exception("Did you forget to set a KeyId? See Readme.txt on how to run live tests"); } if (secret.AccessKey == null) { throw new Exception("Did you forget to set a secret key? See Readme.txt on how to run live tests"); } config.Credentials = secret; }
public SignatureBenchmarks() { S3Config config = new S3Config(new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"), AwsRegion.UsEast1); config.PayloadSignatureMode = SignatureMode.FullSignature; IOptions <S3Config> options = Options.Create(config); _signingKeyBuilder = new SigningKeyBuilder(options, NullLogger <SigningKeyBuilder> .Instance); IScopeBuilder scopeBuilder = new ScopeBuilder(options); _signatureBuilder = new SignatureBuilder(_signingKeyBuilder, scopeBuilder, NullLogger <SignatureBuilder> .Instance, options); _chunkSigBuilder = new ChunkedSignatureBuilder(_signingKeyBuilder, scopeBuilder, NullLogger <ChunkedSignatureBuilder> .Instance); byte[] data = Encoding.UTF8.GetBytes("Hello world"); _req = new PutObjectRequest("examplebucket", "benchmark", new MemoryStream(data)); _req.SetHeader(AmzHeaders.XAmzContentSha256, CryptoHelper.Sha256Hash(data).HexEncode()); _date = DateTimeOffset.UtcNow; }
/// <summary>Creates a new instance of <see cref="S3Client" /></summary> /// <param name="config">The configuration you want to use</param> /// <param name="proxy">A web proxy (optional)</param> public S3Client(S3Config config, WebProxy proxy = null) : this(config, new HttpClientHandler { Proxy = proxy }) { }
protected override void ConfigureConfig(S3Config config) { //We force streaming signatures as it is the only one that supports non-seekable streams config.StreamingChunkSize = 8096; config.PayloadSignatureMode = SignatureMode.StreamingSignature; }
public HomeController(IConfiguration configuration) { config = configuration; s3config = config.GetSection("S3Config").Get <S3Config>(); }
public async Task <TResp> SendRequestAsync <TReq, TResp>(TReq request, CancellationToken cancellationToken = default) where TResp : IResponse, new() where TReq : IRequest { cancellationToken.ThrowIfCancellationRequested(); request.Timestamp = DateTimeOffset.UtcNow; request.RequestId = Guid.NewGuid(); _logger.LogTrace("Sending {RequestType} with request id {RequestId}", typeof(TReq).Name, request.RequestId); S3Config config = _options.Value; Stream requestStream = _marshaller.MarshalRequest(request, config); _validator.ValidateAndThrow(request); string bucketName = null; if (request is IHasBucketName bn) { bucketName = bn.BucketName; } string objectKey = null; if (request is IHasObjectKey ok) { objectKey = ok.ObjectKey; } //Ensure that the object key is encoded string encodedResource = objectKey != null?UrlHelper.UrlPathEncode(objectKey) : null; if (config.Endpoint == null || config.NamingMode == NamingMode.PathStyle) { if (bucketName != null) { objectKey = bucketName + '/' + encodedResource; } else { objectKey = encodedResource; } } else { objectKey = encodedResource; } StringBuilder sb = StringBuilderPool.Shared.Rent(100); Uri endpoint = config.Endpoint; if (endpoint != null) { sb.Append(endpoint.Host); if (!endpoint.IsDefaultPort) { sb.Append(':').Append(endpoint.Port); } } else { if (config.NamingMode == NamingMode.VirtualHost) { if (bucketName != null) { sb.Append(bucketName).Append(".s3.").Append(ValueHelper.EnumToString(config.Region)).Append(".amazonaws.com"); } else { sb.Append("s3.").Append(ValueHelper.EnumToString(config.Region)).Append(".amazonaws.com"); } } else { sb.Append("s3.").Append(ValueHelper.EnumToString(config.Region)).Append(".amazonaws.com"); } } request.SetHeader(HttpHeaders.Host, sb.ToString()); request.SetHeader(AmzHeaders.XAmzDate, request.Timestamp, DateTimeFormat.Iso8601DateTime); if (requestStream != null) { foreach (IRequestStreamWrapper wrapper in _requestStreamWrappers) { if (wrapper.IsSupported(request)) { requestStream = wrapper.Wrap(requestStream, request); } } } if (!request.Headers.TryGetValue(AmzHeaders.XAmzContentSha256, out string contentHash)) { if (config.PayloadSignatureMode == SignatureMode.Unsigned) { contentHash = "UNSIGNED-PAYLOAD"; } else { contentHash = requestStream == null ? "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" : CryptoHelper.Sha256Hash(requestStream, true).HexEncode(); } request.SetHeader(AmzHeaders.XAmzContentSha256, contentHash); } _logger.LogDebug("ContentSha256 is {ContentSha256}", contentHash); //We add the authorization header here because we need ALL other headers to be present when we do request.SetHeader(HttpHeaders.Authorization, _authBuilder.BuildAuthorization(request)); sb.Append('/').Append(objectKey); //Map all the parameters on to the url if (request.QueryParameters.Count > 0) { sb.Append('?').Append(UrlHelper.CreateQueryString(request.QueryParameters)); } string scheme = endpoint == null ? config.UseTLS ? "https" : "http" : endpoint.Scheme; string fullUrl = scheme + "://" + sb; StringBuilderPool.Shared.Return(sb); _logger.LogDebug("Building request for {Url}", fullUrl); (int statusCode, IDictionary <string, string> headers, Stream responseStream) = await _networkDriver.SendRequestAsync(request.Method, fullUrl, request.Headers, requestStream, cancellationToken).ConfigureAwait(false); //Clear sensitive material from the request if (request is IContainSensitiveMaterial sensitive) { sensitive.ClearSensitiveMaterial(); } TResp response = new TResp(); response.StatusCode = statusCode; response.ContentLength = headers.GetHeaderLong(HttpHeaders.ContentLength); response.ConnectionClosed = "closed".Equals(headers.GetHeader(HttpHeaders.Connection), StringComparison.OrdinalIgnoreCase); response.Date = headers.GetHeaderDate(HttpHeaders.Date, DateTimeFormat.Rfc1123); response.Server = headers.GetHeader(HttpHeaders.Server); response.ResponseId = headers.GetHeader(AmzHeaders.XAmzId2); response.RequestId = headers.GetHeader(AmzHeaders.XAmzRequestId); // https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html response.IsSuccess = !(statusCode == 403 || //Forbidden statusCode == 400 || //BadRequest statusCode == 500 || //InternalServerError statusCode == 416 || //RequestedRangeNotSatisfiable statusCode == 405 || //MethodNotAllowed statusCode == 411 || //LengthRequired statusCode == 404 || //NotFound statusCode == 501 || //NotImplemented statusCode == 504 || //GatewayTimeout statusCode == 301 || //MovedPermanently statusCode == 412 || //PreconditionFailed statusCode == 307 || //TemporaryRedirect statusCode == 409 || //Conflict statusCode == 503); //ServiceUnavailable //Only marshal successful responses if (response.IsSuccess) { _marshaller.MarshalResponse(config, request, response, headers, responseStream); } else { MemoryStream ms = new MemoryStream(); responseStream.CopyTo(ms); if (ms.Length > 0) { ms.Seek(0, SeekOrigin.Begin); using (responseStream) response.Error = ErrorHandler.Create(ms); _logger.LogError("Received error: '{Message}'. Details: '{Details}'", response.Error.Message, response.Error.GetExtraData()); } } return(response); }
/// <summary>Creates a new instance of <see cref="S3Client" /></summary> /// <param name="config">The configuration you want to use</param> /// <param name="proxy">A web proxy (optional)</param> public S3Client(S3Config config, IWebProxy?proxy = null) : this(Options.Create(config), proxy) { }
public S3Repository(IAmazonS3 amazonS3Client, S3Config config) { _amazonS3Client = amazonS3Client; _config = config; }
protected virtual void ConfigureConfig(S3Config config) { }