couchbase 3.0.0.alpha.1 → 3.0.0.alpha.2

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,24 @@ module Couchbase
 
       # Creates new bucket
       #
-      # @param [CreateBucketSettings] settings bucket settings
+      # @param [BucketSettings] settings bucket settings
       # @param [CreateBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketExists
+      # @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,
+        )
       end
 
       # Updates the bucket settings
@@ -38,10 +51,20 @@ module Couchbase
       # @param [BucketSettings] settings bucket settings
       # @param [UpdateBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketNotFound
+      # @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,
+        )
       end
 
       # Removes a bucket
@@ -49,23 +72,24 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [DropBucketOptions] options
       #
-      # @raise ArgumentError
-      # @raise BucketNotFound
+      # @raise [ArgumentError]
+      # @raise [Error::BucketNotFound]
       def drop_bucket(bucket_name, options = DropBucketOptions.new)
-        # DELETE /pools/default/buckets/#{bucket_name}
+        @backend.bucket_drop(bucket_name)
       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)
+        extract_bucket_settings(res)
       end
 
       # Get settings for all buckets
@@ -73,15 +97,16 @@ module Couchbase
       # @param [GetAllBucketsOptions] options
       # @return [Array<BucketSettings>]
       def get_all_buckets(options = GetAllBucketsOptions.new)
-        # GET /pools/default/buckets
+        res = @backend.bucket_get_all
+        res.map(&method(:extract_bucket_settings))
       end
 
       # @param [String] bucket_name name of the bucket
-      # @raise ArgumentError
-      # @raise BucketNotFound
-      # @raise BucketNotFlushable
+      # @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)
       end
 
       class CreateBucketOptions
@@ -137,6 +162,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 +200,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

data/lib/couchbase/management/collection_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 CollectionManager
@@ -23,6 +25,169 @@ module Couchbase
         @backend = backend
         @bucket_name = bucket_name
       end
