wakame-vdc-agents 10.12.0 → 11.06.0

data/lib/dcmgr/cli/keypair.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class KeyPair < Base
+    namespace :keypair
+    M = Dcmgr::Models
+
+    desc "add [options]", "Register a new key pair."
+    method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new key pair"
+    method_option :account_id, :type => :string, :aliases => "-a", :desc => "The UUID of the account this key pair belongs to", :required => true
+    method_option :name, :type => :string, :aliases => "-n", :desc => "The name for this key pair", :required => true
+    method_option :public_key, :type => :string, :aliases => "-p", :desc => "The path to the public key", :required => true
+    method_option :private_key, :type => :string, :aliases => "-r", :desc => "The path to the private key", :required => true
+    def add
+      UnknownUUIDError.raise(options[:account_id]) if M::Account[options[:account_id]].nil?
+      private_key_path = File.expand_path(options[:private_key])
+      public_key_path = File.expand_path(options[:public_key])
+      Error.raise "Private key file doesn't exist",100 unless File.exists?(private_key_path)
+      Error.raise "Public key file doesn't exist",100 unless File.exists?(public_key_path)
+      
+      fields = options.dup
+      
+      #Get the keys from their respective files.
+      fields[:public_key] = File.open(public_key_path) {|f| f.readline}
+      fields[:private_key] = File.open(private_key_path) {|f| f.readlines.map.join}
+      
+      #Generate the fingerprint from the public key file
+      fields[:finger_print] = %x{ssh-keygen -lf #{options[:public_key]} | cut -d ' ' -f2}.chomp
+      
+      puts super(M::SshKeyPair,fields)
+    end
+    
+    desc "modify UUID [options]", "Modify an existing key pair"
+    method_option :account_id, :type => :string, :aliases => "-a", :desc => "The UUID of the account this key pair belongs to"
+    method_option :name, :type => :string, :aliases => "-n", :desc => "The name for this key pair"
+    def modify(uuid)
+      UnknownUUIDError.raise(options[:account_id]) if options[:account_id] && M::Account[options[:account_id]].nil?
+      super(M::SshKeyPair,uuid,options)
+    end
+    
+    desc "del UUID", "Delete an existing keypair"
+    def del(uuid)
+      super(M::SshKeyPair,uuid)
+    end
+    
+    desc "show [UUID] [options]", "Show network(s)"
+    def show(uuid=nil)
+      if uuid
+        keypair = M::SshKeyPair[uuid] || UnknownUUIDError.raise(uuid)
+        puts ERB.new(<<__END, nil, '-').result(binding)
+Keypair UUID:
+  <%= keypair.canonical_uuid %>
+Account id:
+  <%= keypair.account_id %>
+Name:
+  <%= keypair.name%>
+Finger print:
+  <%= keypair.finger_print %>
+Public Key:
+  <%= keypair.public_key%>
+__END
+      else
+        puts ERB.new(<<__END, nil, '-').result(binding)
+<%- M::SshKeyPair.each { |row| -%>
+<%= row.canonical_uuid %>\t<%= row.account_id %>\t<%= row.name %>\t<%= row.finger_print %>
+<%- } -%>
+__END
+      end
+    end
+    
+  end
+end

data/lib/dcmgr/cli/network.rb

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+
+require 'ipaddress'
+
+module Dcmgr::Cli
+class Network < Base
+  namespace :network
+  M=Dcmgr::Models
+  
+  desc "add [options]", "Register a new network entry"
+  method_option :uuid, :type => :string, :aliases => "-u", :desc => "UUID of the network"
+  method_option :ipv4_gw, :type => :string, :aliases => "-g", :required => true, :desc => "Gateway address for IPv4 network"
+  method_option :prefix, :type => :numeric, :default=>24, :aliases => "-p", :desc => "IP network mask size (1 < prefix < 32)"
+  method_option :domain, :type => :string, :aliases => "-m", :desc => "DNS domain name of the network"
+  method_option :dns, :type => :string, :aliases => "-n", :desc => "IP address for DNS server of the network"
+  method_option :dhcp, :type => :string, :aliases => "-c", :desc => "IP address for DHCP server of the network"
+  method_option :metadata, :type => :string, :aliases => "-t", :desc => "IP address for metadata server of the network"
+  method_option :metadata_port, :type => :string, :aliases => "--tp", :desc => "Port for the metadata server of the network"
+  method_option :bandwidth, :type => :numeric, :aliases => "-b", :desc => "The maximum bandwidth for the network in Mbit/s"
+  method_option :vlan_id, :type => :numeric, :default=>0, :aliases => "-l", :desc => "Tag VLAN (802.1Q) ID of the network. 0 is for no VLAN network"
+  method_option :description, :type => :string, :aliases => "-d", :desc => "Description for the network"
+  method_option :account_id, :type => :string, :default=>'a-shpool', :aliases => "-a", :desc => "The account ID to own this"
+  def add
+    vlan_pk = if options[:vlan_id].to_i > 0
+                vlan = M::VlanLease.find(:tag_id=>options[:vlan_id]) || Error.raise("Invalid or Unknown VLAN ID: #{options[:vlan_id]}", 100)
+                vlan.id
+              else
+                0
+              end
+    
+    fields = {
+       :ipv4_gw => options[:ipv4_gw],
+       :prefix => options[:prefix],
+       :dns_server => options[:dns],
+       :domain_name => options[:domain],
+       :dhcp_server => options[:dhcp],
+       :metadata_server => options[:metadata],
+       :metadata_server_port => options[:metadata_port],
+       :description => options[:description],
+       :account_id => options[:account_id],
+       :bandwidth => options[:bandwidth],
+       :vlan_lease_id => vlan_pk,
+    }
+    fields.merge!({:uuid => options[:uuid]}) unless options[:uuid].nil?
+
+    puts super(M::Network,fields)
+  end
+
+  desc "del UUID", "Deregister a network entry"
+  def del(uuid)
+    super(M::Network,uuid)
+  end
+
+  desc "modify UUID [options]", "Update network information"
+  method_option :ipv4_gw, :type => :string, :aliases => "-g", :desc => "Gateway address for IPv4 network"
+  method_option :prefix, :type => :numeric, :aliases => "-p", :desc => "IP network mask size (1 < prefix < 32)"
+  method_option :domain, :type => :string, :aliases => "-m", :desc => "DNS domain name of the network"
+  method_option :dns, :type => :string, :aliases => "-n", :desc => "IP address for DNS server of the network"
+  method_option :dhcp, :type => :string, :aliases => "-c", :desc => "IP address for DHCP server of the network"
+  method_option :metadata, :type => :string, :aliases => "-t", :desc => "IP address for metadata server of the network"
+  method_option :metadata_port, :type => :string, :aliases => "--tp", :desc => "Port for the metadata server of the network" 
+  method_option :vlan_id, :type => :numeric, :aliases => "-l", :desc => "Tag VLAN (802.1Q) ID of the network. 0 is for no VLAN network"
+  method_option :bandwidth, :type => :numeric, :aliases => "-b", :desc => "The maximum bandwidth for the network in Mbit/s"
+  method_option :description, :type => :string, :aliases => "-d", :desc => "Description for the network"
+  method_option :account_id, :type => :string, :aliases => "-a", :desc => "The account ID to own this"
+  def modify(uuid)
+    vlan_pk = if options[:vlan_id].to_i > 0
+                vlan = M::VlanLease.find(:tag_id=>options[:vlan_id]) || Error.raise("Invalid or Unknown VLAN ID: #{options[:vlan_id]}", 100)
+                vlan.id
+              else
+                0
+              end
+    
+    fields = {
+       :ipv4_gw => options[:ipv4_gw],
+       :prefix => options[:prefix],
+       :dns_server => options[:dns],
+       :domain_name => options[:domain],
+       :dhcp_server => options[:dhcp],
+       :metadata_server => options[:metadata],
+       :metadata_server_port => options[:metadata_port],
+       :description => options[:description],
+       :account_id => options[:account_id],
+       :bandwidth => options[:bandwidth],
+       :vlan_lease_id => vlan_pk,
+    }
+    super(M::Network,uuid,fields)
+  end
+
+  desc "nat UUID [options]", "Set or clear nat mapping for a network"
+  method_option :outside_network_id, :type => :string, :aliases => "-o", :desc => "The network that this network will be natted to"
+  method_option :clear, :type => :boolean, :aliases => "-c", :desc => "Clears a previously natted network"
+  def nat(uuid)
+    in_nw = M::Network[uuid] || Error.raise("Unknown network UUID: #{uuid}", 100)
+    ex_nw = M::Network[options[:outside_network_id]] || Error.raise("Unknown network UUID: #{uuid}", 100) unless options[:outside_network_id].nil?
+
+    if options[:clear] then
+      in_nw.set_only({:nat_network_id => nil},:nat_network_id)
+      in_nw.save_changes
+    else
+      in_nw.set_only({:nat_network_id => ex_nw.id},:nat_network_id)
+      in_nw.save_changes
+    end
+  end
+
+  desc "show [UUID] [options]", "Show network(s)"
+  method_option :vlan_id, :type => :numeric, :aliases => "-l", :desc => "Show networks in the VLAN ID"
+  method_option :account_id, :type => :string, :aliases => "-a", :desc => "Show networks with the account"
+  def show(uuid=nil)
+    if uuid
+      nw = M::Network[uuid] || Error.raise("Unknown network UUID: #{uuid}", 100)
+      puts ERB.new(<<__END, nil, '-').result(binding)
+Network UUID:
+  <%= nw.canonical_uuid %>
+Tag VLAN:
+  <%= nw.vlan_lease_id == 0 ? 'none' : nw.vlan_lease.tag_id %>
+IPv4:
+  Network address: <%= nw.ipaddress.network %>/<%= nw.prefix %>
+  Gateway address: <%= nw.ipv4_gw %>
+<%- if nw.nat_network_id -%>
+  Outside NAT network address: <%= nw.nat_network.ipaddress.network %>/<%= nw.nat_network.prefix %> (<%= nw.nat_network.canonical_uuid %>)
+<%- end -%>
+DHCP Information:
+  DHCP Server: <%= nw.dhcp_server %>
+  DNS Server: <%= nw.dns_server %>
+<%- if nw.metadata_server -%>
+  Metadata Server: <%= nw.metadata_server %>
+<%- end -%>
+Bandwidth:
+<%- if nw.bandwidth.nil? -%>
+  unlimited
+<%- else -%>
+  <%= nw.bandwidth %> Mbit/s
+<%- end -%>
+<%- if nw.description -%>
+Description:
+  <%= nw.description %>
+<%- end -%>
+__END
+    else
+      cond = {}
+      cond[:account_id]= options[:account_id] if options[:account_id]
+      if options[:vlan_id]
+        vlan = M::VlanLease.find(:tag_id=>options[:vlan_id]) || abort("Unknown Tag VLAN ID: #{options[:vlan_id]}")
+        cond[:vlan_lease_id] = vlan.id
+      end
+
+      nw = M::Network.filter(cond).all
+      puts ERB.new(<<__END, nil, '-').result(binding)
+<%- nw.each { |row| -%>
+<%= row.canonical_uuid %>\t<%= row.ipaddress.network %>/<%= row.prefix %>\t<%= (row.vlan_lease && row.vlan_lease.tag_id) %>
+<%- } -%>
+__END
+    end
+  end
+
+  desc "leases UUID", "Show IPs used in the network"
+  def leases(uuid)
+    nw = M::Network[uuid] || Error.raise("Unknown network UUID: #{uuid}", 100)
+
+    print ERB.new(<<__END, nil, '-').result(binding)
+<%- nw.ip_lease_dataset.order(:ipv4).all.each { |l| -%>
+<%= "%-20s  %-15s" % [l.ipv4, M::IpLease::TYPE_MESSAGES[l.alloc_type]] %>
+<%- } -%>
+__END
+  end
+
+  desc "reserve UUID", "Add reserved IP to the network"
+  method_option :ipv4, :type => :string, :aliases => "-i", :required => true, :desc => "The ip address to reserve"
+  def reserve(uuid)
+    nw = M::Network[uuid] || UnknownUUIDError.raise(uuid)
+
+    if nw.ipaddress.include?(IPAddress(options[:ipv4]))
+      nw.ip_lease_dataset.add_reserved(options[:ipv4])
+    else
+      Error.raise("IP address is out of range: #{options[:ipv4]} => #{nw.ipaddress.network}/#{nw.ipaddress.prefix}",100)
+    end
+  end
+
+  desc "release UUID", "Release a reserved IP from the network"
+  method_option :ipv4, :type => :string, :aliases => "-i", :required => true, :desc => "The ip address to release"
+  def release(uuid)
+    nw = M::Network[uuid] || UnknownUUIDError.raise(uuid)
+
+    if nw.ip_lease_dataset.filter(:ipv4=>options[:ipv4]).delete == 0
+      Error.raise("The IP is not reserved in network #{uuid}: #{options[:ipv4]}", 100)
+    end
+  end
+
+  no_tasks {
+    private
+    def find_network(uuid)
+      M::Network[uuid] || Error.raise("Unknown network UUID: #{uuid}")
+    end
+  }
+
+end
+end

data/lib/dcmgr/cli/quota.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class Quota < Base
+    namespace :quota
+    M = Dcmgr::Models
+  
+    desc "modify ACCOUNT_UUID [options]", "Modify the quota settings for an account"
+    method_option :weight, :type => :numeric, :aliases => "-w", :desc => "The instance total weight for this account's quota"
+    method_option :size, :type => :numeric, :aliases => "-s", :desc => "The volume total size for this account's quota"
+    def modify(account_uuid)
+      acc = M::Account[account_uuid] || UnknownUUIDError.raise(account_uuid)
+      super(M::Quota,acc.quota.canonical_uuid,{:instance_total_weight => options[:weight], :volume_total_size => options[:size]})
+    end
+    
+    desc "show ACCOUNT_UUID", "Show the quota settings for an account"
+    def show(account_uuid)
+      acc = M::Account[account_uuid] || raise(Thor::Error, "Unknown Account UUID: #{account_uuid}")
+      puts ERB.new(<<__END, nil, '-').result(binding)
+Instance total weight:
+  <%= acc.quota.instance_total_weight %>
+Volume total size:
+  <%= acc.quota.volume_total_size %>
+__END
+    end
+    
+  end
+end

data/lib/dcmgr/cli/spec.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class Spec < Base
+    namespace :spec
+    M = Dcmgr::Models
+
+    desc "add [options]", "Register a new machine spec"
+    method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new machine spec"
+    method_option :account_id, :type => :string, :aliases => "-a", :required => true, :desc => "The UUID of the account that this machine spec belongs to"
+    method_option :arch, :type => :string, :default => 'x86_64', :aliases => "-r", :desc => "The architecture for the new machine image. [#{M::HostPool::SUPPORTED_ARCH.join(', ')}]"
+    method_option(:hypervisor, :type => :string, :aliases => "-p", :default => M::HostPool::HYPERVISOR_KVM.to_s,
+                  :desc => "The hypervisor type for the new instance. [#{M::HostPool::SUPPORTED_HYPERVISOR.join(', ')}]")
+    method_option :cpu_cores, :type => :numeric, :aliases => "-c", :default => 1, :desc => "The initial cpu cores for the new instance"
+    method_option :memory_size, :type => :numeric, :aliases => "-m", :default => 1024, :desc => "The memory size for the new instance"
+    method_option :quota_weight, :type => :numeric, :aliases => "-w", :default => 1.0, :desc => "The cost weight factor for the new instance"
+    #method_option :is_public, :type => :boolean, :aliases => "-p", :default => false, :desc => "A flag that determines whether the new machine image is public or not."
+    def add
+      UnknownUUIDError.raise(options[:account_id]) if M::Account[options[:account_id]].nil?
+      UnsupportedArchError.raise(options[:arch]) unless M::HostPool::SUPPORTED_ARCH.member?(options[:arch])
+      UnsupportedHypervisorError.raise(options[:hypervisor]) unless M::HostPool::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
+      fields = options.dup
+      fields[:config] = {
+      }
+      puts super(M::InstanceSpec, fields)
+    end
+    
+    desc "modify UUID [options]", "Modify an existing machine spec"
+    method_option :account_id, :type => :string, :aliases => "-a", :desc => "The UUID of the account that this machine spec belongs to"
+    method_option :arch, :type => :string, :aliases => "-r", :desc => "The architecture for the new machine image. [#{M::HostPool::SUPPORTED_ARCH.join(', ')}]"
+    method_option(:hypervisor, :type => :string, :aliases => "-p",
+                  :desc => "The hypervisor type for the new instance. [#{M::HostPool::SUPPORTED_HYPERVISOR.join(', ')}]")
+    method_option :cpu_cores, :type => :numeric, :aliases => "-c", :desc => "The initial cpu cores for the new instance"
+    method_option :memory_size, :type => :numeric, :aliases => "-m", :desc => "The memory size for the new instance"
+    method_option :quota_weight, :type => :numeric, :aliases => "-w", :desc => "The cost weight factor for the new instance"
+    def modify(uuid)
+      UnknownUUIDError.raise(options[:account_id]) if options[:account_id] && M::Account[options[:account_id]].nil?
+      UnsupportedArchError.raise(options[:arch]) unless options[:arch].nil? || M::HostPool::SUPPORTED_ARCH.member?(options[:arch])
+      UnsupportedHypervisorError.raise(options[:hypervisor]) unless options[:hypervisor].nil? || M::HostPool::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
+      super(M::InstanceSpec,uuid,options)
+    end
+    
+    desc "del UUID", "Delete registered machine spec"
+    def del(uuid)
+      UnknownUUIDError.raise(uuid) if M::InstanceSpec[uuid].nil?
+      super(M::InstanceSpec, uuid)
+    end
+
+    desc "show [UUID]", "Show list of machine spec and details"
+    def show(uuid=nil)
+      if uuid
+        spec = M::InstanceSpec[uuid]
+        print ERB.new(<<__END, nil, '-').result(binding)
+UUID:
+  <%= spec.canonical_uuid %>
+Account ID:
+  <%= spec.account_id %>
+Hypervisor:
+  <%= spec.hypervisor %>
+Arch:
+  <%= spec.arch %>
+CPU Cores:
+  <%= spec.cpu_cores %>
+Memory Size:
+  <%= spec.memory_size %>
+Quota Weight:
+  <%= spec.quota_weight %>
+Hypervisor Configuration:
+  <%= spec.config.inspect %>
+__END
+      else
+        cond = {}
+        specs = M::InstanceSpec.filter(cond).all
+        print ERB.new(<<__END, nil, '-').result(binding)
+<%- specs.each { |row| -%>
+<%= "%-20s  %-15s %-15s" % [row.canonical_uuid, row.account_id, row.arch] %>
+<%- } -%>
+__END
+      end
+    end
+  end
+end

data/lib/dcmgr/cli/storage.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+require 'thor'
+require 'isono'
+
+module Dcmgr::Cli
+class Storage < Base
+  namespace :storage
+  include Dcmgr::Models
+  
+  desc "add NODE_ID [options]", "Register a new storage node"
+  method_option :uuid, :type => :string, :aliases => "-u", :desc => "The uuid for the new storage pool."
+  method_option :base_path, :type => :string, :aliases => "-b", :required => true, :desc => "Base path to store volume files"
+  method_option :snapshot_base_path, :type => :string, :aliases => "-n", :required => true, :desc => "Base path to store snapshot files"
+  method_option :disk_space, :type => :numeric, :aliases => "-s", :required => true, :desc => "Amount of disk size to be exported (in MB)."
+  method_option :transport_type, :type => :string, :aliases => "-t", :default=>'iscsi', :desc => "Transport type [iscsi]"
+  method_option :ipaddr, :type => :string, :aliases => "-i", :required=>true, :desc => "IP address of transport target"
+  method_option :storage_type, :type => :string, :aliases => "-o", :default=>'zfs', :desc => "Storage type [zfs]"
+  method_option :account_id, :type => :string, :default=>'a-shpool', :aliases => "-a", :desc => "The account ID to own this."
+  def add(node_id)
+    unless (options[:force] == false && Isono::Models::NodeState.exists?(:node_id=>options[:node_id]))
+      abort("Node ID is not registered yet: #{options[:node_id]}")
+    end
+
+    fields = {:node_id=>options[:node_id],
+              :offering_disk_space=>options[:disk_space],
+              :transport_type=>options[:transport_type],
+              :storage_type=>options[:storage_type],
+              :export_path=>options[:base_path],
+              :snapshot_base_path => options[:snapshot_base_path],
+              :ipaddr=>options[:ipaddr],
+              :account_id=>options[:account_id],
+    }
+    fields.merge!({:uuid => options[:uuid]}) unless options[:uuid].nil?
+    
+    puts super(StoragePool,fields)
+  end
+
+  desc "del UUID", "Deregister a storage node"
+  def del(uuid)
+    super(StoragePool,uuid)
+  end
+
+  desc "show [UUID]", "Show list of storage nodes and details"
+  def show(uuid=nil)
+    if uuid
+      st = StoragePool[uuid]
+      puts ERB.new(<<__END, nil, '-').result(binding)
+UUID:
+  <%= st.canonical_uuid %>
+Node ID:
+  <%= st.node_id %>
+Disk space (offerring):
+  <%= st.offering_disk_space %>MB
+Storage:
+  <%= st.storage_type %>
+Transport:
+  <%= st.transport_type %>
+IP Address:
+  <%= st.ipaddr %>
+Export path:
+  <%= st.export_path %>
+Snapshot base path:
+  <%= st.snapshot_base_path %>
+__END
+    else
+      cond = {}
+      all = StoragePool.filter(cond).all
+      puts ERB.new(<<__END, nil, '-').result(binding)
+<%- all.each { |row| -%>
+<%= "%-15s %-20s %-10s" % [row.canonical_uuid, row.node_id, row.status] %>
+<%- } -%>
+__END
+    end
+  end
+
+  desc "shownodes", "Show node (agents)"
+  def shownodes
+    nodes = Isono::Models::NodeState.filter.all
+
+    puts ERB.new(<<__END, nil, '-').result(binding)
+<%- nodes.each { |row| -%>
+<%= "%-20s %-10s" % [row.node_id, row.state] %>
+<%- } -%>
+__END
+  end
+end
+end