private async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(CosmosDbConfiguration config)
{
//var databaseName = Configuration["CosmosConfig:DatabaseId"];
//var containerName = Configuration["CosmosConfig:ExpenseCollectionId"];
//var account = Configuration["CosmosConfig:EndpointUri"];
//var key = Configuration["CosmosConfig:AuthorizationKey"];
var clientBuilder = new CosmosClientBuilder(config.EndpointUri, config.AuthorizationKey);
var client = clientBuilder
.WithConnectionModeDirect()
.Build();
var cosmosDbService = new CosmosDbService(client, config.DatabaseId, config.ExpenseCollectionId);
var databaseResponse = await client.CreateDatabaseIfNotExistsAsync(config.DatabaseId);
Console.WriteLine($@"Cosmos DB '{config.DatabaseId} {(databaseResponse.StatusCode == HttpStatusCode.Created ? "created" : "retrieved")}");
Console.WriteLine($@" - Etag '{databaseResponse.ETag}");
Console.WriteLine($@" - ActivityId {databaseResponse.ActivityId}");
Console.WriteLine($@" - Charge {databaseResponse.RequestCharge:#.00}");
//TODO: Get a better partition name
var partitionKey = "/expense/name";
var containerResponse = await databaseResponse.Database.CreateContainerIfNotExistsAsync(config.ExpenseCollectionId, partitionKey);
Console.WriteLine($@"Cosmos container '{config.ExpenseCollectionId} {(containerResponse.StatusCode == HttpStatusCode.Created ? "created" : "retrieved")}");
Console.WriteLine($@" - Etag '{containerResponse.ETag}");
Console.WriteLine($@" - ActivityId {containerResponse.ActivityId}");
Console.WriteLine($@" - Charge {containerResponse.RequestCharge:#.00}");
return(cosmosDbService);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="options"></param>
/// <param name="cosmosDbClient"></param>
public InitializeCosmosDbLogic(IOptions <CosmosDbConfiguration> options, CosmosClient cosmosDbClient)
{
_settings = options.Value;
_cosmosDbClient = cosmosDbClient;
_cosmosDatabase = _cosmosDbClient.GetDatabase(_settings.DatabaseId);
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (AccessPolicies == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "AccessPolicies");
}
if (AccessPolicies != null)
{
foreach (var element in AccessPolicies)
{
if (element != null)
{
element.Validate();
}
}
}
if (CosmosDbConfiguration != null)
{
CosmosDbConfiguration.Validate();
}
if (CorsConfiguration != null)
{
CorsConfiguration.Validate();
}
}
private static CosmosDbConfiguration BuildConfigurationForSection(IConfiguration configuration, string sectionName)
{
CosmosDbConfiguration cosmosDbConfiguration = new CosmosDbConfiguration();
configuration.GetSection(sectionName).Bind(cosmosDbConfiguration);
return(cosmosDbConfiguration);
}
public async Task InitializeAsync()
{
Settings = config.For <CosmosDbConfiguration>("CosmosDB");
_secretResolver = new SecretResolver();
//Notes:
// if using an azure instance to run the tests, make sure you set the environment variable before you start visual studio
// Ex: CMD C:\> setx COSMOSDB_KEY ABCDEFGASD==
// On CosmosDB, make sure you create the collection 'SampleEntity' in the database defined in the config 'Stacks'
// To overrride the appsettings values, set the environment variable using SectionName__PropertyName. i.e: CosmosDB__DatabaseAccountUri
// Note the use of a double _ between the section and the property name
if (Environment.GetEnvironmentVariable(Settings.SecurityKeySecret.Identifier) == null)
{
//if localhost and running in visual studio
if (Settings.DatabaseAccountUri.Contains("localhost", StringComparison.InvariantCultureIgnoreCase) &&
Environment.GetEnvironmentVariable("VisualStudioEdition") != null)
{
Environment.SetEnvironmentVariable(Settings.SecurityKeySecret.Identifier, this.Settings.PrimaryKey);
}
else
{
throw new ArgumentNullException(
$"The environment variable '{Settings.SecurityKeySecret.Identifier}' has not been set");
}
}
string cosmosDbKey = await _secretResolver.ResolveSecretAsync(Settings.SecurityKeySecret);
CosmosClient = new CosmosClient(Settings.DatabaseAccountUri, cosmosDbKey);
await CosmosClient.CreateDatabaseIfNotExistsAsync(Settings.DatabaseName);
Database database = CosmosClient.GetDatabase(Settings.DatabaseName);
await database.CreateContainerIfNotExistsAsync(nameof(SampleEntity), $"/{nameof(SampleEntity.OwnerId)}");
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="Rest.ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (AccessPolicies != null)
{
foreach (var element in AccessPolicies)
{
if (element != null)
{
element.Validate();
}
}
}
if (CosmosDbConfiguration != null)
{
CosmosDbConfiguration.Validate();
}
if (CorsConfiguration != null)
{
CorsConfiguration.Validate();
}
if (PrivateEndpointConnections != null)
{
foreach (var element1 in PrivateEndpointConnections)
{
if (element1 != null)
{
element1.Validate();
}
}
}
}
public PushNotifcationService(IOptions <VapidSettings> vapidSettings, IOptions <CosmosDbConfiguration> cosmosDbOptions, DocumentClient client)
{
_client = client;
_vapidSettings = vapidSettings.Value;
_pushClient = new WebPushClient();
_cosmosConfig = cosmosDbOptions.Value;
_pushClient.SetVapidDetails(_vapidSettings.Subject, _vapidSettings.PublicKey, _vapidSettings.PrivateKey);
}
public void Setup()
{
_cosmosDbConfiguration = new CosmosDbConfiguration("https://localhost:8081",
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==", "People", "PeopleCollection");
_documentsToDelete = new List <Documents.Person>();
var mapper = MappingConfiguration.Configure(new MappingProfile());
_commandCosmosDbRepository = new CommandCosmosDbRepository <Person, Documents.Person>(_cosmosDbConfiguration, mapper);
}
public ReviewRepository(CosmosDbConfiguration CosmosDbConfiguration)
{
_databaseName = CosmosDbConfiguration.DatabaseName;
_reviewCollectionName = CosmosDbConfiguration.CollectionName;
_collectionUri = UriFactory.CreateDocumentCollectionUri(_databaseName, _reviewCollectionName);
_client = new DocumentClient(new Uri(CosmosDbConfiguration.EndPointUrl), CosmosDbConfiguration.AuthorizationKey,
new ConnectionPolicy {
ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp
});
}
public async Task SetupAsync()
{
_cosmosDbConfiguration = new CosmosDbConfiguration("https://localhost:8081",
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==", "People", "PeopleCollection");
_mapper = MappingConfiguration.Configure(new MappingProfile());
_queryCosmosDbRepository = new QueryCosmosDbRepository <Entities.Person, Person>(_cosmosDbConfiguration, _mapper);
_querySameEntityAndDocumentCosmosDbRepository = new QueryCosmosDbRepository <Entities.Person, Entities.Person>(_cosmosDbConfiguration, _mapper);
_peopleListToTest = await IntegrationTestsUtils.AddDocumentListToTestAsync(_cosmosDbConfiguration, _mapper).ConfigureAwait(false);
}
public ChangeFeedReader(IConfiguration configuration, IHubContext <ClientHub> signalRHubContext)
{
var cosmosDbConfiguration = ChangeFeedReader.BuildConfigurationForSection(configuration, "CosmosDB");
this.cosmosDbConfiguration = cosmosDbConfiguration;
this.signalRHubContext = signalRHubContext;
TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.Active;
telemetryConfiguration.InstrumentationKey = ChangeFeedReader.DetectAppInsightsInstrumentationKey(configuration);
telemetryConfiguration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
telemetryConfiguration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
this.telemetryClient = new TelemetryClient();
}
private static ConnectionPolicy BuildConnectionPolicy(CosmosDbConfiguration cosmosDbConfiguration)
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy();
if (cosmosDbConfiguration.Endpoint.Contains("localhost"))
{
// Emulator does not support PreferredLocations
return(connectionPolicy);
}
foreach (var region in cosmosDbConfiguration.ValidatedPreferredLocations)
{
connectionPolicy.PreferredLocations.Add(region);
}
return(connectionPolicy);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="cosmosDbConfiguration"></param>
/// <param name="healthPlanetConfiguration"></param>
/// <param name="googleConfiguration"></param>
/// <param name="initializeCosmosDbLogic"></param>
/// <param name="healthPlanetLogic"></param>
/// <param name="googleFitLogic"></param>
public InitializeFunctions(
IOptions <CosmosDbConfiguration> cosmosDbConfiguration,
IOptions <HealthPlanetConfiguration> healthPlanetConfiguration,
IOptions <GoogleConfiguration> googleConfiguration,
InitializeCosmosDbLogic initializeCosmosDbLogic,
HealthPlanetLogic healthPlanetLogic,
GoogleFitLogic googleFitLogic
)
{
_cosmosDbConfiguration = cosmosDbConfiguration.Value;
_healthPlanetConfiguration = healthPlanetConfiguration.Value;
_googleConfiguration = googleConfiguration.Value;
_initializeCosmosDbLogic = initializeCosmosDbLogic;
_healthPlanetLogic = healthPlanetLogic;
_googleFitLogic = googleFitLogic;
}
/// <summary>
/// Protected Constructor
/// </summary>
/// <param name="settings"></param>
/// <param name="databaseName"></param>
/// <param name="connectionPolicy"></param>
/// <param name="logger"></param>
protected CosmosDbContextBase(IOptions <CosmosDbConfiguration> settings,
string databaseName,
ConnectionPolicy connectionPolicy = null,
ILogger logger = null)
{
Guard.ForNullOrDefault(settings.Value, nameof(settings));
Guard.ForNullOrDefault(settings.Value.EndPointUrl, nameof(settings.Value.EndPointUrl));
Guard.ForNullOrDefault(settings.Value.PrimaryKey, nameof(settings.Value.PrimaryKey));
Logger = logger;
Configuration = settings.Value;
var serviceEndPoint = new Uri(settings.Value.EndPointUrl);
DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,
connectionPolicy ?? ConnectionPolicy.Default);
EnsureDatabaseCreated(databaseName);
}
public CosmosDBFixture()
{
_config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
CosmosDbConfig = new CosmosDbConfiguration
{
AuthorizationKey = _config.GetSection("CosmosDbConfiguration")["AuthorizationKey"],
CollectionName = _config.GetSection("CosmosDbConfiguration")["CollectionName"],
DatabaseName = _config.GetSection("CosmosDbConfiguration")["DatabaseName"],
EndPointUrl = _config.GetSection("CosmosDbConfiguration")["EndPointUrl"]
};
// Initializing collection with configuration
_client = new DocumentClient(
new Uri(CosmosDbConfig.EndPointUrl),
CosmosDbConfig.AuthorizationKey);
CreateReviewCollectionAndInitializeIfNotExistsAsync().Wait();
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="Rest.ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (AccessPolicies != null)
{
foreach (var element in AccessPolicies)
{
if (element != null)
{
element.Validate();
}
}
}
if (CosmosDbConfiguration != null)
{
CosmosDbConfiguration.Validate();
}
if (CorsConfiguration != null)
{
CorsConfiguration.Validate();
}
}
/// <summary>
/// Protected Constructor
/// </summary>
/// <param name="settings"></param>
/// <param name="connectionPolicy"></param>
/// <param name="logger"></param>
protected CosmosDbContextBase(
IOptions <CosmosDbConfiguration> settings,
ConnectionPolicy connectionPolicy = null,
ILogger logger = null)
{
Guard.ForNullOrDefault(settings.Value, nameof(settings));
Guard.ForNullOrDefault(settings.Value.EndPointUrl, nameof(settings.Value.EndPointUrl));
Guard.ForNullOrDefault(settings.Value.PrimaryKey, nameof(settings.Value.PrimaryKey));
_logger = logger;
Configuration = settings.Value;
var serviceEndPoint = new Uri(settings.Value.EndPointUrl);
if (Configuration.DangerousAcceptAnyServerCertificateValidator)
{
CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
{
HttpClientFactory = () =>
{
HttpMessageHandler httpMessageHandler = new HttpClientHandler()
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
};
return(new HttpClient(httpMessageHandler));
},
ConnectionMode = Microsoft.Azure.Cosmos.ConnectionMode.Gateway
};
CosmosClient = new CosmosClient(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey, cosmosClientOptions);
}
else
{
CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey);
CosmosClient = configurationBuilder.Build();
}
// DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,connectionPolicy ?? ConnectionPolicy.Default);
// EnsureDatabaseCreated(Configuration.DatabaseName).Wait();
}
/// <summary>
/// Protected Constructor
/// </summary>
/// <param name="settings"></param>
/// <param name="connectionPolicy"></param>
/// <param name="logger"></param>
protected CosmosDbContextBase(
IOptions <CosmosDbConfiguration <T> > settings,
ConnectionPolicy connectionPolicy = null,
ILogger logger = null)
{
Guard.ForNullOrDefault(settings.Value, nameof(settings));
Guard.ForNullOrDefault(settings.Value.EndPointUrl, nameof(settings.Value.EndPointUrl));
Guard.ForNullOrDefault(settings.Value.PrimaryKey, nameof(settings.Value.PrimaryKey));
Guard.ForNullOrDefault(settings.Value.DatabaseName, nameof(settings.Value.EndPointUrl));
Logger = logger;
Configuration = settings.Value;
var serviceEndPoint = new Uri(settings.Value.EndPointUrl);
CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey);
CosmosClient = configurationBuilder.Build();
DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,
connectionPolicy ?? ConnectionPolicy.Default);
EnsureDatabaseCreated(Configuration.DatabaseName).Wait();
}
public MyOrdersGet(IOptions <CosmosDbConfiguration> options)
{
_cosmosDbConfiguration = options.Value;
}
public QueryCosmosDbRepository(CosmosDbConfiguration cosmosDbConfiguration, IMapper mapper)
{
CosmosDbConfiguration = cosmosDbConfiguration;
_mapper = mapper;
}
public TopicsController(IOptions <CosmosDbConfiguration> cosmosConfig, DocumentClient client, IPushNotifcationService notifcationService)
{
_cosmosConfig = cosmosConfig.Value;
_client = client;
_notifcationService = notifcationService;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
//services.AddMvc();
services.AddControllersWithViews();
services.AddMemoryCache();
//Configure Redis distributed cache
var redisConnectionString = Configuration["RedisConnectionString"];
services.AddStackExchangeRedisCache(options => {
options.Configuration = redisConnectionString;
options.InstanceName = "";
});
services.AddTransient <IDataGenerator, BogusDataGenerator>();
services.AddHttpClient <ILocationService, LocationService>();
//Configure CosmosDB
var cosmosConfig = new CosmosDbConfiguration();
Configuration.Bind("CosmosConfig", cosmosConfig);
services.AddSingleton(cosmosConfig);
try
{
services.AddHttpClient <ICosmosDbService, CosmosDbService>();
services.AddSingleton <ICosmosDbService>(
InitializeCosmosClientInstanceAsync(cosmosConfig)
.GetAwaiter().GetResult());
}
catch (Exception ex)
{
LogException(ex, "Could not start CosmosDB services");
}
//Configure PostgresSQL
services.AddTransient <IPostgresSqlRepository, PostgresSqlRepository>();
services.AddTransient <IPostgresSqlService, PostgresSqlService>();
//Configure SQL Server
var sqlConnectionString = Configuration["SqlConnectionString"];
services.AddDbContext <LocationDbContext>(options =>
options.UseSqlServer(sqlConnectionString, builder => builder
.UseNetTopologySuite()
.EnableRetryOnFailure()),
ServiceLifetime.Transient);
//Configure PostgresSql
var pgConnectionString = Configuration["PostgreSql:ConnectionString"];
var pgPassword = Configuration["PostgreSql:DbPassword"];
var pgBuilder = new NpgsqlConnectionStringBuilder(pgConnectionString)
{
Password = pgPassword
};
services.AddDbContext <StudentDbContext>(options =>
options.UseNpgsql(pgBuilder.ConnectionString));
//Configure Azure Search
//AzureSearchConfiguration
var azureConfig = new AzureSearchConfiguration();
Configuration.Bind("AzureSearchConfiguration", azureConfig);
services.AddSingleton(azureConfig);
//var azureConfig = Configuration["AzureSearchConfiguration"];
}
