leo_manager_client 0.4.8 → 0.4.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af45abcecfde935e83f87353d7f9ade9f5699be3
+  data.tar.gz: 13f6d2867d69df2a906a5e3ea4aa8c89d3c41d55
+SHA512:
+  metadata.gz: ad1f1eaae382faca27c4f08ef36f580956ebe00d624badd71c9b4788e05fd4d4e96ca8e292d4dece173fc908803a90c059b35108d25a0b01372eddd3f81a3e8f
+  data.tar.gz: 4fd20d6085984a0ea0691fa694778a31d63295bdf6d97c27eac67312d42e454b33a6c23f7a900ef827b68b017e3114184ae55faaf2ee6d24afd4e845443c97e4

data/lib/leo_manager_client.rb

@@ -2,7 +2,7 @@
 #
 #  LeoFS Manager Client
 #
-#  Copyright (c) 2012 Rakuten, Inc.
+#  Copyright (c) 2012-2014 Rakuten, Inc.
 #
 #  This file is provided to you under the Apache License,
 #  Version 2.0 (the "License"); you may not use this file
@@ -26,7 +26,7 @@ require "time"
 require_relative "leo_manager_models"
 
 module LeoManager
-  VERSION = "0.4.8"
+  VERSION = "0.4.9"
 
   class Client
     CMD_VERSION           = "version"
@@ -56,6 +56,7 @@ module LeoManager
     CMD_ADD_BUCKET        = "add-bucket %s %s"
     CMD_DELETE_BUCKET     = "delete-bucket %s %s"
     CMD_GET_BUCKETS       = "get-buckets"
+    CMD_UPDATE_ACL        = "update-acl %s %s %s"
     CMD_RECOVER_FILE      = "recover file %s"
     CMD_RECOVER_NODE      = "recover node %s"
     CMD_RECOVER_RING      = "recover ring %s"
@@ -80,242 +81,292 @@ module LeoManager
     attr_reader :current_server
 
     # Retrieve LeoFS's version from LeoFS Manager
-    # Return::
+    # ==== Return
     #   Version of LeoFS
     def version
-      h = sender(CMD_VERSION)
+      h = call(CMD_VERSION)
       return h[:result]
     end
 
     # Retrieve LeoFS's system status from LeoFS Manager
-    # Return::
+    # ==== Args
+    #   node :: Node
+    # ==== Return
     #   Status
     def status(node=nil)
-      Status.new(sender(CMD_STATUS % node))
+      Status.new(call(CMD_STATUS % node))
     end
 
     # Login as specifies user
-    # Return::
+    # ==== Args
+    #   user_id  :: user id
+    #   password :: password
+    # ==== Return
     #   LoginInfo
     def login(user_id, password)
-      LoginInfo.new(sender(CMD_LOGIN % [user_id, password]))
+      LoginInfo.new(call(CMD_LOGIN % [user_id, password]))
     end
 
     # Launch LeoFS's storage cluster
-    # Return::
-    #   _nil_
+    # ==== Return
+    #   Result
     def start
-      sender(CMD_START)
-      nil
+      Result.new(call(CMD_START))
     end
 
     # Leave a node from the storage cluster
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def detach(node)
-      sender(CMD_DETACH % node)
-      nil
+      Result.new(call(CMD_DETACH % node))
     end
 
     # Suspend a node in the storage cluster
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def suspend(node)
-      sender(CMD_SUSPEND % node)
-      nil
+      Result.new(call(CMD_SUSPEND % node))
     end
 
     # Resume a node in the storage cluster
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def resume(node)
-      sender(CMD_RESUME % node)
-      nil
+      Result.new(call(CMD_RESUME % node))
     end
 
-    # Execute 'rebalance' in the storage cluster
-    # Return::
-    #   _nil_
+    # Execute relocate of objects - "rebalance" in the storage cluster
+    # ==== Return
+    #   Result
     def rebalance
-      sender(CMD_REBALANCE)
-      nil
+      Result.new(call(CMD_REBALANCE))
     end
 
     # Retrieve assigned file information
-    # Return::
+    # ==== Args
+    #   path :: an object path
+    # ==== Return
     #   Array of AssignedFile
     def whereis(path)
