collins_shell 0.2.14

data/lib/collins_shell/console/commands/versions.rb

@@ -0,0 +1,42 @@
+require 'pry'
+
+module CollinsShell; module Console; module Commands
+  Versions = Pry::CommandSet.new do
+    create_command "latest", "Latest version of collins shell" do
+      group "Software"
+
+      def options(opt)
+        opt.banner <<-BANNER
+          Usage: latest
+
+          Display the latest version of collins shell
+        BANNER
+      end
+
+      def process
+        o = CollinsShell::Console.options
+        render_output CollinsShell::Cli.new([], o).get_latest_version
+      end
+
+    end # create_command
+
+    create_command "version", "Current version of collins shell" do
+      group "Software"
+
+      def options(opt)
+        opt.banner <<-BANNER
+          Usage: version
+
+          Display the current version of collins shell
+        BANNER
+      end
+
+      def process
+        o = CollinsShell::Console.options
+        render_output CollinsShell::Cli.new([], o).get_version
+      end
+
+    end # create_command
+
+  end # CommandSet
+end; end; end

data/lib/collins_shell/console/filesystem.rb

@@ -0,0 +1,121 @@
+require 'collins_shell/console/asset'
+
+module CollinsShell; module Console
+  class Filesystem
+    include CollinsShell::Console::CommandHelpers
+
+    attr_accessor :console_asset, :stack # Using console_asset, don't want to steal asset
+
+    def initialize optns = {}
+      options = Collins::Util.symbolize_hash(optns)
+      @console_asset = options.fetch(:console_asset, nil)
+      @options = options
+      @stack = options.fetch(:stack, [])
+    end
+
+    def root?
+      @stack.size == 0
+    end
+
+    def asset?
+      !console_asset.nil?
+    end
+
+    def path
+      '/' + @stack.join('/')
+    end
+
+    def pop
+      stk = @stack.dup
+      stk.pop
+      stk = [] if stk.nil?
+      asset = resolve_location(stk) if stk.size > 0
+      opts = @options.merge(:stack => stk, :console_asset => asset)
+      CollinsShell::Console::Filesystem.new(opts)
+    end
+
+    def push ctxt
+      stk = @stack.dup
+      stk << ctxt
+      asset = resolve_location stk
+      if asset? and asset then
+        raise StandardError.new("Can not nest assets in assets")
+      end
+      opts = @options.merge(:stack => stk, :console_asset => asset)
+      CollinsShell::Console::Filesystem.new(opts)
+    end
+
+    def available_commands
+      includes = ['clear_cache'] + pry_commands
+      if asset? then
+        excludes = ['respond_to?','to_s','cput'].map{|s|s.to_sym}
+        cmds1 = CollinsShell::Console::Asset.public_instance_methods(false).reject{|i| excludes.include?(i.to_sym)}
+        cmds2 = Collins::Asset.public_instance_methods(false).reject{|i| excludes.include?(i.to_sym)}.map{|s| "asset.#{s}"}
+        cmds1 + cmds2 + includes
+      else
+        includes
+      end
+    end
+
+    def to_s
+      "#{self.class}(path = '#{path}', asset? = '#{asset?}')"
+    end
+
+    protected
+    def method_missing meth, *args, &block
+      if asset? then
+        a = @console_asset
+        if a.respond_to?(meth) then
+          a.send(meth, *args, &block)
+        else
+          Pry.output.puts("Command not found: #{meth}")
+          cmds = available_commands.join(', ')
+          Pry.output.puts("Available commands: #{cmds}")
+        end
+      elsif pry_commands.include?(meth) then
+        arg = args.unshift(meth).join(' ')
+        runner = CollinsShell::Console
+        runner.run_pry_command(arg, :context => self, :binding_stack => [Pry.binding_for(self)])
+      else
+        Pry.output.puts("command not found: #{meth}")
+      end
+    end
+
+    def pry_commands
+      @pry_commands ||= Pry.commands.list_commands.select{|c| c.respond_to?(:to_sym)}.map{|c| c.to_sym}
+    end
+
+    # @return [Collins::Asset,NilClass] asset if context is one, nil otherwise
+    # @raise [ExpectationFailedException] if invalid nesting is attempted
+    def resolve_location stack
+      context = stack.last
+      path = "/#{stack.join('/')}"
+
+      if get_all_tags.include?(context) then
+        Pry.output.puts("Found tag: '#{context}'")
+        nil
+      elsif asset_exists?(context) then
+        Pry.output.puts("Found asset: '#{context}'")
+        CollinsShell::Console::Asset.new(context)
+      elsif stack.size % 2 == 0 then # should be key/value, we know it's not root
+        begin
+          assets = find_assets(stack, false)
+          if assets.size == 0 then
+            raise StandardError.new("No assets in path #{path}")
+          elsif assets.size == 1 then
+            Pry.output.puts("Found asset #{assets[0]} in #{path}")
+            CollinsShell::Console::Asset.new(assets[0])
+          else
+            Pry.output.puts("#{assets.size} assets in path #{path}")
+            nil
+          end
+        rescue Exception => e
+          raise StandardError.new("Invalid path #{path} - #{e}")
+        end
+      else
+        raise StandardError.new("Path #{path} is invalid")
+      end
+    end
+
+  end
+end; end