+
+      # Get all scopes
+      #
+      # @param [GetAllScopesOptions] options
+      #
+      # @return [Array<ScopeSpec>]
+      def get_all_scopes(options = GetAllScopesOptions.new)
+        res = @backend.scope_get_all(@bucket_name)
+        res[:scopes].map do |s|
+          ScopeSpec.new do |scope|
+            scope.name = s[:name]
+            scope.collections = s[:collections].map do |c|
+              CollectionSpec.new do |collection|
+                collection.name = c[:name]
+                collection.scope_name = s[:name]
+              end
+            end
+          end
+        end
+      end
+
+      # Removes a scope
+      #
+      # @param [String] scope_name name of the scope
+      # @param [GetScopeOptions] options
+      #
+      # @return [ScopeSpec]
+      #
+      # @raise [Error::ScopeNotFound]
+      def get_scope(scope_name, options = GetScopeOptions.new)
+        get_all_scopes.find { |scope| scope.name == scope_name } or raise Error::ScopeNotFound, "unable to find scope #{scope_name}"
+      end
+
+      # Creates a new scope
+      #
+      # @param [String] scope_name name of the scope
+      # @param [CreateScopeOptions] options
+      #
+      # @raise [ArgumentError]
+      def create_scope(scope_name, options = CreateScopeOptions.new)
+        @backend.scope_create(@bucket_name, scope_name)
+      end
+
+      # Removes a scope
+      #
+      # @param [String] scope_name name of the scope
+      # @param [DropScopeOptions] options
+      #
+      # @raise [Error::ScopeNotFound]
+      def drop_scope(scope_name, options = DropScopeOptions.new)
+        @backend.scope_drop(@bucket_name, scope_name)
+      end
+
+      # Creates a new collection
+      #
+      # @param [CollectionSpec] collection specification of the collection
+      # @param [CreateCollectionOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::CollectionExist]
+      # @raise [Error::ScopeNotFound]
+      def create_collection(collection, options = CreateCollectionOptions.new)
+        @backend.collection_create(@bucket_name, collection.scope_name, collection.name, collection.max_expiry)
+      end
+
+      # Removes a collection
+      #
+      # @param [CollectionSpec] collection specification of the collection
+      # @param [DropCollectionOptions] options
+      #
+      # @raise [Error::CollectionNotFound]
+      def drop_collection(collection, options = DropCollectionOptions.new)
+        @backend.collection_drop(@bucket_name, collection.scope_name, collection.name)
+      end
+
+      class GetScopeOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetScopeOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class GetAllScopesOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetAllScopesOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class CreateScopeOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [CreateScopeOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class DropScopeOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropScopeOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class CreateCollectionOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [CreateCollectionOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class DropCollectionOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropCollectionOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+    end
+
+    class ScopeSpec
+      # @return [String] name of the scope
+      attr_accessor :name
+
+      # @return [Array<CollectionSpec>] list of collections associated with the scope
+      attr_accessor :collections
+
+      # @yieldparam [ScopeSpec] self
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class CollectionSpec
+      # @return [String] name of the collection
+      attr_accessor :name
+
+      # @return [String] name of the scope
+      attr_accessor :scope_name
+
+      # @return [Integer] time in seconds of the expiration for new documents in the collection (set to +nil+ to disable it)
+      attr_accessor :max_expiry
+
+      # @yieldparam [CollectionSpec] self
+      def initialize
+        yield self if block_given?
+      end
     end
   end
-end
+end

data/lib/couchbase/management/query_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 QueryIndexManager
@@ -21,6 +23,265 @@ module Couchbase
       def initialize(backend)
         @backend = backend
       end
+
+      # Fetches all indexes from the server
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [GetAllIndexOptions] options
+      #
+      # @return [Array<QueryIndex>]
+      #
+      # @raise [ArgumentError]
+      def get_all_indexes(bucket_name, options = GetAllIndexOptions.new)
+        res = @backend.query_index_get_all(bucket_name)
+        res[:indexes].map do |idx|
+          QueryIndex.new do |index|
+            index.name = idx[:name]
+            index.is_primary = idx[:is_primary]
+            index.type = idx[:type]
+            index.state = idx[:state]
+            index.key_space = idx[:keyspace_id]
+            index.name_space = idx[:namespace_id]
+            index.index_key = idx[:index_key]
+            index.condition = idx[:condition]
+          end
+        end
+      end
+
+      # Creates a new index
+      #
+      # @param [String] bucket_name  name of the bucket
+      # @param [String] index_name name of the index
+      # @param [Array<String>] fields the lists of fields to create th index over
+      # @param [CreateIndexOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexExists]
+      def create_index(bucket_name, index_name, fields, options = CreateIndexOptions.new)
+        @backend.query_index_create(bucket_name, index_name, fields, {
+            ignore_if_exists: options.ignore_if_exists,
+            condition: options.condition,
+            deferred: options.deferred,
+            num_replicas: options.num_replicas,
+        })
+      end
+
+      # Creates new primary index
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [CreatePrimaryIndexOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexExists]
+      def create_primary_index(bucket_name, options = CreatePrimaryIndexOptions.new)
+        @backend.query_index_create_primary(bucket_name, {
+            ignore_if_exists: options.ignore_if_exists,
+            deferred: options.deferred,
+            num_replicas: options.num_replicas,
+        })
+      end
+
+      # Drops the index
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [String] index_name name of the index
+      # @param [DropIndexOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexNotFound]
+      def drop_index(bucket_name, index_name, options = DropIndexOptions.new)
+        @backend.query_index_drop(bucket_name, index_name, {
+            ignore_if_does_not_exist: options.ignore_if_does_not_exist,
+        })
+        true
+      end
+
+      # Drops the primary index
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [DropPrimaryIndexOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexNotFound]
+      def drop_primary_index(bucket_name, options = DropPrimaryIndexOptions.new)
+        @backend.query_index_drop_primary(bucket_name, {
+            ignore_if_does_not_exist: options.ignore_if_does_not_exist,
+            index_name: options.index_name,
+        })
+        true
+      end
+
+      # Build all indexes which are currently in deferred state
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [BuildDeferredIndexOptions] options
+      #
+      # @raise [ArgumentError]
+      def build_deferred_indexes(bucket_name, options = BuildDeferredIndexOptions.new)
+        @backend.query_index_build_deferred(bucket_name, {})
+      end
+
+      # Polls indexes until they are online
+      #
+      # @param [String] bucket_name name of the bucket
+      # @param [Array<String>] index_names names of the indexes to watch
+      # @param [Integer] timeout
+      # @param [WatchIndexesOptions] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexNotFound]
+      def watch_indexes(bucket_name, index_names, timeout, options = WatchIndexesOptions.new)
+        @backend.query_index_watch(bucket_name, index_names, timeout, {})
+      end
+
+      class GetAllIndexOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [GetAllIndexOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class CreateIndexOptions
+        # @return [Boolean] do not raise error if the index already exist
+        attr_accessor :ignore_if_exists
+
+        # @return [Integer] the number of replicas that this index should have
+        attr_accessor :num_replicas
+
+        # @return [Boolean] whether the index should be created as a deferred index.
+        attr_accessor :deferred
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @return [String] condition to apply to the index
+        attr_accessor :condition
+
+        # @yieldparam [CreateIndexOptions] self
+        def initialize
+          @ignore_if_exists = false
+          yield self if block_given?
+        end
+      end
+
+      class CreatePrimaryIndexOptions
+        # @return [String] name of the index
+        attr_accessor :index_name
+
+        # @return [Boolean] do not raise error if the index already exist
+        attr_accessor :ignore_if_exists
+
+        # @return [Integer] the number of replicas that this index should have
+        attr_accessor :num_replicas
+
+        # @return [Boolean] whether the index should be created as a deferred index.
+        attr_accessor :deferred
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [CreatePrimaryIndexOptions] self
+        def initialize
+          @ignore_if_exists = false
+          yield self if block_given?
+        end
+      end
+
+      class DropIndexOptions
+        # @return [Boolean] do not raise error if the index does not exist
+        attr_accessor :ignore_if_does_not_exist
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropIndexOptions] self
+        def initialize
+          @ignore_if_does_not_exist = false
+          yield self if block_given?
+        end
+      end
+
+      class DropPrimaryIndexOptions
+        # @return [String] name of the index
+        attr_accessor :index_name
+
+        # @return [Boolean] do not raise error if the index does not exist
+        attr_accessor :ignore_if_does_not_exist
+
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [DropPrimaryIndexOptions] self
+        def initialize
+          @ignore_if_does_not_exist = false
+          yield self if block_given?
+        end
+      end
+
+      class WatchIndexesOptions
+        # @return [Boolean] whether or not to watch the primary index
+        attr_accessor :watch_primary
+
+        # @yieldparam [WatchIndexesOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+
+      class BuildDeferredIndexOptions
+        # @return [Integer] the time in milliseconds allowed for the operation to complete
+        attr_accessor :timeout
+
+        # @yieldparam [BuildDeferredIndexOptions] self
+        def initialize
+          yield self if block_given?
+        end
+      end
+    end
+
+    class QueryIndex
+      # @return [String] name of the index
+      attr_accessor :name
+
+      # @return [Boolean] true if this is a primary index
+      attr_accessor :is_primary
+      alias_method :primary?, :is_primary
+
+      # @return [:gsi, :view] type of the index
+      attr_accessor :type
+
+      # @return [Symbol] state
+      attr_accessor :state
+
+      # @return [String] the key space for the index, typically the bucket name.
+      attr_accessor :key_space
+
+      # @return [String] the namespace for the index. A namespace is a resource pool that contains multiple key spaces.
+      attr_accessor :name_space
+
+      # @return [Array<String>] an array of Strings that represent the index key(s). The array is empty in the case of a
+      #   PRIMARY INDEX.
+      #
+      # @note the query service can present the key in a slightly different manner from when you declared the index: for
+      #   instance, it will show the indexed fields in an escaped format (surrounded by backticks).
+      attr_accessor :index_key
+
+
+      # @return [String] the string representation of the index's condition (the WHERE clause of the index),
+      #   or an empty Optional if no condition was set.
+      #
+      # @note that the query service can present the condition in a slightly different manner from when you declared the
+      #   index. For instance it will wrap expressions with parentheses and show the fields in an escaped format
+      #   (surrounded by backticks).
+      attr_accessor :condition
+
+      # @yieldparam [QueryIndex] self
+      def initialize
+        yield self if block_given?
+      end
     end
   end
 end