pve 0.1.2

data/lib/pve/cli/ct.rb

@@ -0,0 +1,115 @@
+class PVE::Cli
+def cli_ct
+  cli.sub :ct, "Containers", aliases: %w[lx lxc] do |ct_cli|
+    ct_cli.cmd :list, "List CT-IDs", aliases: ['ls'], &lambda {|node=nil|
+      connect
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.flat_map do |n|
+        n.lxc.map {|c| c.vmid.to_i }
+      end.sort.each {|c| puts c }
+    }
+
+    ct_cli.cmd :status, "List CTs with status", aliases: [nil], &lambda {|node=nil|
+      connect
+      to = TablizedOutput.new %w[Status HA ID Name Host Uptime CPU Mem/MiB Disk/MiB]
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.each do |n|
+        n.lxc.each &to.method( :virt)
+      end
+      to.print order: [3]
+    }
+
+    ct_cli.cmd :enter, "Enter Console of CT", &lambda {|name_or_id|
+      connect
+      STDERR.puts "! #{$?.exitstatus}"  unless Proxmox::LXC.find!( name_or_id).enter
+    }
+
+    ct_cli.cmd :exec, "Executes Command in CT", min: 4, &lambda {|name_or_id, *command|
+      connect
+      STDERR.puts "! #{$?.exitstatus}"  unless Proxmox::LXC.find!( name_or_id).exec *command
+    }
+
+    ct_cli.cmd( :start, "Starts CT", min: 3, &lambda {|name_or_id, node: nil, fire:, timeout:, secs:|
+      connect
+      ct = Proxmox::LXC.find! name_or_id
+      start ct, node: node, fire: fire, timeout: timeout, secs: secs
+    }).
+      opt( :node, "-nNODE", "--node=NODE", "On NODE (default, as is, so without migration)").
+      tap {|c| opts_wait c }
+
+    ct_cli.cmd( :stop, "Stops CT", min: 3, &lambda {|name_or_id, fire: nil, timeout:, secs:|
+      connect
+      ct = Proxmox::LXC.find! name_or_id
+      stop ct, fire: fire, timeout: timeout, secs: secs
+    }).tap {|c| opts_wait c }
+
+    ct_cli.cmd( :wait, "Wait till CT is in state", &lambda {|name_or_id, state, timeout: nil, secs: nil|
+      connect
+      ct = Proxmox::LXC.find! name_or_id
+      wait ct, state, timeout: timeout, secs: secs
+    }).
+      opt( :timeout, "-tTIMEOUT", "--timeout=TIMEOUT", "Wait for max TIMEOUT seconds (default: endless)", default: nil).
+      opt( :secs, "-sSECONDS", "--seconds=SECONDS", "Check every SECONDS for state (default: 0.2)", default: 0.2)
+
+    ct_cli.cmd( :create, "Creates a new container", &lambda {|template, *options| #, fire:, timeout:, secs:, start:|
+      if %w[-h --help].include? template
+        STDERR.puts "Usage: ct create TEMPLATE -h        # Shows template-related options"
+        STDERR.puts "       ct create TEMPLATE [OPTIONS] # Creates a container"
+        exit 1
+      end
+      ctopts = {}
+      OptionParser.new do |opts|
+        opts.banner = <<EOU
+Usage: ct create #{template} [options]
+
+Options: (*=Required)
+EOU
+        opts.on '-h', '--help', " Help!" do
+          STDERR.puts opts
+          exit 1  unless interactive?
+          return
+        end
+        opts.on( '-r', '--[no-]-start', " Start container after creation") {|v| ctopts[:start] = v }
+        opts.on( '-f', '--[no-]-fire', " Do not wait till running") {|v| ctopts[:start] = v }
+        opts.on( '-t', '--timeout=TIMEOUT', " Wait for max TIMEOUT seconds (default: endless)") {|v| ctopts[:timeout] = v }
+        opts.on( '-s', '--seconds=SECONDS', " Check every SECONDS for state (default: 0.2)") {|v| ctopts[:seconds] = v }
+        ctt = PVE::CTTemplate.const_get template.classify
+        ctt.requirements.each do |name, (type, req, desc, *args)|
+          req = req ? "*" : " "
+          case type
+          when :boolean
+            opts.on( "--[no-]#{name}", "#{req}#{desc}") {|v| ctopts[name] = v }
+          when :string, :numeric
+            opts.on( "--#{name}=#{type.upcase}", "#{req}#{desc}") {|v| ctopts[name] = v }
+          when :enum
+            opts.on( "--#{name}=#{type.upcase}", "#{req}#{desc} (#{args.first.join ', '})") do |v|
+              ctopts[name] = v
+            end
+          end
+        end
+      end.parse! options
+      connect
+      create Proxmox::LXC, template, **ctopts
+    })
+
+    ct_cli.cmd( :config, '', &lambda {|name_or_id|
+      connect
+      ct = Proxmox::LXC.find! name_or_id
+      STDOUT.puts ct.config.to_json
+    })
+
+    ct_cli.cmd( :destroy, '', min: 7, &lambda {|name_or_id, fire:, secs:, timeout:, i_really_want_to_destroy:|
+      raise UsageError, "Name/ID is not what you want to destroy"  unless name_or_id == i_really_want_to_destroy
+      connect
+      ct = Proxmox::LXC.find! name_or_id
+      raise UsageError, "Container is not stopped"  unless ct.stopped?
+      destroy ct, fire: fire, timeout: timeout, secs: secs
+    }).tap {|c| opts_wait c }.
+      opt( :i_really_want_to_destroy, "--i-really-want-to-destroy=NAMEORID", "Repeat the name/ID")
+
+    ct_cli.cmd( :help, '', aliases: ['-h', '--help']) {|*args| help ct_cli, *args }
+  end
+end
+end