data/lib/collins_shell/console/options_helpers.rb

@@ -0,0 +1,8 @@
+module CollinsShell; module Console; module OptionsHelpers
+
+  module_function
+  def pager_options opt
+    opt.on :f, :flood, "Do not use a pager to view text longer than one screen"
+  end
+
+end; end; end

data/lib/collins_shell/errors.rb

@@ -0,0 +1,7 @@
+module CollinsShell
+
+  class CollinsShellError < StandardError; end
+  class ConfigurationError < CollinsShellError; end
+  class RequirementFailedError < CollinsShellError; end
+
+end

data/lib/collins_shell/ip_address.rb

@@ -0,0 +1,144 @@
+require 'collins_shell/thor'
+require 'collins_shell/util'
+require 'thor'
+require 'thor/group'
+
+module CollinsShell
+
+  class IpAddress < Thor
+
+    include ThorHelper
+    include CollinsShell::Util
+    namespace :ip_address
+    def self.banner task, namespace = true, subcommand = false
+      "#{basename} #{task.formatted_usage(self, true, subcommand).gsub(':',' ')}"
+    end
+
+    desc 'allocate POOL', 'allocate addresses for an asset in the specified pool'
+    use_collins_options
+    use_tag_option(true)
+    method_option :count, :type => :numeric, :default => 1, :desc => 'Number of addresses to allocate'
+    def allocate pool
+      call_collins get_collins_client, "ip_address allocate" do |client|
+        addresses = client.ipaddress_allocate! options.tag, pool, options["count"]
+        header = [["Gateway","Netmask","Address","Pool"]]
+        tags = header + addresses.map do |address|
+          [address.gateway, address.netmask, address.address, address.pool]
+        end
+        print_table tags
+      end
+    end
+
+    desc 'delete POOL', 'delete addresses for an asset in the specified pool'
+    use_collins_options
+    use_tag_option(true)
+    def delete pool
+      call_collins get_collins_client, "ip_address delete" do |client|
+        delete_count = client.ipaddress_delete! options.tag, pool
+        say_success "Deleted #{delete_count} addresses"
+      end
+    end
+
+    desc 'delete_all', 'delete all addresses for an asset'
+    use_collins_options
+    use_tag_option(true)
+    def delete_all
+      call_collins get_collins_client, "ip_address delete_all" do |client|
+        delete_count = client.ipaddress_delete! options.tag
+        say_success "Deleted #{delete_count} addresses"
+      end
+    end
+
+    desc 'find ADDRESS', 'find asset using specified IP address'
+    use_collins_options
+    def find address
+      call_collins get_collins_client, "ip_address find" do |client|
+        asset = client.asset_at_address address
+        if asset then
+          say_success "Asset #{asset.tag} is using address #{address}"
+        else
+          say_error "No asset using address #{address}"
+        end
+      end
+    end
+
+    desc 'assets POOL', 'find all assets in a pool'
+    use_collins_options
+    method_option :details, :type => :boolean, :default => false, :desc => 'Retrieve details for each asset. SLOW'
+    def assets pool
+      call_collins get_collins_client, "ip_address assets" do |client|
+        header = true
+        client.assets_in_pool(pool).each do |asset|
+          if options.details then
+            asset = client.get asset
+            print_find_results asset, [:tag,:status,:type,:hostname,:addresses], :header => header
+            header = false
+          else
+            puts(asset.tag)
+          end
+        end
+      end
+    end
+
+    desc 'pools', 'find all pools that are in use'
+    use_collins_options
+    method_option :used, :type => :boolean, :default => false, :desc => 'Only pools that are in use'
+    def pools
+      call_collins get_collins_client, "ip_address pools" do |client|
+        # NAME, NETWORK, START_ADDRESS, SPECIFIED_GATEWAY, GATEWAY, BROADCAST, POSSIBLE_ADDRESSES
+        header = [["Pool","Network","Gateway","Broadcast","Possible Addresses","Start Address","Specified Gateway"]]
+        rows = client.ipaddress_pools(!options.used).map do |pool|
+          [pool["NAME"], pool["NETWORK"], pool["GATEWAY"], pool["BROADCAST"], pool["POSSIBLE_ADDRESSES"],
+            pool["START_ADDRESS"], pool["SPECIFIED_GATEWAY"]]
+        end
+        print_table header + rows
+      end
+    end
+
+    desc 'create', 'create a new IP address (Use allocate, not create)'
+    use_collins_options
+    use_tag_option(true)
+    method_option :address, :required => true, :type => :string, :desc => 'IP address'
+    method_option :gateway, :required => true, :type => :string, :desc => 'IP gateway'
+    method_option :netmask, :required => true, :type => :string, :desc => 'IP netmask'
+    method_option :pool, :type => :string, :desc => 'Name of pool'
+    def create
+      call_collins get_collins_client, "create address" do |client|
+        address = client.ipaddress_update! options.tag, nil,
+                                                :address => options.address,
+                                                :gateway => options.gateway,
+                                                :netmask => options.netmask,
+                                                :pool => options.pool
+        if address then
+          say_success "Address for #{options.tag} created"
+        else
+          say_error "Address for #{options.tag} not created"
+        end
+      end
+    end
+
+    desc 'update OLD_ADDRESS', 'update the IP info for an asset'
+    use_collins_options
+    use_tag_option(true)
+    method_option :address, :type => :string, :desc => 'New IP address'
+    method_option :gateway, :type => :string, :desc => 'New IP gateway'
+    method_option :netmask, :type => :string, :desc => 'New IP netmask'
+    method_option :pool, :type => :string, :desc => 'New pool'
+    def update old_address
+      call_collins get_collins_client, "update address" do |client|
+        address = client.ipaddress_update! options.tag, old_address,
+                                                :address => options.address,
+                                                :gateway => options.gateway,
+                                                :netmask => options.netmask,
+                                                :pool => options.pool
+        if address then
+          say_success "Address for #{options.tag} updated"
+        else
+          say_error "Address for #{options.tag} not updated"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/collins_shell/ipmi.rb

