598 lines
15 KiB
Ruby
598 lines
15 KiB
Ruby
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'
|