leo_manager_client 0.4.7

data/lib/leo_manager_models.rb

@@ -0,0 +1,275 @@
+# ======================================================================
+#
+#  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 LeoManager
+
+  # ==========================
+  # System Information Model
+  # ==========================
+  class Status
+    # Node
+    attr_reader :node_stat
+    # System
+    attr_reader :system_info
+    # Array of Node
+    attr_reader :node_list
+
+    def initialize(h)
+      @node_stat = NodeStat.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 = Integer(h[:n])
+        @r = Integer(h[:r])
+        @w = Integer(h[:w])
+        @d = Integer(h[:d])
+        @ring_size = Integer(h[:ring_size])
+        #XXX: leo_manager returns ring_hash_(cur|prev) as decimal (not hex)
+        @ring_cur  = Integer(h[:ring_hash_cur]).to_s(16)
+        @ring_prev = Integer(h[:ring_hash_prev]).to_s(16)
+      end
+    end
+
+    # Node Status Model
+    class Node
+      attr_reader :type, :node, :state, :ring_cur, :ring_prev, :when
+
+      def initialize(h)
+        @type  = h[:type]
+        @node  = h[:node]
+        @when  = Time.parse(h[:when])
+        @state = h[:state]
+        #XXX: these are written in hex
+        @ring_cur  = h[:ring_cur]
+        @ring_prev = h[:ring_prev]
+      end
+
+      alias joined_at when
+    end
+
+    class NodeStat
+      @@properties = [
+        :version, :log_dir, :ring_cur, :ring_prev, :vm_version,
+        :total_mem_usage, :system_mem_usage, :procs_mem_usage,
+        :ets_mem_usage, :num_of_procs, :limit_of_procs, :thread_pool_size,
+        :replication_msgs, :sync_vnode_msgs, :rebalance_msgs, :kernel_poll
+      ]
+
+      attr_reader *@@properties
+
+      def initialize(h)
+        @@properties.each do |property|
+          instance_variable_set("@#{property}", h[property])
+        end
+        @kernel_poll = (h[:kernel_poll] == "true") if h.has_key?(:kernel_poll)
+      end
+    end
+  end
+
+  # ==========================
+  # Assigned file info Model
+  # ==========================
+  class AssignedFile
+    attr_reader :node, :vnode_id, :size, :clock, :checksum, :timestamp, :delete, :num_of_chunks
+
+    def initialize(h)
+      @node      = h[:node]
+      @vnode_id  = h[:vnode_id]
+      @size      = h[:size]
+      @clock     = h[:clock]
+      @checksum  = h[:checksum]
+      timestamp = h[:timestamp]
+      @timestamp = timestamp.empty? ? timestamp : Time.parse(timestamp)
+      @delete    = h[:delete] != 0 # bool
+      @num_of_chunks = h[:num_of_chunks]
+    end
+  end
+
+  # ==========================
+  # Storage Status Model
+  # ==========================
+  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
+
+    alias total_of_objects total_num_of_objects # for compatibility
+
+    def initialize(h)
+      @active_num_of_objects  = h[:active_num_of_objects]
+      @total_num_of_objects   = h[:total_num_of_objects]
+      @active_size_of_objects = h[:active_size_of_objects]
+      @total_size_of_objects  = h[:total_size_of_objects]
+      @ratio_of_active_size   = h[:ratio_of_active_size]
+
+      last_compaction_start = h[:last_compaction_start]
+      if last_compaction_start == "____-__-__ __:__:__"
+        @last_compaction_start = nil # you have never done compaction
+      else
+        @last_compaction_start = Time.parse(last_compaction_start)
+      end
+
+      last_compaction_end = h[:last_compaction_end]
+      if last_compaction_end == "____-__-__ __:__:__"
+        @last_compaction_end = nil
+      else
+        @last_compaction_end = Time.parse(last_compaction_end)
+      end
+    end
+
+    def file_size
+      warn "property 'file_size' is deprecated"
+    end
+  end
+
+  # ==========================
+  # S3 Credential Model
+  # ==========================
+  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]
+      @secret_access_key = h[:secret_access_key]
+    end
+  end
+
+  # ==========================
+  # Login Info Model
+  # ==========================
+  RoleDef = {
+    1 => :general,
+    9 => :admin
+  }
+  RoleDef.default_proc = proc {|_, key| raise "invalid @user_id: #{key}" }
+  RoleDef.freeze
+
+  class LoginInfo
+    attr_reader :id, :role_id, :access_key_id, :secret_key, :created_at
+
+    def initialize(h)
+      h = h[:user]
+      @id = h[:id]
+      @role_id = h[:role_id]
+      @access_key_id = h[:access_key_id]
+      @secret_key = h[:secret_key]
+      @created_at = Time.parse(h[:created_at])
+    end
+
+    def role
+      RoleDef[@role_id]
+    end
+  end
+
+  # ==========================
+  # User Info Model
+  # ==========================
+  class User
+    attr_reader :user_id, :role_id, :access_key_id, :created_at
+
+    def initialize(h)
+      @user_id = h[:user_id]
+      @role_id = h[:role_id]
+      @access_key_id = h[:access_key_id]
+      @created_at = Time.parse(h[:created_at])
+    end
+
+    def role
+      RoleDef[@role_id]
+    end
+  end
+
+  # ==========================
+  # Endpoint Model
+  # ==========================
+  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 = Time.parse(h[:created_at])
+    end
+  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])
+    end
+  end
+
+  # ==========================
+  # Compaction Status Model
+  # ==========================
+  class CompactionStatus
+    attr_reader :status, :last_compaction_start,
+                :total_targets, :num_of_pending_targets,
+                :num_of_ongoing_targets, :num_of_out_of_targets
+
+    def initialize(h)
+      @status                 = h[:status]
+      @total_targets          = h[:total_targets]
+      @num_of_pending_targets = h[:num_of_pending_targets]
+      @num_of_ongoing_targets = h[:num_of_ongoing_targets]
+      @num_of_out_of_targets  = h[:num_of_out_of_targets]
+
+      last_compaction_start = h[:last_compaction_start]
+      if last_compaction_start == "____-__-__ __:__:__"
+        @last_compaction_start = nil # you have never done compaction
+      else
+        @last_compaction_start = Time.parse(last_compaction_start)
+      end
+    end
+  end
+end

