leofs_manager_client 0.2.2 → 0.2.4

data/lib/leofs_manager_client/leofs_manager_models.rb

@@ -1,11 +1,52 @@
+# ======================================================================
+#
+#  LeoFS Manager Client
+#
+#  Copyright (c) 2012 Rakuten, Inc.
+#
+#  This file is provided to you under the Apache License,
+#  Version 2.0 (the "License"); you may not use this file
+#  except in compliance with the License.  You may obtain
+#  a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+#
+# ======================================================================
 module LeoFSManager
-  ## ======================================================================
-  ## CLASS
-  ## ======================================================================
-  ## @doc System Information Model
-  ##
+  # System Information Model
   class Status
-    class SystemInfo
+    # Node
+    attr_reader :node_stat
+    # System
+    attr_reader :system_info
+    # Array of Node
+    attr_reader :node_list
+
+    def initialize(h)
+      @node_stat = Node.new(h[:node_stat]) if h.has_key?(:node_stat)
+      @system_info = System.new(h[:system_info]) if h.has_key?(:system_info)
+      @node_list = h[:node_list].map {|node| Node.new(node) } if h.has_key?(:node_list)
+    end
+
+    class System
+      attr_reader :version, :ring_size, :ring_cur, :ring_prev
+
+      # number of replicas
+      attr_reader :n
+      # number of replicas needed for a successful READ operation
+      attr_reader :r
+      # number of replicas needed for a successful WRITE operation
+      attr_reader :w
+      # number of replicas needed for a successful DELETE operation
+      attr_reader :d
+
       def initialize(h)
         @version = h[:version]
         @n = h[:n]
@@ -16,99 +57,95 @@ module LeoFSManager
         @ring_cur  = h[:ring_cur]
         @ring_prev = h[:ring_prev]
       end
-
-      attr_reader :version, :n, :r, :w, :d, :ring_size, :ring_cur, :ring_prev
     end
 
-    ## @doc Node Info Model
-    ##
-    class NodeInfo
+    # Node Status Model
+    class Node
+      attr_reader :version, :type, :node, :state, :log_dir, :ring_cur, :ring_prev, :joined_at,
+                  :tota_mem_usage, :system_mem_usage,  :procs_mem_usage, :ets_mem_usage, :num_of_procs
+
       def initialize(h)
+        @version   = h[:version]
         @type      = h[:type]
         @node      = h[:node]
         @state     = h[:state]
-        @ring_cur  = h[:ring_cur]
-        @ring_prev = h[:ring_prev]
-        @joined_at = h[:when]
-      end
-
-      attr_reader :type, :node, :state, :ring_cur, :ring_prev, :joined_at
-    end
-
-    ## @doc Node Status Model
-    ##
-    class NodeStat
-      def initialize(h)
-        @type      = h[:version]
         @log_dir   = h[:log_dir]
         @ring_cur  = h[:ring_cur]
         @ring_prev = h[:ring_prev]
+        @joined_at = h[:when]
         @total_mem_usage  = h[:total_mem_usage]
         @system_mem_usage = h[:system_mem_usage]
         @procs_mem_usage  = h[:procs_mem_usage]
         @ets_mem_usage    = h[:ets_mem_usage]
         @num_of_procs     = h[:num_of_procs]
       end
-
-      attr_reader :version, :log_dir, :ring_cur, :ring_prev, :tota_mem_usage,
-                  :system_mem_usage,  :procs_mem_usage, :ets_mem_usage, :num_of_procs
-    end
-
-    def initialize(h)
-      @node_stat = NodeStat.new(h[:node_stat]) if h.has_key?(:node_stat)
-      @system_info = SystemInfo.new(h[:system_info]) if h.has_key?(:system_info)
-      @node_list = h[:node_list].map {|node| NodeInfo.new(node) } if h.has_key?(:node_list)
     end
-
-    attr_reader :node_stat, :system_info, :node_list
   end
 
-  class WhereInfo
+  # Assigned file info Model
+  class AssignedFile
+    attr_reader :node, :vnode_id, :size, :clock, :checksum, :timestamp, :delete
+
     def initialize(h)
-      @node = h[:node]
-      @vnode_id = h[:vnode_id]
-      @size = h[:size]
-      @clock = h[:clock]
-      @checksum = h[:checksum]
+      @node      = h[:node]
+      @vnode_id  = h[:vnode_id]
+      @size      = h[:size]
+      @clock     = h[:clock]
+      @checksum  = h[:checksum]
       @timestamp = h[:timestamp]
-      @delete = h[:delete]
+      @delete    = h[:delete]
     end
- 
-    attr_reader :node, :vnode_id, :size, :clock, :checksum, :timestamp, :delete 
   end
 
-  class DiskUsage
+  # Storage Status Model
+  class StorageStat
+    attr_reader :file_size, :total_of_objects
+
     def initialize(h)
       @file_size = h[:file_size]
-      @total_of_objects = h[:total_of_objects] 
+      @total_of_objects = h[:total_of_objects]
     end
-
-    attr_reader :file_size, :total_of_objects
   end
 
