wakame-vdc-dcmgr 10.12.0 → 11.06.0

data/lib/dcmgr/cli/host.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+require 'thor'
+require 'isono'
+
+module Dcmgr::Cli
+class Host < Base
+  namespace :host
+  include Dcmgr::Models
+  
+  desc "add NODE_ID [options]", "Register a new host node"
+  method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new host pool"
+  #method_option :force, :type => :boolean, :aliases => "-f", :default=>false, :desc => "Force to create new entry"
+  method_option :cpu_cores, :type => :numeric, :aliases => "-c", :default=>1, :desc => "Number of cpu cores to be offered"
+  method_option :memory_size, :type => :numeric, :aliases => "-m", :default=>1024, :desc => "Amount of memory to be offered (in MB)"
+  method_option :hypervisor, :type => :string, :aliases => "-p", :default=>'kvm', :desc => "The hypervisor name. [#{HostPool::SUPPORTED_HYPERVISOR.join(', ')}]"
+  method_option :arch, :type => :string, :aliases => "-r", :default=>'x86_64', :desc => "The CPU architecture type. [#{HostPool::SUPPORTED_ARCH.join(', ')}]"
+  method_option :account_id, :type => :string, :default=>'a-shpool', :aliases => "-a", :desc => "The account ID to own this"
+  def add(node_id)
+    UnknownUUIDError.raise(options[:account_id]) if Account[options[:account_id]].nil?
+    UnsupportedArchError.raise(options[:arch]) unless HostPool::SUPPORTED_ARCH.member?(options[:arch])
+    UnsupportedHypervisorError.raise(options[:hypervisor]) unless HostPool::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
+
+    if (options[:force] == false && Isono::Models::NodeState.filter(:node_id=>node_id).first == nil)
+      abort("Node ID is not registered yet: #{node_id}")
+    end
+    
+    fields = {
+              :node_id=>node_id,
+              :offering_cpu_cores=>options[:cpu_cores],
+              :offering_memory_size=>options[:memory_size],
+              :hypervisor=>options[:hypervisor],
+              :arch=>options[:arch],
+              :account_id=>options[:account_id],
+    }
+    fields.merge!({:uuid => options[:uuid]}) unless options[:uuid].nil?
+    puts super(HostPool,fields)
+  end
+  
+  desc "modify UUID [options]", "Modify a registered host node"
+  method_option :cpu_cores, :type => :numeric, :aliases => "-c", :desc => "Number of cpu cores to be offered"
+  method_option :account_id, :type => :string, :aliases => "-a", :desc => "The account ID to own this"
+  method_option :memory_size, :type => :numeric, :aliases => "-m", :desc => "Amount of memory to be offered (in MB)"
+  method_option :hypervisor, :type => :string, :aliases => "-p", :desc => "The hypervisor name. [#{HostPool::SUPPORTED_HYPERVISOR.join(', ')}]"
+  def modify(uuid)
+    UnknownUUIDError.raise(options[:account_id]) if options[:account_id] && Account[options[:account_id]].nil?
+    UnsupportedHypervisorError.raise(options[:hypervisor]) unless options[:hypervisor].nil? || HostPool::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
+    fields = {
+              :offering_memory_size=>options[:memory_size],
+              :offering_cpu_cores=>options[:cpu_cores],
+              :account_id=>options[:account_id],
+              :hypervisor=>options[:hypervisor]
+    }
+    super(HostPool,uuid,fields)
+  end
+
+  desc "del UUID", "Deregister a host node"
+  def del(uuid)
+    super(HostPool,uuid)
+  end
+
+  desc "show [UUID]", "Show list of host nodes and details"
+  def show(uuid=nil)
+    if uuid
+      host = HostPool[uuid]
+      puts ERB.new(<<__END, nil, '-').result(binding)
+Host UUID:
+  <%= host.canonical_uuid %>
+Node ID:
+  <%= host.node_id %>
+CPU Cores (offerring):
+  <%= host.offering_cpu_cores %>
+Memory (offerring):
+  <%= host.offering_memory_size %>MB
+Hypervisor:
+  <%= host.hypervisor %>
+__END
+    else
+      cond = {}
+      all = HostPool.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)
+Node ID              State
+<%- nodes.each { |row| -%>
+<%= "%-20s %-10s" % [row.node_id, row.state] %>
+<%- } -%>
+__END
+  end
+end
+end