data/spec/dummy_tcp_server.rb

@@ -0,0 +1,162 @@
+# ======================================================================
+#
+#  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.
+#
+# ======================================================================
+
+require "socket"
+
+module Dummy
+  module Response
+    Login = {
+      :user => {
+        :id => "foo",
+        :role_id => 0,
+        :access_key_id => "855d2f9bf21f51b4fd38",
+        :secret_key => "ea6d9540d6385f32d674c925929748e00e0e961a",
+        :created_at => "2012-11-29 17:18:39 +0900"
+      }
+    }.to_json
+
+    Status = {
+      :system_info => {
+        :version => "0.10.1",
+        :n => "1",
+        :r => "1",
+        :w => "1",
+        :d => "1",
+        :ring_size => "128",
+        :ring_hash_cur => "2688134336",
+        :ring_hash_prev => "2688134336"},
+        :node_list => [
+          {
+            :type => "S",
+            :node => "storage_0@127.0.0.1",
+            :state => "running",
+            :ring_cur => "a039acc0",
+            :ring_prev => "a039acc0",
+            :when => "2012-09-21 15:08:22 +0900"
+          }, {
+            :type => "G",
+            :node => "gateway_0@127.0.0.1",
+            :state => "running",
+            :ring_cur => "a039acc0",
+            :ring_prev => "a039acc0",
+            :when => "2012-09-21 15:08:25 +0900"
+          }
+        ]
+    }.to_json
+
+    Whereis = {
+      :assigned_info => [
+        {
+          :node => "storage_0@127.0.0.1",
+          :vnode_id => "",
+          :size => "",
+          :clock => "",
+          :checksum => "",
+          :timestamp => "2012-12-07 16:51:08 +0900",
+          :delete => 0,
+          :num_of_chunks => 0
+        }
+      ]
+    }.to_json
+
+    StorageStat = {
+      :active_num_of_objects => 0,
+      :total_num_of_objects => 0,
+      :active_size_of_objects => 0,
+      :total_size_of_objects => 0,
+      :ratio_of_active_size => 0,
+      :last_compaction_start => "2013-03-13 09:11:04 +0900",
+      :last_compaction_end => "2013-03-13 09:11:04 +0900"
+    }.to_json
+
+    GetEndpoints = {:endpoints => [{:endpoint => "s3.amazonaws.com", :created_at=>"2012-09-21 15:08:11 +0900"},
+                                   {:endpoint => "localhost",        :created_at=>"2012-09-21 15:08:11 +0900"},
+                                   {:endpoint => "foo",              :created_at=>"2012-09-21 18:51:08 +0900"},
+                                   {:endpoint => "leofs.org",        :created_at=>"2012-09-21 15:08:11 +0900"}
+                                  ]}.to_json
+    GetBuckets = {:buckets => [{:bucket => "test",
+                                :owner => "test",
+                                :created_at => "2012-09-24 15:38:49 +0900"
+                               }]}.to_json
+
+    GetUsers = {:users => [{:access_key_id => "05236",
+                             :user_id => "_test_leofs_",
+                             :role_id => 1,
+                             :created_at => "2012-11-20 15:13:20 +0900"}]}.to_json
+
+    CreateUser = {:access_key_id => "xxxxxxxxxxxxxxxxxxxx",
+                  :secret_access_key => "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}.to_json
+  end
+
+  Argument = "arg" # passed to command which requires some arguments.
+
+  # dummy Manager
+  class Manager
+    def initialize
+      t = Thread.new do
+        TCPServer.open(Host, Port) do |server|
+          loop do
+            begin
+              socket = server.accept
+              while line = socket.readline.split.first
+                response = process_line(line)
+                socket.puts(response)
+              end
+            rescue EOFError
+            end
+          end
+        end
+      end
+      nil until t.stop? # wait server start
+    end
+
+    def process_line(line)
+      line.rstrip!
+      begin
+        case line
+        when "login"
+          Response::Login
+        when "status"
+          Response::Status
+        when "get-buckets"
+          Response::GetBuckets
+        when "whereis"
+          Response::Whereis
+        when "get-endpoints"
+          Response::GetEndpoints
+        when "get-buckets"
+          Response::GetBuckets
+        when "get-users"
+          Response::GetUsers
+        when "create-user"
+          Response::CreateUser
+        when /^du/
+          Response::StorageStat
+        else
+          { :result => line }.to_json
+        end
+      rescue => ex
+        { :error => ex.message }.to_json
+      end
+    end
+  end
+end

data/spec/leo_manager_client_spec.rb

@@ -0,0 +1,281 @@
+# ======================================================================
+#
+#  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.
+#
+# ======================================================================
+
+require "json"
+require_relative "dummy_tcp_server"
+require_relative "../lib/leo_manager_client"
+
+Host = "localhost"
+Port = 50000
+
+$DEBUG = false
+
+# key: api_name, value: num of args
+NoResultAPIs = {
+  :start => 0,
+  :detach => 1,
+  :rebalance => 0,
+  :purge => 1,
+  :set_endpoint => 1,
+  :del_endpoint => 1,
+  :add_bucket => 2,
+  :delete_bucket => 2
+}
+
+include LeoManager
+
+describe LeoManager do
+  describe StorageStat do
+    shared_examples_for StorageStat do
+      its(:active_num_of_objects) { should == 0 }
+      its(:total_num_of_objects) { should == 0 }
+      its(:active_size_of_objects) { should == 0 }
+      its(:total_size_of_objects) { should == 0 }
+    end
+
+    context "there is no last compaction" do
+      subject do
+        StorageStat.new(:active_num_of_objects => 0,
+                        :total_num_of_objects => 0,
+                        :active_size_of_objects => 0,
+                        :total_size_of_objects => 0,
+                        :ratio_of_active_size => "0.0%",
+                        :last_compaction_start => "____-__-__ __:__:__",
+                        :last_compaction_end => "____-__-__ __:__:__"
+                        )
+      end
+
+      it_behaves_like StorageStat
+
+      its(:last_compaction_start) { should be_nil }
+      its(:last_compaction_end) { should be_nil }
+    end
+
+    context "there is last compaction" do
+      let(:time_str) { Time.now.to_s }
+
+      subject do
+        StorageStat.new(
+          :active_num_of_objects => 0,
+          :total_num_of_objects => 0,
+          :active_size_of_objects => 0,
+          :total_size_of_objects => 0,
+          :last_compaction_start => time_str,
+          :last_compaction_end => time_str
+        )
+      end
+
+      it_behaves_like StorageStat
+
+      its(:last_compaction_start) { subject.to_s == time_str }
+      its(:last_compaction_end) { subject.to_s == time_str }
+    end
+  end
+
+  describe Status do
+    describe Status::System do
+      let(:ring_hash) { "1679896365" }
+
+      subject do
+        Status::System.new({
+          :version   => "0.14.0",
+          :n         => "2",
+          :r         => "1",
+          :w         => "1",
+          :d         => "1",
+          :ring_size => "128",
+          :ring_hash_cur  => ring_hash,
+          :ring_hash_prev => ring_hash
+        })
+      end
+
+      [:n, :r, :w, :d, :ring_size].each do |property|
+        its(property) { should be_a Integer }
+      end
+
+      [:ring_cur, :ring_prev].each do |property|
+        its(property) { should be_a String }
+        its(property) { should == Integer(ring_hash).to_s(16) }
+      end
+    end
+
+    describe Status::NodeStat do
+      config = {
+        :version    => "0.14.0-RC2",
+        :log_dir    => "./log",
+        :ring_cur   => "64212f2d",
+        :ring_prev  => "64212f2d",
+        :vm_version => "5.9.3.1",
+        :total_mem_usage  => 29281552,
+        :system_mem_usage => 11874433,
+        :procs_mem_usage  => 17411895,
+        :ets_mem_usage    => 1022392,
+        :num_of_procs     => 325,
+        :limit_of_procs   => 1048576,
+        :kernel_poll      => "true",
+        :thread_pool_size => 32,
+        :replication_msgs => 0,
+        :sync_vnode_msgs  => 0,
+        :rebalance_msgs   => 0
+      }
+
+      subject do
+        Status::NodeStat.new(config)
+      end
+
+      its(:kernel_poll) { should == (config[:kernel_poll] == "true") }
+      _config = config.reject {|key| key == :kernel_poll }
+      _config.each {|key, value| its(key) { should == value } }
+    end
+  end
+
+  describe Client do
+    before(:all) do
+      Dummy::Manager.new
+      @manager = Client.new("#{Host}:#{Port}")
+    end
+    subject { @manager }
+
+    it "raises error when it is passed invalid params" do
+      lambda { Client.new }.should raise_error
+    end
+
+    describe "#login" do
+      it "returns LoginInfo" do
+        subject.login("user_id", "pass").should be_a LoginInfo
+      end
+    end
+
+    describe "#status" do
+      its(:status) { should be_a Status }
+      its("status.system_info") { should be_a Status::System }
+      its("status.node_list") do
+        should be_a Array
+        should be_all {|node| node.is_a?(Status::Node) }
+      end
+    end
+
+    describe "#whereis" do
+      it "returns Array of WhereInfo" do
+        result = subject.whereis("path")
+        result.should be_a Array
+        result.each do |where_info|
+          where_info.should be_a AssignedFile
+          where_info.num_of_chunks.should be_a Integer
+        end
+      end
+    end
+
+    describe "#du" do
+      it "returns DiskUsage" do
+        subject.du("node").should be_a StorageStat
+      end
+    end
+
+    describe "#create_user" do
+      it "returns Credential" do
+        subject.create_user("user_id", "password").should be_a Credential
+      end
+
+      it "goes with only user_id" do
+        subject.create_user("user_id").should be_a Credential
+      end
+    end
+
+    describe "#update_user_role" do
+      it "returns nil" do
+        subject.update_user_role("user_id", "admin").should be_nil
+      end
+    end
+
+    describe "#update_user_password" do
+      it "returns nil" do
+        subject.update_user_password("user_id", "new_password").should be_nil
+      end
+    end
+
+    describe "#delete_user" do
+      it "returns nil" do
+        subject.delete_user("user_id").should be_nil
+      end
+    end
+
+    its(:get_users) do
+      should be_a Array
+      should be_all do |account|
+        account.is_a?(User)
+      end
+    end
+
+    its(:get_endpoints) do
+      should be_a Array
+      should be_all do |endpoint|
+        endpoint.is_a?(Endpoint)
+      end
+    end
+
+    its(:get_buckets) do
+      should be_a Array
+      should be_all do |bucket|
+        bucket.is_a?(Bucket)
+      end
+    end
+
+    describe "#recover_file" do
+      it do
+        subject.recover_file("path").should be_nil
+      end
+    end
+
+    describe "#recover_node" do
+      it do
+        subject.recover_node("node").should be_nil
+      end
+    end
+
+    describe "#recover_ring" do
+      it do
+        subject.recover_ring("node").should be_nil
+      end
+    end
+
+    NoResultAPIs.each do |api, num_of_args|
+      describe "##{api}" do
+        it "returns nil" do
+          subject.send(api, *(["argument"] * num_of_args)).should be_nil
+        end
+      end
+    end
+
+    describe "#disconnect!" do
+      it "returns nil" do
+        subject.disconnect!.should be_nil
+      end
+
+      it "accepts no more requests" do
+        lambda {
+          subject.status
+        }.should raise_error
+      end
+    end
+  end
+end