+  # S3 Credential
   class Credential
+    # AWS_ACCESS_KEY_ID
+    attr_reader :access_key_id
+    # AWS_SECRET_ACCESS_KEY
+    attr_reader :secret_access_key
+
     def initialize(h)
-      @access_key_id = h[:access_key_id] 
+      @access_key_id = h[:access_key_id]
       @secret_access_key = h[:secret_access_key]
     end
-
-    attr_reader :access_key_id, :secret_access_key
   end
 
+  # Endpoint
   class Endpoint
+    # host of the endpoint
+    attr_reader :endpoint
+    # When the endpoint created at
+    attr_reader :created_at
+
     def initialize(h)
       @endpoint = h[:endpoint]
       @created_at = h[:created_at]
     end
-
-    attr_reader :endpoint, :created_at
   end
 
+  # S3-Bucket Model
   class Bucket
+    # name of bucket
+    attr_reader :name
+    # name of the bucket's owner
+    attr_reader :owner
+    # when the bucket created at
+    attr_reader :created_at
+
     def initialize(h)
-      @name = h[:bucket]
-      @owner = h[:owner]
-      @created_at = Time.parse(h[:created_at])
+      @name       = h[:bucket]
+      @owner      = h[:owner]
+      @created_at = h[:created_at]
     end
   end
 end

data/lib/leofs_manager_client.rb

@@ -26,13 +26,15 @@ require "time"
 require_relative "leofs_manager_client/leofs_manager_models"
 
 module LeoFSManager
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 
+  # Class for close TCP socket on GC.
   class Remover
     def initialize(data)
       @data = data
     end
 
+    # it will be called on GC.
     def call(*args)
       socket = @data[0]
       socket.close if socket && !socket.closed?
@@ -41,7 +43,6 @@ module LeoFSManager
   end
 
   class Client
-    ## LeoFS-related commands:
     CMD_VERSION          = "version"
     CMD_STATUS           = "status %s"
     CMD_START            = "start"
@@ -60,131 +61,152 @@ module LeoFSManager
     CMD_S3_ADD_BUCKET    = "s3-add-bucket %s %s"
     CMD_S3_GET_BUCKETS   = "s3-get-buckets"
 
-    ## ======================================================================
-    ## APIs
-    ## ======================================================================
-    ## @doc Constructor
-    ##
+    # ======================================================================
+    # APIs
+    # ======================================================================
+    # Constructor
+    #
     def initialize(*servers)
       @servers = parse_servers(servers)
       set_current_server
       final = Remover.new(@data = [])
       ObjectSpace.define_finalizer(self, final)
-      @mutex = Mutex.new
       connect
     end
 
-    attr_reader :servers, :current_server
+    # servers to connect 
+    attr_reader :servers
+    # the server currently connected
+    attr_reader :current_server
 
-    ## @doc Retrieve LeoFS's version from LeoFS Manager
-    ## @return version
+    # Retrieve LeoFS's version from LeoFS Manager
+    # Return::
+    #   Version of LeoFS
     def version
       h = sender(CMD_VERSION)
       return h[:result]
     end
 
-    ## @doc Retrieve LeoFS's system status from LeoFS Manager
-    ## @return
+    # Retrieve LeoFS's system status from LeoFS Manager
+    # Return::
+    #   Status 
     def status(node=nil)
       Status.new(sender(CMD_STATUS % node))
     end
 
-    ## @doc Launch LeoFS's storage cluster
-    ## @return nil
+    # Launch LeoFS's storage cluster
+    # Return::
+    #   _nil_
     def start
       sender(CMD_START)
       nil
     end
 
-    ## @doc Leave a node from the storage cluster
-    ##
+    # Leave a node from the storage cluster
+    # Return::
+    #   _nil_
     def detach(node)
       sender(CMD_DETACH % node)
       nil
     end
 
-    ## @doc Suspend a node in the storage cluster
-    ##
+    # Suspend a node in the storage cluster
+    # Return::
+    #   _nil_
     def suspend(node)
       sender(CMD_SUSPEND % node)
       nil
     end
 
-    ## @doc Resume a node in the storage cluster
-    ##
+    # Resume a node in the storage cluster
+    # Return::
+    #   _nil_
     def resume(node)
       sender(CMD_RESUME % node)
       nil
     end
 
-    ## @doc Execute 'rebalance' in the storage cluster
-    ##
+    # Execute 'rebalance' in the storage cluster
+    # Return::
+    #   _nil_
     def rebalance
       sender(CMD_REBALANCE)
       nil
     end
 
-    ## @doc Retrieve assigned file information
-    ##
+    # Retrieve assigned file information
+    # Return::
+    #   Array of AssignedFile
     def whereis(path)
-      whereis = sender(CMD_WHEREIS % path)[:buckets]
-      whereis.map {|h| WhereInfo.new(h)}
+      assigned_info = sender(CMD_WHEREIS % path)[:assigned_info]
+      assigned_info.map {|h| AssignedFile.new(h)}
     end
 