data/lib/dcmgr/cli/image.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class Image < Base
+    namespace :image
+    M = Dcmgr::Models
+
+
+    class AddOperation < Base
+      namespace :add
+
+      desc "local IMAGE_LOCATION [options]", "Register local store machine image"
+      method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new machine image"
+      method_option :account_id, :type => :string, :aliases => "-a", :required => true, :desc => "The UUID of the account that this machine image 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 :is_public, :type => :boolean, :aliases => "-p", :default => false, :desc => "A flag that determines whether the new machine image is public or not"
+      method_option :description, :type => :string, :aliases => "-d", :desc => "An arbitrary description of the new machine image"
+      method_option :state, :type => :string, :aliases => "-s", :default => "init", :desc => "The state for the new machine image"
+      def local(location)
+        UnknownUUIDError.raise(options[:account_id]) if M::Account[options[:account_id]].nil?
+        UnsupportedArchError.raise(options[:arch]) unless M::HostPool::SUPPORTED_ARCH.member?(options[:arch])
+        
+        full_path = File.expand_path(location)
+        File.exists?(full_path) || Error.raise("File not found: #{full_path}",100)
+        
+        #TODO: Check if :state is a valid state
+        fields = options.dup
+        fields[:boot_dev_type]=M::Image::BOOT_DEV_LOCAL
+        fields[:source] = {
+          :uri => "file://#{full_path}",
+        }
+        puts add(M::Image, fields)
+      end
+
+      desc "volume snapshot_id [options]", "Register volume store machine image."
+      method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new machine image."
+      method_option :account_id, :type => :string, :aliases => "-a", :required => true, :desc => "The UUID of the account that this machine image 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 :is_public, :type => :boolean, :aliases => "-p", :default => false, :desc => "A flag that determines whether the new machine image is public or not."
+      method_option :description, :type => :string, :aliases => "-d", :desc => "An arbitrary description of the new machine image"
+      method_option :state, :type => :string, :aliases => "-s", :default => "init", :desc => "The state for the new machine image"
+      def volume(snapshot_id)
+        UnknownUUIDError.raise(options[:account_id]) if M::Account[options[:account_id]].nil?
+        UnsupportedArchError.raise(options[:arch]) unless M::HostPool::SUPPORTED_ARCH.member?(options[:arch])
+        UnknownUUIDError.raise(snapshot_id) if M::VolumeSnapshot[snapshot_id].nil?
+        #TODO: Check if :state is a valid state
+        fields = options.dup
+        fields[:boot_dev_type]=M::Image::BOOT_DEV_SAN
+        fields[:source] = {
+          :snapshot_id => snapshot_id,
+        }
+        puts add(M::Image, fields)
+      end
+      
+      protected
+      def self.basename
+        "vdc-manage #{Image.namespace} #{self.namespace}"
+      end
+    end
+
+    register AddOperation, 'add', "add IMAGE_TYPE [options]", "Add image metadata [#{AddOperation.tasks.keys.join(', ')}]"
+
+    desc "modify UUID [options]", "Modify a registered machine image"
+    method_option :description, :type => :string, :aliases => "-d", :desc => "An arbitrary description of the machine image"
+    method_option :state, :type => :string, :aliases => "-s", :default => "init", :desc => "The state for the machine image"
+    def modify(uuid)
+      #TODO: Check if state is valid here too
+      super(M::Image,uuid,options)
+    end
+
+    desc "del IMAGE_ID", "Delete registered machine image"
+    def del(image_id)
+      UnknownUUIDError.raise(image_id) if M::Image[image_id].nil?
+      super(M::Image, image_id)
+    end
+
+    desc "show [IMAGE_ID]", "Show list of machine image and details"
+    def show(uuid=nil)
+      if uuid
+        img = M::Image[uuid]
+        print ERB.new(<<__END, nil, '-').result(binding)
+UUID:
+  <%= img.canonical_uuid %>
+Boot Type:
+  <%= img.boot_dev_type %>
+Arch:
+  <%= img.arch %>
+<%- if img.description -%>
+Description:
+  <%= img.description %>
+<%- end -%>
+Is Public:
+  <%= img.is_public %>
+State:
+  <%= img.state %>
+__END
+      else
+        cond = {}
+        imgs = M::Image.filter(cond).all
+        print ERB.new(<<__END, nil, '-').result(binding)
+<%- imgs.each { |row| -%>
+<%= "%-20s  %-15s %-15s" % [row.canonical_uuid, row.boot_dev_type, row.arch] %>
+<%- } -%>
+__END
+      end
+    end
+  end
+end

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