data/lib/pve/cli/ha.rb

@@ -0,0 +1,78 @@
+class PVE::Cli
+def opts_ha cl
+  cl.
+    opt( :group, "-gGROUP", "--group=GROUP", "Put host in GROUP", default: 'all').
+    opt( :comment, "-cCOMMENT", "--comment=COMMENT", "Set comment").
+    opt( :max_relocate, "-lCOUNT", "--max-relocate=COUNT", "How often host can be relocate before givingup?", default: 2).
+    opt( :max_restart, "-rCOUNT", "--max-restart=COUNT", "How often host can be restarted before givingup?", default: 2).
+    opt( :state, "-sSTATE", "--state=STATE", "Host should have STATE.  If you start/stop be `pct/qm/e start/stop` STATE will be set before action.", default: "started")
+end
+
+def cli_ha
+  cli.sub :ha, "Inspect High-Availability" do |hacli|
+    hacli.cmd( :create, "Create HA for CT/VM", &lambda {|name_or_id, group:, comment: nil, max_relocate:, max_restart:, state:|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      raise UsageError, "#{th.sid} is already High-Available"  unless ha.active?
+      ha.create group: group, comment: comment, max_relocate: max_relocate, max_restart: max_restart
+    }).tap {|cl| opts_ha cl }
+
+    hacli.cmd :remove, "Remove CT/VM from HA", &lambda {|name_or_id|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      raise UsageError, "#{th.sid} is not High-Available"  if ha.active?
+      ha.delete
+    }
+
+    hacli.cmd( :active, "CT/VM should be high-available. Options are only for defaults, if not activated, yet.", &lambda {|name_or_id, group:, comment: nil, max_relocate:, max_restart:, state:|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      ha.create group: group, comment: comment, max_relocate: max_relocate, max_restart: max_restart  if ha.active?
+    }).tap {|cl| opts_ha cl }
+
+    hacli.cmd :deactive, "CT/VM should NOT be high-available.", &lambda {|name_or_id|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      ha.delete  unless ha.active?
+    }
+
+    hacli.cmd( :started, "CT/VM should be in state started.  By stopping CT/VM via pct/e state will be changed in HA, too.", &lambda {|name_or_id, force: nil|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      ha = ha.create  unless ha.active?
+      ha.disabled!  if force and ha.error?
+      ha.started!
+    }).opt( :force, "-f", "--force", "If CT/VM is in error-state, first disable HA, than try to start.")
+
+    hacli.cmd :stopped, "CT/VM should be in state stopped.  By starting CT/VM via pct/e state will be changed in HA, too.", min: 3, &lambda {|name_or_id|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      ha = ha.create  unless ha.active?
+      ha.stopped!
+    }
+
+    hacli.cmd :reset, "If state of CT/VM is failed, Proxmox will not start/stop it anyway.  You have to reset state (state=disabled), first", &lambda {|name_or_id|
+      connect
+      th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
+      raise UsageError, "Container or VirtualMachine not found: #{name_or_id}"  unless th
+      ha = th.ha
+      raise UsageError, "#{th.sid} is not High-Available"  if ha.active?
+      ha.state = :disabled
+    }
+
+    hacli.cmd 'help', '', aliases: ['-h', '--help'], &lambda {|*args| help hacli, *args }
+  end
+end
+end

data/lib/pve/cli/node.rb