-      assigned_info = sender(CMD_WHEREIS % path)[:assigned_info]
+      assigned_info = call(CMD_WHEREIS % path)[:assigned_info]
       assigned_info.map {|h| AssignedFile.new(h)}
     end
 
     # Retrieve storage status from the storage
-    # Return::
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
     #   StorageStat
     def du(node)
-      StorageStat.new(sender(CMD_DU % node))
+      StorageStat.new(call(CMD_DU % node))
     end
 
-    # Execute 'compact start'
-    # Return::
-    #   _nil_
+    # Execute data comaction in a storage node
+    # ==== Args
+    #   node :: a storage node
+    #   num_of_targets_or_all :: a number of targets - [integer | all]
+    #   num_of_concurrents    :: a number of concurrents
+    # ==== Return
+    #   Result
     def compact_start(node, num_of_targets_or_all, num_of_concurrents=nil)
       case num_of_targets_or_all.to_s
       when /^all$/i
-        sender(CMD_COMPACT_START_ALL % node)
+        Result.new(call(CMD_COMPACT_START_ALL % node))
       else
         num_of_concurrents = num_of_concurrents ? Integer(num_of_concurrents) : ""
-        sender(CMD_COMPACT_START % [node, Integer(num_of_targets_or_all), num_of_concurrents])
+        Result.new(call(CMD_COMPACT_START % [node, Integer(num_of_targets_or_all), num_of_concurrents]))
       end
-      nil
     end
 
     # Execute 'compact suspend'
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def compact_suspend(node)
-      sender(CMD_COMPACT_SUSPEND % node)
-      nil
+      Result.new(call(CMD_COMPACT_SUSPEND % node))
     end
 
     # Execute 'compact suspend'
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def compact_resume(node)
-      sender(CMD_COMPACT_RESUME % node)
-      nil
+      Result.new(call(CMD_COMPACT_RESUME % node))
     end
 
     # Execute 'compact status'
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   CompactionStatus
     def compact_status(node)
-      compaction = sender(CMD_COMPACT_STATUS % node)[:compaction_status]
+      compaction = call(CMD_COMPACT_STATUS % node)[:compaction_status]
       CompactionStatus.new(compaction)
     end
 
-    # Purge a cache in gateways
-    # Return::
-    #   _nil_
+    # Purge a cache in the gateways
+    # ==== Args
+    #   path :: an object path
+    # ==== Return
+    #   Result
     def purge(path)
-      sender(CMD_PURGE % path)
-      nil
+      Result.new(call(CMD_PURGE % path))
     end
 
-    # Generate credential for LeoFS
-    # Return::
+    # Generate credential of a user
+    # ==== Args
+    #   user_id  :: user id
+    #   password :: password
+    # ==== Return
     #   Credential
     def create_user(user_id, password=nil)
-      Credential.new(sender(CMD_CRE_USER % [user_id, password]))
+      Credential.new(call(CMD_CRE_USER % [user_id, password]))
     end
 
-    # Update user role
-    # Return ::
-    #   _nil_
+    # Update role of a user
+    # ==== Args
+    #   user_id :: user id
+    #   role    :: operation role of a user
+    # ==== Return
+    #   Result
     def update_user_role(user_id, role)
       role = role.to_sym if role.is_a? String
       role = USER_ROLES[role] if role.is_a? Symbol
-      sender(CMD_UPD_USER_ROLE % [user_id, role])
-      nil
+      Result.new(call(CMD_UPD_USER_ROLE % [user_id, role]))
     end
 
-    # Update user password
-    # Return::
-    #   _nil_
+    # Update password of a user
+    # ==== Args
+    #   user_id      :: user id
+    #   new_password :: new password
+    # ==== Return
+    #   Result
     def update_user_password(user_id, new_password)
-      sender(CMD_UPD_USER_PASS % [user_id, new_password])
-      nil
+      Result.new(call(CMD_UPD_USER_PASS % [user_id, new_password]))
     end
 
-    # Delete user
-    # Return::
-    #   _nil_
+    # Delete a user
+    # ==== Args
+    #   user_id :: user id
+    # ==== Return
+    #   Result
     def delete_user(user_id)
