示例#1
0
        /// <summary>
        /// Removes all databases from the gateway.
        /// </summary>
        public static async Task ClearAsync()
        {
            using (var gateway = new Gateway(Settings))
            {
                var manager = gateway.CreateManager();

                foreach (var database in await manager.DatabaseListAsync())
                {
                    await manager.DatabaseRemoveAsync(database);
                }
            }

            // $hack(jeff.lill):
            //
            // Looks like the test server needs some time to stablize after
            // deleting databases.

            await Task.Delay(1000);
        }
示例#2
0
        /// <summary>
        /// Creates the specified databases with each referencing a bucket
        /// named <b>[database]_bucket</b>.
        /// </summary>
        /// <param name="databases">The list of databases to create.</param>
        public static async Task CreateDatabaseAsync(params string[] databases)
        {
            using (var gateway = new Gateway(Settings))
            {
                var manager = gateway.CreateManager();

                foreach (var name in databases)
                {
                    var databaseConfig = new DatabaseConfiguration()
                    {
                        Name   = name,
                        Bucket = $"{name}_bucket",
                        Server = WalrusUri,
                        Sync   = "function (doc, oldDoc) { channel(doc.channels); }"
                    };

                    await manager.DatabaseCreateAsync(databaseConfig);
                }
            }
        }
示例#3
0
        private async Task InitAsync()
        {
            // Initialize a clean Couchbase bucket.

            cluster        = new Cluster();
            clusterManager = cluster.CreateManager(CouchbaseUID, CouchbasePWD);

            if (clusterManager.ListBuckets().Value.Count(b => b.Name == BucketName) > 0)
            {
                clusterManager.RemoveBucket(BucketName);
            }

            if (!clusterManager.CreateBucket(BucketName, 100).Success)
            {
                Assert.True(false, $"Could not create the [{BucketName}] Couchbase bucket.");
            }

            Bucket = cluster.OpenBucket(BucketName);

            // Crank up the sync gateway.

            syncGatewayProcess = Process.Start(SyncGatewayPath, $"-bucket \"{BucketName}\" -dbname \"{DatabaseName}\"");

            if (syncGatewayProcess.WaitForExit(2000))
            {
                Assert.True(false, $"Could not start a Couchbase Sync Gateway.  Verify that the service is not already running.");
            }

            // Initialize the sync gateway database.

            gateway = new Gateway(
                new GatewaySettings()
            {
                Host = "localhost"
            });

            gatewayManager = gateway.CreateManager();

            var databasesDeleted = false;

            foreach (var database in await gatewayManager.DatabaseListAsync())
            {
                if (database == DatabaseName)
                {
                    await gatewayManager.DatabaseRemoveAsync(database);

                    databasesDeleted = true;
                }
            }

            if (databasesDeleted)
            {
                // Looks like the sync gateway needs some time to stablize
                // after deleting databases.

                await Task.Delay(TimeSpan.FromSeconds(5));
            }

            await gatewayManager.DatabaseCreateAsync(
                new DatabaseConfiguration()
            {
                Name   = DatabaseName,
                Bucket = BucketName,
                Server = "http://127.0.0.1:8091",
                Sync   = "function (doc, oldDoc) { channel(doc.channels); }"
            });
        }