@@ -0,0 +1,46 @@
+class PVE::Cli
+def cli_node
+  cli.sub :node, "Nodes" do |nod_cli|
+    nod_cli.cmd :status, "Lists nodes with status", aliases: [nil], &lambda {|node=nil|
+      connect
+      to = TablizedOutput.new %w[Status Node Uptime CPU Mem/MiB Disk/MiB]
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.each do |n|
+        to.push [
+          n.status,
+          n.node,
+          Measured.seconds( n.uptime),
+          "%.02f/%d" % [n.cpu, n.maxcpu],
+          "#{Measured.bytes( n.mem)}/#{Measured.bytes( n.maxmem)}",
+          "#{Measured.bytes( n.disk)}/#{Measured.bytes( n.maxdisk)}",
+        ]
+      end
+      to.print order: [1]
+    }
+
+    nod_cli.cmd :exec, "Executes command on node", min: 4 do |name, *args|
+      connect
+      STDERR.puts "! #{$?.exitstatus}"  unless Proxmox::Node.find_by_name!( name).exec *args
+    end
+
+    nod_cli.cmd :enter, "Enter Console of node" do |name, *args|
+      connect
+      STDERR.puts "! #{$?.exitstatus}"  unless Proxmox::Node.find_by_name!( name).enter *args
+    end
+
+    nod_cli.sub :task, "Inspect tasks" do |tcli|
+      tcli.cmd :list, "List done tasks", aliases: [nil, 'ls'], &lambda {|node|
+        connect
+        Proxmox::Node.find_by_name!( node).
+          tasks.
+          map( &:upid).
+          sort.
+          each {|upid| puts upid }
+      }
+    end
+
+    nod_cli.cmd( 'help', '', aliases: ['-h', '--help']) {|*args| help nod_cli, *args }
+  end
+end
+end

data/lib/pve/cli/qm.rb

@@ -0,0 +1,32 @@
+class PVE::Cli
+def cli_qm
+  cli.sub :qm, "Virtual Machines", aliases: %w[v vm qemu], &lambda {|qm|
+    qm.cmd :list, "List VM-IDs", aliases: ['ls'], &lambda {|node=nil|
+      connect
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.flat_map do |n|
+        n.qemu.map {|c| c.vmid.to_i }
+      end.sort.each {|c| puts c }
+    }
+
+    qm.cmd :status, "List VMs with status", aliases: [nil], &lambda {|node=nil|
+      connect
+      to = TablizedOutput.new %w[Status HA ID Name Host Uptime CPU Mem/MiB Disk/MiB]
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.each do |n|
+        n.qemu.each &to.method( :virt)
+      end
+      to.print order: [3]
+    }
+
+    qm.cmd :exec, "Executes Command in VM via qemu-guest-agent", min: 4, &lambda {|name_or_id, *command|
+      connect
+      STDERR.puts "! #{$?.exitstatus}"  unless Proxmox::Qemu.find!( name_or_id).exec *command
+    }
+
+    qm.cmd 'help', '', aliases: ['-h', '--help'], &lambda {|*args| help qm, *args }
+  }
+end
+end

data/lib/pve/cli/task.rb

@@ -0,0 +1,26 @@
+class PVE::Cli
+def cli_task
+  cli.sub :task, "Inspect tasks" do |tcli|
+    tcli.cmd :list, "List done tasks", &lambda {|node=nil|
+      connect
+      nodes = Proxmox::Node.all
+      nodes = nodes.select {|n| node == n.name }  if node
+      nodes.flat_map do |n|
+        n.tasks.map &:upid
+      end.sort.each {|upid| puts upid }
+    }
+
+    tcli.cmd :get, "Inspect a task", &lambda {|upid|
+      connect
+      Proxmox::Node.all.each do |n|
+        n.tasks.each do |t|
+          next  unless t.upid == upid
+          puts t.upid
+          t.log.each {|l| puts l[:l] }
+          return
+        end
+      end
+    }
+  end
+end
+end

data/lib/pve/helper.rb

