couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/{bin/setup → lib/couchbase/json_transcoder.rb}

@@ -1,5 +1,3 @@
-#!/usr/bin/env bash
-
 #    Copyright 2020 Couchbase, Inc.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,10 +12,21 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-PROJECT_ROOT="$( cd "$(dirname "$0"/..)" >/dev/null 2>&1 ; pwd -P )"
+require "json"
+
+module Couchbase
+  class JsonTranscoder
+    # @param [Object] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      [JSON.generate(document), (0x02 << 24) | 0x06]
+    end
 
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-bundle config set --local path ${PROJECT_ROOT}/vendor/bundle
-bundle install
+    # @param [String, nil] blob string of bytes, containing encoded representation of the document
+    # @param [Integer, :json] flags bit field, describing how the data encoded
+    # @return Object decoded document
+    def decode(blob, flags)
+      JSON.parse(blob) unless blob.nil?
+    end
+  end
+end

data/lib/couchbase/management/analytics_index_manager.rb

@@ -12,6 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require "couchbase/errors"
+
 module Couchbase
   module Management
     class AnalyticsIndexManager
@@ -27,43 +29,198 @@ module Couchbase
       # @param [String] dataverse_name
       # @param [CreateDataverseOptions] options
       #
-      # @raise DataverseExists
-      # @raise ArgumentError
-      def create_dataverse(dataverse_name, options = CreateDataverseOptions.new) end
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::DataverseExists]
+      def create_dataverse(dataverse_name, options = CreateDataverseOptions.new)
+        @backend.analytics_dataverse_create(
+            dataverse_name,
+            options.ignore_if_exists,
+            options.timeout
+        )
+      end
 
       # Drops a dataverse
       #
       # @param [String] dataverse_name name of the dataverse
       # @param [DropDataverseOptions] options
       #
-      # @raise DataverseNotFound
-      # @raise ArgumentError
-      def drop_dataverse(dataverse_name, options = DropDataverseOptions.new) end
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::DataverseNotFound]
+      def drop_dataverse(dataverse_name, options = DropDataverseOptions.new)
+        @backend.analytics_dataverse_drop(
+            dataverse_name,
+            options.ignore_if_does_not_exist,
+            options.timeout
+        )
+      end
 
       # Creates a new dataset
       #
       # @param [String] dataset_name name of dataset
       # @param [String] bucket_name name of the bucket
+      # @param [CreateDatasetOptions] options
       #
-      # @raise DatasetAlreadyExistsError
-      # @raise ArgumentError
-      def create_dataset(dataset_name, bucket_name, options = CreateDatasetOptions.new) end
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::DatasetExists]
+      # @raise [Error::LinkNotFound]
+      def create_dataset(dataset_name, bucket_name, options = CreateDatasetOptions.new)
+        @backend.analytics_dataset_create(
+            dataset_name,
+            bucket_name,
+            options.condition,
+            options.dataverse_name,
+            options.ignore_if_exists,
+            options.timeout
+        )
+      end
 
-      def drop_dataset(dataset_name, options = DropDatasetOptions.new) end
+      # Drops a dataset
+      #
+      # @param [String] dataset_name name of the dataset
+      # @param [DropDatasetOptions] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::DatasetNotFound]
+      def drop_dataset(dataset_name, options = DropDatasetOptions.new)
+        @backend.analytics_dataset_drop(
+            dataset_name,
+            options.dataverse_name,
+            options.ignore_if_does_not_exist,
+            options.timeout
+        )
+      end
 
-      def get_all_datasets(options = GetAllDatasetOptions.new) end
+      # Gets all datasets
+      #
+      # @param [GetAllDatasetsOptions] options
+      #
+      # @return [Array<AnalyticsDataset>]
+      def get_all_datasets(options = GetAllDatasetsOptions.new)
+        resp = @backend.analytics_dataset_get_all(options.timeout)
+        resp.map do |entry|
+          AnalyticsDataset.new do |dataset|
+            dataset.name = entry[:name]
+            dataset.dataverse_name = entry[:dataverse_name]
+            dataset.link_name = entry[:link_name]
+            dataset.bucket_name = entry[:bucket_name]
+          end
+        end
+      end
 
