public static void RegisterComponents()
{
var container = new UnityContainer();
var documentUri = ConfigurationManager.AppSettings["DocumentUri"];
string authKey = ConfigurationManager.AppSettings["AuthorizationKey"];
string redisConnection = ConfigurationManager.AppSettings["RedisConnection"];
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
Uri uri = new Uri(documentUri);
ConnectionPolicy connectionPolicy = new ConnectionPolicy() { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp };
ConsistencyLevel consistencyLevel = new ConsistencyLevel();
consistencyLevel = ConsistencyLevel.Session;
container.RegisterType<IApplicationUserStore, ApplicatonUserStore>();
container.RegisterType<DocumentClient>(new ContainerControlledLifetimeManager(), new InjectionConstructor(uri, authKey, connectionPolicy, consistencyLevel));
ConnectionMultiplexer connectionMulp = ConnectionMultiplexer.Connect(redisConnection);
container.RegisterInstance<IConnectionMultiplexer>(ConnectionMultiplexer.Connect(redisConnection));
container.RegisterType<IRedisRepository, RedisRepository>();
container.RegisterType<IUserRepository, UserRepository>();
var repo = container.Resolve<IRedisRepository>();
container.RegisterType<RefreshTokenProvider>(new InjectionConstructor(repo));
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public void Set(ConnectionPolicy connectionPolicy)
{
lock (_policies)
{
_policies.Clear();
_policies.Push(connectionPolicy);
}
}
public DocumentClient GetClient(string endpointUrl, string authorizationKey, ConnectionPolicy connectionPolicy = null)
{
if (string.IsNullOrWhiteSpace(endpointUrl))
throw new ArgumentNullException("endpointUrl");
if (string.IsNullOrWhiteSpace(authorizationKey))
throw new ArgumentNullException("authorizationKey");
return new DocumentClient(new Uri(endpointUrl), authorizationKey, connectionPolicy ?? new ConnectionPolicy());
}
static void Main(string[] args)
{
if (args.Count() < 4)
{
Console.WriteLine("You must specify the following parameters: Document DB endpoint URL, secret key, database name, and collection name.");
Console.WriteLine("Program terminated. Press any key to exit");
Console.ReadKey();
return; // exit program
}
// setup DocumentDB client using passed parameters
Uri endpoint = new Uri(args[0]);
string authKey = args[1];
string databaseId = args[2];
string collectionId = args[3];
var connectionPolicy = new ConnectionPolicy()
{
ConnectionProtocol = Protocol.Https,
ConnectionMode = ConnectionMode.Gateway
};
client = new DocumentClient(endpoint, authKey, connectionPolicy);
Database database = client.CreateDatabaseQuery().Where(db => db.Id == databaseId).ToArray().FirstOrDefault();
DocumentCollection collection = client.CreateDocumentCollectionQuery(database.SelfLink).Where(c => c.Id == collectionId).ToArray().FirstOrDefault();
// get list of SP files
var currentDir = new DirectoryInfo(Directory.GetCurrentDirectory());
foreach (FileInfo tmpFile in currentDir.GetFiles("SP_*.js"))
{
string storedProecureId = tmpFile.Name.Substring(3, (tmpFile.Name.Length - 6));
Console.WriteLine("Found File: " + storedProecureId);
var storedProc = new StoredProcedure()
{
Id = storedProecureId,
Body = File.ReadAllText(tmpFile.FullName)
};
TryDeleteStoredProcedure(collection.SelfLink, storedProc.Id);
client.CreateStoredProcedureAsync(collection.SelfLink, storedProc, null).Wait();
}
Console.WriteLine("Stored Procedure Setup completed. Press any key to continue.");
Console.ReadKey();
}
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);
}
public void GenerateEventMain(string cartId, string actionEvent, string productName, double unitPrice)
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy();
connectionPolicy.UserAgentSuffix = " samples-net/3";
connectionPolicy.ConnectionMode = ConnectionMode.Direct;
connectionPolicy.ConnectionProtocol = Protocol.Tcp;
connectionPolicy.PreferredLocations.Add(LocationNames.WestUS);
connectionPolicy.PreferredLocations.Add(LocationNames.NorthEurope);
connectionPolicy.PreferredLocations.Add(LocationNames.SoutheastAsia);
Initialize(ConfigurationManager.AppSettings["database"],
ConfigurationManager.AppSettings["collection"],
ConfigurationManager.AppSettings["endpoint"],
ConfigurationManager.AppSettings["authKey"], connectionPolicy);
InsertData(GenerateEventHelper(cartId, actionEvent, productName, unitPrice));
}
public void UserAgentContainsEnvironmentInformation()
{
EnvironmentInformation environmentInformation = new EnvironmentInformation();
string expectedValue = environmentInformation.ToString();
CosmosClientOptions cosmosClientOptions = new CosmosClientOptions();
string userAgentSuffix = "testSuffix";
cosmosClientOptions.ApplicationName = userAgentSuffix;
Assert.IsTrue(cosmosClientOptions.UserAgentContainer.Suffix.EndsWith(userAgentSuffix));
Assert.IsTrue(cosmosClientOptions.UserAgentContainer.Suffix.Contains(expectedValue));
ConnectionPolicy connectionPolicy = cosmosClientOptions.GetConnectionPolicy();
Assert.IsTrue(connectionPolicy.UserAgentSuffix.EndsWith(userAgentSuffix));
Assert.IsTrue(connectionPolicy.UserAgentSuffix.Contains(expectedValue));
}
/// <inheritdoc/>
public async Task <DocumentClient> GetDocumentClient(string environment)
{
if (_clients.TryGetValue(environment, out DocumentClient documentClient))
{
return(documentClient);
}
try
{
_accountConfig.TryGetValue(environment, out CosmosAccountConfig config);
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https,
};
string token = await _accessTokenService.GetToken(new TokenRequestContext(new[] { "https://management.azure.com/user_impersonation" }));
using HttpClient client = new HttpClient();
string url = $"https://management.azure.com/subscriptions/{config.SubscriptionId}/resourceGroups/{config.ResourceGroup}/providers/Microsoft.DocumentDB/databaseAccounts/{config.AccountName}/listKeys?api-version=2020-04-01";
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage res = await client.PostAsync(url, null);
if (res.StatusCode == System.Net.HttpStatusCode.OK)
{
JObject responseObject = JObject.Parse(await res.Content.ReadAsStringAsync());
config.PrimaryKey = responseObject["primaryMasterKey"].ToString();
_accountConfig[environment].PrimaryKey = config.PrimaryKey;
documentClient = new DocumentClient(new Uri($"https://altinn-{environment}-cosmos-db.documents.azure.com:443/"), config.PrimaryKey, connectionPolicy);
_clients.Add(environment, documentClient);
}
client.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(documentClient);
}
/// <summary>
///
/// </summary>
/// <param name="configurationSection"></param>
public BaseRepository(IConfigurationSection configurationSection)
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
MaxConnectionLimit = 500,
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
connectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = 2;
connectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = 5;
_client = new DocumentClient(new Uri(configurationSection.GetSection("EndpointUri").Value),
configurationSection.GetSection("PrimaryKey").Value,
new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver(),
NullValueHandling = NullValueHandling.Ignore
},
connectionPolicy: connectionPolicy);
_databaseId = configurationSection.GetSection("DatabaseId").Value;
_collectionId = configurationSection.GetSection("CollectionId").Value;
_maxItemCount = int.Parse(configurationSection.GetSection("MaxItemCount").Value);
#region Database/Container Initialization
_client.CreateDatabaseIfNotExistsAsync(new Database {
Id = _databaseId
}).Wait();
DocumentCollection collectionDefinition = new DocumentCollection();
collectionDefinition.Id = _collectionId;
collectionDefinition.PartitionKey.Paths.Add("/Type");
_client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri(_databaseId),
collectionDefinition,
new RequestOptions {
OfferThroughput = 400
}).Wait();
#endregion
}
public void RetryExceedingMaxTimeLimit()
{
Mock <IStoreModel> mockStoreModel = new Mock <IStoreModel>();
mockStoreModel.Setup(model => model.ProcessMessageAsync(It.IsAny <DocumentServiceRequest>(), default(CancellationToken)))
.Throws(this.CreateTooManyRequestException(100));
ConnectionPolicy connectionPolicy = new ConnectionPolicy()
{
EnableEndpointDiscovery = false,
RetryOptions = new RetryOptions {
MaxRetryAttemptsOnThrottledRequests = 100, MaxRetryWaitTimeInSeconds = 1
}
};
DocumentClient client = new DocumentClient(
new Uri(ConfigurationManager.AppSettings["GatewayEndpoint"]),
ConfigurationManager.AppSettings["MasterKey"],
connectionPolicy);
client.GetDatabaseAccountAsync().Wait();
int expectedExecutionTimes = 11;
client.StoreModel = mockStoreModel.Object;
client.GatewayStoreModel = mockStoreModel.Object;
bool throttled = false;
try
{
CosmosDatabaseSettings db = new CosmosDatabaseSettings {
Id = "test db 1"
};
client.CreateDatabaseAsync(db).Wait();
}
catch (Exception exp)
{
DocumentClientException docExp = exp.InnerException as DocumentClientException;
Assert.AreEqual((HttpStatusCode)429, docExp.StatusCode);
throttled = true;
}
mockStoreModel.Verify(model => model.ProcessMessageAsync(It.IsAny <DocumentServiceRequest>(), default(CancellationToken)), Times.Exactly(expectedExecutionTimes));
Assert.IsTrue(throttled);
}
private IDocumentClient GetDocumentClient()
{
var resourceAccessKey = cosmosDBConfiguration?.Key;
var resourceEndpoint = cosmosDBConfiguration?.Uri;
var connectionPolicy = new ConnectionPolicy()
{
ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp
};
if (System.Diagnostics.Debugger.IsAttached)
{
this.logger.LogWarning($"Program has debugger attached and will use https for docdb calls, this will reduce performance but allow for tracing.");
connectionPolicy.ConnectionProtocol = Protocol.Https;
}
return(new DocumentClient(new Uri(resourceEndpoint), resourceAccessKey, connectionPolicy: connectionPolicy));
}
public DocumentRepository(
string endpoint, SecureString accessKey,
string databaseName, string collectionName, string documentTypeName = null,
JsonSerializerSettings serializerSettings = null,
ConnectionPolicy connectionPolicy = null, ConsistencyLevel?consistencyLevel = null)
{
ArgCheck.NotNullOrEmpty(nameof(endpoint), endpoint);
ArgCheck.NotNull(nameof(accessKey), accessKey);
ArgCheck.NotNullOrEmpty(nameof(databaseName), databaseName);
ArgCheck.NotNullOrEmpty(nameof(collectionName), collectionName);
_databaseName = databaseName;
_collectionName = collectionName;
_documentTypeName = documentTypeName;
_client = new DocumentClient(new Uri(endpoint), accessKey, serializerSettings, connectionPolicy, consistencyLevel);
_serializerSettings = serializerSettings;
_collectionUri = UriFactory.CreateDocumentCollectionUri(_databaseName, _collectionName);
}
/// <summary>
/// Initializes a new instance of the <see cref="BlogBase"/> class.
/// </summary>
/// <param name="config">Configuration.</param>
/// <param name="loggerFactory">Logger factory.</param>
public BlogBase(IConfigurationRoot config, ILoggerFactory loggerFactory)
{
this.ServiceEndpoint = config["manticaDocumentDbServiceEndpoint"];
this.AuthKey = config["manticaDocumentDbAuthKey"];
this.DatabaseId = config["manticaDocumentDbDatabaseId"];
this.CollectionId = config["manticaDocumentDbCollectionId"];
this.CollectionUri = UriFactory.CreateDocumentCollectionUri(this.DatabaseId, this.CollectionId);
this.CounterMapper = new CounterMapper();
this.Log = loggerFactory.CreateLogger(this.GetType().Name);
var connPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
this.Client = new DocumentClient(new Uri(this.ServiceEndpoint), this.AuthKey, connPolicy);
}
/// <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 CosmosDbClient(DocumentClientConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
this.documentClient = new DocumentClient(
new Uri(configuration.DocumentDbUri),
configuration.DocumentDbKey,
connectionPolicy);
}
static void Main(string[] args)
{
InitializeLists();
r = new Random();
var connectionPolicy = new ConnectionPolicy()
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Https
};
client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey, connectionPolicy);
bool recreate = true;
Setup(recreate).Wait();
SeedDocdb().Wait();
}
public DocumentClient CreateDocumentClient()
{
var serializerSettings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore
};
var connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
var documentEndpoint = new Uri(this.config.Cosmos.DocumentEndpoint);
return(new DocumentClient(documentEndpoint, this.config.Cosmos.PrimaryMasterKey, serializerSettings, connectionPolicy));
}
public void Initialize()
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy();
connectionPolicy.PreferredLocations.Add(LocationNames.CentralIndia);
//create client without connection policy
//client = new DocumentClient(
// new Uri(ConfigurationManager.AppSettings["endpoint"]), ConfigurationManager.AppSettings["authKey"]);
//with connection policy
client = new DocumentClient(
new Uri(ConfigurationManager.AppSettings["endpoint"]), ConfigurationManager.AppSettings["authKey"], connectionPolicy);
CreateDatabaseIfNotExistsAsync().Wait();
CreateCollectionIfNotExistsAsync().Wait();
}
private async Task <DocumentClient> CreateDatabaseAndCollection(CancellationToken cancellationToken)
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Gateway,
ConnectionProtocol = Protocol.Https,
};
DocumentClient client = new DocumentClient(new Uri(_cosmosSettings.EndpointUri), _cosmosSettings.PrimaryKey, connectionPolicy);
DatabaseUri = UriFactory.CreateDatabaseUri(DatabaseId);
CollectionUri = UriFactory.CreateDocumentCollectionUri(DatabaseId, _collectionId);
await client.CreateDatabaseIfNotExistsAsync(new Database { Id = DatabaseId })
.WithCancellation(cancellationToken);
return(client);
}
private DocumentClient GetClient(Connection connection)
{
if (!_clientInstances.ContainsKey(connection))
{
var policy = new ConnectionPolicy
{
ConnectionMode = connection.ConnectionType == ConnectionType.Gateway ? ConnectionMode.Gateway : ConnectionMode.Direct,
ConnectionProtocol = connection.ConnectionType == ConnectionType.DirectHttps ? Protocol.Https : Protocol.Tcp
};
var client = new DocumentClient(connection.DatabaseUri, connection.AuthenticationKey, policy);
client.OpenAsync();
_clientInstances.Add(connection, client);
}
return(_clientInstances[connection]);
}
public void ConnectionPolicyConfiguratorShouldBeCalled()
{
if (CheckEmulator())
{
ConnectionPolicy policyRef = null;
_storage = new CosmosDbStorage(new CosmosDbStorageOptions
{
AuthKey = CosmosAuthKey,
CollectionId = CosmosCollectionName,
CosmosDBEndpoint = new Uri(CosmosServiceEndpoint),
DatabaseId = CosmosDatabaseName,
ConnectionPolicyConfigurator = (ConnectionPolicy policy) => policyRef = policy
});
Assert.IsNotNull(policyRef, "ConnectionPolicy configurator was not called.");
}
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args).
UseApplicationInsights().
ConfigureAppConfiguration((hostingContext, config) =>
{
Configuration = config.Build();
}).
ConfigureServices(s =>
{
s.AddMvc();
#region CosmosDB
var cosmosDbConfig = ConfigurationBinder.Get <CosmosDbConfig>(Configuration.GetSection("CosmosDb"));
s.AddSingleton(cosmosDbConfig);
var connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true
};
if (cosmosDbConfig.PreferredLocations != null && cosmosDbConfig.PreferredLocations.Any() && cosmosDbConfig.PreferredLocations.All(l => AllowedLocations.Contains(l)))
{
// write
connectionPolicy.SetCurrentLocation(cosmosDbConfig.PreferredLocations.First());
// read
foreach (var location in cosmosDbConfig.PreferredLocations)
{
connectionPolicy.PreferredLocations.Add(location);
}
}
var client = new DocumentClient(new Uri(cosmosDbConfig.Endpoint), cosmosDbConfig.Key, connectionPolicy);
client.OpenAsync().GetAwaiter().GetResult();
s.AddSingleton(client);
#endregion
}).
Configure(app =>
{
app.UseHttpsRedirection();
app.UseMvc();
});
public SingleMultiMaster()
{
string endpoint, key, region;
databaseName = Environment.GetEnvironmentVariable("database");
containerName = Environment.GetEnvironmentVariable("container");
storedProcName = Environment.GetEnvironmentVariable("storedproc");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
//Single-Master Connection Policy
ConnectionPolicy policySingleMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion");
policySingleMaster.SetCurrentLocation(region);
// Create the Single-Master account client
endpoint = Environment.GetEnvironmentVariable("SingleMasterEndpoint");
key = Environment.GetEnvironmentVariable("SingleMasterKey");
clientSingle = new DocumentClient(new Uri(endpoint), key, policySingleMaster, ConsistencyLevel.Eventual);
clientSingle.OpenAsync().GetAwaiter().GetResult();
//Multi-Master Connection Policy
ConnectionPolicy policyMultiMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true //Required for Multi-Master
};
region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion");
policyMultiMaster.SetCurrentLocation(region); //Enable multi-homing
// Create the Multi-Master account client
endpoint = Environment.GetEnvironmentVariable("MultiMasterEndpoint");
key = Environment.GetEnvironmentVariable("MultiMasterKey");
clientMulti = new DocumentClient(new Uri(endpoint), key, policyMultiMaster, ConsistencyLevel.Eventual);
clientMulti.OpenAsync().GetAwaiter().GetResult();
}
private DocumentClient GetDocumentClient()
{
var dict = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var segment in options.ConnectionString.Split(';').Where(x => !string.IsNullOrWhiteSpace(x)))
{
var pos = segment.IndexOf('=', StringComparison.Ordinal);
if (pos <= 0)
{
Log.Error("Unexpected connection string segment: {Segment}", segment);
return(null);
}
dict.Add(segment.Substring(0, pos), segment.Substring(pos + 1, segment.Length - pos - 1));
}
if (!dict.TryGetValue("AccountEndpoint", out string accountEndpoint))
{
Log.Error("Missing connection string segment: AccountEndpoint");
return(null);
}
if (!dict.TryGetValue("AccountKey", out string accountKey))
{
Log.Error("Missing connection string segment: AccountKey");
return(null);
}
var policy = new ConnectionPolicy();
if (options.ConnectionMode == CosmosConnection.Direct)
{
policy.ConnectionMode = ConnectionMode.Direct;
policy.ConnectionProtocol = Protocol.Tcp;
}
else
{
policy.ConnectionMode = ConnectionMode.Gateway;
policy.ConnectionProtocol = Protocol.Https;
}
return(new DocumentClient(new Uri(accountEndpoint, UriKind.Absolute), accountKey, policy));
}
/// <summary>
/// Initializes a new instance of the <see cref="CosmosDbStorage"/> class.
/// using the provided CosmosDB credentials, database ID, and collection ID.
/// </summary>
/// <param name="cosmosDbStorageOptions">Cosmos DB storage configuration options.</param>
public CosmosDbStorage(CosmosDbStorageOptions cosmosDbStorageOptions)
{
if (cosmosDbStorageOptions == null)
{
throw new ArgumentNullException(nameof(cosmosDbStorageOptions));
}
if (cosmosDbStorageOptions.CosmosDBEndpoint == null)
{
throw new ArgumentNullException(nameof(cosmosDbStorageOptions.CosmosDBEndpoint), "Service EndPoint for CosmosDB is required.");
}
if (string.IsNullOrEmpty(cosmosDbStorageOptions.AuthKey))
{
throw new ArgumentException("AuthKey for CosmosDB is required.", nameof(cosmosDbStorageOptions.AuthKey));
}
if (string.IsNullOrEmpty(cosmosDbStorageOptions.DatabaseId))
{
throw new ArgumentException("DatabaseId is required.", nameof(cosmosDbStorageOptions.DatabaseId));
}
if (string.IsNullOrEmpty(cosmosDbStorageOptions.CollectionId))
{
throw new ArgumentException("CollectionId is required.", nameof(cosmosDbStorageOptions.CollectionId));
}
_databaseId = cosmosDbStorageOptions.DatabaseId;
_collectionId = cosmosDbStorageOptions.CollectionId;
_partitionKey = cosmosDbStorageOptions.PartitionKey;
_documentCollectionCreationRequestOptions = cosmosDbStorageOptions.DocumentCollectionRequestOptions;
_databaseCreationRequestOptions = cosmosDbStorageOptions.DatabaseCreationRequestOptions;
// Inject BotBuilder version to CosmosDB Requests
var version = GetType().Assembly.GetName().Version;
var connectionPolicy = new ConnectionPolicy {
UserAgentSuffix = $"Microsoft-BotFramework {version}"
};
// Invoke CollectionPolicy delegate to further customize settings
cosmosDbStorageOptions.ConnectionPolicyConfigurator?.Invoke(connectionPolicy);
_client = new DocumentClient(cosmosDbStorageOptions.CosmosDBEndpoint, cosmosDbStorageOptions.AuthKey, connectionPolicy);
}
public static void Main(string[] args)
{
try
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy();
connectionPolicy.UserAgentSuffix = " samples-net/3";
connectionPolicy.ConnectionMode = ConnectionMode.Direct;
connectionPolicy.ConnectionProtocol = Protocol.Tcp;
// Set the read region selection preference order
connectionPolicy.PreferredLocations.Add(LocationNames.EastUS); // first preference
connectionPolicy.PreferredLocations.Add(LocationNames.NorthEurope); // second preference
connectionPolicy.PreferredLocations.Add(LocationNames.SoutheastAsia); // third preference
using (client = new DocumentClient(new Uri(endpointUrl), authorizationKey, new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc
}, connectionPolicy))
{
Initialize().Wait();
RunDocumentsDemo().Wait();
Cleanup();
}
}
#if !DEBUG
catch (DocumentClientException de)
{
Exception baseException = de.GetBaseException();
Console.WriteLine("{0} error occurred: {1}, Message: {2}", de.StatusCode, de.Message, baseException.Message);
}
catch (Exception e)
{
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
#endif
finally
{
Console.WriteLine("End of demo, press any key to exit.");
Console.ReadKey();
}
}
public ConsistencyLatency()
{
string endpoint, key, region;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
region = ConfigurationManager.AppSettings["ConsistencyLatencyRegion"];
Console.WriteLine("Latency vs Eventual and Strong Consistency");
Console.WriteLine("-------------------------------------------------------------------------------------");
//Shared connection policy
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
//Eventual consistency client
endpoint = ConfigurationManager.AppSettings["EventualEndpoint"];
key = ConfigurationManager.AppSettings["EventualKey"];
clientEventual = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientEventual.OpenAsync();
Console.WriteLine($"Created DocumentClient with Eventual consistency in: {region}.");
//Strong consistency client 1K miles
endpoint = ConfigurationManager.AppSettings["Strong1kMilesEndpoint"];
key = ConfigurationManager.AppSettings["Strong1kMilesKey"];
clientStrong1kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong1kMiles.OpenAsync();
Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 1000 miles.");
//Strong consistency client 2K miles
endpoint = ConfigurationManager.AppSettings["Strong2kMilesEndpoint"];
key = ConfigurationManager.AppSettings["Strong2kMilesKey"];
clientStrong2kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong2kMiles.OpenAsync();
Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 2000 miles.");
Console.WriteLine();
}
private void SetupDateTimeScenario(JsonSerializerSettings serializerSettings, string jsonPropertyName, out DocumentClient client, out Document originalDocument, out Document outputDocument, out Document outputPartitionedDocument)
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy {
ConnectionMode = ConnectionMode.Gateway
};
ConsistencyLevel defaultConsistencyLevel = ConsistencyLevel.Session;
client = this.CreateDocumentClient(
this.hostUri,
this.masterKey,
serializerSettings,
connectionPolicy,
defaultConsistencyLevel);
originalDocument = new Document();
originalDocument.SetPropertyValue(jsonPropertyName, "2017-05-18T17:17:32.7514920Z");
originalDocument.SetPropertyValue(PartitionKeyProperty, "value");
outputDocument = client.CreateDocumentAsync(this.collectionUri, originalDocument, this.ApplyRequestOptions(new RequestOptions(), serializerSettings), disableAutomaticIdGeneration: false).Result.Resource;
outputPartitionedDocument = client.CreateDocumentAsync(this.partitionedCollectionUri, originalDocument, this.ApplyRequestOptions(new RequestOptions(), serializerSettings), disableAutomaticIdGeneration: false).Result.Resource;
}
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;
var serviceEndPoint = new Uri(settings.Value.EndPointUrl);
DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,
connectionPolicy ?? ConnectionPolicy.Default);
DatabaseUri = UriFactory.CreateDatabaseUri(databaseName);
Database = new Database {
Id = databaseName
};
Database = DocumentClient.CreateDatabaseIfNotExistsAsync(Database).Result;
}
public void UserAgentContainsEnvironmentInformation()
{
EnvironmentInformation environmentInformation = new EnvironmentInformation();
string expectedValue = "cosmos-netstandard-sdk/" + environmentInformation.ClientVersion;
CosmosClientOptions cosmosClientOptions = new CosmosClientOptions();
string userAgentSuffix = "testSuffix";
cosmosClientOptions.ApplicationName = userAgentSuffix;
Assert.AreEqual(userAgentSuffix, cosmosClientOptions.ApplicationName);
Assert.AreEqual(userAgentSuffix, cosmosClientOptions.UserAgentContainer.Suffix);
Assert.IsTrue(cosmosClientOptions.UserAgentContainer.UserAgent.StartsWith(expectedValue));
Assert.IsTrue(cosmosClientOptions.UserAgentContainer.UserAgent.EndsWith(userAgentSuffix));
ConnectionPolicy connectionPolicy = cosmosClientOptions.GetConnectionPolicy();
Assert.AreEqual(userAgentSuffix, connectionPolicy.UserAgentSuffix);
Assert.IsTrue(connectionPolicy.UserAgentContainer.UserAgent.StartsWith(expectedValue));
Assert.IsTrue(connectionPolicy.UserAgentContainer.UserAgent.EndsWith(userAgentSuffix));
}
public CosmosStoreSettings(
string databaseName,
Uri endpointUrl,
string authKey,
ConnectionPolicy connectionPolicy = null,
IndexingPolicy indexingPolicy = null,
int defaultCollectionThroughput = CosmosConstants.MinimumCosmosThroughput,
bool scaleCollectionRUsAutomatically = false,
int maximumUpscaleRequestUnits = CosmosConstants.DefaultMaximumUpscaleThroughput)
{
DatabaseName = databaseName ?? throw new ArgumentNullException(nameof(databaseName));
EndpointUrl = endpointUrl ?? throw new ArgumentNullException(nameof(endpointUrl));
AuthKey = authKey ?? throw new ArgumentNullException(nameof(authKey));
ConnectionPolicy = connectionPolicy;
DefaultCollectionThroughput = defaultCollectionThroughput;
ScaleCollectionRUsAutomatically = scaleCollectionRUsAutomatically;
MaximumUpscaleRequestUnits = maximumUpscaleRequestUnits;
IndexingPolicy = indexingPolicy ?? CosmosConstants.DefaultIndexingPolicy;
}
/// <summary>
/// Create Client.
/// </summary>
/// <param name="connectionSettings">Connection Settings.</param>
/// <returns><see cref="IDocumentClient"/>.</returns>
public IDocumentClient CreateClient(IClientSettings connectionSettings, bool bypassSsl)
{
if (_client == null)
{
var connectionPolicy = new ConnectionPolicy
{
RequestTimeout = TimeSpan.FromSeconds(5),
MediaRequestTimeout = TimeSpan.FromSeconds(5),
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
// OpenSSL on Linux won't accept the emulator certificate so we have to ignore it.
if (bypassSsl)
{
// If bypassing ssl also switch to a simpler connection method.
connectionPolicy.ConnectionMode = ConnectionMode.Gateway;
connectionPolicy.ConnectionProtocol = Protocol.Https;
var handler = new HttpClientHandler
{
ClientCertificateOptions = ClientCertificateOption.Manual,
ServerCertificateCustomValidationCallback = (message, certificate2, arg3, arg4) => true
};
// All connections will now use our handler and ignore the SSL certificate.
_client = new DocumentClient(
connectionSettings.EndPointUri,
connectionSettings.PrimaryKey,
handler,
connectionPolicy);
}
else
{
_client = new DocumentClient(
connectionSettings.EndPointUri,
connectionSettings.PrimaryKey,
connectionPolicy);
}
}
return(_client);
}
public static async Task <DocumentClient> ConnectToCosmosDB(string accountUrl, string accountKey, List <string> preferredRegions)
{
DocumentClient result = null;
ConnectionPolicy connectionPolicy = new ConnectionPolicy()
{
ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp
};
ConsistencyLevel?consistency = null; // Use default, can only be weaker than default!
if (preferredRegions != null)
{
preferredRegions.ForEach(region => connectionPolicy.PreferredLocations.Add(region));
}
result = new DocumentClient(new System.Uri(accountUrl), accountKey, connectionPolicy, consistency);
await result.OpenAsync().ConfigureAwait(false); // Initialize connection (https://msdn.microsoft.com/en-us/magazine/jj991977.aspx)
return(result);
}
public SingleMultiRegion()
{
Console.WriteLine("Single Region vs Multi-Region Read Latency");
Console.WriteLine("-------------------------------------------------------------------------");
string endpoint, key, region;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
storedProcName = ConfigurationManager.AppSettings["storedproc"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
//Single-Region account client
endpoint = ConfigurationManager.AppSettings["SingleRegionEndpoint"];
key = ConfigurationManager.AppSettings["SingleRegionKey"];
region = ConfigurationManager.AppSettings["SingleRegionRegion"];
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
clientSingle = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientSingle.OpenAsync();
Console.WriteLine($"Created DocumentClient for Single-Region account in: {region}.");
//Multi-Region account client
endpoint = ConfigurationManager.AppSettings["MultiRegionEndpoint"];
key = ConfigurationManager.AppSettings["MultiRegionKey"];
region = ConfigurationManager.AppSettings["MultiRegionRegion"];
policy.SetCurrentLocation(region);
clientMulti = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientMulti.OpenAsync();
Console.WriteLine($"Created DocumentClient for Multi-Region account in: {region}.");
Console.WriteLine();
}
static void Main(string[] args)
{
ConnectionPolicy policy = new ConnectionPolicy()
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
Uri endPoint = new Uri(EndpointUrl);
using (DocumentClient client = new DocumentClient(endPoint, AuthKey, policy))
{
Database database =
client.CreateDatabaseQuery().Where(db => db.Id == DatabasebId).AsEnumerable().First();
DocumentCollection collection =
client.CreateDocumentCollectionQuery(database.SelfLink)
.Where(c => c.Id == CollectionId)
.AsEnumerable()
.First();
IEnumerable<DataClass> dataSet = GetDataObjects(100);
Task<ResourceResponse<Document>>[] documentTasks =
dataSet.Select(d => client.CreateDocumentAsync(collection.DocumentsLink, d)).ToArray();
Task.WaitAll(documentTasks);
Document[] docs = documentTasks.Select(t => t.Result.Resource).ToArray();
Document doc = docs.First();
Task<ResourceResponse<Attachment>>[] attachmentTasks =
docs.Select(d => client.CreateAttachmentAsync(doc.AttachmentsLink, GetStream(1024))).ToArray();
Task.WaitAll(attachmentTasks);
DataClass[] data =
client.CreateDocumentQuery<DataClass>(collection.DocumentsLink).Select(d => d).ToArray();
Attachment[] attachments = client.CreateAttachmentQuery(doc.AttachmentsLink).ToArray();
string sql = "SELECT c.Name FROM c Where c.ObjectKey < 30 AND c.ObjectKey > 20";
dynamic[] dataArray = client.CreateDocumentQuery(collection.DocumentsLink, sql).ToArray();
}
}
public static void Main(string[] args)
{
try
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy();
connectionPolicy.UserAgentSuffix = " samples-net/3";
connectionPolicy.ConnectionMode = ConnectionMode.Direct;
connectionPolicy.ConnectionProtocol = Protocol.Tcp;
// Set the read region selection preference order
connectionPolicy.PreferredLocations.Add(LocationNames.EastUS); // first preference
connectionPolicy.PreferredLocations.Add(LocationNames.NorthEurope); // second preference
connectionPolicy.PreferredLocations.Add(LocationNames.SoutheastAsia); // third preference
using (client = new DocumentClient(new Uri(endpointUrl), authorizationKey, connectionPolicy))
{
Initialize().Wait();
RunDocumentsDemo().Wait();
Cleanup();
}
}
#if !DEBUG
catch (DocumentClientException de)
{
Exception baseException = de.GetBaseException();
Console.WriteLine("{0} error occurred: {1}, Message: {2}", de.StatusCode, de.Message, baseException.Message);
}
catch (Exception e)
{
Exception baseException = e.GetBaseException();
Console.WriteLine("Error: {0}, Message: {1}", e.Message, baseException.Message);
}
#endif
finally
{
Console.WriteLine("End of demo, press any key to exit.");
Console.ReadKey();
}
}
public IConnection NewUDPConnection(ConnectionPolicy policy, System.Net.EndPoint server, bool start)
{
IConnection conn = null;
if (policy.Proxy.ProxyType == ProxyType.None)
{
conn = new UDPConnection(policy, server);
}
else
{
return null;
}
registry.Add(policy.ID, conn);
if (start)
{
conn.Connect();
}
return conn;
}
public UDPConnection(ConnectionPolicy policy, EndPoint server)
: base(policy, server)
{
}
public IConnection NewTCPConnection(ConnectionPolicy policy, System.Net.EndPoint server, bool start)
{
IConnection conn = null;
if (policy.Proxy.ProxyType == ProxyType.None)
{
conn = new TCPConnection(policy, server);
}
else
{
conn = new ProxyTCPConnection(policy, server, policy.Proxy);
}
if (start)
{
//如果网络连接失败，则返回null
if (!conn.Connect())
{
return null;
}
}
registry.Add(policy.ID, conn);
return conn;
}
public void Pop(ConnectionPolicy policy)
{
lock (_policies)
if (_policies.Peek() == policy)
_policies.Pop();
}
public ProxyTCPConnection(ConnectionPolicy policy, EndPoint server, Proxy proxy)
: base(policy,server)
{
this.proxy = proxy;
}
public SocketConnection(ConnectionPolicy policy, EndPoint server)
{
this.policy = policy;
this.epServer = server;
//outPacketQueue = new Queue<OutPacket>();
}
public void Push(ConnectionPolicy policy)
{
lock (_policies)
_policies.Push(policy);
}
static DocumentClient CreateDocumentClient(string endpointUrl, string authorizationKey, ConnectionPolicy connectionPolicy)
=> new DocumentClient(new Uri(endpointUrl), authorizationKey, connectionPolicy);