-      sender(CMD_DEL_USER % user_id)
-      nil
+      Result.new(call(CMD_DEL_USER % user_id))
     end
 
+    # Retrieve a user
+    # ==== Return
+    #   Map
     def get_users
-      users = sender(CMD_GET_USERS)[:users]
+      users = call(CMD_GET_USERS)[:users]
       users.map {|account| User.new(account) }
     end
 
     # Insert an endpoint in the system
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   endpoint :: an endpoint
+    # ==== Return
+    #   Result
     def set_endpoint(endpoint)
-      sender(CMD_SET_ENDPOINT % endpoint)
-      nil
+      Result.new(call(CMD_SET_ENDPOINT % endpoint))
     end
 
     # Remove an endpoint from the system
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   endpoint :: an endpoint
+    # ==== Return
+    #   nil
     def delete_endpoint(endpoint)
-      sender(CMD_DEL_ENDPOINT % endpoint)
-      nil
+      Result.new(call(CMD_DEL_ENDPOINT % endpoint))
     end
     alias :del_endpoint :delete_endpoint
 
     # Retrieve an endpoint in the system
-    # Return::
+    # ==== Return
     #   Array of Endpoint
     def get_endpoints
-      endpoints = sender(CMD_GET_ENDPOINTS)[:endpoints]
+      endpoints = call(CMD_GET_ENDPOINTS)[:endpoints]
       endpoints.map {|endpoint| Endpoint.new(endpoint) }
     end
 
     # Add an Bucket in the system
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   bucket_name :: a bucket name
+    #   access_key_id :: access key id
+    # ==== Return
+    #   Result
     def add_bucket(bucket_name, access_key_id)
-      sender(CMD_ADD_BUCKET % [bucket_name, access_key_id])
-      nil
+      Result.new(call(CMD_ADD_BUCKET % [bucket_name, access_key_id]))
     end
 
     # Delete an Bucket in the system
-    # Return::
-    #   _nil_
+    # ==== Args
+    #   bucket_name :: a bucket name
+    #   access_key_id :: access key id
+    # ==== Return
+    #   Result
     def delete_bucket(bucket_name, access_key_id)
-      sender(CMD_DELETE_BUCKET % [bucket_name, access_key_id])
-      nil
+      Result.new(call(CMD_DELETE_BUCKET % [bucket_name, access_key_id]))
     end
 
     # Retrieve all buckets from the system
-    # Return::
+    # ==== Return
     #   Array of Bucket
     def get_buckets
-      buckets = sender(CMD_GET_BUCKETS)[:buckets]
+      buckets = call(CMD_GET_BUCKETS)[:buckets]
       buckets.map {|bucket| Bucket.new(bucket) }
     end
 
+    # Update acl of a bucket
+    # ==== Args
+    #   bucket_name   :: a bucket name
+    #   access_key_id :: access key id
+    #   acl :: acl of a bucket
+    # ==== Return
+    #   Result
+    def update_acl(bucket, accesskey, acl)
+      Result.new(call(CMD_UPDATE_ACL % [bucket, accesskey, acl]))
+    end
+
     # Recover file
-    # Return::
-    #   nil
+    # ==== Args
+    #   path :: an object path
+    # ==== Return
+    #   Result
     def recover_file(path)
-      sender(CMD_RECOVER_FILE % path)
-      nil
+      Result.new(call(CMD_RECOVER_FILE % path))
     end
 
     # Recover node
-    # Return::
-    #   nil
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def recover_node(node)
-      sender(CMD_RECOVER_NODE % node)
-      nil
+      Result.new(call(CMD_RECOVER_NODE % node))
     end
 
     # Recover ring
-    # Return::
-    #   nil
+    # ==== Args
+    #   node :: a storage node
+    # ==== Return
+    #   Result
     def recover_ring(node)
-      sender(CMD_RECOVER_RING % node)
+      Result.new(call(CMD_RECOVER_RING % node))
       nil
     end
 
     # Disconnect to LeoFS Manager explicitly
-    # Return::
-    #   _nil_
+    # ==== Return
+    #   Result
     def disconnect!
       disconnect
     end
@@ -380,7 +431,7 @@ module LeoManager
     # Send a request to LeoFS Manager
     # Return::
     #   Hash