-      def create_index(index_name, dataset_name, fields, options = CreateIndexOptions.new) end
+      # Creates a new index
+      #
+      # @param [String] index_name name of the index
+      # @param [String] dataset_name name of the dataset
+      # @param [Hash<String => String>] fields mapping of the field name to field type
+      # @param [CreateIndexOptions] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexExists]
+      def create_index(index_name, dataset_name, fields, options = CreateIndexOptions.new)
+        @backend.analytics_index_create(
+            index_name,
+            dataset_name,
+            fields.entries,
+            options.dataverse_name,
+            options.ignore_if_exists,
+            options.timeout
+        )
+      end
 
-      def drop_index(index_name, dataset_name, options = DropIndexOptions.new) end
+      # Drops an index
+      #
+      # @param [String] index_name name of the index
+      # @param [String] dataset_name name of the dataset
+      # @param [DropIndexOptions] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexNotFound]
+      def drop_index(index_name, dataset_name, options = DropIndexOptions.new)
+        @backend.analytics_index_drop(
+            index_name,
+            dataset_name,
+            options.dataverse_name,
+            options.ignore_if_does_not_exist,
+            options.timeout
+        )
+      end
 
-      def get_all_indexes(options = GetAllIndexesOptions.new) end
+      # Gets all indexes
+      #
+      # @param [GetAllIndexesOptions] options
+      #
+      # @return [Array<AnalyticsIndex>]
+      def get_all_indexes(options = GetAllIndexesOptions.new)
+        resp = @backend.analytics_index_get_all(options.timeout)
+        resp.map do |entry|
+          AnalyticsIndex.new do |dataset|
+            dataset.name = entry[:name]
+            dataset.dataverse_name = entry[:dataverse_name]
+            dataset.dataset_name = entry[:dataset_name]
+            dataset.is_primary = entry[:is_primary]
+          end
+        end
+      end
 
-      def connect_link(options = ConnectLinkOptions.new) end
+      # Connects a link
+      #
+      # @param [ConnectLinkOptions] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkNotFound]
+      def connect_link(options = ConnectLinkOptions.new)
+        @backend.analytics_link_connect(
+            options.link_name,
+            options.force,
+            options.dataverse_name,
+            options.timeout
+        )
+      end
 
-      def disconnect_link(options = DisconnectLinkOptions.new) end
+      # Disconnects a link,
+      #
+      # @param [DisconnectLinkOptions] options
+      #
+      # @return [void]
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::LinkNotFound]
+      def disconnect_link(options = DisconnectLinkOptions.new)
+        @backend.analytics_link_disconnect(
+            options.link_name,
+            options.dataverse_name,
+            options.timeout
+        )
+      end
 
-      def get_pending_mutations(options = GetPendingMutations.new) end
+      # Gets the pending mutations for all datasets.
+      #
+      # @note If a link is disconnected then it will return no results. If all links are disconnected, then
+      # an empty object is returned.
+      #
+      # @param [GetPendingMutationsOptions] options
+      #
+      # @return [Hash<String => Integer>] dictionary, where keys are dataset coordinates encoded as +"dataverse.dataset"+
+      #   and values are number of mutations for given dataset.
+      def get_pending_mutations(options = GetPendingMutationsOptions.new)
+        @backend.analytics_get_pending_mutations(
+            options.timeout
+        )
+      end
 
       class CreateDataverseOptions
         # @return [Boolean] ignore if the dataverse already exists
