public static void CreateClientCreatesAmazonS3Client()
        {
            // TODO: how do i verify the correct params were passed in?
            var client = S3ClientFactory.CreateClient("key", "secret", "url");

            Assert.IsType <AmazonS3Client>(client);
        }
예제 #2
0
        public async Task ListBuckets()
        {
            using (var client = S3ClientFactory.CreateClient(ProfileName))
            {
                var response = await client.ListBucketsAsync();

                Console.WriteLine(response.Buckets.Count);
            }
        }
    public static IS3ClientFactory Create(string[] regions, AWSOptions options)
    {
        var factory = new S3ClientFactory();

        foreach (var region in regions)
        {
            var regionEndPoint = RegionEndpoint.GetBySystemName(region);
            options.Region = regionEndPoint;
            factory._container.Add(region, options.CreateServiceClient <IAmazonS3>());
        }
        return(factory);
    }
예제 #4
0
        public async Task SaveObjectAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreItemAdder>();
            var deleter     = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter  = provider.GetRequiredService <ScoreItemInfoGetter>();


            var ownerId = Guid.Parse("f2240c15-0f2d-41ce-941d-6b173bae94c0");
            var scoreId = Guid.Parse("0d9fb491-43ae-44a1-9056-55bb25b21187");
            var itemId  = Guid.Parse("cc42d1b1-c6b0-4895-ba74-de6e89d853a1");

            var imageRelativeResourceName = "Resources.pexels-cottonbro-4709821.jpg";

            await using var imageStream = ResourceUtils.CreateResourceStream(imageRelativeResourceName);

            var data = new byte[imageStream.Length];
            await imageStream.ReadAsync(data, 0, data.Length);

            await creator.SaveObjectAsync(ownerId, scoreId, itemId, data, ScoreObjectAccessControls.Public);
        }
        public static IServiceCollection AddS3ObjectStores(this IServiceCollection services, S3Settings settings)
        {
            services.AddSingleton <GuidKeyConverter>(_ => new GuidKeyConverter());
            services.AddSingleton <StringKeyConverter>(_ => new StringKeyConverter());

            services.AddSingleton <IAmazonS3>(
                _ => S3ClientFactory.CreateClient(settings.Key, settings.Secret, settings.Url));

            services.AddSingleton <IS3ObjectStore <Message, Guid> >(
                provider =>
            {
                var s3Client      = provider.GetService <IAmazonS3>();
                var keyConverter  = provider.GetService <GuidKeyConverter>();
                var storeSettings = new S3ObjectStoreSettings
                {
                    BucketName = settings.BucketName,
                    KeyPrefix  = nameof(Message)
                };

                return(new S3ObjectStore <Message, Guid>(s3Client, storeSettings, keyConverter));
            });

            services.AddSingleton <IS3ObjectStore <MessageStatusContainer, string> >(
                provider =>
            {
                var s3Client      = provider.GetService <IAmazonS3>();
                var keyConverter  = provider.GetService <StringKeyConverter>();
                var storeSettings = new S3ObjectStoreSettings
                {
                    BucketName = settings.BucketName,
                    KeyPrefix  = nameof(MessageStatusContainer)
                };

                return(new S3ObjectStore <MessageStatusContainer, string>(s3Client, storeSettings, keyConverter));
            });
            return(services);
        }
        private string GetCurrentDocumentVersion(string domain)
        {
            using (var client = S3ClientFactory.GetS3Client(_regionName, _profileName))
            {
                try
                {
                    var iterator = new S3VersionIterator(client, _bucketName, _folder);

                    var version = iterator.Where((v) => { return(v.IsLatest && !v.IsDeleteMarker && Path.GetFileName(v.Key).StartsWith(domain)); }).FirstOrDefault();
                    if (version == null)
                    {
                        return(null);
                    }

                    return(version.VersionId);
                }
                catch (Exception ex)
                {
                    logger.Error(ex);
                }
            }

            return(null);
        }
