pve initialized
This commit is contained in:
commit
626e4b60b3
2
.gitignore
vendored
Normal file
2
.gitignore
vendored
Normal file
|
@ -0,0 +1,2 @@
|
|||
*.sw[pomnqrst]
|
||||
*.gem
|
6
Gemfile
Normal file
6
Gemfile
Normal file
|
@ -0,0 +1,6 @@
|
|||
source 'https://rubygems.org'
|
||||
gem 'dencli'
|
||||
gem 'rest-client'
|
||||
gem 'ipaddress'
|
||||
gem 'activesupport'
|
||||
gem 'pmap'
|
49
Gemfile.lock
Normal file
49
Gemfile.lock
Normal file
|
@ -0,0 +1,49 @@
|
|||
GEM
|
||||
remote: https://rubygems.org/
|
||||
specs:
|
||||
activesupport (6.1.3.1)
|
||||
concurrent-ruby (~> 1.0, >= 1.0.2)
|
||||
i18n (>= 1.6, < 2)
|
||||
minitest (>= 5.1)
|
||||
tzinfo (~> 2.0)
|
||||
zeitwerk (~> 2.3)
|
||||
concurrent-ruby (1.1.8)
|
||||
dencli (0.3.1)
|
||||
domain_name (0.5.20190701)
|
||||
unf (>= 0.0.5, < 1.0.0)
|
||||
http-accept (1.7.0)
|
||||
http-cookie (1.0.3)
|
||||
domain_name (~> 0.5)
|
||||
i18n (1.8.10)
|
||||
concurrent-ruby (~> 1.0)
|
||||
ipaddress (0.8.3)
|
||||
mime-types (3.3.1)
|
||||
mime-types-data (~> 3.2015)
|
||||
mime-types-data (3.2021.0225)
|
||||
minitest (5.14.4)
|
||||
netrc (0.11.0)
|
||||
pmap (1.1.1)
|
||||
rest-client (2.1.0)
|
||||
http-accept (>= 1.7.0, < 2.0)
|
||||
http-cookie (>= 1.0.2, < 2.0)
|
||||
mime-types (>= 1.16, < 4.0)
|
||||
netrc (~> 0.8)
|
||||
tzinfo (2.0.4)
|
||||
concurrent-ruby (~> 1.0)
|
||||
unf (0.1.4)
|
||||
unf_ext
|
||||
unf_ext (0.0.7.7)
|
||||
zeitwerk (2.4.2)
|
||||
|
||||
PLATFORMS
|
||||
x86_64-linux
|
||||
|
||||
DEPENDENCIES
|
||||
activesupport
|
||||
dencli
|
||||
ipaddress
|
||||
pmap
|
||||
rest-client
|
||||
|
||||
BUNDLED WITH
|
||||
2.2.15
|
22
README.adoc
Normal file
22
README.adoc
Normal file
|
@ -0,0 +1,22 @@
|
|||
Proxmox Virtual Environment High Level API for Ruby
|
||||
===================================================
|
||||
|
||||
This is a limited, but easier to use library for ruby.
|
||||
It provides additional a command line interface for administration named `pvecli`.
|
||||
The Rest-API will be used for controlling your server.
|
||||
|
||||
You need to provide a config-file `/etc/pve/pvecli.yml`:
|
||||
|
||||
auth:
|
||||
username: USERNAME
|
||||
password: PASSWORD
|
||||
realm: pve or something like that
|
||||
connect:
|
||||
verify_tls: no if you do not use known CA-signed X509-Certificates
|
||||
|
||||
pvecli
|
||||
======
|
||||
|
||||
This tool should usable like PVE-WebGUI, instead of low-level-tools like `pct`
|
||||
or user-unfriendlier tools like `pvesh`.
|
||||
So `pvecli` provides a global control over your cluster on command line.
|
5
bin/pvecli
Executable file
5
bin/pvecli
Executable file
|
@ -0,0 +1,5 @@
|
|||
#!/usr/bin/env ruby
|
||||
require 'pathname'
|
||||
$:.unshift Pathname.new(__FILE__).dirname.dirname.join('lib').to_s
|
||||
require 'pve/cli'
|
||||
PVE::Cli.new.call *ARGV
|
4
lib/pve.rb
Executable file
4
lib/pve.rb
Executable file
|
@ -0,0 +1,4 @@
|
|||
module PVE
|
||||
end
|
||||
|
||||
require_relative 'pve/proxmox'
|
159
lib/pve/cli.rb
Normal file
159
lib/pve/cli.rb
Normal file
|
@ -0,0 +1,159 @@
|
|||
require 'dencli'
|
||||
require 'yaml'
|
||||
|
||||
require 'pve'
|
||||
require_relative 'helper'
|
||||
require_relative 'cli/base'
|
||||
require_relative 'cli/ct'
|
||||
require_relative 'cli/ha'
|
||||
require_relative 'cli/task'
|
||||
require_relative 'cli/qm'
|
||||
require_relative 'cli/node'
|
||||
|
||||
class UsageError <RuntimeError
|
||||
end
|
||||
|
||||
class PVE::Cli
|
||||
attr_reader :cfg, :cli
|
||||
|
||||
def connect
|
||||
@conn ||=
|
||||
Proxmox.connect cfg[:auth][:username], cfg[:auth][:password],
|
||||
realm: cfg[:auth][:realm], **cfg[:connect]
|
||||
#RestClient.log = STDERR
|
||||
@conn
|
||||
end
|
||||
|
||||
def initialize config_file = nil
|
||||
config_file ||= '/etc/pve/pvecli.yml'
|
||||
@cfg =
|
||||
YAML.safe_load File.read( config_file), [], [], false,
|
||||
config_file, symbolize_names: true
|
||||
@cli = DenCli.new File.basename($0), "PVE CLI"
|
||||
@interactive = false
|
||||
prepare
|
||||
end
|
||||
|
||||
def interactive?
|
||||
@interactive
|
||||
end
|
||||
|
||||
def enter host, *args
|
||||
r = host.enter *args
|
||||
STDERR.puts "! #{$?.exitstatus}" unless r
|
||||
end
|
||||
|
||||
def wait_state host, state, timeout: nil, lock: nil
|
||||
spinners = %w[- / | \\]
|
||||
spin = 0
|
||||
r =
|
||||
host.wait state, lock: lock, timeout: timeout, secs: 0.2 do |state, lock|
|
||||
lock = " (locked: #{lock})" if lock
|
||||
STDERR.printf "\r[%s] %s Still %s%s...\e[J\n", host.name, spinners[spin = (spin + 1) % 4], state, lock
|
||||
end
|
||||
STDERR.printf "\r\e[J"
|
||||
exit 1 unless interactive? and r
|
||||
end
|
||||
|
||||
def wait task, secs: nil, text: nil
|
||||
secs ||= 0.1
|
||||
spinners, spin, logn = "▖▘▝▗", 0, 0
|
||||
STDERR.puts task.upid
|
||||
loop do
|
||||
s = task.status
|
||||
if s[:exitstatus]
|
||||
STDERR.printf "\r[%s] %s %s\e[J\n",
|
||||
task.host ? task.host.name : s[:id],
|
||||
case s[:exitstatus]
|
||||
when "OK" then "\e[32;1m✓\e[0m"
|
||||
else "\e[31;1m✗\e[0m"
|
||||
end,
|
||||
s[:status]
|
||||
return task
|
||||
end
|
||||
log = task.log start: logn
|
||||
log = [] if [{n: 1, t: 'no content'}] == log
|
||||
unless log.empty?
|
||||
STDERR.printf "\r\e[J"
|
||||
log.each {|l| puts l[:t] }
|
||||
logn = log.last[:n]
|
||||
end
|
||||
STDERR.printf "\r[%s] \e[33;1m%s\e[0m %s...\e[J", task.host ? task.host.name : s[:id], spinners[spin = (spin + 1) % 4], text || "Working"
|
||||
sleep secs
|
||||
end
|
||||
end
|
||||
|
||||
def start host, node: nil, timeout: nil, fire: nil, secs: nil
|
||||
timeout ||= 30
|
||||
if node
|
||||
task = host.migrate Proxmox::Node.find_by_name!( node)
|
||||
wait task, text: "Migrating"
|
||||
end
|
||||
if host.running?
|
||||
STDERR.puts "Already running."
|
||||
return
|
||||
end
|
||||
task = host.start
|
||||
unless fire
|
||||
wait task, text: "Starting"
|
||||
end
|
||||
end
|
||||
|
||||
def stop host, timeout: nil, fire: nil, secs: nil
|
||||
timeout ||= 30
|
||||
if host.stopped?
|
||||
STDERR.puts "Already stopped."
|
||||
return
|
||||
end
|
||||
task = host.stop
|
||||
unless fire
|
||||
wait task, text: "Stopping"
|
||||
end
|
||||
end
|
||||
|
||||
def create klass, template, timeout: nil, fire: nil, secs: nil, start: nil, **options
|
||||
options[:start] = true if fire and start
|
||||
task = klass.create template, **options
|
||||
return if fire
|
||||
wait task, text: "Creating"
|
||||
host = task.host.refresh!
|
||||
start host, timeout: timeout, secs: secs
|
||||
end
|
||||
|
||||
def destroy ct, timeout: nil, fire: nil, secs: nil
|
||||
task = ct.destroy
|
||||
unless fire
|
||||
wait task, text: "Destroying"
|
||||
end
|
||||
end
|
||||
|
||||
def help cl, *args
|
||||
STDERR.puts cl.help( *args)
|
||||
exit 1 unless interactive?
|
||||
end
|
||||
|
||||
def opts_wait cl
|
||||
cl.
|
||||
opt( :timeout, "-t", "--timeout=TIMEOUT", "Wait for max TIMEOUT seconds (default: endless)", default: nil).
|
||||
opt( :secs, "-s", "--seconds=SECONDS", "Check every SECONDS for state (default: 0.2)", default: 0.2).
|
||||
opt( :fire, "-f", "--[no-]fire", "Do not wait till running", default: false)
|
||||
end
|
||||
|
||||
def prepare
|
||||
cli_node
|
||||
cli_ct
|
||||
cli_qm
|
||||
cli_task
|
||||
cli_ha
|
||||
cli_base
|
||||
end
|
||||
|
||||
def call *argv
|
||||
cli.call *argv
|
||||
rescue RestClient::ExceptionWithResponse
|
||||
STDERR.puts "#$! - #{$!.response} (#{$!.class})", $!.backtrace.map {|b|" #{b}"}
|
||||
rescue UsageError, DenCli::UsageError
|
||||
STDERR.puts $!
|
||||
exit 1
|
||||
end
|
||||
end
|
187
lib/pve/cli/base.rb
Normal file
187
lib/pve/cli/base.rb
Normal file
|
@ -0,0 +1,187 @@
|
|||
require 'pmap'
|
||||
|
||||
class PVE::Cli
|
||||
|
||||
def cli_base
|
||||
cli.cmd :list, "List CT/VM-IDs", aliases: ['ls'], &lambda {|target=nil|
|
||||
connect
|
||||
nodes = Proxmox::Node.all
|
||||
nodes.
|
||||
flat_map {|n| [ n.method(:lxc), n.method(:qemu) ] }.
|
||||
flat_pmap {|m| m.call.map {|c| c.vmid.to_i } }.
|
||||
sort.
|
||||
each {|c| puts c }
|
||||
}
|
||||
|
||||
cli.cmd( :status, "Lists Nodes/VMs/CTs with status", &lambda {|target=nil, sort: 'n', node: nil|
|
||||
connect
|
||||
node &&= /\A#{node}\z/
|
||||
to = TablizedOutput.new %w[Status HA ID Name Host Uptime CPU/% Mem/MiB Mem/% Disk/MiB Disk/%]
|
||||
push =
|
||||
if target
|
||||
target = /\A#{target}\z/
|
||||
lambda {|n| to.virt n if n === target }
|
||||
else
|
||||
lambda {|n| to.virt n }
|
||||
end
|
||||
nodes = Proxmox::Node.all
|
||||
nodes.
|
||||
select {|n| not node or n === node }.
|
||||
flat_map {|n| [ n.method(:lxc), n.method(:qemu) ] }.
|
||||
each {|m| m.call.each &push }
|
||||
to.print order: sort.each_char.map {|c| (2*c.ord[5]-1) * (' sainhucmd'.index( c.downcase)) }
|
||||
}).
|
||||
opt( :sort, '-s', '--sort=COLUMNS', "Sort by COLUMNs eg hn for host and name ([s]tatus, h[a], [i]d, [n]ame (default), [h]ost, [u]ptime, [c]pu, [m]em, [d]isk)").
|
||||
opt( :node, '-n', '--node=NODE', "List only hosted by this NODE")
|
||||
|
||||
def prepare_show_config cnf
|
||||
r = {}
|
||||
cnf.each do |k,v|
|
||||
case k
|
||||
when :network
|
||||
v.each do |net|
|
||||
s =
|
||||
net.
|
||||
reject {|k, v| :card == k }.
|
||||
sort_by {|k, v| :name == k ? :AAAAAAAAA : k }.
|
||||
map {|k, v| case v when true then [k,1] when false then [k,0] else [k,v] end }.
|
||||
map {|k, v| "#{k}=#{v}" }
|
||||
r[net[:card].to_sym] = s.join(",")
|
||||
end
|
||||
when :sshkeys
|
||||
r[k] = CGI.unescape(v).gsub( /^/, " "*14).gsub /\A {14}|\n\z/, ''
|
||||
else
|
||||
case v
|
||||
when true then v = 1
|
||||
when false then v = 0
|
||||
end
|
||||
r[k] = v.to_s.gsub( /$^/, " "*14).gsub /\n\z/, ''
|
||||
end
|
||||
end
|
||||
r
|
||||
end
|
||||
|
||||
def show_config cnf, old = nil
|
||||
cnf = prepare_show_config cnf
|
||||
if old
|
||||
old = prepare_show_config old
|
||||
(cnf.keys+old.keys).uniq.sort.each do |k|
|
||||
v, o = cnf[k], old[k]
|
||||
if v == o
|
||||
puts "#{k}:#{' ' * (12-k.length)} #{v}"
|
||||
else
|
||||
puts "\e[31m#{k}:#{' ' * (12-k.length)} #{o}\e[0m" unless o.nil?
|
||||
puts "\e[32m#{k}:#{' ' * (12-k.length)} #{v}\e[0m" unless v.nil?
|
||||
end
|
||||
end
|
||||
else
|
||||
cnf.sort_by{|k,v|k}.each do |k,v|
|
||||
puts "#{k}:#{' ' * (12-k.length)} #{v}"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
cli.sub :config, "CT/VM Configuration", min: 2, aliases: %w[cnf] do |ccli|
|
||||
ccli.cmd 'help', '', aliases: [nil, '-h', '--help'], &lambda {|*args| help ccli, *args }
|
||||
|
||||
ccli.cmd :show, "Show Config of CT/VM", &lambda {|name_or_id|
|
||||
connect
|
||||
th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
|
||||
show_config th.config
|
||||
}
|
||||
|
||||
ccli.cmd :set, "Set Configs for CT/VM", &lambda {|name_or_id, *args|
|
||||
if %w[-h --help].include? name_or_id
|
||||
STDERR.puts "Usage: set -h|--help # Show help"
|
||||
STDERR.puts " set ct|vm --CNF1=VAL1 --CNF2=VAL2 ... # Set config-value. Empty value clears field."
|
||||
exit 1
|
||||
end
|
||||
opts = {}
|
||||
until args.empty?
|
||||
case arg = args.shift
|
||||
when /\A--(\w+)=(.*)\z/
|
||||
opts[$1.to_sym] = $2
|
||||
when /\A--(\w+)\z/
|
||||
opts[$1.to_sym] = args.shift
|
||||
else
|
||||
raise UsageError, "Expection option to set. What do you mean with: #{arg}"
|
||||
end
|
||||
end
|
||||
opts.each do |k, v|
|
||||
opts[k] =
|
||||
case v = opts[k]
|
||||
when '' then nil
|
||||
else v
|
||||
end
|
||||
end
|
||||
%i[migrate_downtime].each do |k|
|
||||
next unless opts.has_key? k
|
||||
opts[k] =
|
||||
case v = opts[k]
|
||||
when nil, '', 'nil' then nil
|
||||
else v.to_f
|
||||
end
|
||||
end
|
||||
%i[memory background_delay balloon cores cpulimit cpuunits migrate_speed shares smp sockets vcpus swap tty].each do |k|
|
||||
next unless opts.has_key? k
|
||||
opts[k] =
|
||||
case v = opts[k]
|
||||
when nil, '', 'nil' then nil
|
||||
else v.to_i
|
||||
end
|
||||
end
|
||||
%i[unprivileged debug onboot protection template].each do |k|
|
||||
next unless opts.has_key? k
|
||||
opts[k] =
|
||||
case v = opts[k]
|
||||
when *%w[1 T TRUE t true True Y YES y yes Yes] then true
|
||||
when *%w[0 F FALSE f false False N NO n no No] then false
|
||||
when '', 'nil', nil then nil
|
||||
else raise UsageError, "Boolean expected, given: #{v.inspect}"
|
||||
end
|
||||
end
|
||||
connect
|
||||
th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
|
||||
old = th.config
|
||||
opts[:digest] ||= old[:digest]
|
||||
th.cnfset opts
|
||||
show_config th.config, old
|
||||
}
|
||||
end
|
||||
|
||||
cli.cmd :enter, "Enter Console of CT/Node", &lambda {|name_or_id|
|
||||
connect
|
||||
th = Proxmox::LXC.find( name_or_id) || Proxmox::Node.find_by_name( name_or_id)
|
||||
raise UsageError, "Container or Node not found: #{name_or_id}" unless th
|
||||
STDERR.puts "! #{$?.exitstatus}" unless th.enter
|
||||
}
|
||||
|
||||
cli.cmd :run, "Starts CT/VM", aliases: %w[start star], &lambda {|name_or_id|
|
||||
connect
|
||||
th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
|
||||
raise UsageError, "Container or Node not found: #{name_or_id}" unless th
|
||||
start th
|
||||
}
|
||||
|
||||
#cli.cmd :reboot, "Reboot CT/VM (not implemented, yet)", min: 6, &lambda {|name_or_id|
|
||||
# connect
|
||||
# th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
|
||||
# raise UsageError, "Container or Node not found: #{name_or_id}" unless th
|
||||
# reboot th
|
||||
#}
|
||||
|
||||
cli.cmd :stop, "Stops CT/VM", min: 4, &lambda {|name_or_id|
|
||||
connect
|
||||
th = Proxmox::LXC.find( name_or_id) || Proxmox::Qemu.find_by_name( name_or_id)
|
||||
raise UsageError, "Container or Node not found: #{name_or_id}" unless th
|
||||
stop th
|
||||
}
|
||||
|
||||
cli.cmd 'help', '', aliases: ['-h', '--help'], &lambda {|*args| help cli, *args }
|
||||
|
||||
cli.cmd 'cli', 'Opens interactive console', min: 3, aliases: [nil], &lambda {
|
||||
@interactive = true
|
||||
cli.interactive( File.basename($0,'.rb')).run
|
||||
}
|
||||
end
|
||||
end
|
115
lib/pve/cli/ct.rb
Normal file
115
lib/pve/cli/ct.rb
Normal file
|
@ -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
|
78
lib/pve/cli/ha.rb
Normal file
78
lib/pve/cli/ha.rb
Normal file
|
@ -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
|
46
lib/pve/cli/node.rb
Normal file
46
lib/pve/cli/node.rb
Normal file
|
@ -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
|
32
lib/pve/cli/qm.rb
Normal file
32
lib/pve/cli/qm.rb
Normal file
|
@ -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
|
26
lib/pve/cli/task.rb
Normal file
26
lib/pve/cli/task.rb
Normal file
|
@ -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
|
167
lib/pve/helper.rb
Normal file
167
lib/pve/helper.rb
Normal file
|
@ -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
|
597
lib/pve/proxmox.rb
Normal file
597
lib/pve/proxmox.rb
Normal file
|
@ -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'
|
32
lib/pve/qm.rb
Normal file
32
lib/pve/qm.rb
Normal file
|
@ -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
|
154
lib/pve/templates.rb
Normal file
154
lib/pve/templates.rb
Normal file
|
@ -0,0 +1,154 @@
|
|||
require 'ostruct'
|
||||
|
||||
module PVE::CTTemplate
|
||||
class Base
|
||||
attr_reader :options
|
||||
|
||||
def initialize **opts
|
||||
@options = OpenStruct.new opts
|
||||
@virts = Proxmox::LXC.all + Proxmox::Qemu.all
|
||||
end
|
||||
|
||||
def name() options.name end
|
||||
def node() options.node end
|
||||
def arch() options.arch || 'amd64' end
|
||||
def vmid() options.vmid end
|
||||
def ostype() options.ostype end
|
||||
def cmode() options.cmode || 'shell' end
|
||||
def cores() options.cores || 1 end
|
||||
def description() options.description || '' end
|
||||
def hostname() options.hostname || name end
|
||||
def memory() options.memory || 1024 end
|
||||
def swap() options.swap || 0 end
|
||||
def unprivileged() options.unprivileged() || 1 end
|
||||
|
||||
def ssh_public_keys
|
||||
options[:'ssh-public-keys'] ||
|
||||
File.read( options[:'ssh-public-keys-file'] || '/root/.ssh/authorized_keys')
|
||||
end
|
||||
|
||||
def net0()
|
||||
if options.ipv4 || options.ipv6
|
||||
ipv4 = IPAddress::IPv4.new options.ipv4
|
||||
{
|
||||
name: 'eth0',
|
||||
bridge: 'vmbr1',
|
||||
ip: ipv4.to_string,
|
||||
gw: options.gateway || ipv4.hosts.last.to_s
|
||||
}
|
||||
end
|
||||
end
|
||||
def net1() nil end
|
||||
def net2() nil end
|
||||
def net3() nil end
|
||||
end
|
||||
|
||||
class Default < Base
|
||||
def self.requirements
|
||||
{
|
||||
node: [:string, false, "Create CT on this node."],
|
||||
name: [:string, true, "Set (uniq) name"],
|
||||
arch: [:enum, false, "Architecture", %w[amd64 i386 arm64 armhf]],
|
||||
vmid: [:numeric, true, "VM-ID. Proxmox internal number (100...)"],
|
||||
ostype: [:string, true, "OS-Type (OS or distribution)"],
|
||||
cmode: [:enum, false, "Console-mode", %w[shell console tty]],
|
||||
cores: [:numeric, false, "Count of cores"],
|
||||
description: [:string, false, "Description. Eg. What should this CT do?"],
|
||||
hostname: [:string, false, "Hostname"],
|
||||
memory: [:numeric, false, "How much memory CT could use?"],
|
||||
swap: [:numeric, false, "How much CT can swap?"],
|
||||
unprivileged: [:boolean, false, "Unprivileged are restricted to own UID/GID-space."],
|
||||
:'ssh-public-keys' => [:string, false, "SSH-Public-Keys, which should be added to root-user in CT."],
|
||||
:'ssh-public-keys-file' => [:string, false, "Read SSH-Public-Keys from file."],
|
||||
ipv4: [:string, false, "IPv4-Address with net-size."],
|
||||
gateway4: [:string, false, "IPv4-Address of gateway."],
|
||||
ipv6: [:string, false, "IPv6-Address with net-size."],
|
||||
gateway6: [:string, false, "IPv6-Address of gateway."],
|
||||
storage: [:string, false, "Device will be create on this Storage (default: local"],
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
class Datacenter < Base
|
||||
def self.requirements
|
||||
{
|
||||
node: [:string, false, "Create CT on this node."],
|
||||
name: [:string, true, "Set (uniq) name"],
|
||||
arch: [:enum, false, "Architecture", %w[amd64 i386 arm64 armhf]],
|
||||
vmid: [:numeric, true, "VM-ID. Proxmox internal number (100...)"],
|
||||
ostype: [:string, true, "OS-Type (OS or distribution)"],
|
||||
cmode: [:enum, false, "Console-mode", %w[shell console tty]],
|
||||
cores: [:numeric, false, "Count of cores"],
|
||||
description: [:string, false, "Description. Eg. What should this CT do?"],
|
||||
hostname: [:string, false, "Hostname"],
|
||||
memory: [:numeric, false, "How much memory CT could use?"],
|
||||
swap: [:numeric, false, "How much CT can swap?"],
|
||||
unprivileged: [:boolean, false, "Unprivileged are restricted to own UID/GID-space."],
|
||||
:'ssh-public-keys' => [:string, false, "SSH-Public-Keys, which should be added to root-user in CT."],
|
||||
:'ssh-public-keys-file' => [:string, false, "Read SSH-Public-Keys from file."],
|
||||
:'network-id' => [:numeric, true, "Put Container to this VLAN and use a random IPv4-Address for this CT."],
|
||||
ipv4: [:string, false, "IPv4-Address with net-size."],
|
||||
gateway4: [:string, false, "IPv4-Address of gateway."],
|
||||
ipv6: [:string, false, "IPv6-Address with net-size."],
|
||||
gateway6: [:string, false, "IPv6-Address of gateway."],
|
||||
storage: [:string, false, "Device will be create on this Storage (default: root)"],
|
||||
}
|
||||
end
|
||||
|
||||
def node() options.node || 'svc1' end
|
||||
def ostype() options.ostype || 'debian' end
|
||||
def memory() options.memory || 2048 end
|
||||
def storage() options.storage || 'root' end
|
||||
|
||||
def network_id
|
||||
return @network_id if @network_id
|
||||
expect = 0..12
|
||||
nid = options[:'network-id']
|
||||
unless nid == nid.to_i.to_s && expect.include?( nid.to_i)
|
||||
raise ArgumentError, "Network ID must be #{expect.inspect}. Given: #{nid.inspect}"
|
||||
end
|
||||
@network_id = nid.to_i
|
||||
end
|
||||
|
||||
def net0
|
||||
{
|
||||
name: 'eth0',
|
||||
bridge: 'vmbr1',
|
||||
tag: 2000+network_id,
|
||||
mtu: 9166,
|
||||
firewall: 1,
|
||||
ip: ipv4.to_string,
|
||||
gw: ipv4.hosts.last.to_s,
|
||||
}
|
||||
end
|
||||
|
||||
def vmid
|
||||
super || ((0...100).map {|i| "#{100*network_id+i}" } - @virts.map( &:vmid)).first
|
||||
end
|
||||
|
||||
def network
|
||||
IPAddress::IPv4.new "10.#{network_id}.255.0/24"
|
||||
end
|
||||
|
||||
def ipv4
|
||||
return options.ipv4 if options.ipv4
|
||||
return @ipv4 if @ipv4
|
||||
ipv4s = network.hosts
|
||||
@virts.each do |v|
|
||||
v.config[:network].each {|n| ipv4s.delete n[:ip] if n[:ip] }
|
||||
end
|
||||
@ipv4 = ipv4s.first
|
||||
end
|
||||
|
||||
def ostemplate
|
||||
@ostemplate ||=
|
||||
options.ostemplate ||
|
||||
case ostype
|
||||
when 'debian'
|
||||
'local:vztmpl/debian-10-standard_10.5-1_amd64.tar.gz'
|
||||
else
|
||||
raise ArgumentError, "OS-Template for ostype #{ostype} not found or ostemplate not provided."
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
3
lib/pve/version.rb
Normal file
3
lib/pve/version.rb
Normal file
|
@ -0,0 +1,3 @@
|
|||
module PVE
|
||||
VERSION = '0.1.1'
|
||||
end
|
32
pve.gemspec
Normal file
32
pve.gemspec
Normal file
|
@ -0,0 +1,32 @@
|
|||
require_relative 'lib/pve/version'
|
||||
|
||||
Gem::Specification.new do |spec|
|
||||
spec.name = "pve"
|
||||
spec.version = PVE::VERSION
|
||||
spec.authors = ["Denis Knauf"]
|
||||
spec.email = ["git+pve@denkn.at"]
|
||||
spec.licenses = ["LGPL-3.0"]
|
||||
|
||||
spec.summary = %q{Proxmox Virtual Environment higher level API }
|
||||
spec.description = %q{Provides a higher level API with objects for controlling PVE}
|
||||
spec.homepage = "https://git.denkn.at/deac/pve"
|
||||
# Ruby3 interpret **opts in another way than before.
|
||||
# 2.7.0 should work with both(?) behaviours.
|
||||
# PVE based on debian, so ruby 2.5 is default.
|
||||
spec.required_ruby_version = Gem::Requirement.new "~> 2.5.0"
|
||||
|
||||
spec.metadata["homepage_uri"] = spec.homepage
|
||||
spec.metadata["source_code_uri"] = spec.homepage
|
||||
spec.metadata["changelog_uri"] = spec.homepage
|
||||
|
||||
spec.add_development_dependency "rspec", "~> 3.2"
|
||||
|
||||
# Specify which files should be added to the gem when it is released.
|
||||
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
|
||||
spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
|
||||
`git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
|
||||
end
|
||||
spec.bindir = "bin"
|
||||
spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
|
||||
spec.require_paths = ["lib"]
|
||||
end
|
Loading…
Reference in a new issue