@@ -72,6 +229,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [CreateDataverseOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -80,11 +238,12 @@ module Couchbase
 
       class DropDataverseOptions
         # @return [Boolean] ignore if the dataverse does not exists
-        attr_accessor :ignore_if_not_exists
+        attr_accessor :ignore_if_does_not_exist
 
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [DropDataverseOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -104,12 +263,132 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [CreateDatasetOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
         end
       end
 
+      class DropDatasetOptions
+        # @return [Boolean] ignore if the dataset does not exists
+        attr_accessor :ignore_if_does_not_exist
+
+        # @return [String] The name of the dataverse to use (defaults to +nil+)
+        attr_accessor :dataverse_name
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropDatasetOptions]
+        def initialize
+          @ignore_if_does_not_exist = false
+          yield self if block_given?
+        end
+      end
+
+      class GetAllDatasetsOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetAllDatasetsOptions]
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class CreateIndexOptions
+        # @return [Boolean] ignore if the index already exists
+        attr_accessor :ignore_if_exists
+
+        # @return [String] The name of the dataverse to use (defaults to +nil+)
+        attr_accessor :dataverse_name
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [CreateIndexOptions]
+        def initialize
+          @ignore_if_exists = false
+          yield self if block_given?
+        end
+      end
+
+      class DropIndexOptions
+        # @return [Boolean] ignore if the index does not exists
+        attr_accessor :ignore_if_does_not_exist
+
+        # @return [String] The name of the dataverse to use (defaults to +nil+)
+        attr_accessor :dataverse_name
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropIndexOptions]
+        def initialize
+          @ignore_if_does_not_exist = false
+          yield self if block_given?
+        end
+      end
+
+      class GetAllIndexesOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetAllIndexesOptions]
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class ConnectLinkOptions
+        # @return [String] The name of the link (defaults to +"Local"+)
+        attr_accessor :link_name
+
+        # @return [Boolean] Whether to force link creation even if the bucket UUID changed, for example due to the
+        #  bucket being deleted and recreated (defaults to +false+)
+        attr_accessor :force
+
+        # @return [String] The name of the dataverse to use (defaults to +nil+)
+        attr_accessor :dataverse_name
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [ConnectLinkOptions]
+        def initialize
+          @link_name = "Local"
+          @force = false
+          yield self if block_given?
+        end
+      end
+
+      class DisconnectLinkOptions
+        # @return [String] The name of the link (defaults to +"Local"+)
+        attr_accessor :link_name
+
+        # @return [String] The name of the dataverse to use (defaults to +nil+)
+        attr_accessor :dataverse_name
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DisconnectLinkOptions]
+        def initialize
+          @link_name = "Local"
+          yield self if block_given?
+        end
+      end
+
+      class GetPendingMutationsOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetPendingMutationsOptions]
+        def initialize
+          yield self if block_given?
+        end
+      end
     end
 
     class AnalyticsDataset
@@ -124,6 +403,11 @@ module Couchbase
 
       # @return [String]
       attr_accessor :bucket_name
+
+      # @yieldparam [AnalyticsDataset]
+      def initialize
+        yield self if block_given?
+      end
     end
 
     class AnalyticsIndex
@@ -138,6 +422,12 @@ module Couchbase
 
       # @return [Boolean]
       attr_accessor :is_primary
+      alias_method :primary?, :is_primary
+
+      # @yieldparam [AnalyticsIndex]
+      def initialize
+        yield self if block_given?
+      end
     end
   end
-end
+end

data/lib/couchbase/management/bucket_manager.rb

@@ -12,6 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require "couchbase/errors"
+
 module Couchbase
   module Management
     class BucketManager
@@ -24,13 +26,29 @@ module Couchbase
 
       # Creates new bucket
       #
-      # @param [CreateBucketSettings] settings bucket settings
+      # @param [BucketSettings] settings bucket settings
       # @param [CreateBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketExists
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::BucketExists]
       def create_bucket(settings, options = CreateBucketOptions.new)
-        # POST /pools/default/buckets
+        @backend.bucket_create(
+            {
+
+                name: settings.name,
+                flush_enabled: settings.flush_enabled,
+                ram_quota_mb: settings.ram_quota_mb,
+                num_replicas: settings.num_replicas,
+                replica_indexes: settings.replica_indexes,
+                bucket_type: settings.bucket_type,
+                ejection_policy: settings.ejection_policy,
+                max_expiry: settings.max_expiry,
+                compression_mode: settings.compression_mode,
+                conflict_resolution_type: settings.conflict_resolution_type,
+            }, options.timeout
+        )
       end
 
       # Updates the bucket settings
@@ -38,10 +56,24 @@ module Couchbase
       # @param [BucketSettings] settings bucket settings
       # @param [UpdateBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketNotFound
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::BucketNotFound]
       def update_bucket(settings, options = UpdateBucketOptions.new)
-        # POST /pools/default/buckets/#{settings.name}
+        @backend.bucket_update(
+            {
+                name: settings.name,
+                flush_enabled: settings.flush_enabled,
+                ram_quota_mb: settings.ram_quota_mb,
+                num_replicas: settings.num_replicas,
+                replica_indexes: settings.replica_indexes,
+                bucket_type: settings.bucket_type,
+                ejection_policy: settings.ejection_policy,
+                max_expiry: settings.max_expiry,
+                compression_mode: settings.compression_mode,
+            }, options.timeout
+        )
       end
 
       # Removes a bucket