@@ -0,0 +1,67 @@
+require 'collins_shell/thor'
+require 'collins_shell/util'
+require 'thor'
+require 'thor/group'
+
+module CollinsShell
+
+  class Ipmi < Thor
+    include ThorHelper
+    include CollinsShell::Util
+    namespace :ipmi
+    def self.banner task, namespace = true, subcommand = false
+      "#{basename} #{task.formatted_usage(self, true, subcommand).gsub(':',' ')}"
+    end
+
+    def self.ipmi_options required = false
+      method_option :ipmi_username, :type => :string, :required => required, :desc => 'IPMI username'
+      method_option :ipmi_password, :type => :string, :required => required, :desc => 'IPMI password'
+      method_option :address, :type => :string, :required => required, :desc => 'IPMI address'
+      method_option :gateway, :type => :string, :required => required, :desc => 'IPMI gateway'
+      method_option :netmask, :type => :string, :required => required, :desc => 'IPMI netmask'
+    end
+
+    def self.print_ipmi ipmi
+      puts("address,gateway,netmask,username,password")
+      puts([ipmi.address,ipmi.gateway,ipmi.netmask,ipmi.username,ipmi.password].join(','))
+    end
+
+    desc 'create', 'create a new IPMI address for the specified asset'
+    use_collins_options
+    use_tag_option(true)
+    ipmi_options(true)
+    def create
+      call_collins get_collins_client, "create ipmi" do |client|
+        ipmi = client.ipmi_create options.tag, options.ipmi_username, options.ipmi_password, options.address, options.gateway, options.netmask
+        if ipmi then
+          asset = client.get options.tag
+          CollinsShell::Ipmi.print_ipmi asset.ipmi
+        else
+          say_error "create IPMI address"
+        end
+      end
+    end
+
+    desc 'update', 'update IPMI settings for an asset'
+    use_collins_options
+    use_tag_option(true)
+    ipmi_options(false)
+    def update
+      call_collins get_collins_client, "update ipmi" do |client|
+        ipmi = client.ipmi_update options.tag, :username => options.ipmi_username,
+                                               :password => options.ipmi_password,
+                                               :address => options.address,
+                                               :gateway => options.gateway,
+                                               :netmask => options.netmask
+        if ipmi then
+          asset = client.get options.tag
+          CollinsShell::Ipmi.print_ipmi asset.ipmi
+        else
+          say_error "update IPMI address"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/collins_shell/monkeypatch.rb

