public async Task Test_GetAllScopes() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName1 = "test_scopex1", collectionName = "test_collection1", scopeName2 = "test_scopex2", scopeName3 = "test_scopex3", scopeName4 = "test_scopex4"; var scopeSpec1 = new ScopeSpec(scopeName1); var scopeSpec2 = new ScopeSpec(scopeName2); var scopeSpec3 = new ScopeSpec(scopeName3); var scopeSpec4 = new ScopeSpec(scopeName4); var collectionSpec = new CollectionSpec(scopeName1, collectionName); // create scope await collectionManager.CreateScopeAsync(scopeSpec1).ConfigureAwait(false); await collectionManager.CreateScopeAsync(scopeSpec2).ConfigureAwait(false); await collectionManager.CreateScopeAsync(scopeSpec3).ConfigureAwait(false); await collectionManager.CreateScopeAsync(scopeSpec4).ConfigureAwait(false); // get all scopes var getAllScopesResult = await collectionManager.GetAllScopesAsync().ConfigureAwait(false); Assert.NotNull(getAllScopesResult); }
public async Task Test_RemoveOps() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope13", collectionName = "test_collection13"; var collectionSpec = new CollectionSpec(scopeName, collectionName); await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); try { // create scope and collection await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var scope = await bucket.ScopeAsync(scopeName); var collection = await scope.CollectionAsync(collectionName); var insertTasks = Enumerable.Range(0, 20).Select(x => collection.InsertAsync($"mykey-{x}", new { })); await Task.WhenAll(insertTasks); var removeTasks = Enumerable.Range(0, 20).Select(x => collection.RemoveAsync($"mykey-{x}")); await Task.WhenAll(removeTasks); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
public async Task Test_DropNonExistentCollection_Throws_CollectionNotFoundException() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "scope_only"; var collectionSpecNone = new CollectionSpec(scopeName, "collection_null"); await DropScopeAndCollectionIfExists(scopeName, collectionSpecNone, collectionManager); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); await collectionManager.DropCollectionAsync(collectionSpecNone).ConfigureAwait(false); } catch (CollectionNotFoundException e) { Assert.Equal("Collection with name collection_null not found in scope scope_only", e.Message); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpecNone, collectionManager); } }
public async Task Test_DropNonExistentScope_Throws_ScopeNotFoundException() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope8", collectionName = "test_collection8"; var collectionSpec = new CollectionSpec(scopeName, collectionName); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); await collectionManager.DropScopeAsync("scope_none").ConfigureAwait(false); } catch (ScopeNotFoundException e) { Assert.Equal("Scope with name scope_none not found", e.Message); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
public async Task Test_SingleScopeMaxNumberOfCollections() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; string scopeName = "singlescope1"; var scopeSpec = new ScopeSpec(scopeName); try { await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); for (int i = 0; i < 1000; i++) { var collectionSpec = new CollectionSpec(scopeName, (1000 + i).ToString()); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); } } finally { // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
public async Task Test_ScopeNotFound() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope3", collectionName = "test_collection3"; var collectionSpec = new CollectionSpec(scopeName, collectionName); var collectionSpecInvalid = new CollectionSpec("noscope", "emptycollection"); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // create collection await Assert.ThrowsAsync <ScopeNotFoundException>(async() => await collectionManager.CreateCollectionAsync(collectionSpecInvalid).ConfigureAwait(false)); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
public async Task Test_Collection_Exists() { var bucket = await _fixture.Cluster.BucketAsync("default"); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "my_scope", collectionName = "my_collection"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); try { // create scope //await collectionManager.CreateScopeAsync(scopeSpec); // create collection // await collectionManager.CreateCollectionAsync(collectionSpec); var collection = bucket.Scope(scopeName).Collection(collectionName); var result = await collection.UpsertAsync("key3", new { }); var result2 = await collection.UpsertAsync("key3", new { boo = "bee" }, new UpsertOptions().Expiry(TimeSpan.FromMilliseconds(100000))); } catch { // ??? } finally { // drop collection //await collectionManager.DropCollectionAsync(collectionSpec); //await collectionManager.DropScopeAsync(scopeName); } }
public async Task Test_CollectionExists() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope3", collectionName = "test_collection3"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); try { // create scope await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); } finally { // drop collection await collectionManager.DropCollectionAsync(collectionSpec).ConfigureAwait(false); // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
private async Task DropCollectionIfExists(CollectionSpec collectionSpec, CollectionManager collectionManager) { if (await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false)) { // drop collection await collectionManager.DropCollectionAsync(collectionSpec).ConfigureAwait(false); } }
public async Task InitializeAsync() { var opts = GetClusterOptions(); Cluster = await Couchbase.Cluster.ConnectAsync( _settings.ConnectionString, opts) .ConfigureAwait(false); var bucketSettings = new BucketSettings() { BucketType = BucketType.Couchbase, Name = BucketName, RamQuotaMB = 100, NumReplicas = 0 }; try { await Cluster.Buckets.CreateBucketAsync(bucketSettings).ConfigureAwait(false); } catch (BucketExistsException) { } catch (System.Net.Http.HttpRequestException) { // why did it fail? } try { var bucket = await Cluster.BucketAsync(BucketName); try { await bucket.Collections.CreateScopeAsync(CustomScopeName); await Task.Delay(5_000); } catch (ScopeExistsException) {} try { var collectionSpec = new CollectionSpec(scopeName: CustomScopeName, CustomCollectionName); await bucket.Collections.CreateCollectionAsync(collectionSpec); await Task.Delay(5_000); } catch (CollectionExistsException) {} } catch { throw; } }
public async Task Test_CollectionManager_With_MinExpiry() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope", collectionName = "test_collection"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName) { MaxExpiry = TimeSpan.FromMinutes(10) }; try { // create scope await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); // scope exists var scopeExistsResult = await collectionManager.ScopeExistsAsync(scopeName).ConfigureAwait(false); Assert.True(scopeExistsResult); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // get all scopes var getAllScopesResult = await collectionManager.GetAllScopesAsync().ConfigureAwait(false); var scope = getAllScopesResult.SingleOrDefault(x => x.Name == scopeName); Assert.NotNull(scope); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); // collection exists scope = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(TimeSpan.FromMinutes(10), scope.Collections.First(x => x.Name == collectionName).MaxExpiry); } finally { // drop collection await collectionManager.DropCollectionAsync(collectionSpec).ConfigureAwait(false); // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
public async Task Test_CollectionExistsException() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope5", collectionName = "test_collection5"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); try { await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); // scope exists var scopeExistsResult = await collectionManager.ScopeExistsAsync(scopeName).ConfigureAwait(false); Assert.True(scopeExistsResult); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); } catch (CollectionExistsException e) { Assert.Equal("Collection with name test_collection5 already exists in scope test_scope5", e.Message); } finally { // drop collection await collectionManager.DropCollectionAsync(collectionSpec).ConfigureAwait(false); // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
public async Task Test_CollectionManager() { var bucket = await _fixture.Cluster.BucketAsync("default"); var collectionManager = bucket.Collections; const string scopeName = "test_scope", collectionName = "test_collection"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); try { // create scope await collectionManager.CreateScopeAsync(scopeSpec); // scope exists var scopeExistsResult = await collectionManager.ScopeExistsAsync(scopeName); Assert.True(scopeExistsResult); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName); Assert.Equal(scopeName, getScopeResult.Name); // get all scopes var getAllScopesResult = await collectionManager.GetAllScopesAsync(); var scope = getAllScopesResult.SingleOrDefault(x => x.Name == scopeName); Assert.NotNull(scope); // create collection await collectionManager.CreateCollectionAsync(collectionSpec); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec); Assert.True(collectionExistsResult); } finally { // drop collection await collectionManager.DropCollectionAsync(collectionSpec); // drop scope await collectionManager.DropScopeAsync(scopeName); } }
public async Task Test_CollectionManager() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope2", collectionName = "test_collection2"; var collectionSpec = new CollectionSpec(scopeName, collectionName); try { // create scope await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // scope exists var scopeExistsResult = await collectionManager.ScopeExistsAsync(scopeName).ConfigureAwait(false); Assert.True(scopeExistsResult); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // get all scopes var getAllScopesResult = await collectionManager.GetAllScopesAsync().ConfigureAwait(false); var scope = getAllScopesResult.SingleOrDefault(x => x.Name == scopeName); Assert.NotNull(scope); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
public async System.Threading.Tasks.Task Test_Collections_QueryOps() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; var scopeName = "query_test_scope2"; var collectionName = "query_test_collection2"; var docId = "mydoc2"; var collectionSpec = new CollectionSpec(scopeName, collectionName); await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var scope = await bucket.ScopeAsync(scopeName); var collection = await scope.CollectionAsync(collectionName); var task = await collection.InsertAsync(docId, new { }).ConfigureAwait(false); var options = new QueryOptions("select * from `" + collectionName + "` where meta().id=\"" + docId + "\"") { QueryContext = "namespace:bucket:scope:collection" }; var args = options.GetFormValues(); Assert.Equal("namespace:bucket:scope:collection", args["query_context"]); options = new QueryOptions("SELECT * FROM `$bucket` WHERE collectionName=$name") .Parameter("bucket", "default").Parameter("collectionName", "query_test_collection2"); var values = options.GetFormValues(); Assert.Equal("default", values["$bucket"]); Assert.Equal("query_test_collection2", values["$collectionName"]); } catch (CouchbaseException e) { } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
/// <summary> /// Re-requests light information and updates all properties /// </summary> public async Task Refresh() { Light light = await GetRefreshed(); Id = light.Id; UUID = light.UUID; Label = light.Label; IsConnected = light.IsConnected; PowerState = light.PowerState; Color = light.Color; Brightness = light.Brightness; group = light.group; location = light.location; LastSeen = light.LastSeen; SecondsSinceSeen = light.SecondsSinceSeen; ProductName = light.ProductName; }
public async Task Test_ScopeNotFound() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope1", collectionName = "test_collection1"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); var collectionSpecInvalid = new CollectionSpec("noscope", "emptycollection"); try { await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // create collection await collectionManager.CreateCollectionAsync(collectionSpecInvalid).ConfigureAwait(false); var scopeExistsResult = await collectionManager.ScopeExistsAsync("noscope").ConfigureAwait(false); Assert.False(scopeExistsResult); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpecInvalid).ConfigureAwait(false); Assert.False(collectionExistsResult); } finally { // drop collection await collectionManager.DropCollectionAsync(collectionSpec).ConfigureAwait(false); // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
public async Task Test_Collections_DataverseCollectionQuery() { var cluster = await _fixture.GetCluster().ConfigureAwait(false); var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); string dataverseName = bucket.Name + "." + scopeName; var collectionManager = (CollectionManager)bucket.Collections; var scopeSpec = new ScopeSpec(scopeName); var analytics = cluster.AnalyticsIndexes; await analytics.CreateDataverseAsync(dataverseName); string statement = "CREATE ANALYTICS COLLECTION `" + dataverseName + "`.`" + collectionName + "` ON `" + bucket.Name + "`.`" + scopeName + "`.`" + collectionName + "`"; try { var analyticsResult = await cluster.AnalyticsQueryAsync <TestRequest>(statement).ConfigureAwait(false); var result = await analyticsResult.ToListAsync().ConfigureAwait(false); await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); var collectionSpec = new CollectionSpec(scopeName, collectionName); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); var scope = bucket.Scope(scopeName); statement = "SELECT * FROM `" + collectionName + "` where `" + collectionName + "`.foo= \"bar\""; analyticsResult = await cluster.AnalyticsQueryAsync <TestRequest>(statement).ConfigureAwait(false); result = await analyticsResult.ToListAsync().ConfigureAwait(false); Assert.True(result.Any()); } finally { // drop scope await collectionManager.DropScopeAsync(scopeName).ConfigureAwait(false); } }
public async Task Test_CollectionExistsException() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "test_scope7", collectionName = "test_collection7"; var collectionSpec = new CollectionSpec(scopeName, collectionName); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); // get scope var getScopeResult = await collectionManager.GetScopeAsync(scopeName).ConfigureAwait(false); Assert.Equal(scopeName, getScopeResult.Name); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); // collection exists var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); // scope exists var scopeExistsResult = await collectionManager.ScopeExistsAsync(scopeName).ConfigureAwait(false); Assert.True(scopeExistsResult); await Assert .ThrowsAsync <CollectionExistsException>(async() => await collectionManager.CreateCollectionAsync(collectionSpec)).ConfigureAwait(false); } finally { await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); } }
public async System.Threading.Tasks.Task Test_Collections_QueryOptionsAsync() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; var scopeName = "query_test_scope1"; var collectionName = "query_test_collection1"; var docId = "mydoc1"; var collectionSpec = new CollectionSpec(scopeName, collectionName); await DropScopeAndCollectionIfExists(scopeName, collectionSpec, collectionManager); try { await collectionManager.CreateScopeAsync(scopeName).ConfigureAwait(false); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); var scope = await bucket.ScopeAsync(scopeName); var collection = await scope.CollectionAsync(collectionName); var task = await collection.InsertAsync(docId, new { }).ConfigureAwait(false); var options = new QueryOptions("select * from `" + collectionName + "` where meta().id=\"" + docId + "\"") { QueryContext = "namespace:bucket:scope:collection" }; var args = options.GetFormValues(); Assert.Equal("namespace:bucket:scope:collection", args["query_context"]); } finally { await DropScopeIfExists(scopeName, collectionManager); } }
private async Task CreateCollectionsAsync() { _logger.LogInformation("Creating collections..."); var tables = (await _sqlConnection.QueryAsync(@" select TABLE_SCHEMA, TABLE_NAME from INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")).ToList(); foreach (var table in tables) { string collectionName = GetCollectionName(table.TABLE_SCHEMA, table.TABLE_NAME); string scopeName = GetScopeName(table.TABLE_SCHEMA); _logger.LogInformation($"Creating collection `{collectionName}`..."); await CreateScopeIfNecessaryAsync(scopeName); if (await CollectionExistsAsync(collectionName, scopeName)) { _logger.LogInformation("already exists."); continue; } try { var spec = new CollectionSpec(scopeName, collectionName); await _collManager.CreateCollectionAsync(spec); } catch { _logger.LogError($"Unable to create collection `{collectionName}` in scope `{scopeName}`"); throw; } _logger.LogInformation("Done"); } _logger.LogInformation("Collection creation complete."); }
public async Task Test_RemoveOps() { var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var collectionManager = (CollectionManager)bucket.Collections; const string scopeName = "my_scope1", collectionName = "my_collection1"; var scopeSpec = new ScopeSpec(scopeName); var collectionSpec = new CollectionSpec(scopeName, collectionName); // create scope await collectionManager.CreateScopeAsync(scopeSpec).ConfigureAwait(false); // create collection await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); var collection = bucket.Scope(scopeName).Collection(collectionName); var tasks = new List <Task>(); for (var i = 0; i < 20; i++) { await collection.RemoveAsync($"mykey-{i}").ConfigureAwait(false); } }
public async Task ExecuteAsync() { ICluster cluster = await Cluster.ConnectAsync("couchbase://localhost", "Administrator", "password"); IUserManager users = cluster.Users; Console.WriteLine("bucketAdmin"); // tag::bucketAdmin[] { var user = new User("bucketAdmin"); user.Password = "******"; user.DisplayName = "Bucket Admin [travel-sample]"; user.Roles = new List <Role>() { new Role("bucket_admin", "travel-sample") }; await users.UpsertUserAsync(user); } // end::bucketAdmin[] { var collectionMgr = await getCollectionManager("bucketAdmin", "password"); // tag::create-scope[] try { await collectionMgr.CreateScopeAsync("example-scope"); } catch (ScopeExistsException) { Console.WriteLine("The scope already exists"); } // end::create-scope[] } Console.WriteLine("scopeAdmin"); // tag::scopeAdmin[] { var user = new User("scopeAdmin"); user.Password = "******"; user.DisplayName = "Manage Collections in Scope [travel-sample:*]"; user.Roles = new List <Role>() { new Role("scope_admin", "travel-sample"), new Role("data_reader", "travel-sample") }; await users.UpsertUserAsync(user); } // end::scopeAdmin[] { Console.WriteLine("create-collection"); var collectionMgr = await getCollectionManager("scopeAdmin", "password"); // tag::create-collection[] var spec = new CollectionSpec("example-scope", "example-collection"); try { await collectionMgr.CreateCollectionAsync(spec); } catch (CollectionExistsException) { Console.WriteLine("Collection already exists"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::create-collection[] Console.WriteLine("drop-collection"); // tag::drop-collection[] try { await collectionMgr.DropCollectionAsync(spec); } catch (CollectionNotFoundException) { Console.WriteLine("The specified collection doesn't exist"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::drop-collection[] } { Console.WriteLine("drop-scope"); var collectionMgr = await getCollectionManager("bucketAdmin", "password"); // tag::drop-scope[] try { await collectionMgr.DropScopeAsync("example-scope"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified scope doesn't exist"); } // end::drop-scope[] } }
public override bool Equals(object obj) { CollectionSpec spec = obj as CollectionSpec; return(spec != null && spec.id == id && spec.name == name); }
public override bool Equals(object obj) { CollectionSpec spec = obj as CollectionSpec; return(spec != null && spec.Id == Id && spec.Name == Name); }
public async Task ExecuteAsync() { Console.WriteLine("scopeAdmin"); { // tag::scopeAdmin[] ICluster clusterAdmin = await Cluster.ConnectAsync( "couchbase://localhost", "Administrator", "password"); IUserManager users = clusterAdmin.Users; var user = new User("scopeAdmin") { Password = "******", DisplayName = "Manage Scopes [travel-sample:*]", Roles = new List <Role>() { new Role("scope_admin", "travel-sample"), new Role("data_reader", "travel-sample") } }; await users.UpsertUserAsync(user); // end::scopeAdmin[] } ICluster cluster = await Cluster.ConnectAsync("couchbase://localhost", "scopeAdmin", "password"); IBucket bucket = await cluster.BucketAsync("travel-sample"); // tag::create-collection-manager[] ICouchbaseCollectionManager collectionMgr = bucket.Collections; // end::create-collection-manager[] { Console.WriteLine("create-scope"); // tag::create-scope[] try { await collectionMgr.CreateScopeAsync("example-scope"); } catch (ScopeExistsException) { Console.WriteLine("The scope already exists"); } // end::create-scope[] } { Console.WriteLine("create-collection"); // tag::create-collection[] var spec = new CollectionSpec("example-scope", "example-collection"); try { await collectionMgr.CreateCollectionAsync(spec); } catch (CollectionExistsException) { Console.WriteLine("Collection already exists"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::create-collection[] Console.WriteLine("listing-scope-collection"); // tag::listing-scope-collection[] var scopes = await collectionMgr.GetAllScopesAsync(); foreach (ScopeSpec scopeSpec in scopes) { Console.WriteLine($"Scope: {scopeSpec.Name}"); foreach (CollectionSpec collectionSpec in scopeSpec.Collections) { Console.WriteLine($" - {collectionSpec.Name}"); } } // end::listing-scope-collection[] Console.WriteLine("drop-collection"); // tag::drop-collection[] try { await collectionMgr.DropCollectionAsync(spec); } catch (CollectionNotFoundException) { Console.WriteLine("The specified collection doesn't exist"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::drop-collection[] } { Console.WriteLine("drop-scope"); // tag::drop-scope[] try { await collectionMgr.DropScopeAsync("example-scope"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified scope doesn't exist"); } // end::drop-scope[] } }
public async Task CreateAndDropCollectionIndex() { var cluster = await _fixture.GetCluster().ConfigureAwait(false); var bucketName = _fixture.GetDefaultBucket().Result.Name; var collectionManager = _fixture.GetDefaultBucket().Result.Collections; var scopeName = Guid.NewGuid().ToString(); var collectionName = Guid.NewGuid().ToString(); var collectionSpec = new CollectionSpec(scopeName, collectionName); try { await collectionManager.CreateScopeAsync(scopeName); await collectionManager.CreateCollectionAsync(collectionSpec); const string indexName = "indexmgr_test_collection"; try { await cluster.QueryIndexes.CreateIndexAsync(bucketName, indexName, new[] { "type" }, options => { options.ScopeNameValue = scopeName; options.CollectionNameValue = collectionName; }).ConfigureAwait(false); } catch (IndexExistsException) { _outputHelper.WriteLine("IndexExistsException. Maybe from a previous run. Skipping."); } var failedCleanup = false; try { await cluster.QueryIndexes.BuildDeferredIndexesAsync(bucketName, options => { options.ScopeNameValue = scopeName; options.CollectionNameValue = collectionName; }).ConfigureAwait(false); using var cts = new CancellationTokenSource(10000); await cluster.QueryIndexes.WatchIndexesAsync(bucketName, new[] { indexName }, options => { options.CancellationToken(cts.Token); options.ScopeNameValue = scopeName; options.CollectionNameValue = collectionName; }).ConfigureAwait(false); var getIndexes = await cluster.QueryIndexes.GetAllIndexesAsync(bucketName, options => { options.ScopeNameValue = scopeName; options.CollectionNameValue = collectionName; }); Assert.Contains(indexName, getIndexes.Select(idx => idx.Name)); } finally { try { await cluster.QueryIndexes.DropIndexAsync(bucketName, indexName, options => { options.ScopeNameValue = scopeName; options.CollectionNameValue = collectionName; }).ConfigureAwait(false); } catch (Exception e) { _outputHelper.WriteLine($"Failure during cleanup: {e}"); failedCleanup = true; } } Assert.False(failedCleanup); } finally { await collectionManager.DropScopeAsync(scopeName); } }
private async Task DropScopeAndCollectionIfExists(string scopeName, CollectionSpec collectionSpec, CollectionManager collectionManager) { await DropCollectionIfExists(collectionSpec, collectionManager); await DropScopeIfExists(scopeName, collectionManager); }
public async Task Test_Collections_DataverseCollectionQuery() { var cluster = await _fixture.GetCluster().ConfigureAwait(false); var bucket = await _fixture.Cluster.BucketAsync("default").ConfigureAwait(false); var dataverseName = bucket.Name + "." + ScopeName; var collectionManager = (CollectionManager)bucket.Collections; var analytics = cluster.AnalyticsIndexes; try { await using var dataverseDisposer = DisposeCleaner.DropDataverseOnDispose(analytics, dataverseName, _output); await collectionManager.CreateScopeAsync(ScopeName).ConfigureAwait(false); await using var scopeDispose = DisposeCleaner.DropScopeOnDispose(collectionManager, ScopeName, _output); var collectionSpec = new CollectionSpec(ScopeName, CollectionName); await Task.Delay(TimeSpan.FromSeconds(1)); await collectionManager.CreateCollectionAsync(collectionSpec).ConfigureAwait(false); await Task.Delay(TimeSpan.FromSeconds(1)); var collectionExistsResult = await collectionManager.CollectionExistsAsync(collectionSpec).ConfigureAwait(false); Assert.True(collectionExistsResult); await bucket.Scope(ScopeName).Collection(CollectionName).UpsertAsync("KEY1", new { bar = "foo" }); await analytics.CreateDataverseAsync(dataverseName).ConfigureAwait(false); await Task.Delay(TimeSpan.FromSeconds(5)); var statement = $"CREATE ANALYTICS COLLECTION {FilteredCollection} ON {bucket.Name}.{ScopeName}.{CollectionName}"; await cluster.AnalyticsQueryAsync <TestRequest>(statement).ConfigureAwait(false); await using var analyticsCollectionDisposer = new DisposeCleanerAsync(() => cluster.AnalyticsQueryAsync <dynamic>($"DROP ANALYTICS COLLECTION {FilteredCollection}"), _output ); await Task.Delay(TimeSpan.FromSeconds(5)); var selectStatement = $"SELECT * FROM `{FilteredCollection}`"; var analyticsResult2 = await cluster.AnalyticsQueryAsync <TestRequest>(selectStatement).ConfigureAwait(false); var result = await analyticsResult2.ToListAsync().ConfigureAwait(false); Assert.True(result.Any()); } catch (Exception e) { _output.WriteLine("oops{0}", e); } finally { // give some time befor the cleanups happen. await Task.Delay(TimeSpan.FromSeconds(1)); } }