@@ -49,23 +81,26 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [DropBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketNotFound
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::BucketNotFound]
       def drop_bucket(bucket_name, options = DropBucketOptions.new)
-        # DELETE /pools/default/buckets/#{bucket_name}
+        @backend.bucket_drop(bucket_name, options.timeout)
       end
 
       # Fetch settings of the bucket
       #
       # @param [String] bucket_name name of the bucket
-      # @param [GetBucketOptions]
+      # @param [GetBucketOptions] options
       #
       # @return [BucketSettings]
       #
-      # @raise ArgumentError
-      # @raise BucketNotFound
+      # @raise [ArgumentError]
+      # @raise [Error::BucketNotFound]
       def get_bucket(bucket_name, options = GetBucketOptions.new)
-        # GET /pools/default/buckets/#{bucket_name}
+        res = @backend.bucket_get(bucket_name, options.timeout)
+        extract_bucket_settings(res)
       end
 
       # Get settings for all buckets
@@ -73,15 +108,19 @@ module Couchbase
       # @param [GetAllBucketsOptions] options
       # @return [Array<BucketSettings>]
       def get_all_buckets(options = GetAllBucketsOptions.new)
-        # GET /pools/default/buckets
+        res = @backend.bucket_get_all(options.timeout)
+        res.map(&method(:extract_bucket_settings))
       end
 
       # @param [String] bucket_name name of the bucket
-      # @raise ArgumentError
-      # @raise BucketNotFound
-      # @raise BucketNotFlushable
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::BucketNotFound]
+      # @raise [Error::BucketNotFlushable]
       def flush_bucket(bucket_name, options = FlushBucketOptions.new)
-        # POST /pools/default/buckets/#{bucket_name}/controller/doFlush
+        @backend.bucket_flush(bucket_name, options.timeout)
       end
 
       class CreateBucketOptions
@@ -137,6 +176,23 @@ module Couchbase
           yield self if block_given?
         end
       end
+
+      private
+
+      def extract_bucket_settings(entry)
+        BucketSettings.new do |bucket|
+          bucket.name = entry[:name]
+          bucket.flush_enabled = entry[:flush_enabled]
+          bucket.ram_quota_mb = entry[:ram_quota_mb]
+          bucket.num_replicas = entry[:num_replicas]
+          bucket.replica_indexes = entry[:replica_indexes]
+          bucket.bucket_type = entry[:bucket_type]
+          bucket.max_expiry = entry[:max_expiry]
+          bucket.ejection_policy = entry[:max_expiry]
+          bucket.compression_mode = entry[:compression_mode]
+          bucket.instance_variable_set("@healthy", entry[:nodes].all? { |node| node[:status] == "healthy" })
+        end
+      end
     end
 
     class BucketSettings
@@ -158,30 +214,39 @@ module Couchbase
       # @return [:couchbase, :memcached, :ephemeral] the type of the bucket. Defaults to +:couchbase+
       attr_accessor :bucket_type
 
-      # @return [:full_eviction, :value_only] the eviction policy to use
-      attr_accessor :ejection_method
+      # @return [:full, :value_only] the eviction policy to use
+      attr_accessor :ejection_policy
 
-      # @return [Integer] value of TTL (expiration) in seconds for new documents created without TTL
-      attr_accessor :max_ttl
+      # @return [Integer] value of TTL (expiration) in seconds for new documents created without expiration
+      attr_accessor :max_expiry
 
       # @return [:off, :passive, :active] the compression mode to use
       attr_accessor :compression_mode
 
-      def initialize
-        obj.flush_enabled = true
-        obj.bucket_type = :couchbase
-        yield self if block_given?
-      end
-    end
-
-    class CreateBucketSettings < BucketSettings
       # @return [:timestamp, :sequence_number] conflict resolution policy
       attr_accessor :conflict_resolution_type
 
+      # @api private
+      # @return [Boolean] false if status of the bucket is not healthy
+      def healthy?
+        @healthy
+      end
+
+      # @yieldparam [BucketSettings] self
       def initialize
-        super()
+        @bucket_type = :couchbase
+        @name = nil
+        @healthy = true
+        @flush_enabled = false
+        @ram_quota_mb = 100
+        @num_replicas = 1
+        @replica_indexes = false
+        @max_expiry = 0
+        @compression_mode = :passive
+        @conflict_resolution_type = :sequence_number
+        @ejection_policy = :value_only
         yield self if block_given?
       end
     end
   end
-end
+end