wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/drivers/raw.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Drivers
+    class Raw < BackingStore
+      include Dcmgr::Logger
+      include Dcmgr::Helpers::CliHelper
+
+      def create_volume(ctx, snap_file = nil)
+        @volume_id   = ctx.volume_id
+        @volume      = ctx.volume
+        @snapshot    = ctx.snapshot
+
+        logger.info("creating new volume: #{@volume_id}")
+
+        if @snapshot
+          cp_sparse(snap_file, vol_path)
+          if $?.exitstatus != 0
+            raise "failed copy snapshot: #{snap_file}"
+          end
+        else
+          unless File.exist?(vol_path)
+            logger.info("creating parent filesystem(size:#{@volume[:size]}): #{vol_path}")
+
+            sh("/bin/mkdir -p #{File.dirname(vol_path)}") unless File.directory?(File.dirname(vol_path))
+            sh("/bin/dd if=/dev/zero of=#{vol_path} bs=1 count=0 seek=#{@volume[:size] * 1024 * 1024}")
+            du_hs(vol_path)
+
+            logger.info("create parent filesystem(size:#{@volume[:size]}): #{vol_path}")
+          else
+            raise "volume already exists: #{@volume_id}"
+          end
+        end
+
+        logger.info("created new volume: #{@volume_id}")
+      end
+
+      def delete_volume(ctx)
+        @volume = ctx.volume
+        sh("/bin/rm %s", [vol_path]) if File.exists?(vol_path)
+      end
+
+      def create_snapshot(ctx, snap_file)
+        @volume      = ctx.volume
+
+        logger.info("creating new snapshot: #{snap_file}")
+        cp_sparse(vol_path, snap_file)
+        if $?.exitstatus != 0
+          raise "failed snapshot file : #{snap_file}"
+        end
+        du_hs(snap_file)
+
+        logger.info("created new snapshot: #{snap_file}")
+      end
+
+      private
+      def vol_path
+        vol_base_path = @volume[:storage_node][:export_path]
+        vol_account_path = "#{vol_base_path}/#{@volume[:account_id]}"
+        "#{vol_account_path}/#{@volume[:uuid]}"
+      end
+
+      def cp_sparse(src, dst)
+        sh("/bin/cp -p --sparse=always %s %s",[src, dst])
+      end
+
+      def du_hs(path)
+        sh("du -hs %s", [path])
+        sh("du -hs --apparent-size %s", [path])
+      end
+
+    end
+  end
+end

data/lib/dcmgr/drivers/s3_storage.rb

@@ -3,36 +3,24 @@
 module Dcmgr::Drivers
   
   class S3Storage < SnapshotStorage
-
     include Dcmgr::Logger
+    include Dcmgr::Helpers::SnapshotStorageHelper
 
-    def download(keyname, filename, path) 
+    def download(filename) 
       cmd = "get %s %s %s" 
-      args = [@bucket, keyname, File.join(path, filename)]
+      args = [@bucket, key(filename), self.snapshot(filename)]
       execute(cmd, args)
     end
 
-    def upload(keyname, file)
+    def upload(filename)
       cmd = "put %s %s %s"
-      args = [@bucket, keyname, file]
+      args = [@bucket, key(filename), self.snapshot(filename)]
       execute(cmd, args)
     end
 
-    def delete(keyname)
+    def delete(filename)
       cmd = "rm %s %s"
-      args = [@bucket, keyname]
-      execute(cmd, args)
-    end
-
-    def check(keyname)
-      cmd = "test %s %s"
-      args = [@bucket, keyname]
-      execute(cmd, args)
-    end
-    
-    def list
-      cmd = "ls %s"
-      args = [@bucket]
+      args = [@bucket, key(filename)]
       execute(cmd, args)
     end
   end

data/lib/dcmgr/drivers/snapshot_storage.rb

@@ -1,51 +1,41 @@
 # -*- coding: utf-8 -*-
 
-require 'rexml/document'
-
 module Dcmgr::Drivers
   class SnapshotStorage
     include Dcmgr::Helpers::CliHelper
- 
-    def initialize(bucket)
+    attr_reader :volume_snaphost_path
+
+    def initialize(account_id, bucket, volume_snaphost_path, options = {})
+      @account_id = account_id
       @env = []
+      @volume_snaphost_path = volume_snaphost_path
       @bucket = bucket
+      @tmp_dir = options[:tmp_dir] || '/var/tmp'
     end
 
     def setenv(key, value)
       @env.push("#{key}=#{value}")
     end
+    
+    def clear
+      sh("/bin/rm #{@temporary_file}") if File.exists?(@temporary_file)
+    end
 
-    def download
+    def snapshot(filename)
+      raise 'filename is empty' if filename == ''
+      @temporary_file = File.join(@tmp_dir, filename)
     end
 
-    def upload
+    def download(filename)
     end
 
-    def delete
+    def upload(filename)
     end
 
-    def check
+    def delete(filename)
     end
-    
-    def execute(cmd, args)
-      script_root_path = File.join(File.expand_path('../../../../',__FILE__), 'script')
-      script = File.join(script_root_path, 'storage_service')
-      cmd = "/usr/bin/env #{@env.join(' ')} %s " + cmd
-      args = [script] + args
-      res = sh(cmd, args)
-      
-      if res[:stdout] != ''
-        doc = REXML::Document.new res[:stdout]
-        code = REXML::XPath.match( doc, "//Error/Code/text()" ).to_s
-        message = REXML::XPath.match( doc, "//Error/Message/text()" ).to_s
-        bucket_name = REXML::XPath.match( doc, "//Error/BucketName/text()" ).to_s
-        request_id = REXML::XPath.match( doc, "//Error/RequestId/text()" ).to_s
-        host_id = REXML::XPath.match( doc, "//Error/HostId/text()" ).to_s
-        error_message = ["Snapshot execute error: ",cmd, code, message, bucket_name, request_id, host_id].join(',')
-        raise error_message
-      else
-        res
-      end
+
+    def check(filename)
     end
   end
 end

data/lib/dcmgr/drivers/storage_initiator.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Drivers
+    # Base class for remote storage initiators: NFS, ISCSI...
+    class StorageInitiator
+      
+      def mount(hva_ctx)
+        raise NotImplementedError
+      end
+      
+      def umount(hva_ctx)
+        raise NotImplementedError
+      end
+      
+    end
+
+
+    class LinuxIscsiInitiator < StorageInitiator
+      def mount(hva_ctx)
+      end
+
+      def umount(hva_ctx, volume)
+        sh("iscsiadm -m node -T '%s' --logout", [volume[:transport_information][:iqn]])
+      end
+    end
+  end
+end

data/lib/dcmgr/drivers/sun_iscsi.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Drivers
+    class SunIscsi < IscsiTarget
+      include Dcmgr::Logger
+      include Dcmgr::Helpers::CliHelper
+
+      def create(ctx)
+        @volume    = ctx.volume
+        @volume_id = ctx.volume_id
+        sh("/usr/sbin/zfs shareiscsi=on %s/%s", [@volume[:storage_node][:export_path], @volume[:uuid]])
+
+        if $?.exitstatus != 0
+          raise "failed iscsi target request: #{@volume_id}"
+        end
+        il = sh("iscsitadm list target -v %s", ["#{@volume[:storage_node][:export_path]}/#{@volume[:uuid]}"])
+        if $?.exitstatus != 0
+          raise "iscsi target has not be created #{@volume_id}"
+        end
+        il = il[:stdout].downcase.split("\n").select {|row| row.strip!}
+        # :transport_information => {:iqn => "iqn.1986-03.com.sun:02:787bca42-9639-44e4-f115-f5b06ed31817", :lun => 0}
+        opt = {:iqn => il[0].split(": ").last, :lun=>il[6].split(": ").last.to_i}
+      end
+
+      def delete(ctx)
+        @volume = ctx.volume
+        sh("/usr/sbin/zfs shareiscsi=off %s/%s", [@volume[:storage_node][:export_path], @volume[:uuid]])
+      end
+    end
+  end
+end

data/lib/dcmgr/drivers/zfs.rb

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+require 'fileutils'
+
+module Dcmgr
+  module Drivers
+    class Zfs < BackingStore
+      include Dcmgr::Logger
+      include Dcmgr::Helpers::CliHelper
+
+      def create_volume(ctx, zsnap_file)
+        @volume_id   = ctx.volume_id
+        @volume      = ctx.volume
+        @snapshot    = ctx.snapshot
+        @destination = ctx.destination
+
+        ### sta_handler :create_volume
+        vol_path = "#{@volume[:storage_node][:export_path]}/#{@volume[:uuid]}"
+        sh("/usr/sbin/zfs list %s", [File.dirname(vol_path)])
+        if $?.exitstatus != 0
+          # create parent filesystem
+          sh("/usr/sbin/zfs create -p %s", [File.dirname(vol_path)])
+          logger.info("create parent filesystem: #{File.dirname(vol_path)}")
+        end
+
+        if @snapshot
+          # create volume from snapshot
+          if File.exists?(zsnap_file)
+            sh("/usr/sbin/zfs receive %s < %s", [vol_path, zsnap_file])
+            if $?.exitstatus != 0
+              raise "volume already exists: #{@volume_id}"
+            end
+          else
+            raise "snapshot file isn't exists: #{zsnap_file}"
+          end
+
+          sh("/usr/sbin/zfs destroy %s@%s", [vol_path, @snapshot[:uuid]])
+          if $?.exitstatus != 0
+            raise "volume snapshot has not deleted: #{@volume_id}@#{@snapshot[:uuid]}"
+          end
+        else
+          # create volume
+          #sh("/usr/sbin/zfs create -p -V %s %s", ["#{@volume[:size]}m", vol_path])
+          # thin provisioning
+          sh("/usr/sbin/zfs create -p -s -V %s %s", ["#{@volume[:size]}m", vol_path])
+          if $?.exitstatus != 0
+            raise "volume already exists: #{@volume_id}"
+          end
+        end
+        
+        sh("/usr/sbin/zfs list %s", [vol_path])
+        if $?.exitstatus != 0
+          raise "volume has not be created: #{@volume_id}"
+        end
+
+        logger.info("created new volume: #{@volume_id}")
+        ### sta_handler :create_volume
+      end
+
+      def delete_volume(ctx)
+        @volume = ctx.volume
+        sh("/usr/sbin/zfs destroy %s", ["#{@volume[:storage_node][:export_path]}/#{@volume[:uuid]}"])
+      end
+
+      def create_snapshot(ctx, zsnap_file)
+        @snapshot_id = ctx.snapshot_id
+        @destination = ctx.destination
+        @snapshot    = ctx.snapshot
+        @volume      = ctx.volume
+
+        vol_path = "#{@volume[:storage_node][:export_path]}/#{@volume[:uuid]}"
+        sh("/usr/sbin/zfs snapshot %s@%s", [vol_path, @snapshot[:uuid]])
+        sh("/usr/sbin/zfs send %s@%s > %s", [vol_path, @snapshot[:uuid], zsnap_file])
+        sh("/usr/sbin/zfs destroy %s@%s", [vol_path, @snapshot[:uuid]])
+      end
+    end
+  end
+end

data/lib/dcmgr/endpoints/core_api.rb

@@ -16,7 +16,7 @@ module Dcmgr
     HTTP_X_VDC_ACCOUNT_UUID='HTTP_X_VDC_ACCOUNT_UUID'.freeze
 
     RACK_FRONTEND_SYSTEM_ID='dcmgr.frotend_system.id'
-    
+
     class CoreAPI < Sinatra::Base
       include Dcmgr::Logger
       register Sinatra::Rabbit
@@ -42,7 +42,7 @@ module Dcmgr
           end
           raise InvalidRequestCredentials if @account.nil?
         end
-         
+
         @requester_token = request.env[HTTP_X_VDC_REQUESTER_TOKEN]
         #@frontend = Models::FrontendSystem[request.env[RACK_FRONTEND_SYSTEM_ID]]
 
@@ -79,6 +79,7 @@ module Dcmgr
           hash = {:dummy=>@params}
         else
           mime = @mime_types.first
+          begin
           case mime.to_s
           when 'application/json', 'text/json'
             require 'json'
@@ -91,6 +92,10 @@ module Dcmgr
           else
             raise "Unsupported body document type: #{mime.to_s}"
           end
+          rescue => e
+            # fall back to query string params
+            hash = {:dummy=>@params}
+          end
         end
         return hash.values.first
       end
@@ -105,7 +110,7 @@ module Dcmgr
           raise NotImplementedError
         else
           content_type 'json'
-          body res.to_json
+          body res.to_json(JSON::PRETTY_STATE_PROTOTYPE)
         end
       end
 
@@ -113,6 +118,14 @@ module Dcmgr
       # when matches the Exception class exactly. I expect to match
       # whole subclasses of APIError so that override handle_exception!().
       def handle_exception!(boom)
+        # Translate common non-APIError to APIError
+        boom = case boom
+               when Sequel::DatabaseError
+                   DatabaseError.new
+               else
+                   boom
+               end
+
         if boom.kind_of?(APIError)
           @env['sinatra.error'] = boom
           Dcmgr::Logger.create('API Error').error("#{request.path_info} -> #{boom.class.to_s}: #{boom.message} (#{boom.backtrace.first})")
@@ -123,14 +136,13 @@ module Dcmgr
         end
       end
 
-      def create_volume_from_snapshot(account_id, snapshot_id)
-        vs = find_by_uuid(:VolumeSnapshot, snapshot_id)
+      def find_volume_snapshot(snapshot_id)
+        vs = Models::VolumeSnapshot[snapshot_id]
         raise UnknownVolumeSnapshot if vs.nil?
         raise InvalidVolumeState unless vs.state.to_s == 'available'
-
-        vs.create_volume(account_id)
+        vs
       end
-        
+
       def examine_owner(account_resource)
         if @account.canonical_uuid == account_resource.account_id ||
             @account.canonical_uuid == 'a-00000000'
@@ -157,7 +169,7 @@ module Dcmgr
         else
           total_ds = model_class.where(:account_id=>@account.canonical_uuid)
         end
-        
+
         if %w(Dcmgr::Models::Instance Dcmgr::Models::Volume Dcmgr::Models::VolumeSnapshot).member?(model_class.to_s)
           total_ds = total_ds.alives_and_recent_termed
         end
@@ -201,83 +213,36 @@ module Dcmgr
           description 'Runs a new VM instance'
           # param :image_id, string, :required
           # param :instance_spec_id, string, :required
-          # param :host_id, string, :optional
-          # param :host_name, string, :optional
+          # param :host_node_id, string, :optional
+          # param :hostname, string, :optional
           # param :user_data, string, :optional
-          # param :nf_group, array, :optional
-          # param :ssh_key, string, :optional
+          # param :security_groups, array, :optional
+          # param :ssh_key_id, string, :optional
           # param :network_id, string, :optional
           # param :ha_enabled, string, :optional
           control do
             Models::Instance.lock!
-            
+
             wmi = Models::Image[params[:image_id]] || raise(InvalidImageID)
             spec = Models::InstanceSpec[params[:instance_spec_id]] || raise(InvalidInstanceSpec)
 
-            # look up params[:host_id] in following order:
-            # 1. assume the host pool name.
-            # 2. assume hp-xxxxx or tag-xxxxx style uuid
-            # 3. assign default shared host pool.
-            params[:host_id] ||= params[:host_pool_id]
-            hostnode = pool = nil
-            if params[:host_id]
-              # TODO: smart way to preload model libs.
-              Models::HostPool; Tags::HostPool;
-              if pool = Tags::HostPool.find(:account_id=>@account.canonical_uuid,
-                                            :name=>params[:host_id])
-                # Pattern 1st
-              elsif hostnode = Models::Taggable.find(params[:host_id])
-                # Pattern 2nd
-                case hostnode
-                when Models::HostPool
-                when Tags::HostPool
-                  hostnode = hostnode.pick(spec)
-                else
-                  raise UnknownHostPool, "Could not find the host: #{params[:host_id]}"
-                end
-              end
-            else
-              # Pattern 3rd
-              pool = Tags::HostPool[Dcmgr.conf.default_shared_host_pool]
-              hostnode = pool.pick(spec)
+            if !Models::HostNode.check_domain_capacity?(spec.cpu_cores, spec.memory_size)
+              raise OutOfHostCapacity
             end
-            raise UnknownHostPool, "Could not find host pool: #{params[:host_id]}" if hostnode.nil?
-            raise OutOfHostCapacity unless hostnode.check_capacity(spec)
-
-            # look up params[:network_id] in following order:
-            # 1. assume the network pool name.
-            # 2. assume nw-xxxxx or tag-xxxxx style uuid
-            # 3. assign default shared network pool.
-            # then randomly choose one network from the pool object.
-            network = pool = nil
-            if params[:network_id]
-              # TODO: smart way to preload model libs.
-              Models::Network; Tags::NetworkPool;
-              if pool = Tags::NetworkPool.find(:account_id=>@account.canonical_uuid,
-                                               :name=>params[:network_id])
-                # Pattern 1st
-                network = pool.pick
-              elsif network = Models::Taggable.find(params[:network_id])
-                # Pattern 2nd
-                case network
-                when Models::Network
-                when Tags::NetworkPool
-                  network = network.pick
-                else
-                  raise "Unknown network uuid: #{params[:network_id]}"
-                end
-              end
-            else
-              # Pattern 3rd
-              pool = Tags::NetworkPool[Dcmgr.conf.default_shared_network_pool]
-              network = pool.pick
+            
+            # TODO:
+            #  "host_id" and "host_pool_id" will be obsolete.
+            #  They are used in lib/dcmgr/scheduler/host_node/specify_node.rb.
+            if params[:host_id] || params[:host_pool_id] || params[:host_node_id]
+              host_node_id = params[:host_id] || params[:host_pool_id] || params[:host_node_id]
+              host_node = Models::HostNode[host_node_id]
+              raise UnknownHostNode, "#{host_node_id}" if host_node.nil?
+              raise InvalidHostNodeID, "#{host_node_id}" if host_node.status != 'online'
             end
-            raise "Can not find the network" if network.nil?
-            raise "Out of IP addresses in the network" unless network.available_ip_nums > 0
 
-            inst = hostnode.create_instance(@account, wmi, spec, network) do |i|
-              # TODO: do not use rand() to decide vnc port.
-              i.runtime_config = {:vnc_port=>rand(2000), :telnet_port=> (rand(2000) + 2000)}
+            # params is a Mash object. so coverts to raw Hash object.
+            instance = Models::Instance.entry_new(@account, wmi, spec, params.to_hash) do |i|
+              # Set common parameters from user's request.
               i.user_data = params[:user_data] || ''
               # set only when not nil as the table column has not null
               # condition.
@@ -290,11 +255,11 @@ module Dcmgr
                 end
               end
 
-              if params[:ssh_key]
-                ssh_key_pair = Models::SshKeyPair.find(:account_id=>@account.canonical_uuid,
-                                                       :name=>params[:ssh_key])
+              if params[:ssh_key_id]
+                ssh_key_pair = Models::SshKeyPair[params[:ssh_key_id]]
+
                 if ssh_key_pair.nil?
-                  raise UnknownSshKeyPair, "#{params[:ssh_key]}"
+                  raise UnknownSshKeyPair, "#{params[:ssh_key_id]}"
                 else
                   i.set_ssh_key_pair(ssh_key_pair)
                 end
@@ -304,31 +269,52 @@ module Dcmgr
                 i.ha_enabled = 1
               end
             end
+            instance.save
 
-            unless params[:nf_group].is_a?(Array)
-              params[:nf_group] = ['default']
+            if params[:nf_group].is_a?(Array) || params[:nf_group].is_a?(String)
+              instance.join_security_group(params[:nf_group])
+            elsif params[:security_groups].is_a?(Array) || params[:security_groups].is_a?(String)
+              instance.join_security_group(params[:security_groups])
             end
-            inst.join_nfgroup_by_name(@account.canonical_uuid, params[:nf_group])
+            
+            instance.state = :scheduling
+            instance.save
 
             case wmi.boot_dev_type
             when Models::Image::BOOT_DEV_SAN
               # create new volume from snapshot.
               snapshot_id = wmi.source[:snapshot_id]
-              vol = create_volume_from_snapshot(@account.canonical_uuid, snapshot_id)
+              vs = find_volume_snapshot(snapshot_id)
 
-              vol.boot_dev = 1
-              vol.instance = inst
+              if !Models::StorageNode.check_domain_capacity?(vs.size)
+                raise OutOfDiskSpace
+              end
+              
+              vol = Models::Volume.entry_new(@account, vs.size, params.to_hash) do |v|
+                if vs
+                  v.snapshot_id = vs.canonical_uuid
+                end
+                v.boot_dev = 1
+              end
+              # assign instance -> volume
+              vol.instance = instance
+              vol.state = :scheduling
               vol.save
-              commit_transaction
-              res = Dcmgr.messaging.submit("kvm-handle.#{hostnode.node_id}", 'run_vol_store', inst.canonical_uuid, vol.canonical_uuid)
+
             when Models::Image::BOOT_DEV_LOCAL
-              commit_transaction
-              res = Dcmgr.messaging.submit("kvm-handle.#{hostnode.node_id}", 'run_local_store', inst.canonical_uuid)
             else
               raise "Unknown boot type"
             end
-            
-            response_to(inst.to_api_document)
+
+            commit_transaction
+            Dcmgr.messaging.submit("scheduler",
+                                   'schedule_instance', instance.canonical_uuid)
+
+            # retrieve latest instance data.
+            # if not, security_groups value is empty.
+            instance = find_by_uuid(:Instance, instance.canonical_uuid)
+
+            response_to(instance.to_api_document)
           end
         end
 
@@ -337,7 +323,7 @@ module Dcmgr
           control do
             i = find_by_uuid(:Instance, params[:id])
             raise UnknownInstance if i.nil?
-            
+
             response_to(i.to_api_document)
           end
         end
@@ -350,7 +336,16 @@ module Dcmgr
             else
               raise OperationNotPermitted
             end
-            res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'terminate', i.canonical_uuid)
+
+            case i.state
+            when 'stopped'
+              # just destroy the record.
+              i.destroy
+            when 'terminated', 'scheduling'
+              raise InvalidInstanceState, i.state
+            else
+              res = Dcmgr.messaging.submit("hva-handle.#{i.host_node.node_id}", 'terminate', i.canonical_uuid)
+            end
             response_to([i.canonical_uuid])
           end
         end
@@ -359,10 +354,42 @@ module Dcmgr
           description 'Reboots the instance'
           control do
             i = find_by_uuid(:Instance, params[:id])
-            Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'reboot', i.canonical_uuid)
+            raise InvalidInstanceState, i.state if i.state != 'running'
+            Dcmgr.messaging.submit("hva-handle.#{i.host_node.node_id}", 'reboot', i.canonical_uuid)
             response_to({})
           end
         end
+
+        operation :stop, :method=>:put, :member=>true do
+          description 'Stop the instance'
+          control do
+            i = find_by_uuid(:Instance, params[:id])
+            raise InvalidInstanceState, i.state if i.state != 'running'
+
+            # relase IpLease from nic.
+            i.nic.each { |nic|
+              nic.release_ip_lease
+            }
+            
+            Dcmgr.messaging.submit("hva-handle.#{i.host_node.node_id}", 'stop', i.canonical_uuid)
+            response_to([i.canonical_uuid])
+          end
+        end
+
+        operation :start, :method=>:put, :member=>true do
+          description 'Restart the instance'
+          control do
+            instance = find_by_uuid(:Instance, params[:id])
+            raise InvalidInstanceState, instance.state if instance.state != 'stopped'
+            instance.state = :scheduling
+            instance.save
+
+            commit_transaction
+            Dcmgr.messaging.submit("scheduler", 'schedule_start_instance', instance.canonical_uuid)
+            response_to([instance.canonical_uuid])
+          end
+        end
+
       end
 
       collection :images do
@@ -400,7 +427,7 @@ module Dcmgr
             Models::Image.lock!
             i = find_by_uuid(:Image, params[:id])
             if examine_owner(i)
-              i.delete
+              i.destroy
             else
               raise OperationNotPermitted
             end
@@ -408,25 +435,28 @@ module Dcmgr
           end
         end
       end
-        
-      collection :host_pools do
-        operation :index do
-          description 'Show list of host pools'
-          control do
-            res = select_index(:HostPool, {:start => params[:start],
-                                 :limit => params[:limit]})
-            response_to(res)
+
+      # obsolute path: "/host_pools"
+      [ :host_pools, :host_nodes ].each do |path|
+        collection path do
+          operation :index do
+            description 'Show list of host pools'
+            control do
+              res = select_index(:HostNode, {:start => params[:start],
+                                   :limit => params[:limit]})
+              response_to(res)
+            end
           end
-        end
 
-        operation :show do
-          description 'Show status of the host'
-          #param :account_id, :string, :optional
-          control do
-            hp = find_by_uuid(:HostPool, params[:id])
-            raise OperationNotPermitted unless examine_owner(hp)
-            
-            response_to(hp.to_api_document)
+          operation :show do
+            description 'Show status of the host'
+            #param :account_id, :string, :optional
+            control do
+              hp = find_by_uuid(:HostNode, params[:id])
+              raise OperationNotPermitted unless examine_owner(hp)
+
+              response_to(hp.to_api_document)
+            end
           end
         end
       end
@@ -434,7 +464,7 @@ module Dcmgr
       collection :volumes do
         operation :index do
           description 'Show lists of the volume'
-          # params start, fixnum, optional 
+          # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
             res = select_index(:Volume, {:start => params[:start],
@@ -461,39 +491,69 @@ module Dcmgr
           # params storage_pool_id, string, optional
           control do
             Models::Volume.lock!
+            sp = vs = vol = nil
+            # input parameter validation
             if params[:snapshot_id]
-              v = create_volume_from_snapshot(@account.canonical_uuid, params[:snapshot_id])
-              sp = v.storage_pool
-              vs = find_by_uuid(:VolumeSnapshot, params[:snapshot_id])
-              repository_address = Dcmgr::StorageService.repository_address(vs.destination_key)
+              vs = find_volume_snapshot(params[:snapshot_id])
             elsif params[:volume_size]
-              if Dcmgr.conf.create_volume_min_size.to_i > params[:volume_size].to_i
-                raise InvalidVolumeSize, "(>#{Dcmgr.conf.create_volume_min_size.to_i})"
-              end
-              if Dcmgr.conf.create_volume_max_size.to_i < params[:volume_size].to_i
-                raise InvalidVolumeSize, "Requested Size is(<#{Dcmgr.conf.create_volume_max_size.to_i})"
+              if !(Dcmgr.conf.create_volume_max_size.to_i >= params[:volume_size].to_i) ||
+                  !(params[:volume_size].to_i >= Dcmgr.conf.create_volume_min_size.to_i)
+                raise InvalidVolumeSize
               end
               if params[:storage_pool_id]
-                sp = find_by_uuid(:StoragePool, params[:storage_pool_id])
-                raise StoragePoolNotPermitted if sp.account_id != @account.canonical_uuid
+                sp = find_by_uuid(:StorageNode, params[:storage_pool_id])
+                raise UnknownStorageNode if sp.nil?
+                raise StorageNodeNotPermitted if sp.account_id != @account.canonical_uuid
               end
-              raise UnknownStoragePool if sp.nil?
+            else
+              raise UndefinedRequiredParameter
+            end
+
+            volume_size = (vs ? vs.size : params[:volume_size].to_i)
+
+            if !Models::StorageNode.check_domain_capacity?(volume_size)
+              raise OutOfDiskSpace
+            end
+
+            # params is a Mash object. so coverts to raw Hash object.
+            vol = Models::Volume.entry_new(@account, volume_size, params.to_hash) do |v|
+              if vs
+                v.snapshot_id = vs.canonical_uuid
+              end
+            end
+            vol.save
+
+            if sp.nil?
+              # going to storage node scheduling mode.
+              vol.state = :scheduling
+              vol.save
+
+              commit_transaction
+
+              Dcmgr.messaging.submit("scheduler", 'schedule_volume', vol.canonical_uuid)
+            else
               begin
-                v = sp.create_volume(@account.canonical_uuid, params[:volume_size])
-              rescue Models::Volume::DiskError => e
+                vol.storage_node = sp
+                vol.save
+              rescue Models::Volume::CapacityError => e
                 logger.error(e)
                 raise OutOfDiskSpace
-              rescue Sequel::DatabaseError => e
-                logger.error(e)
-                raise DatabaseError
               end
-            else
-              raise UndefinedRequiredParameter
+
+              vol.state = :pending
+              vol.save
+
+              commit_transaction
+
+              repository_address = nil
+              if vol.snapshot
+                repository_address = Dcmgr::StorageService.repository_address(vol.snapshot.destination_key)
+              end
+
+              res = Dcmgr.messaging.submit("sta-handle.#{vol.storage_node.node_id}", 'create_volume', vol.canonical_uuid, repository_address)
             end
 
-            commit_transaction
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.values[:node_id]}", 'create_volume', v.canonical_uuid, repository_address)
-            response_to(v.to_api_document)
+            response_to(vol.to_api_document)
           end
         end
 
@@ -503,10 +563,11 @@ module Dcmgr
           control do
             volume_id = params[:id]
             raise UndefinedVolumeID if volume_id.nil?
-            
+
             vol = find_by_uuid(:Volume, volume_id)
             raise UnknownVolume if vol.nil?
-            raise InvalidVolumeState unless vol.state == "available"
+            raise InvalidVolumeState, "#{vol.state}" unless vol.state == "available"
+
 
             begin
               v  = Models::Volume.delete_volume(@account.canonical_uuid, volume_id)
@@ -515,10 +576,9 @@ module Dcmgr
               raise InvalidDeleteRequest
             end
             raise UnknownVolume if v.nil?
-            sp = v.storage_pool
 
             commit_transaction
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.values[:node_id]}", 'delete_volume', v.canonical_uuid)
+            res = Dcmgr.messaging.submit("sta-handle.#{v.storage_node.node_id}", 'delete_volume', v.canonical_uuid)
             response_to([v.canonical_uuid])
           end
         end
@@ -530,7 +590,7 @@ module Dcmgr
           control do
             raise UndefinedInstanceID if params[:instance_id].nil?
             raise UndefinedVolumeID if params[:id].nil?
-            
+
             i = find_by_uuid(:Instance, params[:instance_id])
             raise UnknownInstance if i.nil?
             raise InvalidInstanceState unless i.live? && i.state == 'running'
@@ -542,7 +602,7 @@ module Dcmgr
             v.instance = i
             v.save
             commit_transaction
-            res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'attach', i.canonical_uuid, v.canonical_uuid)
+            res = Dcmgr.messaging.submit("hva-handle.#{i.host_node.node_id}", 'attach', i.canonical_uuid, v.canonical_uuid)
 
             response_to(v.to_api_document)
           end
@@ -562,13 +622,13 @@ module Dcmgr
             i = v.instance
             raise InvalidInstanceState unless i.live? && i.state == 'running'
             commit_transaction
-            res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'detach', i.canonical_uuid, v.canonical_uuid)
+            res = Dcmgr.messaging.submit("hva-handle.#{i.host_node.node_id}", 'detach', i.canonical_uuid, v.canonical_uuid)
             response_to(v.to_api_document)
           end
         end
 
       end
-      
+
       get '/api/volume_snapshots/upload_destination' do
         c = StorageService::snapshot_repository_config.dup
         tmp = c['local']
@@ -580,16 +640,16 @@ module Dcmgr
           }
         }
         results.unshift({
-          :destination_id => 'local', 
+          :destination_id => 'local',
           :destination_name => tmp['display_name']
         })
         response_to([{:results => results}])
       end
-      
+
       collection :volume_snapshots do
         operation :index do
           description 'Show lists of the volume_snapshots'
-          # params start, fixnum, optional 
+          # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
             res = select_index(:VolumeSnapshot, {:start => params[:start],
@@ -612,6 +672,7 @@ module Dcmgr
         operation :create do
           description 'Create a new volume snapshot'
           # params volume_id, string, required
+          # params detination, string, required
           # params storage_pool_id, string, optional
           control do
             Models::Volume.lock!
@@ -621,13 +682,13 @@ module Dcmgr
             raise UnknownVolume if v.nil?
             raise InvalidVolumeState unless v.ready_to_take_snapshot?
             vs = v.create_snapshot(@account.canonical_uuid)
-            sp = vs.storage_pool
+            sp = vs.storage_node
             destination_key = Dcmgr::StorageService.destination_key(@account.canonical_uuid, params[:destination], sp.snapshot_base_path, vs.snapshot_filename)
             vs.update_destination_key(@account.canonical_uuid, destination_key)
             commit_transaction
-            
+
             repository_address = Dcmgr::StorageService.repository_address(destination_key)
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.node_id}", 'create_snapshot', vs.canonical_uuid, repository_address)
+            res = Dcmgr.messaging.submit("sta-handle.#{sp.node_id}", 'create_snapshot', vs.canonical_uuid, repository_address)
             response_to(vs.to_api_document)
           end
         end
@@ -639,13 +700,13 @@ module Dcmgr
             Models::VolumeSnapshot.lock!
             snapshot_id = params[:id]
             raise UndefindVolumeSnapshotID if snapshot_id.nil?
-            
+
             v = find_by_uuid(:VolumeSnapshot, snapshot_id)
             raise UnknownVolumeSnapshot if v.nil?
             raise InvalidVolumeState unless v.state == "available"
-            
+
             destination_key = v.destination_key
-            
+
             begin
               vs  = Models::VolumeSnapshot.delete_snapshot(@account.canonical_uuid, snapshot_id)
             rescue Models::VolumeSnapshot::RequestError => e
@@ -653,32 +714,32 @@ module Dcmgr
               raise InvalidDeleteRequest
             end
             raise UnknownVolumeSnapshot if vs.nil?
-            sp = vs.storage_pool
+            sp = vs.storage_node
 
             commit_transaction
-             
+
             repository_address = Dcmgr::StorageService.repository_address(destination_key)
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.node_id}", 'delete_snapshot', vs.canonical_uuid, repository_address)
+            res = Dcmgr.messaging.submit("sta-handle.#{sp.node_id}", 'delete_snapshot', vs.canonical_uuid, repository_address)
             response_to([vs.canonical_uuid])
           end
         end
 
       end
 
