wakame-vdc-agents 10.12.0 → 11.06.0

data/lib/dcmgr/cli/base.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+require 'thor'
+
+module Dcmgr::Cli
+  class Base < Thor
+    protected
+    def self.basename
+      "#{super()} #{namespace}"
+    end
+
+    no_tasks {
+      public
+      # add before/after task hook.
+      def invoke_task(task, *args)
+        Dcmgr::Models::BaseNew.db.transaction do
+          before_task
+          super(task, *args)
+          after_task
+        end
+      end
+    
+      protected
+      def before_task
+      end
+      
+      def after_task
+      end
+    }
+    
+    def add(model,options)
+      raise ArgumentError unless options.is_a? Hash
+      #TODO: Make this check a little tighter by checking that the model is either from the wakame backend or frontend
+      #UnknownModelError.raise(model) unless model < Dcmgr::Models::BaseNew
+      UnknownModelError.raise(model) unless model < Sequel::Model
+      
+      fields = options.dup
+      
+      if fields.has_key?("uuid") || fields.has_key?(:uuid)
+        fields[:uuid] = model.trim_uuid(fields[:uuid]) if model.check_uuid_format(fields[:uuid])
+        Error.raise("UUID syntax invalid: #{fields[:uuid]}",100) unless model.check_trimmed_uuid_format(fields[:uuid])
+      end
+      
+      #Create database fields
+      new_record = model.create(fields)
+      
+      #Return uuid if there is one
+      new_record.canonical_uuid #if model.respond_to? "canonical_uuid"
+    end
+    
+    def del(model,uuid)
+      #UnknownModelError.raise(model) unless model < Dcmgr::Models::BaseNew
+      UnknownModelError.raise(model) unless model < Sequel::Model
+      to_delete = model[uuid] || UnknownUUIDError.raise(uuid)
+      to_delete.destroy
+    end
+    
+    def modify(model,uuid,fields)
+      #UnknownModelError.raise(model) unless model < Dcmgr::Models::BaseNew
+      UnknownModelError.raise(model) unless model < Sequel::Model
+      raise ArgumentError unless fields.is_a? Hash
+      to_modify = model[uuid] || UnknownUUIDError.raise(uuid)
+      
+      #Use a copy of the fields hash so this method can work with frozen hashes
+      fields_nonil = fields.merge({})
+      #Don't update empty fields
+      fields_nonil.delete_if {|key,value| value.nil?}
+      
+      to_modify.set(fields_nonil)
+      to_modify.updated_at = Time.now.utc.iso8601 if to_modify.with_timestamps?
+      to_modify.save_changes
+    end
+  end
+end

data/lib/dcmgr/cli/errors.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class Error < StandardError
+    attr_reader :exit_code
+    def initialize(msg, exit_code=1)
+      super(msg)
+      @exit_code = exit_code
+    end
+
+    def self.raise(msg, exit_code)
+      Kernel.raise(if msg.is_a?(self)
+                     msg
+                   else
+                     self.new(msg, exit_code)
+                   end)
+    end
+  end
+  
+  class UnknownUUIDError < Error
+    def initialize(uuid,exit_code=100)
+      super("Unknown UUID: '#{uuid}'.")
+    end
+    
+    def self.raise(uuid,exit_code=100)
+      super
+    end
+  end
+  
+  class UnsupportedArchError < Error
+    def initialize(arch,exit_code=100)
+      super("Unsupported arch type: '#{arch}'.")
+    end
+    
+    def self.raise(arch,exit_code=100)
+      super
+    end
+  end
+  
+  class UnknownModelError < Error
+    def initialize(model,exit_code=100)
+      super("Not a sequel model: '#{model}'.")
+    end
+    
+    def self.raise(model,exit_code=100)
+      super
+    end
+  end
+
+  class UnsupportedHypervisorError < Error
+    def initialize(arch,exit_code=100)
+      super("Unsupported hypervisor type: '#{arch}'.")
+    end
+    
+    def self.raise(arch,exit_code=100)
+      super
+    end
+  end
+end