-    def sender(command)
+    def call(command)
       response = nil
       begin
         @mutex.synchronize do
@@ -393,6 +444,7 @@ module LeoManager
         warn "EOFError occured (server: #{@current_server})"
         reconnect
       rescue => ex
+        reconnect
         raise "An Error occured: #{ex.class} (server: #{@current_server})\n#{ex.message}"
       else
         raise response[:error] if response.has_key?(:error)
@@ -409,6 +461,7 @@ if __FILE__ == $PROGRAM_NAME
   $DEBUG = true
   m = LeoManager::Client.new("localhost:10020", "localhost:10021")
   p m.version
+
   p "[status]"
   p m.status
 
@@ -418,6 +471,12 @@ if __FILE__ == $PROGRAM_NAME
   p "[status gateway_0@127.0.0.1]"
   p m.status("gateway_0@127.0.0.1")
 
+  p "[add-bucket]"
+  p m.add_bucket("photo", "05236")
+
+  p "[update-acl]"
+  p m.update_acl("photo", "05236", "public-read")
+
   p "[get-buckets]"
   p m.get_buckets()
 

data/lib/leo_manager_models.rb

@@ -2,7 +2,7 @@
 #
 #  LeoFS Manager Client
 #
-#  Copyright (c) 2012 Rakuten, Inc.
+#  Copyright (c) 2012-2014 Rakuten, Inc.
 #
 #  This file is provided to you under the Apache License,
 #  Version 2.0 (the "License"); you may not use this file
@@ -21,6 +21,23 @@
 # ======================================================================
 module LeoManager
 
+  # ==========================
+  # Common Result
+  # ==========================
+  class Result
+    attr_reader :result
+
+    def initialize(h)
+      error = h[:error]
+      if error == nil
+        @result = h[:result]
+      else
+        @result = error
+      end
+    end
+  end
+
+
   # ==========================
   # System Information Model
   # ==========================
@@ -118,8 +135,10 @@ module LeoManager
       @@properties = [:handler, :port, :ssl_port, :num_of_acceptors, :http_cache,
                       :cache_workers, :cache_expire, :cache_ram_capacity,
                       :cache_disc_capacity, :cache_disc_threshold_len, :cache_disc_dir_data,
-                      :cache_disc_dir_journal, :cache_max_content_len, :max_chunked_objs,
-                      :max_len_for_obj, :chunked_obj_len, :threshold_obj_len]
+                      :cache_disc_dir_journal, :cache_max_content_len,
+                      :max_chunked_objs, :max_len_for_obj, :chunked_obj_len,
+                      :reading_chunked_obj_len, :threshold_of_chunk_len
+                     ]
       attr_reader *@@properties
 
       def initialize(h)
@@ -154,9 +173,9 @@ module LeoManager
   # ==========================
   class StorageStat
     attr_reader :active_num_of_objects, :total_num_of_objects,
-                :active_size_of_objects, :total_size_of_objects,
-                :ratio_of_active_size,
-                :last_compaction_start, :last_compaction_end
+    :active_size_of_objects, :total_size_of_objects,
+    :ratio_of_active_size,
+    :last_compaction_start, :last_compaction_end
 
     alias total_of_objects total_num_of_objects # for compatibility
 
@@ -285,8 +304,8 @@ module LeoManager
   # ==========================
   class CompactionStatus
     attr_reader :status, :last_compaction_start,
-                :total_targets, :num_of_pending_targets,
-                :num_of_ongoing_targets, :num_of_out_of_targets
+    :total_targets, :num_of_pending_targets,
+    :num_of_ongoing_targets, :num_of_out_of_targets
 
     def initialize(h)
       @status                 = h[:status]

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leo_manager_client
 version: !ruby/object:Gem::Version
-  version: 0.4.8
-  prerelease: 
+  version: 0.4.9
 platform: ruby
 authors:
 - Yosuke Hara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-20 00:00:00.000000000 Z
+date: 2014-01-06 00:00:00.000000000 Z
 dependencies: []
 description: Client for LeoFS-Manager
 email:
@@ -18,7 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -30,27 +29,26 @@ files:
 - spec/leo_manager_client_spec.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Client for LeoFS-Manager
 test_files:
 - spec/dummy_tcp_server.rb