@@ -0,0 +1,167 @@
+class Measured
+  class <<self
+    def bytes1 v
+      v = v.to_f
+      return "%d B" % v  if 512 > v
+      %w[KiB MiBy GiByt TiByte ExiByte PetiByte].each_with_index do |m|
+        v /= 1024
+        #return "%.1f %s" % [v, m]  if 10 > v
+        #return "%d %s" % [v, m]  if 512 > v
+        return "%.1f %s" % [v, m]  if 512 > v
+      end
+      "%d  PetiByte" % v
+    end
+
+    def bytes2 v
+      r = (v.to_i / 1024 / 1024).to_s
+      return '·'  if 0 == r
+      r.
+        reverse.
+        each_char.
+        each_slice( 3).
+        to_a.
+        reverse.
+        map {|a| a.reverse.join }.
+        join " "
+    end
+    alias bytes bytes2
+
+    def seconds i
+      i = i.to_i
+      return '·'  if 0 == i
+      return "%d s" % i  if 90 > i
+      i /= 60
+      return "%d mi" % i  if 90 > i
+      i /= 60
+      return "%d hou" % i  if 36 > i
+      i /= 24
+      return "%d days" % i  if 14 > i
+      j = i / 7
+      return "%d weeks" % j  if 25 > j
+      i /= 365
+      return "%.1f years"  if 550 > i
+      "%dy" % i
+    end
+  end
+end
+
+class ColoredString
+  attr_reader :string, :color_codes
+
+  def initialize string, color_codes
+    @string, @color_codes = string, color_codes
+  end
+
+  def inspect
+    "#<ColoredString #{@color_codes} #{@string.inspect}>"
+  end
+
+  def length() @string.length end
+  alias size length
+  #def to_str() self end 
+  def to_s() "\e[#{@color_codes}m#{@string}\e[0m" end
+  alias to_str to_s
+  #alias inspect to_str
+  
+  include Comparable
+  def <=>(o) @string <=> o.string end
+end
+
+
+
+class TablizedOutput
+  def initialize header, stdout: nil
+    @header   = header.map &:to_s
+    @columnc  = header.size
+    @maxs     = header.map &:length
+    @stdout ||= STDOUT
+    @lines    = []
+  end
+
+  class B
+    include Comparable
+    def <=>(o) @v <=> o.v end
+  end
+
+  class V < B
+    attr_reader :v, :s
+    def initialize( v, s=nil) @v, @s = v, s || "#{v}" end
+    def to_s() @s end
+    def length() @s.length end
+    def inspect() "#<TO:V #{@v.inspect} #{@s.inspect}>" end
+  end
+
+  class Percentage < B
+    attr_reader :v, :w
+    def initialize( v, w=nil) @v, @w = v, w || 10 end
+    def length() @w end
+    def inspect() "#<TO:Percentage #{@v}%>" end
+
+    def to_s
+      y = w - (v*w).round
+      x = (100*v).round
+      r = "%*s" % [w, 0==x ? '·' : x]
+      "\e[0m#{r[0...y]}\e[1;4;#{0.75>v ? 32 : 31}m#{r[y..-1]}\e[0m"
+    end
+  end
+
+  def push fields
+    fields =
+      fields.map do |x|
+        case x
+        when String, ColoredString, B then x
+        else V.new x
+        end
+      end
+    @maxs = @columnc.times.map {|i| [@maxs[i], fields[i].length].max }
+    @lines.push fields
+  end
+
+  def pushs lines
+    lines.each &method( :push)
+  end
+
+  def print order: nil
+    format = "#{(["\e[%%sm%% %ds\e[0m"] * @columnc).join( '  ') % @maxs}\n"
+    ls = @lines
+    if order
+      eval <<-EOC, binding, __FILE__, 1+__LINE__
+        ls = ls.sort {|a,b|
+          [#{order.map {|i| 0 < i ? "a[#{i-1}]" : "b[#{-i-1}]" }.join ', '}] <=>
+          [#{order.map {|i| 0 < i ? "b[#{i-1}]" : "a[#{-i-1}]" }.join ', '}]
+        }
+      EOC
+    end
+    #ls = ls.sort_by {|e| p e; order.map &e.method(:[]) }  if order
+    @stdout.printf format, *@header.flat_map {|s|['',s]}
+    ls.each {|l| @stdout.printf format, *l.flat_map {|s| s.is_a?(ColoredString) ? [s.color_codes, s.string] : ["", s.to_s] } }
+  end
+
+  def virt v
+    ha = v.respond_to?( :ha) ? v.ha : nil
+    unknown = V.new 0, '-'
+    push [
+      case v.status
+      when "running", "online" then ColoredString.new v.status, "32"
+      when "stopped" then ColoredString.new v.status, "31"
+      else v.status
+      end,
+      ha&.state || '·',
+      case v.t
+      when "nd" then ColoredString.new v.sid, "33"
+      when "qm" then ColoredString.new v.sid, "35"
+      when "ct" then ColoredString.new v.sid, "36"
+      else v.sid
+      end,
+      v.name, v.node.is_a?(String) ? v.node : v.node.node,
+      v.respond_to?(:uptime) ? V.new( v.uptime, Measured.seconds( v.uptime)) : unknown,
+      v.respond_to?(:cpu) ? Percentage.new( v.cpu) : unknown,
+      v.respond_to?(:mem) ? V.new( v.mem, Measured.bytes( v.mem)) : unknown,
+      v.respond_to?(:maxmem) ? Percentage.new( v.mem/v.maxmem.to_f) : unknown,
+      v.respond_to?(:disk) ? V.new( v.disk.to_i, Measured.bytes( v.disk.to_i)) : unknown,
+      if v.respond_to?(:maxdisk) and 0 < v.maxdisk.to_i
+        Percentage.new( v.disk.to_f/v.maxdisk.to_f)
+      else unknown end,
+    ]
+  end
+end