-    ## @doc Retrieve storage status from the storage
-    ##
+    # Retrieve storage status from the storage
+    # Return::
+    #   StorageStat
     def du(node)
-      DiskUsage.new(sender(CMD_DU % node))
+      StorageStat.new(sender(CMD_DU % node))
     end
 
-    ## @doc Execute 'compaction'
-    ##
+    # Execute 'compaction'
+    # Return::
+    #   _nil_
     def compact(node)
       sender(CMD_COMPACT % node)
       nil
     end
 
-    ## @doc Purge a cache in gateways
-    ##
+    # Purge a cache in gateways
+    # Return::
+    #   _nil_
     def purge(path)
       sender(CMD_PURGE % path)
       nil
     end
 
-    ## @doc Generate credential for LeoFS
-    ##
+    # Generate credential for LeoFS
+    # Return::
+    #   Credential
     def s3_gen_key(user_id)
       Credential.new(sender(CMD_S3_GEN_KEY % user_id))
     end
 
-    ## @doc Insert an endpoint in the system
-    ##
+    # Insert an endpoint in the system
+    # Return::
+    #   _nil_
     def s3_set_endpoint(endpoint)
       sender(CMD_S3_SET_ENDPOINT % endpoint)
       nil
     end
 
-    ## @doc Remove an endpoint from the system
-    ##
+    # Remove an endpoint from the system
+    # Return::
+    #   _nil_
     def s3_del_endpoint(endpoint)
       sender(CMD_S3_DEL_ENDPOINT % endpoint)
       nil
     end
 
-    ## @doc Retrieve an endpoint in the system
-    ##
+    # Retrieve an endpoint in the system
+    # Return::
+    #   Array of Endpoint
     def s3_get_endpoints
       endpoints = sender(CMD_S3_GET_ENDPOINTS)[:endpoints]
       endpoints.map {|endpoint| Endpoint.new(endpoint) }
     end
-  
+
+    # Add an Bucket in the system
+    # Return::
+    #   _nil_
     def s3_add_bucket(bucket_name, access_key_id)
       sender(CMD_S3_ADD_BUCKET % [bucket_name, access_key_id])
       nil
     end
 
-    ## @doc Retrieve all buckets from the system
-    ##
+    # Retrieve all buckets from the system
+    # Return::
+    #   Array of Bucket
     def s3_get_buckets
       buckets = sender(CMD_S3_GET_BUCKETS)[:buckets]
       buckets.map {|bucket| Bucket.new(bucket) }
@@ -210,15 +232,12 @@ module LeoFSManager
       end
     end
 
-    ## @doc
-    ##
     def set_current_server
       raise Error, "No servers to connect" if @servers.empty?
       @current_server = @servers.first
     end
 
-    ## @doc Connect to LeoFS Manager
-    ##
+    # Connect to LeoFS Manager
     def connect
       retry_count = 0
       begin
@@ -239,15 +258,13 @@ module LeoFSManager
       end
     end
 
-    ## @doc Send a request to LeoFS Manager
-    ## @return Hash
+    # Send a request to LeoFS Manager
+    # Return::
+    #   Hash
     def sender(command)
       begin
-        response = nil
-        @mutex.synchronize do
-          @socket.puts command
-          response = JSON.parse(@socket.gets, symbolize_names: true)
-        end
+        @socket.puts command
+        response = JSON.parse(@socket.gets, symbolize_names: true)
       rescue => ex
         raise "An Error occured: #{ex.class} (server: #{@current_server})\n#{ex.message}"
       end
@@ -257,7 +274,7 @@ module LeoFSManager
   end
 end
 
-
+# This section runs only when the file executed directly.
 if __FILE__ == $PROGRAM_NAME
   require "pp"
 

data/spec/leofs_manager_client_spec.rb

@@ -62,7 +62,7 @@ module Dummy
     }.to_json
 
     Whereis = {
-      :buckets => [
+      :assigned_info => [
         { 
           :node => "storage_0@127.0.0.1",
           :vnode_id => "",
@@ -162,14 +162,14 @@ describe LeoFSManager do
     end
 
     it "returns SystemInfo" do
-      @manager.status.system_info.should be_a Status::SystemInfo
+      @manager.status.system_info.should be_a Status::System
     end
 
     it "returns node list" do
       node_list = @manager.status.node_list
       node_list.should be_a Array
       node_list.each do |node|
-        node.should be_a Status::NodeInfo
+        node.should be_a Status::Node
       end
     end
   end
@@ -179,14 +179,14 @@ describe LeoFSManager do
       result = @manager.whereis("path")
       result.should be_a Array
       result.each do |where_info|
-        where_info.should be_a WhereInfo
+        where_info.should be_a AssignedFile
       end
     end    
   end
 
   describe "#du" do
     it "returns DiskUsage" do
-      @manager.du("node").should be_a DiskUsage
+      @manager.du("node").should be_a StorageStat
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leofs_manager_client
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000 Z
+date: 2012-09-27 00:00:00.000000000 Z
 dependencies: []
 description: Client for LeoFS Manager
 email: