wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/config/dcmgr.conf.example

@@ -24,3 +24,54 @@ create_volume_min_size 10
 # Default account quota limit
 account_instance_total_weight 100.0
 account_volume_total_size 100000 # 100GB
+
+stopped_instance_usage_factor 1.0
+
+recent_terminated_instance_period 900
+
+mac_address_vendor_id nil
+
+# Scheduling Algorithms
+#host_node_scheduler :FindFirst
+host_node_scheduler {
+  scheduler :LeastUsage
+}
+  
+#storage_node_scheduler :FindFirst
+storage_node_scheduler {
+  scheduler :LeastUsage
+}
+#network_scheduler :FlatSingle
+network_scheduler {
+  scheduler :PerInstance
+  options {
+    default {
+      scheduler :FlatSingle
+    }
+    nat {
+      scheduler :NatOneToOne
+      options {
+        network_id 'nw-demo1'
+        nat_network_id 'nw-demo2'
+      }
+    }
+    vif3type1 {
+      scheduler :VifTemplate
+      options( {
+        'eth0' => 'nw-demo1',
+        'eth1' => 'nw-demo2',
+        'eth2' => 'nw-demo3',
+      })
+    }
+    vif3type2 {
+      scheduler :VifTemplate
+      options( {
+        'eth0' => 'nw-demo1',
+        'eth1' => 'nw-demo4',
+        'eth2' => 'nw-demo5',
+      })
+    }
+  }
+}
+
+mac_address_vendor_id '525400'

data/lib/dcmgr.rb

@@ -82,15 +82,6 @@ module Dcmgr
     class UUIDPrefixDuplication < StandardError; end
     autoload :Base, 'dcmgr/models/base'
 
-    CREATE_TABLE_CLASSES=[:Account,:Tag,:TagMapping,:FrontendSystem,
-                          :Image,:HostPool,:RequestLog,:Instance,
-                          :NetfilterGroup, :NetfilterRule,
-                          :StoragePool,:Volume,:VolumeSnapshot,
-                          :InstanceNetfilterGroup,
-                          :InstanceSpec, :InstanceNic, :Network, :IpLease,
-                          :SshKeyPair, :History, :HostnameLease, :MacLease,
-                          :VlanLease, :Quota
-                         ].freeze
     autoload :BaseNew, 'dcmgr/models/base_new'
     autoload :Account, 'dcmgr/models/account'
     autoload :Tag, 'dcmgr/models/tag'
@@ -98,49 +89,50 @@ module Dcmgr
     autoload :AccountResource, 'dcmgr/models/account_resource'
     autoload :Instance, 'dcmgr/models/instance'
     autoload :Image, 'dcmgr/models/image'
-    autoload :HostPool, 'dcmgr/models/host_pool'
+    autoload :HostNode, 'dcmgr/models/host_node'
     autoload :RequestLog, 'dcmgr/models/request_log'
     autoload :FrontendSystem, 'dcmgr/models/frontend_system'
-    autoload :StoragePool, 'dcmgr/models/storage_pool'
+    autoload :StorageNode, 'dcmgr/models/storage_node'
     autoload :Volume, 'dcmgr/models/volume'
     autoload :VolumeSnapshot, 'dcmgr/models/volume_snapshot'
-    autoload :NetfilterGroup, 'dcmgr/models/netfilter_group'
-    autoload :NetfilterRule, 'dcmgr/models/netfilter_rule'
+    autoload :SecurityGroup, 'dcmgr/models/security_group'
+    autoload :SecurityGroupRule, 'dcmgr/models/security_group_rule'
     autoload :InstanceSpec, 'dcmgr/models/instance_spec'
     autoload :InstanceNic, 'dcmgr/models/instance_nic'
     autoload :Network, 'dcmgr/models/network'
     autoload :IpLease, 'dcmgr/models/ip_lease'
-    autoload :InstanceNetfilterGroup, 'dcmgr/models/instance_netfilter_group'
+    autoload :InstanceSecurityGroup, 'dcmgr/models/instance_security_group'
     autoload :SshKeyPair, 'dcmgr/models/ssh_key_pair'
     autoload :History, 'dcmgr/models/history'
     autoload :HostnameLease, 'dcmgr/models/hostname_lease'
     autoload :MacLease, 'dcmgr/models/mac_lease'
     autoload :VlanLease, 'dcmgr/models/vlan_lease'
     autoload :Quota, 'dcmgr/models/quota'
+    autoload :DhcpRange, 'dcmgr/models/dhcp_range'
+    autoload :PhysicalNetwork, 'dcmgr/models/physical_network'
   end
 
   module Endpoints
     autoload :CoreAPI, 'dcmgr/endpoints/core_api'
-    autoload :Metadata, 'dcmgr/endpoints/metadata'
+    autoload :Ec2Metadata, 'dcmgr/endpoints/metadata'
   end
 
   module NodeModules
     autoload :StaCollector, 'dcmgr/node_modules/sta_collector'
+    autoload :StaTgtInitializer, 'dcmgr/node_modules/sta_tgt_initializer'
     autoload :HvaCollector, 'dcmgr/node_modules/hva_collector'
     autoload :InstanceHA, 'dcmgr/node_modules/instance_ha'
+    autoload :OpenFlowController, 'dcmgr/node_modules/openflow_controller'
     autoload :ServiceNetfilter, 'dcmgr/node_modules/service_netfilter'
+    autoload :ServiceOpenFlow, 'dcmgr/node_modules/service_openflow'
     autoload :InstanceMonitor, 'dcmgr/node_modules/instance_monitor'
-  end
-
-  module Stm
-    autoload :VolumeContext, 'dcmgr/stm/volume_context'
-    autoload :SnapshotContext, 'dcmgr/stm/snapshot_context'
-    autoload :Instance, 'dcmgr/stm/instance'
+    autoload :Scheduler, 'dcmgr/node_modules/scheduler'
   end
 
   module Helpers
     autoload :CliHelper, 'dcmgr/helpers/cli_helper'
     autoload :NicHelper, 'dcmgr/helpers/nic_helper'
+    autoload :SnapshotStorageHelper, 'dcmgr/helpers/snapshot_storage_helper'
   end
 
   autoload :Tags, 'dcmgr/tags'
@@ -157,7 +149,7 @@ module Dcmgr
     autoload :Vlan, 'dcmgr/cli/vlan'
     autoload :Image, 'dcmgr/cli/image'
     autoload :KeyPair, 'dcmgr/cli/keypair'
-    autoload :Group, 'dcmgr/cli/group'
+    autoload :SecurityGroup, 'dcmgr/cli/security_group'
     autoload :Spec, 'dcmgr/cli/spec'
     autoload :Tag, 'dcmgr/cli/tag'
     autoload :Quota, 'dcmgr/cli/quota'
@@ -165,6 +157,7 @@ module Dcmgr
 
   module Rpc
     autoload :HvaHandler, 'dcmgr/rpc/hva_handler'
+    autoload :StaHandler, 'dcmgr/rpc/sta_handler'
     autoload :KvmHelper, 'dcmgr/rpc/hva_handler'
   end
 
@@ -176,12 +169,96 @@ module Dcmgr
   
   module Drivers
     autoload :SnapshotStorage, 'dcmgr/drivers/snapshot_storage'
+    autoload :LocalStorage, 'dcmgr/drivers/local_storage'
     autoload :S3Storage, 'dcmgr/drivers/s3_storage'
     autoload :IIJGIOStorage, 'dcmgr/drivers/iijgio_storage'
     autoload :Hypervisor, 'dcmgr/drivers/hypervisor'
     autoload :Kvm , 'dcmgr/drivers/kvm'
     autoload :Lxc , 'dcmgr/drivers/lxc'
+    autoload :BackingStore, 'dcmgr/drivers/backing_store'
+    autoload :Zfs,          'dcmgr/drivers/zfs'
+    autoload :Raw,          'dcmgr/drivers/raw'
+    autoload :IscsiTarget,  'dcmgr/drivers/iscsi_target'
+    autoload :SunIscsi,     'dcmgr/drivers/sun_iscsi'
+    autoload :LinuxIscsi,   'dcmgr/drivers/linux_iscsi'
+    autoload :Comstar,      'dcmgr/drivers/comstar'
   end
   
   autoload :StorageService, 'dcmgr/storage_service'
+
+  require 'dcmgr/scheduler'
+  module Scheduler
+    module StorageNode
+      autoload :FindFirst, 'dcmgr/scheduler/storage_node/find_first'
+      autoload :LeastUsage, 'dcmgr/scheduler/storage_node/least_usage'
+    end
+    module HostNode
+      autoload :FindFirst, 'dcmgr/scheduler/host_node/find_first'
+      autoload :LeastUsage, 'dcmgr/scheduler/host_node/least_usage'
+      autoload :ExcludeSame, 'dcmgr/scheduler/host_node/exclude_same'
+      autoload :SpecifyNode, 'dcmgr/scheduler/host_node/specify_node'
+    end
+    module Network
+      autoload :FlatSingle, 'dcmgr/scheduler/network/flat_single'
+      autoload :NatOneToOne, 'dcmgr/scheduler/network/nat_one_to_one'
+      autoload :VifTemplate, 'dcmgr/scheduler/network/vif_template'
+      autoload :PerInstance, 'dcmgr/scheduler/network/per_instance'
+    end
+  end
+  
+  require 'dcmgr/vnet'
+  module VNet
+    autoload :ControllerFactory, 'dcmgr/vnet/factories'
+    autoload :IsolatorFactory, 'dcmgr/vnet/factories'
+    autoload :TaskFactory, 'dcmgr/vnet/factories'
+    autoload :TaskManagerFactory, 'dcmgr/vnet/factories'
+    
+    module Netfilter
+      autoload :NetfilterCache, 'dcmgr/vnet/netfilter/cache'
+      autoload :NetfilterController, 'dcmgr/vnet/netfilter/controller'
+      autoload :Chain, 'dcmgr/vnet/netfilter/chain'
+      autoload :IptablesChain, 'dcmgr/vnet/netfilter/chain'
+      autoload :EbtablesChain, 'dcmgr/vnet/netfilter/chain'
+      autoload :EbtablesRule, 'dcmgr/vnet/netfilter/ebtables_rule'
+      autoload :IptablesRule, 'dcmgr/vnet/netfilter/iptables_rule'
+      autoload :NetfilterTaskManager, 'dcmgr/vnet/netfilter/task_manager'
+      autoload :VNicProtocolTaskManager, 'dcmgr/vnet/netfilter/task_manager'
+    end
+
+    module Tasks
+      autoload :AcceptAllDNS, 'dcmgr/vnet/tasks/accept_all_dns'
+      autoload :AcceptArpBroadcast, 'dcmgr/vnet/tasks/accept_arp_broadcast'
+      autoload :AcceptARPFromFriends, 'dcmgr/vnet/tasks/accept_arp_from_friends'
+      autoload :AcceptARPFromGateway, 'dcmgr/vnet/tasks/accept_arp_from_gateway'
+      autoload :AcceptARPToHost, 'dcmgr/vnet/tasks/accept_arp_to_host'
+      autoload :AcceptIpFromFriends, 'dcmgr/vnet/tasks/accept_ip_from_friends'
+      autoload :AcceptIpFromGateway, 'dcmgr/vnet/tasks/accept_ip_from_gateway'
+      autoload :AcceptIpToAnywhere, 'dcmgr/vnet/tasks/accept_ip_to_anywhere'
+      autoload :AcceptRelatedEstablished, 'dcmgr/vnet/tasks/accept_related_established'
+      autoload :AcceptTcpRelatedEstablished, 'dcmgr/vnet/tasks/accept_related_established'
+      autoload :AcceptUdpEstablished, 'dcmgr/vnet/tasks/accept_related_established'
+      autoload :AcceptIcmpRelatedEstablished, 'dcmgr/vnet/tasks/accept_related_established'
+      autoload :AcceptWakameDHCPOnly, 'dcmgr/vnet/tasks/accept_wakame_dhcp_only'
+      autoload :AcceptWakameDNSOnly, 'dcmgr/vnet/tasks/accept_wakame_dns_only'
+      autoload :DebugIptables, 'dcmgr/vnet/tasks/debug_iptables'
+      autoload :DropArpForwarding, 'dcmgr/vnet/tasks/drop_arp_forwarding'
+      autoload :DropArpToHost, 'dcmgr/vnet/tasks/drop_arp_to_host'
+      autoload :DropIpFromAnywhere, 'dcmgr/vnet/tasks/drop_ip_from_anywhere'
+      autoload :DropIpSpoofing, 'dcmgr/vnet/tasks/drop_ip_spoofing'
+      autoload :DropMacSpoofing, 'dcmgr/vnet/tasks/drop_mac_spoofing'
+      autoload :ExcludeFromNat, 'dcmgr/vnet/tasks/exclude_from_nat'
+      autoload :ExcludeFromNatIpSet, 'dcmgr/vnet/tasks/exclude_from_nat'
+      autoload :SecurityGroup, 'dcmgr/vnet/tasks/security_group'
+      autoload :StaticNat, 'dcmgr/vnet/tasks/static_nat'
+      autoload :StaticNatLog, 'dcmgr/vnet/tasks/static_nat'
+      autoload :TranslateMetadataAddress, 'dcmgr/vnet/tasks/translate_metadata_address'
+    end
+    
+    module Isolators
+      autoload :BySecurityGroup, 'dcmgr/vnet/isolators/by_securitygroup'
+      autoload :DummyIsolator, 'dcmgr/vnet/isolators/dummy'
+    end
+    
+  end
+  
 end

data/lib/dcmgr/cli/base.rb

@@ -27,6 +27,40 @@ module Dcmgr::Cli
       def after_task
       end
     }
+
+    no_tasks {
+      class MapperDSL
+        attr_reader :defs
+        
+        def initialize()
+          @defs = {}
+        end
+      
+        def option(key, map_key=nil, &blk)
+          map_key ||= key
+          @defs[key]=proc { |h,v| h[map_key]=blk.call(v) }
+        end
+        
+        def map(key, map_key)
+          @defs[key]=proc { |h, v| h[map_key] = v}
+        end
+      end
+
+      public
+      def optmap(h, &blk)
+        ret = {}
+        d = MapperDSL.new
+        blk.call(d)
+        h.each { |k, v|
+          if d.defs.has_key?(k.to_sym)
+            d.defs[k.to_sym].call(ret, v)
+          else
+            ret[k.to_sym] = v
+          end
+        }
+        ret
+      end
+    }
     
     def add(model,options)
       raise ArgumentError unless options.is_a? Hash
@@ -67,7 +101,6 @@ module Dcmgr::Cli
       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

data/lib/dcmgr/cli/host.rb

@@ -9,23 +9,25 @@ class Host < Base
   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"
+  method_option :uuid, :type => :string, :desc => "The UUID for the new host node"
+  method_option :name, :type => :string, :size => 255, :desc => "The name for the new host node"
+  method_option :force, :type => :boolean, :default=>false, :desc => "Force new entry creation"
+  method_option :cpu_cores, :type => :numeric, :default=>1, :desc => "Number of cpu cores to be offered"
+  method_option :memory_size, :type => :numeric, :default=>1024, :desc => "Amount of memory to be offered (in MB)"
+  method_option :hypervisor, :type => :string, :default=>'kvm', :desc => "The hypervisor name. [#{HostNode::SUPPORTED_HYPERVISOR.join(', ')}]"
+  method_option :arch, :type => :string, :default=>'x86_64', :desc => "The CPU architecture type. [#{HostNode::SUPPORTED_ARCH.join(', ')}]"
+  method_option :account_id, :type => :string, :default=>'a-shpoolxx', :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])
+    UnsupportedArchError.raise(options[:arch]) unless HostNode::SUPPORTED_ARCH.member?(options[:arch])
+    UnsupportedHypervisorError.raise(options[:hypervisor]) unless HostNode::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
 
-    if (options[:force] == false && Isono::Models::NodeState.filter(:node_id=>node_id).first == nil)
+    unless (options[:force] || Isono::Models::NodeState.find(:node_id=>node_id))
       abort("Node ID is not registered yet: #{node_id}")
     end
     
     fields = {
+              :name=>options[:name],
               :node_id=>node_id,
               :offering_cpu_cores=>options[:cpu_cores],
               :offering_memory_size=>options[:memory_size],
@@ -34,35 +36,37 @@ class Host < Base
               :account_id=>options[:account_id],
     }
     fields.merge!({:uuid => options[:uuid]}) unless options[:uuid].nil?
-    puts super(HostPool,fields)
+    puts super(HostNode,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(', ')}]"
+  method_option :name, :type => :string, :size => 255, :desc => "The name for the new host node"
+  method_option :cpu_cores, :type => :numeric, :desc => "Number of cpu cores to be offered"
+  method_option :account_id, :type => :string, :desc => "The account ID to own this"
+  method_option :memory_size, :type => :numeric, :desc => "Amount of memory to be offered (in MB)"
+  method_option :hypervisor, :type => :string, :desc => "The hypervisor name. [#{HostNode::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])
+    UnsupportedHypervisorError.raise(options[:hypervisor]) unless options[:hypervisor].nil? || HostNode::SUPPORTED_HYPERVISOR.member?(options[:hypervisor])
     fields = {
+              :name=>options[:name],
               :offering_memory_size=>options[:memory_size],
               :offering_cpu_cores=>options[:cpu_cores],
               :account_id=>options[:account_id],
               :hypervisor=>options[:hypervisor]
     }
-    super(HostPool,uuid,fields)
+    super(HostNode,uuid,fields)
   end
 
   desc "del UUID", "Deregister a host node"
   def del(uuid)
-    super(HostPool,uuid)
+    super(HostNode,uuid)
   end
 
   desc "show [UUID]", "Show list of host nodes and details"
   def show(uuid=nil)
     if uuid
-      host = HostPool[uuid]
+      host = HostNode[uuid] || UnknownUUIDError.raise(uuid)
       puts ERB.new(<<__END, nil, '-').result(binding)
 Host UUID:
   <%= host.canonical_uuid %>
@@ -77,7 +81,7 @@ Hypervisor:
 __END
     else
       cond = {}
-      all = HostPool.filter(cond).all
+      all = HostNode.filter(cond).all
       puts ERB.new(<<__END, nil, '-').result(binding)
 <%- all.each { |row| -%>
 <%= "%-15s %-20s %-10s" % [row.canonical_uuid, row.node_id, row.status] %>

data/lib/dcmgr/cli/image.rb

@@ -10,15 +10,16 @@ module Dcmgr::Cli
       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"
+      method_option :uuid, :type => :string, :desc => "The UUID for the new machine image"
+      method_option :account_id, :type => :string, :required => true, :desc => "The UUID of the account that this machine image belongs to"
+      method_option :arch, :type => :string, :default => 'x86_64', :desc => "The architecture for the new machine image. [#{M::HostNode::SUPPORTED_ARCH.join(', ')}]"
+      method_option :is_public, :type => :boolean, :default => false, :desc => "A flag that determines whether the new machine image is public or not"
+      method_option :md5sum, :type => :string, :required => true, :desc => "The md5 checksum of the image you are registering."
+      method_option :description, :type => :string, :desc => "An arbitrary description of the new machine image"
+      #method_option :state, :type => :string, :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])
+        UnsupportedArchError.raise(options[:arch]) unless M::HostNode::SUPPORTED_ARCH.member?(options[:arch])
         
         full_path = File.expand_path(location)
         File.exists?(full_path) || Error.raise("File not found: #{full_path}",100)
@@ -33,15 +34,16 @@ module Dcmgr::Cli
       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"
+      method_option :uuid, :type => :string, :desc => "The UUID for the new machine image."
+      method_option :account_id, :type => :string, :required => true, :desc => "The UUID of the account that this machine image belongs to."
+      method_option :arch, :type => :string, :default => 'x86_64', :desc => "The architecture for the new machine image. [#{M::HostNode::SUPPORTED_ARCH.join(', ')}]"
+      method_option :is_public, :type => :boolean, :default => false, :desc => "A flag that determines whether the new machine image is public or not."
+      method_option :md5sum, :type => :string, :required => true, :desc => "The md5 checksum of the image you are registering."
+      method_option :description, :type => :string, :desc => "An arbitrary description of the new machine image"
+      #method_option :state, :type => :string, :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])
+        UnsupportedArchError.raise(options[:arch]) unless M::HostNode::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
@@ -61,8 +63,8 @@ module Dcmgr::Cli
     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"
+    method_option :description, :type => :string, :desc => "An arbitrary description of the machine image"
+    method_option :state, :type => :string, :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)
@@ -77,15 +79,17 @@ module Dcmgr::Cli
     desc "show [IMAGE_ID]", "Show list of machine image and details"
     def show(uuid=nil)
       if uuid
-        img = M::Image[uuid]
+        img = M::Image[uuid] || UnknownUUIDError.raise(uuid)
         print ERB.new(<<__END, nil, '-').result(binding)
 UUID:
   <%= img.canonical_uuid %>
 Boot Type:
-  <%= img.boot_dev_type %>
+  <%= img.boot_dev_type == M::Image::BOOT_DEV_LOCAL ? 'local' : 'volume'%>
 Arch:
   <%= img.arch %>
 <%- if img.description -%>
+MD5 Sum:
+  <%= img.md5sum %>
 Description:
   <%= img.description %>
 <%- end -%>
@@ -93,16 +97,31 @@ Is Public:
   <%= img.is_public %>
 State:
   <%= img.state %>
+Features:
+<%= img.features %>
 __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] %>
+<%= row.canonical_uuid %>\t<%= row.boot_dev_type == M::Image::BOOT_DEV_LOCAL ? 'local' : 'volume'%>\t<%= row.arch %>
 <%- } -%>
 __END
       end
     end
+
+    desc "features IMAGE_ID", "Set features attribute to the image"
+    method_option :virtio, :type => :boolean, :desc => "Virtio ready image."
+    def features(uuid)
+      img = M::Image[uuid]
+      UnknownUUIDError.raise(uuid) if img.nil?
+
+      if options[:virtio]
+        img.set_feature(:virtio, options[:virtio])
+      end
+      img.save_changes
+    end
+    
   end
 end