@@ -0,0 +1,60 @@
+class Numeric
+  SIZE_ARRAY = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB']
+end
+
+class Float
+  def to_human_size
+    return "0 Bytes" if (self == 0)
+    i = (Math.log(self) / Math.log(1024)).floor.to_i
+    small = self / (1024 ** i)
+    if i == 0 then
+      "#{self} #{SIZE_ARRAY[i]}"
+    else
+      sprintf("%.14f %s", small, SIZE_ARRAY[i])
+    end
+  end
+end
+
+class Fixnum
+
+  def to_human_size
+    return "0 Bytes" if (self == 0)
+    i = (Math.log(self) / Math.log(1024)).floor.to_i
+    small = self / (1024 ** i)
+    if i == 0 then
+      "#{self} #{SIZE_ARRAY[i]}"
+    else
+      sprintf("%.2f %s", small, SIZE_ARRAY[i])
+    end
+  end
+
+end
+
+class String
+
+  def is_disk_size?
+    s = self.downcase
+    s.include?("gb") or s.include?("mb") or s.include?("tb")
+  end
+
+  def to_bytes
+    s = self.downcase
+    size_h = ""
+    multiplier = 0
+    if s.include?("mb") then
+      multiplier = (1024 ** 2)
+      size_h = s.split('mb')[0]
+    elsif s.include?("gb") then
+      multiplier = (1024 ** 3)
+      size_h = s.split('gb')[0]
+    elsif s.include?("tb") then
+      multiplier = (1024 ** 4)
+      size_h = s.split('tb')[0]
+    else
+      raise Exception.new("Unknown size: #{s}")
+    end
+    (multiplier * size_h.to_f).floor.to_i
+  end
+
+
+end