예제 #7
0
        public async Task CreateAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreSnapshotRemover>();



            var ownerId    = Guid.Parse("80b16bc7-5258-441f-9a2a-d6d95fc16c4a");
            var scoreId    = Guid.Parse("fc4ac609-0914-4cd6-9caa-cada12c7b03d");
            var snapshotId = Guid.Parse("3dd43d78-ff83-46f5-8ed3-fddbc06ec943");

            var data = new ScoreSnapshotDetail()
            {
                Id   = snapshotId,
                Name = "スナップショット名",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };
            await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
        }
 public S3ClientFactoryTests()
 {
     _factory = new S3ClientFactory();
 }
        private async Task DownloadFilesForDomain(string domain)
        {
            using (var client = S3ClientFactory.GetS3Client(_regionName, _profileName))
            {
                var documentName = $"{_folder}/{domain}.fullchain.pem";
                var metadata     = await GetMetadata(documentName, client);

                var document = await GetDocument(documentName, client);

                var kmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.GetBySystemName(_regionName));



                var ms = new MemoryStream(Convert.FromBase64String(metadata["x-amz-meta-tmkciphertext"]));

                try
                {
                    var decryptResponse = await kmsClient.DecryptAsync(new DecryptRequest { CiphertextBlob = ms });

                    // TODO: put this in guarded memory somehow?
                    var keyId          = decryptResponse.KeyId;
                    var tmkPlinText    = Convert.ToBase64String(decryptResponse.Plaintext.ToArray());
                    var plainTextArray = decryptResponse.Plaintext.ToArray();

                    var iv = new byte[16];
                    using (var rijndaelManaged =
                               new RijndaelManaged {
                        Key = plainTextArray, IV = iv, Mode = CipherMode.CBC
                    })
                    {
                        rijndaelManaged.BlockSize = 128;
                        rijndaelManaged.KeySize   = 256;
                        rijndaelManaged.Padding   = PaddingMode.None;
                        using (var memoryStream =
                                   new MemoryStream(Convert.FromBase64String(metadata["x-amz-meta-tdkciphertext"])))
                            using (var cryptoStream =
                                       new CryptoStream(memoryStream,
                                                        rijndaelManaged.CreateDecryptor(plainTextArray, iv),
                                                        CryptoStreamMode.Read))
                            {
                                var data = new StreamReader(cryptoStream).ReadToEnd();

                                //var buffer = new byte[256];
                                //List<byte> bytes = new List<byte>();
                                //int lastIndex = 0;
                                //int bytesRead = 0;
                                //do
                                //{
                                //    bytesRead = await cryptoStream.ReadAsync(buffer, lastIndex, buffer.Length);
                                //    lastIndex += bytesRead;

                                //    bytes.AddRange(buffer);

                                //} while (bytesRead == 256);

                                //var data = Convert.ToBase64String(bytes.ToArray());

                                var bytes = Encoding.UTF8.GetBytes(data);
                            }
                    }
                }
                catch (Exception ex)
                {
                    logger.Error(ex);
                }


                // TODO: save data to filename
                var path = Path.Combine(ConfigurationManager.AppSettings["DocumentFolder"], $"{domain}.fullchain.pem");
            }
        }
        public async Task DeleteAllAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreDeleter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreDeleter>();

            var ownerId = Guid.Parse("e9ca7322-9dd6-4429-b1d8-d3c9244a68ed");
            var scoreId = Guid.Parse("eea7e8c1-15ec-4f69-a675-364f24099267");

            var snapshotIds = new[]
            {
                Guid.Parse("0ea2f185-8355-439c-a427-d5734c17f886"),
                Guid.Parse("18be42eb-de3c-4899-bdc3-7ed512ce07ae"),
                Guid.Parse("7569ad9a-1bb4-4c33-9cb8-11e5c680a404"),
            };

            var data = new ScoreSnapshotDetail()
            {
                Name = "スナップショット名(delete all)",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };

            try
            {
                foreach (var snapshotId in snapshotIds)
                {
                    data.Id = snapshotId;
                    await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
                }
            }
            catch
            {
                // 握りつぶす
            }

            await deleter.DeleteAllSnapshotAsync(ownerId, scoreId);
        }
        public async Task DeleteAsyncTest()
        {
            var accessKey       = "minio_test";
            var secretKey       = "minio_test_pass";
            var s3ClientFactory = new S3ClientFactory()
                                  .SetEndpointUrl(new Uri("http://localhost:19000"))
                                  .SetCredentials(new BasicAWSCredentials(accessKey, secretKey));

            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = ScoreBucket,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = ScoreBucket,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(s3ClientFactory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreSnapshotCreator>();
            serviceCollection.AddScoped <ScoreSnapshotRemover>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer = provider.GetRequiredService <Initializer>();
            var creator     = provider.GetRequiredService <ScoreSnapshotCreator>();
            var deleter     = provider.GetRequiredService <ScoreSnapshotRemover>();

            var ownerId    = Guid.Parse("31937be9-d1df-4076-b2b6-9cb5e2d94a17");
            var scoreId    = Guid.Parse("8a9aaa16-2ca2-4b22-9cf5-21e7b681dbc9");
            var snapshotId = Guid.Parse("f30cd5f5-b807-4273-9299-f95d0baf85b9");

            var data = new ScoreSnapshotDetail()
            {
                Id   = snapshotId,
                Name = "スナップショット名(delete)",
                Data = new ScoreData()
                {
                    Title           = "楽譜",
                    DescriptionHash = "楽譜の説明",
                    Annotations     = new [] {
                        new ScoreAnnotation()
                        {
                            Id          = 0,
                            ContentHash = "hash00",
                        },
                        new ScoreAnnotation()
                        {
                            Id          = 1,
                            ContentHash = "hash01",
                        },
                    },
                    Pages = new []
                    {
                        new ScorePage()
                        {
                            Id     = 0,
                            Page   = "page1",
                            ItemId = new Guid("3b74ca20-0e47-49b4-941f-45176766ae7d"),
                        },
                        new ScorePage()
                        {
                            Id     = 1,
                            Page   = "page2",
                            ItemId = new Guid("e3c0a4a6-344d-4247-9932-070ae822186b"),
                        },
                    },
                },
                HashSet = new Dictionary <string, string>()
                {
                    ["hash00"] = "アノテーション1",
                    ["hash01"] = "アノテーション2",
                },
            };

            try
            {
                await creator.CreateSnapshotItemAsync(ownerId, scoreId, data, ScoreObjectAccessControls.Public);
            }
            catch
            {
                // 握りつぶす
            }

            await deleter.DeleteSnapshotAsync(ownerId, scoreId, snapshotId);
        }
예제 #12
0
        public async Task SetAccessControlPolicyAsyncTest()
        {
            var factory = new S3ClientFactory()
                          .SetRegionSystemName(RegionSystemName);
            var dynamoDbClientFactory = new DynamoDbClientFactory().SetEndpointUrl(new Uri("http://localhost:18000"));
            var bucketName            = BucketName;
            var configuration         = new ConfigurationBuilder()
                                        .AddInMemoryCollection(new Dictionary <string, string>()
            {
                [EnvironmentNames.ScoreDynamoDbTableName]             = ScoreTableName,
                [EnvironmentNames.ScoreLargeDataDynamoDbTableName]    = ScoreTableName,
                [EnvironmentNames.ScoreItemDynamoDbTableName]         = ScoreTableName,
                [EnvironmentNames.ScoreItemRelationDynamoDbTableName] = ScoreTableName,
                [EnvironmentNames.ScoreItemS3Bucket]         = BucketName,
                [EnvironmentNames.ScoreDataSnapshotS3Bucket] = BucketName,
            })
                                        .Build();
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton(dynamoDbClientFactory.Create());
            serviceCollection.AddSingleton(factory.Create());
            serviceCollection.AddSingleton <ScoreQuota>();
            serviceCollection.AddSingleton <IConfiguration>(configuration);
            serviceCollection.AddScoped <Initializer>();
            serviceCollection.AddScoped <ScoreItemAdder>();
            serviceCollection.AddScoped <ScoreItemDeleter>();
            serviceCollection.AddScoped <ScoreItemInfoGetter>();
            serviceCollection.AddScoped <ScoreAccessSetter>();

            await using var provider = serviceCollection.BuildServiceProvider();

            var initializer  = provider.GetRequiredService <Initializer>();
            var creator      = provider.GetRequiredService <ScoreItemAdder>();
            var deleter      = provider.GetRequiredService <ScoreItemDeleter>();
            var infoGetter   = provider.GetRequiredService <ScoreItemInfoGetter>();
            var accessSetter = provider.GetRequiredService <ScoreAccessSetter>();

            var ownerId  = Guid.Parse("4935be9f-8b08-4de9-a615-96ec04c2e4c5");
            var scoreIds = new[]
            {
                Guid.Parse("b6538dd3-2e2d-47bf-8ad3-1cb23b982309"),
                Guid.Parse("2ee917b6-94fa-469f-a977-14f57d9a7b4e"),
            };
            var itemIds = new[]
            {
                new Guid("6cf18791-0058-426b-b5fb-8f553079a6f5"),
                new Guid("1e69d895-5487-4de6-ae8e-e0f57cd86954"),
            };

            var imageRelativeResourceName = "Resources.pexels-cottonbro-4709821.jpg";

            await using var imageStream = ResourceUtils.CreateResourceStream(imageRelativeResourceName);

            var data = new byte[imageStream.Length];
            await imageStream.ReadAsync(data, 0, data.Length);

            foreach (var scoreId in scoreIds)
            {
                foreach (var itemId in itemIds)
                {
                    await creator.SaveObjectAsync(ownerId, scoreId, itemId, data, ScoreObjectAccessControls.Private);
                }
            }

            await accessSetter.SetScoreItemAccessControlPolicyAsync(ownerId, scoreIds[0], ScoreObjectAccessControls.Public);
        }