-      collection :netfilter_groups do
-        description 'Show lists of the netfilter_groups'
+      collection :security_groups do
+        description 'Show lists of the security groups'
         operation :index do
           control do
-            res = select_index(:NetfilterGroup, {:start => params[:start],
+            res = select_index(:SecurityGroup, {:start => params[:start],
                                  :limit => params[:limit]})
             response_to(res)
           end
         end
 
         operation :show do
-          description 'Show the netfilter_groups'
+          description 'Show the security group'
           control do
-            g = find_by_uuid(:NetfilterGroup, params[:id])
+            g = find_by_uuid(:SecurityGroup, params[:id])
             raise OperationNotPermitted unless examine_owner(g)
 
             response_to(g.to_api_document)
@@ -686,34 +747,28 @@ module Dcmgr
         end
 
         operation :create do
-          description 'Register a new netfilter_group'
-          # params name, string
+          description 'Register a new security group'
           # params description, string
           # params rule, string
           control do
-            Models::NetfilterGroup.lock!
-            raise UndefinedNetfilterGroup if params[:name].nil?
-
-            @name = params[:name]
-            # TODO: validate @name. @name can use [a-z] [A-Z] '_' '-'
-            # - invalidate? -> raise InvalidCharacterOfNetfilterGroupName
-
-            g = Models::NetfilterGroup.filter(:name => @name, :account_id => @account.canonical_uuid).first
-            raise DuplicatedNetfilterGroup unless g.nil?
+            Models::SecurityGroup.lock!
 
-            g = Models::NetfilterGroup.create_group(@account.canonical_uuid, params)
+            g = Models::SecurityGroup.create(:account_id=>@account.canonical_uuid,
+                                             :description=>params[:description],
+                                             :rule=>params[:rule])
             response_to(g.to_api_document)
           end
         end
 
         operation :update do
-          description "Update parameters for the netfilter group"
+          description "Update parameters for the security group"
           # params description, string
           # params rule, string
           control do
-            g = find_by_uuid(:NetfilterGroup, params[:id])
+            g = find_by_uuid(:SecurityGroup, params[:id])
 
-            raise UnknownNetfilterGroup if g.nil?
+            raise UnknownSecurityGroup if g.nil?
+            raise OperationNotPermitted unless examine_owner(g)
 
             if params[:description]
               g.description = params[:description]
@@ -723,25 +778,22 @@ module Dcmgr
             end
 
             g.save
-            g.rebuild_rule
 
             commit_transaction
-            # refresh netfilter_rules
-            Dcmgr.messaging.event_publish('hva/netfilter_updated', :args=>[g.canonical_uuid])
+            # refresh security group rules on host nodes.
+            Dcmgr.messaging.event_publish('hva/security_group_updated', :args=>[g.canonical_uuid])
 
             response_to(g.to_api_document)
           end
         end
 
         operation :destroy do
-          # params name, string
-          description "Delete the netfilter group"
-
+          description "Delete the security group"
           control do
-            Models::NetfilterGroup.lock!
-            g = find_by_uuid(:NetfilterGroup, params[:id])
+            Models::SecurityGroup.lock!
+            g = find_by_uuid(:SecurityGroup, params[:id])
 
-            raise UnknownNetfilterGroup if g.nil?
+            raise UnknownSecurityGroup if g.nil?
             raise OperationNotPermitted unless examine_owner(g)
 
             # raise OperationNotPermitted if g.instances.size > 0
@@ -758,52 +810,30 @@ module Dcmgr
 
       end
 
-      collection :netfilter_rules do
-        operation :index do
-          control do
-          end
-        end
-
-        operation :show do
-          description 'Show lists of the netfilter_rules'
-          control do
-            rules = []
-            begin
-              @name = params[:id]
-              g = Models::NetfilterGroup.filter(:name => @name, :account_id => @account.canonical_uuid).first
-              raise UnknownNetfilterGroup if g.nil?
-
-              g.netfilter_rules.each { |rule|
-                rules << rule.values
-              }
+      # obsolute path: "/storage_pools"
+      [ :storage_pools, :storage_nodes ].each do |path|
+        collection path do
+          operation :index do
+            description 'Show lists of the storage_pools'
+            # params start, fixnum, optional
+            # params limit, fixnum, optional
+            control do
+              res = select_index(:StorageNode, {:start => params[:start],
+                                   :limit => params[:limit]})
+              response_to(res)
             end
-
-            response_to(rules)
           end
-        end
-      end
 
-      collection :storage_pools do
-        operation :index do
-          description 'Show lists of the storage_pools'
-          # params start, fixnum, optional
-          # params limit, fixnum, optional
-          control do
-            res = select_index(:StoragePool, {:start => params[:start],
-                                 :limit => params[:limit]})
-            response_to(res)
-          end
-        end
-
-        operation :show do
-          description 'Show the storage_pool status'
-          # params id, string, required
-          control do
-            pool_id = params[:id]
-            raise UndefinedStoragePoolID if pool_id.nil?
-            vs = find_by_uuid(:StoragePool, pool_id)
-            raise UnknownStoragePool if vs.nil?
-            response_to(vs.to_api_document)
+          operation :show do
+            description 'Show the storage_pool status'
+            # params id, string, required
+            control do
+              pool_id = params[:id]
+              raise UndefinedStorageNodeID if pool_id.nil?
+              vs = find_by_uuid(:StorageNode, pool_id)
+              raise UnknownStorageNode if vs.nil?
+              response_to(vs.to_api_document)
+            end
           end
         end
       end
@@ -811,7 +841,7 @@ module Dcmgr
       collection :ssh_key_pairs do
         description "List ssh key pairs in account"
         operation :index do
-          # params start, fixnum, optional 
+          # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
             res = select_index(:SshKeyPair, {:start => params[:start],
@@ -819,53 +849,52 @@ module Dcmgr
             response_to(res)
           end
         end
-        
+
         operation :show do
           description "Retrieve details about ssh key pair"
           # params :id required
           # params :format optional [openssh,putty]
           control do
             ssh = find_by_uuid(:SshKeyPair, params[:id])
-            
+
             response_to(ssh.to_api_document)
           end
         end
-        
+
         operation :create do
           description "Create ssh key pair information"
-          # params :name required key name (<100 chars)
           # params :download_once optional set true if you do not want
           #        to save private key info on database.
           control do
             Models::SshKeyPair.lock!
-            keydata = Models::SshKeyPair.generate_key_pair
-            savedata = {
-              :name=>params[:name],
-              :account_id=>@account.canonical_uuid,
-              :public_key=>keydata[:public_key],
-              :finger_print => keydata[:finger_print],
-            }
-            if params[:download_once] != 'true'
-              savedata[:private_key]=keydata[:private_key]
-            end
-            
-            if !Models::SshKeyPair.filter(:account_id=>@account.canonical_uuid,
-                                          :name => params[:name]).empty?
-              raise DuplicateSshKeyName, params[:name]
+            keydata = nil
+
+            ssh = Models::SshKeyPair.entry_new(@account) do |s|
+              keydata = Models::SshKeyPair.generate_key_pair(s.uuid)
+              s.public_key = keydata[:public_key]
+              s.finger_print = keydata[:finger_print]
+
+              if params[:download_once] != 'true'
+                s.private_key = keydata[:private_key]
+              end
+
+              if params[:description]
+                s.description = params[:description]
+              end
             end
-              
+
             begin
-              ssh = Models::SshKeyPair.create(savedata)
+              ssh.save
             rescue => e
               raise DatabaseError, e.message
             end
-                                            
+
             # include private_key data in response even if
             # it's not going to be stored on DB.
             response_to(ssh.to_api_document.merge(:private_key=>keydata[:private_key]))
           end
         end
-        
+
         operation :destroy do
           description "Remove ssh key pair information"
           # params :id required
@@ -877,18 +906,33 @@ module Dcmgr
             else
               raise OperationNotPermitted
             end
-            
+
             response_to([ssh.canonical_uuid])
           end
         end
 
+        operation :update do
+          description "Update ssh key pair information"
+          control do
+            Models::SshKeyPair.lock!
+            ssh = find_by_uuid(:SshKeyPair, params[:id])
+            if examine_owner(ssh)
+              ssh.description = params[:description]
+              ssh.save_changes
+            else
+              raise OperationNotPermitted
+            end
+
+            response_to([ssh.canonical_uuid])
+          end
+        end
       end
 
       collection :networks do
         description "Networks for account"
         operation :index do
           description "List networks in account"
-          # params start, fixnum, optional 
+          # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
             res = select_index(:Network, {:start => params[:start],
@@ -896,18 +940,18 @@ module Dcmgr
             response_to(res)
           end
         end
-        
+
         operation :show do
           description "Retrieve details about a network"
           # params :id required
           control do
             nw = find_by_uuid(:Network, params[:id])
             examine_owner(nw) || raise(OperationNotPermitted)
-            
+
             response_to(nw.to_api_document)
           end
         end
-        
+
         operation :create do
           description "Create new network"
           # params :gw required default gateway address of the network
@@ -923,11 +967,11 @@ module Dcmgr
               :description => params[:description],
             }
             nw = Models::Network.create(savedata)
-                                            
+
             response_to(nw.to_api_document)
           end
         end
-        
+
         operation :destroy do
           description "Remove network information"
           # params :id required
@@ -936,7 +980,7 @@ module Dcmgr
             nw = find_by_uuid(:Network, params[:id])
             examine_owner(nw) || raise(OperationNotPermitted)
             nw.destroy
-            
+
             response_to([nw.canonical_uuid])
           end
         end
@@ -984,7 +1028,7 @@ module Dcmgr
             response_to({})
           end
         end
-        
+
         operation :del_pool, :method=>:put, :member=>true do
           description 'Unlabel network pool name'
           # param :name required
@@ -992,12 +1036,12 @@ module Dcmgr
             Models::Tag.lock!
             nw = find_by_uuid(:Network, params[:id])
             examine_owner(nw) || raise(OperationNotPermitted)
-            
+
             nw.unlabel_tag(:NetworkPool, params[:name], @account.canonical_uuid)
             response_to({})
           end
         end
-        
+
         operation :get_pool, :method=>:get, :member=>true do
           description 'List network pool name'
           # param :name required
@@ -1015,7 +1059,7 @@ module Dcmgr
       collection :instance_specs do
         operation :index do
           description 'Show list of instance template'
-          # params start, fixnum, optional 
+          # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
             res = select_index(:InstanceSpec, {:start => params[:start],
@@ -1023,8 +1067,16 @@ module Dcmgr
             response_to(res)
           end
         end
+
+        operation :show do
+          description "Show the instance template"
+          # params :id required
+          control do
+            inst_spec = find_by_uuid(:InstanceSpec, params[:id])
+            response_to(inst_spec.to_api_document)
+          end
+        end
       end
-      
     end
   end
 end