public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().AddNewtonsoftJson();
services.AddResponseCompression();
services.AddDbContext <DataContext>(options =>
{
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
}, ServiceLifetime.Singleton);
services.AddSingleton <ICosmosService, CosmosService>();
services.AddSingleton(provider =>
{
var cosmosService = provider.GetRequiredService <ICosmosService>();
var client = new CosmonautClientHolder();
var accounts = cosmosService.GetAllCosmosAccounts().GetAwaiter().GetResult();
foreach (var account in accounts)
{
var cosmonautClient = new CosmonautClient(account.Endpoint, account.MasterKey,
new ConnectionPolicy {
ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp
});
client.AddClient(cosmonautClient);
}
return(client);
});
}
private static CosmonautClient SetupCosmonautClient()
{
var documentClient = MockHelpers.GetMockDocumentClient();
var cosmonautClient = new CosmonautClient(documentClient.Object);
var databaseResource = new Database {
Id = "databaseName"
}.ToResourceResponse(HttpStatusCode.OK);
documentClient.Setup(x =>
x.ReadDatabaseAsync(UriFactory.CreateDatabaseUri("databaseName"), It.IsAny <RequestOptions>()))
.ReturnsAsync(databaseResource);
return(cosmonautClient);
}
public CosmosStore <CosmonautModel> CreateStore()
{
var endpoint = new Uri(@"https://localhost:8081/");
var key = "[AUTH KEY]";
var policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
var documentClient = new DocumentClient(endpoint, key, SerializerSettings, policy);
var cosmonautClient = new CosmonautClient(documentClient);
return(new CosmosStore <CosmonautModel>(cosmonautClient, "Cosmonaut"));
}
public void AddClient(string serviceEndpoint, string key)
{
var cosmosAccountEndpoint = serviceEndpoint.TrimEnd('/');
if (CosmonautClients.ContainsKey(cosmosAccountEndpoint))
{
return;
}
var cosmosClient = new CosmonautClient(cosmosAccountEndpoint, key, new ConnectionPolicy {
ConnectionProtocol = Protocol.Tcp, ConnectionMode = ConnectionMode.Direct
});
CosmonautClients.Add(cosmosAccountEndpoint, cosmosClient);
}
public DatabaseFixture()
{
var cosmonautClient = new CosmonautClient(EmulatorUri, EmulatorKey);
var database = cosmonautClient.GetDatabaseAsync(DatabaseId).GetAwaiter().GetResult();
if (database != null)
{
cosmonautClient.DeleteDatabaseAsync(DatabaseId);
}
var cosmosSettings = new CosmosStoreSettings(DatabaseId, EmulatorUri, EmulatorKey);
var serviceCollection = new ServiceCollection()
.AddCosmosStore <FlatForRentAnnouncementEntity>(cosmosSettings, _flatForRentAnnouncementRepositoryTestCollectionName)
.AddCosmosStore <RoomForRentAnnouncementEntity>(cosmosSettings, _roomForRentAnnouncementRepositoryTestCollectionName);
var serviceProvider = serviceCollection.BuildServiceProvider();
FlatForRentAnnouncementCosmosStore = serviceProvider.GetService <ICosmosStore <FlatForRentAnnouncementEntity> >();
RoomForRentAnnouncementCosmosStore = serviceProvider.GetService <ICosmosStore <RoomForRentAnnouncementEntity> >();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureTestServices(services =>
{
var cosmonautClient = new CosmonautClient(EmulatorUri, EmulatorKey);
var database = cosmonautClient.GetDatabaseAsync(DatabaseId).GetAwaiter().GetResult();
if (database != null)
{
cosmonautClient.DeleteDatabaseAsync(DatabaseId);
}
var descriptors = services
.Where(x =>
x.ServiceType == typeof(ICosmosStore <FlatForRentAnnouncementEntity>) ||
x.ServiceType == typeof(ICosmosStore <RoomForRentAnnouncementEntity>) ||
x.ServiceType == typeof(IHttpClientService))
.ToList();
if (descriptors.Any())
{
foreach (var descriptor in descriptors)
{
services.Remove(descriptor);
}
}
var cosmosSettings = new CosmosStoreSettings(DatabaseId, EmulatorUri, EmulatorKey, settings =>
{
settings.JsonSerializerSettings = new JsonSerializerSettings
{
DateFormatHandling = DateFormatHandling.IsoDateFormat,
Formatting = Formatting.Indented,
Converters = { new StringEnumConverter(), new IsoDateTimeConverter() }
};
});
services.AddCosmosStore <FlatForRentAnnouncementEntity>(cosmosSettings);
services.AddCosmosStore <RoomForRentAnnouncementEntity>(cosmosSettings);
services.AddScoped <IHttpClientService, HttpClientServiceStub>();
var sp = services.BuildServiceProvider();
FlatForRentAnnouncementEntityCosmosStore = sp.GetRequiredService <ICosmosStore <FlatForRentAnnouncementEntity> >();
RoomForRentAnnouncementEntityCosmosStore = sp.GetRequiredService <ICosmosStore <RoomForRentAnnouncementEntity> >();
});
}
public async Task <IActionResult> CheckAccountStatus([FromBody] CosmosStatusRequest request)
{
try
{
var pingClient = new CosmonautClient(request.AccountUri, request.AccountKey);
await pingClient.DocumentClient.GetDatabaseAccountAsync();
var cosmosAccount = await _cosmosService.GetCosmosAccount(request.AccountUri);
if (cosmosAccount != null)
{
return(Ok(new StatusResponse("It looks like this account already exists.")));
}
await _cosmosService.AddCosmosAccount(request.AccountUri, request.AccountKey);
_clientHolder.AddClient(request.AccountUri, request.AccountKey);
return(Ok(new StatusResponse(true)));
}
catch
{
return(Ok(new StatusResponse("It looks like the Uri or the Master Key are invalid.")));
}
}
static async Task Main(string[] args)
{
//Uncomment to enable Serilog logging
//SerilogEventListener.Instance.Initialize();
var connectionPolicy = new ConnectionPolicy
{
ConnectionProtocol = Protocol.Tcp,
ConnectionMode = ConnectionMode.Direct
};
var cosmosSettings = new CosmosStoreSettings("localtest",
"https://localhost:8081",
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
, connectionPolicy
, defaultCollectionThroughput: 5000);
var cosmonautClient = new CosmonautClient("https://localhost:8081",
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==");
var serviceCollection = new ServiceCollection();
serviceCollection.AddCosmosStore <Book>("localtest", "https://localhost:8081",
"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
settings =>
{
settings.ConnectionPolicy = connectionPolicy;
settings.DefaultCollectionThroughput = 5000;
});
serviceCollection.AddCosmosStore <Car>(cosmosSettings);
var provider = serviceCollection.BuildServiceProvider();
var booksStore = provider.GetService <ICosmosStore <Book> >();
var carStore = provider.GetService <ICosmosStore <Car> >();
System.Console.WriteLine($"Started");
var scaleableDb = await cosmonautClient.GetDatabaseAsync("scaleabledb");
if (scaleableDb == null)
{
scaleableDb = await cosmonautClient.CreateDatabaseAsync(new Database { Id = "scaleabledb" },
new RequestOptions { OfferThroughput = 10000 });
}
var dbOffer = await cosmonautClient.GetOfferForDatabaseAsync("scaleabledb");
var dbOfferV2 = await cosmonautClient.GetOfferV2ForDatabaseAsync("scaleabledb");
var newOffer = new OfferV2(dbOffer, 20000);
var offerResponse = await cosmonautClient.UpdateOfferAsync(newOffer);
var database = await cosmonautClient.GetDatabaseAsync("localtest");
System.Console.WriteLine($"Retrieved database with id {database.Id}");
var collection = await cosmonautClient.GetCollectionAsync("localtest", "shared");
System.Console.WriteLine($"Retrieved collection with id {collection.Id}");
var offer = await cosmonautClient.GetOfferForCollectionAsync("localtest", "shared");
System.Console.WriteLine($"Retrieved offer with id {offer.Id}");
var offerV2 = await cosmonautClient.GetOfferV2ForCollectionAsync("localtest", "shared");
System.Console.WriteLine($"Retrieved offerV2 with id {offerV2.Id}");
var databases = await cosmonautClient.QueryDatabasesAsync();
System.Console.WriteLine($"Retrieved all {databases.Count()} databased in the account.");
var booksRemoved = await booksStore.RemoveAsync(x => true);
System.Console.WriteLine($"Removed {booksRemoved.SuccessfulEntities.Count} books from the database.");
var carsRemoved = await carStore.RemoveAsync(x => true);
System.Console.WriteLine($"Removed {carsRemoved.SuccessfulEntities.Count} cars from the database.");
var books = new List <Book>();
for (int i = 0; i < 25; i++)
{
books.Add(new Book
{
Id = Guid.NewGuid().ToString(),
Name = "Test " + i,
AnotherRandomProp = "Random " + i
});
}
var cars = new List <Car>();
for (int i = 0; i < 25; i++)
{
cars.Add(new Car
{
Id = Guid.NewGuid().ToString(),
Name = "Car " + i,
});
}
var watch = new Stopwatch();
watch.Start();
var addedCars = await carStore.AddRangeAsync(cars);
var addedBooks = await booksStore.AddRangeAsync(books);
System.Console.WriteLine($"Added {addedCars.SuccessfulEntities.Count + addedBooks.SuccessfulEntities.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Restart();
//await Task.Delay(3000);
var aCarId = addedCars.SuccessfulEntities.First().Entity.Id;
var firstAddedCar = await carStore.Query().FirstOrDefaultAsync();
var allTheCars = await carStore.QueryMultipleAsync <Car>("select * from c");
var carPageOne = await carStore.Query("select * from c order by c.Name asc").WithPagination(1, 5).ToPagedListAsync();
var carPageTwo = await carStore.Query("select * from c order by c.Name asc").WithPagination(carPageOne.NextPageToken, 5).ToPagedListAsync();
var carPageThree = await carPageTwo.GetNextPageAsync();
var carPageFour = await carPageThree.GetNextPageAsync();
var addedRetrieved = await booksStore.Query().OrderBy(x => x.Name).ToListAsync();
var firstPage = await booksStore.Query().WithPagination(1, 10).OrderBy(x => x.Name).ToPagedListAsync();
var secondPage = await firstPage.GetNextPageAsync();
var thirdPage = await secondPage.GetNextPageAsync();
var fourthPage = await secondPage.GetNextPageAsync();
//var thirdPage = await booksStore.Query().WithPagination(secondPage.NextPageToken, 10).OrderBy(x => x.Name).ToPagedListAsync();
//var fourthPage = await booksStore.Query().WithPagination(4, 10).OrderBy(x => x.Name).ToListAsync();
var sqlPaged = await cosmonautClient.Query <Book>("localtest", "shared",
"select * from c where c.CosmosEntityName = 'books' order by c.Name", null, new FeedOptions { EnableCrossPartitionQuery = true })
.WithPagination(2, 10).ToListAsync();
System.Console.WriteLine($"Retrieved {addedRetrieved.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Restart();
foreach (var addedre in addedRetrieved)
{
addedre.AnotherRandomProp += " Nick";
}
var updated = await booksStore.UpsertRangeAsync(addedRetrieved, x => new RequestOptions {
AccessCondition = new AccessCondition
{
Type = AccessConditionType.IfMatch,
Condition = x.Etag
}
});
System.Console.WriteLine($"Updated {updated.SuccessfulEntities.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Restart();
var removed = await booksStore.RemoveRangeAsync(addedRetrieved);
System.Console.WriteLine($"Removed {removed.SuccessfulEntities.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Reset();
watch.Stop();
System.Console.ReadKey();
}
/// <summary>
/// Add services to the container.
/// </summary>
/// <param name="services">Service Collection.</param>
public void ConfigureServices(IServiceCollection services)
{
var oktaSettings = services.ConfigureSettings <OktaSettings>(Configuration, "Okta");
var cosmosDbSettings = services.ConfigureSettings <CosmosDbSettings>(Configuration, "CosmosDB");
var locationMigrationSettings =
services.ConfigureSettings <LocationMigrationSettings>(Configuration, "LocationMigrationSettings");
if (locationMigrationSettings == null)
{
throw new ArgumentNullException(@"there is no location migration settings
example:
LocationMigrationSettings: {
Version: 1
}
");
}
services.ConfigureSettings <AuthorizationSettings>(Configuration, "Authorization");
services.ConfigureSettings <RequestChargeSettings>(Configuration, "RequestCharge");
var urgencySettings = services.ConfigureSettings <UrgencySettings>(Configuration, "UrgencySettings");
ConfigureOktaClient(services);
services.AddSingleton <ITokenService, OktaTokenService>();
services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
{
builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
}));
services.AddScoped <RequestChargeService>();
// Database connections.
services.AddSingleton <IDocumentClientFactory, DocumentClientFactory>();
services.AddScoped <IDatabaseAccess, DatabaseAccess>();
ConfigureQueries(services, cosmosDbSettings);
Mapper.Initialize(config => { config.AddMedicalExaminerProfiles(); });
Mapper.AssertConfigurationIsValid();
services.AddAutoMapper();
ConfigureAuthentication(services, oktaSettings, cosmosDbSettings);
ConfigureAuthorization(services);
services.AddMvcCore()
.AddVersionedApiExplorer(options =>
{
// The format of the version added to the route URL
options.GroupNameFormat = "'v'VVV";
// Tells swagger to replace the version in the controller route
options.SubstituteApiVersionInUrl = true;
});
services.AddMvc(options =>
{
options.UseExaminationContextModelBindingProvider();
options.Filters.Add <GlobalExceptionFilter>();
options.Filters.Add <ControllerActionFilter>();
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddExaminationValidation();
services.AddApiVersioning(config => { config.ReportApiVersions = true; });
// Register the Swagger generator, defining 1 or more Swagger documents
services.AddSwaggerGen(options =>
{
// c.SwaggerDoc("v1", new Info { Title = "Medical Examiner Data API", Version = "v1" });
// note: need a temporary service provider here because one has not been created yet
var provider = services.BuildServiceProvider()
.GetRequiredService <IApiVersionDescriptionProvider>();
// add a swagger document for each discovered API version
foreach (var description in provider.ApiVersionDescriptions)
{
options.SwaggerDoc(description.GroupName,
CreateInfoForApiVersion(description, ApiTitle, ApiDescription));
}
// add a custom operation filter which sets default values
options.OperationFilter <SwaggerDefaultValues>();
// Make all enums appear as strings
options.DescribeAllEnumsAsStrings();
// Locate the XML file being generated by ASP.NET.
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
// Swagger to use those XML comments.
options.IncludeXmlComments(xmlPath);
// Make swagger do authentication
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", Array.Empty <string>() },
};
options.AddSecurityDefinition("Okta", new OAuth2Scheme
{
Type = "oauth2",
Flow = "implicit",
AuthorizationUrl = oktaSettings.AuthorizationUrl,
Scopes = new Dictionary <string, string>
{
{ "profile", "Profile" },
{ "openid", "OpenID" },
},
});
options.AddSecurityDefinition("Bearer",
new ApiKeyScheme
{
Description =
"JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
options.AddSecurityRequirement(security);
});
services.AddScoped <ControllerActionFilter>();
// Can be any service, we just need the database id and uri.
var serviceProvider = services.BuildServiceProvider();
var userConnectionSettings = serviceProvider.GetRequiredService <IUserConnectionSettings>();
var documentClientFactory = serviceProvider.GetRequiredService <IDocumentClientFactory>();
var documentClient = documentClientFactory.CreateClient(userConnectionSettings, cosmosDbSettings.BypassSsl);
var cosmonautClient = new CosmonautClient(documentClient);
const string examinationsCollection = "Examinations";
services.AddCosmosStore <Examination>(cosmonautClient, cosmosDbSettings.DatabaseId, examinationsCollection);
services.AddCosmosStore <AuditEntry <Examination> >(cosmonautClient, cosmosDbSettings.DatabaseId, examinationsCollection.AuditCollection());
}
static async Task Main(string[] args)
{
var connectionPolicy = new ConnectionPolicy
{
ConnectionProtocol = Protocol.Tcp,
ConnectionMode = ConnectionMode.Direct
};
var cosmosSettings = new CosmosStoreSettings("localtest",
"https://*****:*****@id", new { id = aCarId });
var allTheCars = await carStore.QueryMultipleAsync <Car>("select * from c");
var addedRetrieved = await booksStore.Query().ToListAsync();
System.Console.WriteLine($"Retrieved {addedRetrieved.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Restart();
foreach (var addedre in addedRetrieved)
{
addedre.AnotherRandomProp += " Nick";
}
var updated = await booksStore.UpsertRangeAsync(addedRetrieved);
System.Console.WriteLine($"Updated {updated.SuccessfulEntities.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Restart();
var removed = await booksStore.RemoveRangeAsync(addedRetrieved);
System.Console.WriteLine($"Removed {removed.SuccessfulEntities.Count} documents in {watch.ElapsedMilliseconds}ms");
watch.Reset();
watch.Stop();
System.Console.ReadKey();
}
protected override void ConfigureServices(IServiceCollection services)
{
services.AddMemoryCache();
var builder = services.AddIdentityServer();
services.AddSingleton <IAsyncExceptionFilter, DemystifyExceptionFilter>();
services.AddSingleton <DatabaseInitializer <UnitTest_CacheItemCosmosStore> >(sp =>
{
return(new DatabaseInitializer <UnitTest_CacheItemCosmosStore>()
{
action = () =>
{
lock (this)
{
if (!Initialized)
{
var client = sp.GetRequiredService <ICosmonautClient>();
var collection = client.GetCollectionAsync(UnitTest_CacheItemCosmosStore.DatabaseId,
UnitTest_CacheItemCosmosStore.CollectionName).GetAwaiter().GetResult();
collection.DefaultTimeToLive = 7700000;
var response = client.UpdateCollectionAsync(UnitTest_CacheItemCosmosStore.DatabaseId,
UnitTest_CacheItemCosmosStore.CollectionName, collection)
.GetAwaiter()
.GetResult();
Initialized = true;
}
}
}
});
});
services.AddSingleton <DatabaseInitializer <UnitTest_PersistedGrantStore> >(sp =>
{
return(new DatabaseInitializer <UnitTest_PersistedGrantStore>()
{
action = () =>
{
lock (this)
{
if (!Initialized)
{
var client = sp.GetRequiredService <ICosmonautClient>();
var collection = client.GetCollectionAsync(UnitTest_PersistedGrantStore.DatabaseId,
UnitTest_PersistedGrantStore.CollectionName).GetAwaiter().GetResult();
collection.DefaultTimeToLive = 7700000;
var response = client.UpdateCollectionAsync(UnitTest_PersistedGrantStore.DatabaseId,
UnitTest_PersistedGrantStore.CollectionName, collection)
.GetAwaiter()
.GetResult();
Initialized = true;
}
}
}
});
});
services.AddSingleton <DatabaseInitializer <UnitTest_ResourceStore> >(sp =>
{
return(new DatabaseInitializer <UnitTest_ResourceStore>()
{
action = () =>
{
lock (this)
{
if (!Initialized)
{
var client = sp.GetRequiredService <ICosmonautClient>();
var collectionApiResource = client.GetCollectionAsync(UnitTest_ResourceStore.DatabaseId,
UnitTest_ResourceStore.CollectionNameApiResources).GetAwaiter().GetResult();
var collectionIdentityResource = client.GetCollectionAsync(UnitTest_ResourceStore.DatabaseId,
UnitTest_ResourceStore.CollectionNameIdentityResources).GetAwaiter().GetResult();
Initialized = true;
}
}
}
});
});
services.AddTransient <ICosmonautClient>(sp =>
{
var client = new CosmonautClient(_emulatorUri, _emulatorKey, _connectionPolicy);
return(client);
});
// _cosmonautClient = new CosmonautClient(_emulatorUri, _emulatorKey, _connectionPolicy);
var cosmosStoreSettings = new CosmosStoreSettings(
UnitTest_PersistedGrantStore.DatabaseId,
_emulatorUri,
_emulatorKey,
s =>
{
s.ConnectionPolicy = _connectionPolicy;
s.IndexingPolicy = new IndexingPolicy(
new RangeIndex(DataType.Number, -1),
new RangeIndex(DataType.String, -1));
});
var cosmosStoreSettingsCache = new CosmosStoreSettings(
UnitTest_CacheItemCosmosStore.DatabaseId,
_emulatorUri,
_emulatorKey,
s =>
{
s.ConnectionPolicy = _connectionPolicy;
s.IndexingPolicy = new IndexingPolicy(
new RangeIndex(DataType.Number, -1),
new RangeIndex(DataType.String, -1));
});
var cosmosStoreSettingsResources = new CosmosStoreSettings(
UnitTest_ResourceStore.DatabaseId,
_emulatorUri,
_emulatorKey,
s =>
{
s.ConnectionPolicy = _connectionPolicy;
s.IndexingPolicy = new IndexingPolicy(
new RangeIndex(DataType.Number, -1),
new RangeIndex(DataType.String, -1));
});
builder.AddOperationalStore(cosmosStoreSettings, UnitTest_PersistedGrantStore.CollectionName);
builder.AddCosmonautIdentityServerCacheStore(cosmosStoreSettingsCache, UnitTest_CacheItemCosmosStore.CollectionName);
builder.AddCosmonautResourceStore(
cosmosStoreSettingsResources,
UnitTest_ResourceStore.CollectionNameApiResources,
UnitTest_ResourceStore.CollectionNameIdentityResources);
}
