pve 0.1.2

data/lib/pve/proxmox.rb

@@ -0,0 +1,597 @@
+require 'rest_client'
+require 'cgi'
+require 'json'
+require 'ipaddress'
+require 'shellwords'
+require 'active_support/all'
+
+module Proxmox
+  class Exception < ::Exception
+  end
+  class NotFound < Exception
+  end
+  class AlreadyExists < Exception
+  end
+
+  def self.connect username, password, realm: nil, verify_tls: nil, uri: nil
+    uri ||= 'https://localhost:8006/api2/json'
+    cred =
+      {
+        username: username,
+        password: password,
+        realm: realm || 'pve'
+      }
+    @@connection =
+      RestClient::Resource.new( uri, verify_ssl: ! ! verify_tls).tap do |rs|
+        resp = rs['/access/ticket'].post cred
+        case resp.code
+        when 200
+          data = JSON.parse resp.body, symbolize_names: true
+          @@api_ticket =
+            {
+              CSRFPreventionToken: data[:data][:CSRFPreventionToken],
+              cookie: "PVEAuthCookie=#{CGI.escape data[:data][:ticket]}"
+            }
+        else
+          raise Exception, "Authentication failed"
+        end
+      end
+  end
+
+  def self.connection
+    @@connection
+  end
+
+  def self.api_ticket
+    @@api_ticket
+  end
+
+  def self.find_by_name name
+    Proxmox::LXC.find_by_name( name) || Proxmox::Qemu.find_by_name( name) || Proxmox::Node.find_by_name( name)
+  end
+
+  def self.find_by_vmid vmid
+    Proxmox::LXC.find_by_vmid( vmid) || Proxmox::Qemu.find_by_vmid( vmid) || Proxmox::Node.find_by_vmid( vmid)
+  end
+
+  def self.find name_or_id
+    Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find( name_or_id) || Proxmox::Node.find( name_or_id)
+  end
+
+  module RestConnection
+    def __response__ resp
+      case resp.code
+      when 200
+        JSON.parse( resp.body, symbolize_names: true)[:data]
+      when 500
+        nil
+      else
+        raise "Request failed of #{req.url} [#{resp.code}]: #{resp.body.inspect}"
+      end
+    end
+
+    def __headers__ **hdrs
+      Proxmox.api_ticket.merge( 'Accept' => 'application/json').merge( hdrs)
+    end
+
+    def __data__ **data
+      case data
+      when String
+        data
+      else
+        data.to_json
+      end
+    end
+
+    private :__response__, :__headers__, :__data__
+
+    def bench path
+      #t = Time.now
+      r = yield
+      #p path => Time.now-t
+      r
+    end
+
+    def rest_get path, **data, &exe
+      data = data.delete_if {|k,v|v.nil?}
+      path += "#{path.include?( ??) ? ?& : ??}#{data.map{|k,v|"#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"}.join '&'}"  unless data.empty?
+      __response__ Proxmox.connection[path].get( __headers__( :'Content-Type' => 'application/json'))
+    end
+
+    def rest_put path, **data, &exe
+      __response__ Proxmox.connection[path].put( __data__( data), __headers__( :'Content-Type' => 'application/json'))
+    end
+
+    def rest_del path, &exe
+      __response__ Proxmox.connection[path].delete( __headers__( :'Content-Type' => 'application/json'))
+    end
+
+    def rest_post path, **data, &exe
+      __response__ Proxmox.connection[path].post( __data__( data), __headers__( :'Content-Type' => 'application/json'))
+    end
+  end
+
+  class Base
+    include RestConnection
+    extend RestConnection
+
+    attr_reader :sid
+
+    class <<self
+      def __new__ data
+        n = allocate
+        n.send :__update__, data
+      end
+      private :__new__
+    end
+
+    def respond_to? method
+      super or instance_variable_defined?( "@#{method}")
+    end
+
+    def method_missing method, *args, &exe
+      if instance_variable_defined? "@#{method}"
+        instance_variable_get "@#{method}"
+      else
+        super
+      end
+    end
+
+    def __update__ data
+      instance_variables.each do |k|
+        remove_instance_variable k
+      end
+      data.each do |k,v|
+        instance_variable_set "@#{k}", v
+      end
+      initialize
+      self
+    end
+
+    def refresh!
+      __update__ rest_get( @rest_prefix)
+    end
+  end
+
+  class Node < Base
+    class <<self
+      def find_by_name name
+        all.each do |node|
+          return node  if node.node == name
+        end
+        nil
+      end
+
+      def find_by_name! name
+        find_by_name( name) or raise( Proxmox::NotFound, "Node not found: #{name}")
+      end
+
+      def all
+        rest_get( '/nodes').map {|d| __new__ d.merge( t: 'nd') }
+      end
+    end
+
+    attr_reader :name
+
+    def === t
+      @name =~ t or @vmid.to_s =~ t or @sid =~ t
+    end
+
+    def initialize
+      @rest_prefix = "/nodes/#{@node}"
+      @sid = "nd:#{@node}"
+      @name = @node
+    end
+
+    def offline?()  @status.nil? or 'offline' == @status  end
+    def online?()  'online' == @status  end
+
+    def lxc
+      return []  if offline?
+      rest_get( "#{@rest_prefix}/lxc").map {|d| LXC.send :__new__, d.merge( node: self, t: 'ct') }
+    end
+
+    def qemu
+      return []  if offline?
+      rest_get( "#{@rest_prefix}/qemu").map {|d| Qemu.send :__new__, d.merge( node: self, t: 'qm') }
+    end
+
+    def tasks
+      return []  if offline?
+      rest_get( "/#{@rest_prefix}/tasks").map {|d| Task.send :__new__, d.merge( node: self, t: 'task') }
+    end
+
+    def enter *command
+      Kernel.system 'ssh', '-t', node, command.map( &:to_s).shelljoin
+    end
+
+    def exec *command
+      Kernel.system 'ssh', node, command.map( &:to_s).shelljoin
+    end
+  end
+
+  class Task < Base
+    def initialize
+      @rest_prefix = "/nodes/#{@node.node}/tasks/#{upid}"
+      @sid = upid
+    end
+
+    def inspect
+      "#<#{self.class.name} #{upid}>"
+    end
+
+    #def finished?
+    #  rest_get( "/nodes/#{node}/tasks/")
+    #end
+
+    def status
+      rest_get( "#{@rest_prefix}/status")
+    end
+
+    def log start: nil, limit: nil
+      rest_get( "#{@rest_prefix}/log", start: start, limit: limit)
+    end
+  end
+
+  class Hosted < Base
+    def refresh!
+      node, t = @node, @t
+      __update__ rest_get( "#{@rest_prefix}/status/current").merge( node: node, t: t)
+    end
+
+    def === t
+      @name =~ t or @vmid.to_s =~ t or @sid =~ t
+    end
+
+    def migrate node
+      node =
+        case node
+        when Node then node
+        else Node.find!( node.to_s)
+        end
+      Task.send :__new__, node: @node, host: self, upid: rest_post( "#{@rest_prefix}/migrate", target: node.node)
+    end
+
+    def start
+      Task.send :__new__, node: @node, host: self, upid: rest_post( "#{@rest_prefix}/status/start")
+    end
+
+    def stop
+      Task.send :__new__, node: @node, host: self, upid: rest_post( "#{@rest_prefix}/status/stop")
+    end
+
+    def destroy
+      Task.send :__new__, node: @node, host: self, upid: rest_del( "#{@rest_prefix}")
+    end
+
+    def current_status
+      rest_get "#{@rest_prefix}/status/current"
+    end
+
+    def running?
+      current_status[:status] == 'running'
+    end
+
+    def stopped?
+      current_status[:status] == 'stopped'
+    end
+
+    def wait forstatus, timeout: nil, secs: nil, lock: nil, &exe
+      forstatus = forstatus.to_s
+      secs ||= 0.2
+      b = Time.now + timeout.to_i + secs
+      loop do
+        d = current_status
+        return true  if d[:status] == forstatus and (not lock or lock == d[:lock])
+        exe.call d[:status], d[:lock]  if exe
+        return false  if timeout and b <= Time.now
+        sleep secs
+      end
+      nil
+    end
+
+    def config
+      cnf = rest_get "#{@rest_prefix}/config"
+      cnf[:network] =
+        cnf.
+          keys.
+          map( &:to_s).
+          grep( /\Anet\d+\z/).
+          map do |k|
+            nc = {card: k}
+            cnf.delete( k.to_sym).
+              split( ',').
+              each do |f|
+                k, v = f.split( '=', 2)
+                nc[k.to_sym] = v
+              end
+            nc[:ip] &&= IPAddress::IPv4.new nc[:ip]
+            nc[:gw] &&= IPAddress::IPv4.new nc[:gw]
+            nc[:mtu] &&= nc[:mtu].to_i
+            nc[:tag] &&= nc[:tag].to_i
+            nc[:firewall] &&= 1 == nc[:firewall].to_i
+            nc
+          end
+      cnf[:unprivileged] &&= 1 == cnf[:unprivileged]
+      cnf[:memory] &&= cnf[:memory].to_i
+      cnf[:cores] &&= cnf[:cores].to_i
+      cnf
+    end
+
+    def cnfset **cnf
+      r = {delete: []}
+      cnf.each do |k,v|
+        case v
+        when true then r[k] = 1
+        when false then r[k] = 0
+        when nil then r[:delete].push k
+        else r[k] = v
+        end
+      end
+      r.delete :delete  if r[:delete].empty?
+      rest_put "#{@rest_prefix}/config", r
+    end
+  end
+
+  class Qemu < Hosted
+    class <<self
+      def all
+        Node.all.flat_map {|n| n.qemu }
+      end
+
+      def find_by_vmid vmid
+        vmid = vmid.to_s
+        Node.all.each do |n|
+          n.qemu.each do |l|
+            return l  if l.vmid == vmid
+          end
+        end
+        nil
+      end
+
+      def find_by_name name
+        Node.all.each do |n|
+          n.qemu.each do |l|
+            return l  if l.name == name
+          end
+        end
+        nil
+      end
+
+      def find name_or_id = nil, name: nil, vmid: nil
+        if (name and vmid) or (name and name_or_id) or (name_or_id and vmid)
+          raise Proxmox::NotFound, "name xor vmid needed to find CT, not both."
+        elsif name
+          find_by_name name
+        elsif vmid
+          find_by_vmid vmid.to_i
+        elsif name_or_id =~ /\D/
+          find_by_name name_or_id
+        elsif name_or_id.is_a?( Numeric) or name_or_id =~ /\d/
+          find_by_vmid name_or_id.to_i
+        else
+          raise Proxmox::NotFound, "name xor vmid needed to find CT."
+        end
+      end
+
+      def find_by_vmid! name
+        find_by_vmid( name) or raise( Proxmox::NotFound, "Virtual Machine not found: #{name}")
+      end
+
+      def find_by_name! name
+        find_by_name( name) or raise( Proxmox::NotFound, "Virtual Machine not found: #{name}")
+      end
+
+      def find! name
+        find( name) or raise( Proxmox::NotFound, "Virtual Machine not found: #{name}")
+      end
+    end
+
+    def initialize
+      @rest_prefix = "/nodes/%s/qemu/%d" % [@node.node, @vmid]
+      @sid = "qm:#{@vmid}"
+    end
+
+    def ha
+      HA.find self
+    end
+
+    def exec *args
+      node.exec 'qm', 'guest', 'exec', vmid, '--', *args
+    end
+  end
+
+  class LXC < Hosted
+    class <<self
+      def all
+        Node.all.flat_map {|n| n.lxc }
+      end
+
+      def find_by_vmid vmid
+        vmid = vmid.to_s
+        Node.all.each do |n|
+          n.lxc.each do |l|
+            return l  if l.vmid == vmid
+          end
+        end
+        nil
+      end
+
+      def find_by_name name
+        Node.all.each do |n|
+          n.lxc.each do |l|
+            return l  if l.name == name
+          end
+        end
+        nil
+      end
+
+      def find name_or_id = nil, name: nil, vmid: nil
+        if (name and vmid) or (name and name_or_id) or (name_or_id and vmid)
+          raise ArgumentError, "name xor vmid needed to find CT, not both."
+        elsif name
+          find_by_name name
+        elsif vmid
+          find_by_vmid vmid.to_i
+        elsif name_or_id =~ /\D/
+          find_by_name name_or_id
+        elsif name_or_id.is_a?( Numeric) or name_or_id =~ /\d/
+          find_by_vmid name_or_id.to_i
+        else
+          raise ArgumentError, "name xor vmid needed to find CT."
+        end
+      end
+
+      def find_by_vmid! name
+        find_by_vmid( name) or raise( Proxmox::NotFound, "Container not found: #{name}")
+      end
+
+      def find_by_name! name
+        find_by_name( name) or raise( Proxmox::NotFound, "Container not found: #{name}")
+      end
+
+      def find! name
+        find( name) or raise( Proxmox::NotFound, "Container not found: #{name}")
+      end
+
+      def create template, **options
+        tmplt = PVE::CTTemplate.const_get( template&.classify || 'Default').new **options
+        name = tmplt.name
+        virts = Proxmox::LXC.all + Proxmox::Qemu.all
+        vmid = tmplt.vmid
+        if virt = virts.find {|v| v.vmid == vmid }
+          raise Proxmox::AlreadyExists, "VT/VM with vmid [#{vmid}] already exists: #{virt.name}"
+        end
+        already_exists = virts.select {|v| v.name == name }
+        unless already_exists.empty?
+          raise Proxmox::AlreadyExists, "CT/VM named [#{name}] already exists: vmid: #{already_exists.map( &:vmid).inspect}"
+        end
+        node = Proxmox::Node.find_by_name! tmplt.node
+
+        options = {
+          ostemplate: tmplt.ostemplate,
+          vmid: vmid.to_s,
+          arch: tmplt.arch,
+          cmode: tmplt.cmode,
+          cores: tmplt.cores.to_i,
+          description: tmplt.description,
+          hostname: tmplt.hostname,
+          memory: tmplt.memory,
+          net0: tmplt.net0&.map {|k,v| "#{k}=#{v}" }&.join(','),
+          net1: tmplt.net1&.map {|k,v| "#{k}=#{v}" }&.join(','),
+          net2: tmplt.net2&.map {|k,v| "#{k}=#{v}" }&.join(','),
+          net3: tmplt.net3&.map {|k,v| "#{k}=#{v}" }&.join(','),
+          ostype: tmplt.ostype,
+          :'ssh-public-keys' => tmplt.ssh_public_keys,
+          storage: tmplt.storage,
+          #rootfs: {
+          #  volume: "root:vm-#{vmid}-disk-0", size: '4G'
+          #}.map {|k,v| "#{k}=#{v}" }.join( ','),
+          swap: tmplt.swap,
+          unprivileged: tmplt.unprivileged,
+        }.delete_if {|k,v| v.nil? }
+        @temp = LXC.send :__new__, node: node, vmid: options[:vmid], name: name, hostname: options[:hostname]
+        upid = rest_post( "/nodes/%s/lxc" % node.node, **options)
+        Task.send :__new__, node: node, host: @temp, upid: upid
+      end
+    end
+
+    def initialize
+      @rest_prefix = "/nodes/%s/lxc/%d" % [@node.node, @vmid]
+      @sid = "ct:#{@vmid}"
+    end
+
+    def ha
+      HA.find self
+    end
+
+    def exec *args
+      node.exec 'pct', 'exec', vmid, '--', *args
+    end
+
+    def enter
+      node.enter 'pct', 'enter', vmid
+    end
+  end
+
+  class HA < Base
+    def initialize
+      @rest_prefix = "/cluster/ha/resources/#{virt.sid}"
+    end
+
+    class <<self
+      def find host
+        ha = HA.send :__new__, digest: nil, state: nil, virt: host
+        ha.refresh!
+      end
+
+      def create host, **options
+        find( host).create **options
+      end
+    end
+
+    def refresh!
+      virt = @virt
+      __update__( {state: nil}.merge( rest_get( "/cluster/ha/resources/#{virt.sid}")).merge( virt: virt))
+      self
+    rescue RestClient::InternalServerError
+      __update__ digest: nil, state: nil, virt: virt
+    end
+
+    def create group: nil, comment: nil, max_relocate: nil, max_restart: nil, state: nil
+      options = {
+        sid: virt.sid,
+        group: group,
+        comment: comment,
+        max_relocate: max_relocate,
+        max_restart: max_restart,
+        state: state
+      }
+      options.delete_if {|k,v| v.nil? }
+      rest_post "/cluster/ha/resources", **options
+      refresh!
+    end
+
+    def delete
+      rest_del "#{@rest_prefix}"
+    end
+
+    def state= state
+      rest_put "#{@rest_prefix}", state: state.to_s
+      refresh!
+    end
+
+    def started!
+      self.state = :started
+      self
+    end
+
+    def stopped!
+      self.state = :stopped
+      self
+    end
+
+    def disabled!
+      self.state = :disabled
+      self
+    end
+
+    def started?
+      'started' == self.state
+    end
+
+    def stopped?
+      'stopped' == self.state
+    end
+
+    def error?
+      'error' == self.state
+    end
+
+    def active?
+      ! ! digest
+    end
+  end
+end
+
+require_relative 'templates'