data/lib/dcmgr/cli/group.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Cli
+  class Group < Base
+    namespace :group
+    M = Dcmgr::Models
+
+    desc "add [options]", "Add a new security group"
+    method_option :uuid, :type => :string, :aliases => "-u", :desc => "The UUID for the new security group."
+    method_option :account_id, :type => :string, :aliases => "-a", :desc => "The UUID of the account this security group belongs to.", :required => true
+    method_option :name, :type => :string, :aliases => "-n", :desc => "The name for this security group.", :required => true
+    method_option :description, :type => :string, :aliases => "-d", :desc => "The description for this new security group."
+    def add
+      UnknownUUIDError.raise(options[:account_id]) if M::Account[options[:account_id]].nil?
+      
+      puts super(M::NetfilterGroup,options)
+    end
+    
+    desc "del UUID", "Delete a security group"
+    def del(uuid)
+      super(M::NetfilterGroup,uuid)
+    end
+    
+    desc "show [UUID]", "Show security group(s)"
+    def show(uuid=nil)
+      if uuid
+        group = M::NetfilterGroup[uuid] || UnknownUUIDError.raise(uuid)
+        puts ERB.new(<<__END, nil, '-').result(binding)
+Group UUID:
+  <%= group.canonical_uuid %>
+Account id:
+  <%= group.account_id %>
+<%- if group.description -%>
+Description:
+  <%= group.description %>
+<%- end -%>
+<%- unless group.netfilter_rules.empty? -%>
+Rules:
+<%- group.netfilter_rules.each { |rule| -%>
+  <%= rule.permission %>
+<%- } -%>
+<%- end -%>
+__END
+      else
+        puts ERB.new(<<__END, nil, '-').result(binding)
+<%- M::NetfilterGroup.all { |row| -%>
+<%= row.canonical_uuid %>\t<%= row.account_id %>\t<%= row.name %>
+<%- } -%>
+__END
+      end
+    end
+    
+    desc "modify UUID [options]", "Modify an existing security group"
+    method_option :account_id, :type => :string, :aliases => "-a", :desc => "The UUID of the account this security group belongs to."
+    method_option :name, :type => :string, :aliases => "-n", :desc => "The name for this security group."
+    method_option :description, :type => :string, :aliases => "-d", :desc => "The description for this new security group."
+    def modify(uuid)
+      UnknownUUIDError.raise(options[:account_id]) if options[:account_id] && M::Account[options[:account_id]].nil?
+      super(M::NetfilterGroup,uuid,options)
+    end
+    
+    desc "apply UUID [options]", "Apply a security group to an instance"
+    method_option :instance, :type => :string, :aliases => "-i", :required => :true, :desc => "The instance to apply the group to"
+    def apply(uuid)
+      group = M::NetfilterGroup[uuid] || UnknownUUIDError.raise(uuid)
+      instance = M::Instance[options[:instance]] || UnknownUUIDError.raise(options[:instance])
+      Error.raise("Group #{uuid} is already applied to instance #{options[:instance]}.",100) if group.instances.member?(instance)
+      group.add_instance(instance)
+    end
+    
+    desc "remove UUID [options]", "Remove a security group from an instance"
+    method_option :instance, :type => :string, :aliases => "-i", :required => :true, :desc => "The instance to remove the group from"
+    def remove(uuid)
+      group = M::NetfilterGroup[uuid] || UnknownUUIDError.raise(uuid)
+      instance = M::Instance[options[:instance]] || UnknownUUIDError.raise(options[:instance])
+      Error.raise("Group #{uuid} is not applied to instance #{options[:instance]}.",100) unless group.instances.member?(instance)
+      group.remove_instance(instance)
+    end
+    
+    desc "addrule UUID [options]", "Add a rule to a security group"
+    method_option :rule, :type => :string, :aliases => "-r", :desc => "The new rule to be added"
+    def addrule(g_uuid)
+      UnknownUUIDError.raise(g_uuid) if M::NetfilterGroup[g_uuid].nil?
+      
+      #TODO: check rule syntax
+      new_rule = M::NetfilterRule.new(:permission => options[:rule])
+      new_rule.netfilter_group = M::NetfilterGroup[g_uuid]
+      new_rule.save
+    end
+    
+    desc "delrule UUID [options]", "Delete a rule from a security group"
+    method_option :rule, :type => :string, :aliases => "-r", :desc => "The rule to be deleted."
+    def delrule(g_uuid)
+      UnknownUUIDError.raise(g_uuid) if M::NetfilterGroup[g_uuid].nil?
+      rule = M::NetfilterRule.find(:netfilter_group_id => M::NetfilterGroup[g_uuid].id,:permission => options[:rule])
+      Error.raise("Group '#{g_uuid}' does not contain rule '#{options[:rule]}'.",100) if rule.nil?
+      
+      rule.destroy
+    end
+  end
+end

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