wakame-vdc-agents 10.12.0 → 11.06.0

data/lib/dcmgr/drivers/s3_storage.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Drivers
+  
+  class S3Storage < SnapshotStorage
+
+    include Dcmgr::Logger
+
+    def download(keyname, filename, path) 
+      cmd = "get %s %s %s" 
+      args = [@bucket, keyname, File.join(path, filename)]
+      execute(cmd, args)
+    end
+
+    def upload(keyname, file)
+      cmd = "put %s %s %s"
+      args = [@bucket, keyname, file]
+      execute(cmd, args)
+    end
+
+    def delete(keyname)
+      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]
+      execute(cmd, args)
+    end
+  end
+end

data/lib/dcmgr/drivers/snapshot_storage.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+require 'rexml/document'
+
+module Dcmgr::Drivers
+  class SnapshotStorage
+    include Dcmgr::Helpers::CliHelper
+ 
+    def initialize(bucket)
+      @env = []
+      @bucket = bucket
+    end
+
+    def setenv(key, value)
+      @env.push("#{key}=#{value}")
+    end
+
+    def download
+    end
+
+    def upload
+    end
+
+    def delete
+    end
+
+    def check
+    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
+    end
+  end
+end

data/lib/dcmgr/endpoints/core_api.rb

@@ -11,25 +11,40 @@ require 'dcmgr/endpoints/errors'
 
 module Dcmgr
   module Endpoints
+    # HTTP Header constants for request credentials.
+    HTTP_X_VDC_REQUESTER_TOKEN='HTTP_X_VDC_REQUESTER_TOKEN'.freeze
+    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
       register Sinatra::SequelTransaction
 
+      use Dcmgr::Rack::RequestLogger
+
       disable :sessions
       disable :show_exceptions
 
-      before do
-        request.env['dcmgr.frotend_system.id'] = 1
-        request.env['HTTP_X_VDC_REQUESTER_TOKEN']='u-xxxxxx'
-        request.env['HTTP_X_VDC_ACCOUNT_UUID']='a-00000000'
-      end
-
       before do
         @params = parsed_request_body if request.post?
-        @account = Models::Account[request.env['HTTP_X_VDC_ACCOUNT_UUID']]
-        @requester_token = request.env['HTTP_X_VDC_REQUESTER_TOKEN']
-        #@frontend = Models::FrontendSystem[request.env['dcmgr.frotend_system.id']]
+        if request.env[HTTP_X_VDC_ACCOUNT_UUID].to_s == ''
+          raise InvalidRequestCredentials
+        else
+          begin
+            # find or create account entry.
+            @account = Models::Account[request.env[HTTP_X_VDC_ACCOUNT_UUID]] || \
+                        Models::Account.create(:uuid=>Models::Account.trim_uuid(request.env[HTTP_X_VDC_ACCOUNT_UUID]))
+          rescue => e
+            logger.error(e)
+            raise InvalidRequestCredentials, "#{e.message}"
+          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]]
 
         #raise InvalidRequestCredentials if !(@account && @frontend)
         raise DisabledAccount if @account.disable?
@@ -85,12 +100,12 @@ module Dcmgr
         case mime.to_s
         when 'application/yaml', 'text/yaml'
           content_type 'yaml'
-          res.to_yaml
+          body res.to_yaml
         when 'application/xml', 'text/xml'
           raise NotImplementedError
         else
           content_type 'json'
-          res.to_json
+          body res.to_json
         end
       end
 
@@ -98,11 +113,12 @@ 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)
-        logger.error(boom)
         if boom.kind_of?(APIError)
           @env['sinatra.error'] = boom
-          error(boom.status_code, boom.class.to_s)
+          Dcmgr::Logger.create('API Error').error("#{request.path_info} -> #{boom.class.to_s}: #{boom.message} (#{boom.backtrace.first})")
+          error(boom.status_code, response_to({:error=>boom.class.to_s, :message=>boom.message, :code=>boom.error_code}))
         else
+          logger.error(boom)
           super
         end
       end
@@ -110,7 +126,8 @@ module Dcmgr
       def create_volume_from_snapshot(account_id, snapshot_id)
         vs = find_by_uuid(:VolumeSnapshot, snapshot_id)
         raise UnknownVolumeSnapshot if vs.nil?
-        raise InvalidRequestCredentials unless vs.state.to_s == 'available'
+        raise InvalidVolumeState unless vs.state.to_s == 'available'
+
         vs.create_volume(account_id)
       end
         
@@ -123,124 +140,48 @@ module Dcmgr
         end
       end
 
-      collection :accounts do
-        operation :index do
-          control do
-          end
-        end
-
-        operation :show do
-          control do
-            a = find_account(params[:id])
-            response_to(a.to_hash)
-          end
-        end
-
-        operation :create do
-          description 'Register a new account'
-          control do
-            a = Models::Account.create()
-            response_to(a.to_hash)
-          end
-        end
-
-        operation :destroy do
-          description 'Unregister the account.'
-          # Associated resources all have to be destroied prior to
-          # removing the account.
-          #param :id, :string, :required
-          control do
-            a = find_account(params[:id])
-            a.destroy
-
-            response_to([a.canonical_uuid])
-          end
-        end
-
-        operation :enable, :method=>:get, :member=>true do
-          description 'Enable the account for all operations'
-          control do
-            a = find_account(params[:id])
-            a.enabled = Models::Account::ENABLED
-            a.save
-
-            respond_to { |f|
-              f.json { {} }
-            }
-          end
-        end
-
-        operation :disable, :method=>:get, :member=>true do
-          description 'Disable the account for all operations'
-          control do
-            a = find_account(params[:id])
-            a.enabled = Models::Account::DISABLED
-            a.save
-
-            respond_to { |f|
-              f.json { {} }
-            }
-          end
+      def select_index(model_class, data)
+        if model_class.is_a?(Symbol)
+          model_class = Models.const_get(model_class)
         end
 
-        operation :add_tag, :method=>:get, :member=>true do
-          description 'Add a tag belongs to the account'
-          #param :tag_name, :string, :required
-          control do
-            a = find_account(params[:id])
-
-            tag_class = Models::Tags.find_tag_class(params[:tag_name])
-            raise "UnknownTagClass: #{params[:tag_name]}" if tag_class.nil?
+        start = data[:start].to_i
+        start = start < 1 ? 0 : start
+        limit = data[:limit].to_i
+        limit = limit < 1 ? nil : limit
 
-            a.add_tag(tag_class.new(:name=>params[:name]))
-          end
+        if %w(Dcmgr::Models::InstanceSpec).member?(model_class.to_s)
+          total_ds = model_class.where(:account_id=>[@account.canonical_uuid,
+                                                              Models::Account::SystemAccount::SharedPoolAccount.uuid,
+                                                             ])
+        else
+          total_ds = model_class.where(:account_id=>@account.canonical_uuid)
         end
-
-        operation :remove_tag, :method=>:get, :member=>true do
-          description 'Unlink the associated tag of the account'
-          #param :tag_id, :string, :required
-          control do
-            a = find_account(params[:id])
-            t = a.tags_dataset.filter(:uuid=>params[:tag_id]).first
-            if t
-              a.remove_tag(t)
-            else
-              raise "Unknown or disassociated tag for #{a.cuuid}: #{params[:tag_id]}"
-            end
-          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
-      end
-
-      collection :tags do
-        operation :create do
-          description 'Register new tag to the account'
-          #param :tag_name, :string, :required
-          #param :type_id, :fixnum, :optional
-          #param :account_id, :string, :optional
-          control do
-            tag_class = Models::Tag.find_tag_class(params[:tag_name])
-
-            tag_class.create
-
-          end
+        if %w(Dcmgr::Models::Image).member?(model_class.to_s)
+          total_ds = total_ds.or(:is_public=>true)
         end
 
-        operation :show do
-          #param :account_id, :string, :optional
-          control do
-          end
-        end
+        partial_ds  = total_ds.dup.order(:id.desc)
+        partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
 
-        operation :destroy do
-          description 'Create a new user'
-          control do
-          end
-        end
-
-        operation :update do
-          control do
+        results = partial_ds.all.map {|i|
+          if %w(Dcmgr::Models::Image).member?(model_class.to_s)
+            i.to_api_document(@account.canonical_uuid)
+          else
+            i.to_api_document
           end
-        end
+        }
+
+        res = [{
+                 :owner_total => total_ds.count,
+                 :start => start,
+                 :limit => limit,
+                 :results=> results
+               }]
       end
 
       # Endpoint to handle VM instance.
@@ -250,22 +191,8 @@ module Dcmgr
           # params start, fixnum, optional 
           # params limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-            
-            total_ds = Models::Instance.where(:account_id=>@account.canonical_uuid)
-            partial_ds  = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|i| i.to_api_document }
-            }]
-            
+            res = select_index(:Instance, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -284,8 +211,8 @@ module Dcmgr
           control do
             Models::Instance.lock!
             
-            wmi = find_by_uuid(:Image, params[:image_id])
-            spec = find_by_uuid(:InstanceSpec, (params[:instance_spec_id] || 'is-kpf0pasc'))
+            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.
@@ -369,7 +296,7 @@ module Dcmgr
                 if ssh_key_pair.nil?
                   raise UnknownSshKeyPair, "#{params[:ssh_key]}"
                 else
-                  i.ssh_key_pair_id = ssh_key_pair.canonical_uuid
+                  i.set_ssh_key_pair(ssh_key_pair)
                 end
               end
 
@@ -392,8 +319,10 @@ module Dcmgr
               vol.boot_dev = 1
               vol.instance = inst
               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"
@@ -416,7 +345,6 @@ module Dcmgr
         operation :destroy do
           description 'Shutdown the instance'
           control do
-            Models::Instance.lock!
             i = find_by_uuid(:Instance, params[:id])
             if examine_owner(i)
             else
@@ -430,8 +358,9 @@ module Dcmgr
         operation :reboot, :method=>:put, :member=>true do
           description 'Reboots the instance'
           control do
-            Models::Instance.lock!
             i = find_by_uuid(:Instance, params[:id])
+            Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'reboot', i.canonical_uuid)
+            response_to({})
           end
         end
       end
@@ -448,22 +377,8 @@ module Dcmgr
         operation :index do
           description 'Show list of machine images'
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-            
-            total_ds = Models::Image.where(:account_id=>@account.canonical_uuid)
-            partial_ds  = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|i| i.to_hash }
-            }]
-            
+            res = select_index(:Image, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -472,11 +387,10 @@ module Dcmgr
           description "Show a machine image details."
           control do
             i = find_by_uuid(:Image, params[:id])
-            # TODO: add visibility by account check
-            unless examine_owner(i)
+            if !(examine_owner(i) || i.is_public)
               raise OperationNotPermitted
             end
-            response_to(i.to_hash)
+            response_to(i.to_api_document(@account.canonical_uuid))
           end
         end
 
@@ -499,22 +413,8 @@ module Dcmgr
         operation :index do
           description 'Show list of host pools'
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-            
-            total_ds = Models::HostPool.where(:account_id=>@account.canonical_uuid)
-            partial_ds  = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|i| i.to_hash }
-            }]
-            
+            res = select_index(:HostPool, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -526,7 +426,7 @@ module Dcmgr
             hp = find_by_uuid(:HostPool, params[:id])
             raise OperationNotPermitted unless examine_owner(hp)
             
-            response_to(hp.to_hash)
+            response_to(hp.to_api_document)
           end
         end
       end
@@ -537,20 +437,8 @@ module Dcmgr
           # params start, fixnum, optional 
           # params limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-
-            total_v = Models::Volume.where(:account_id => @account.canonical_uuid)
-            partial_v = total_v.dup.order(:id)
-            partial_v = partial_v.limit(limit, start) if limit.is_a?(Integer)
-            res = [{
-              :owner_total => total_v.count,
-              :start => start,
-              :limit => limit,
-              :results => partial_v.all.map { |v| v.to_api_document}
-            }]
+            res = select_index(:Volume, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -576,10 +464,14 @@ module Dcmgr
             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)
             elsif params[:volume_size]
-              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
+              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})"
               end
               if params[:storage_pool_id]
                 sp = find_by_uuid(:StoragePool, params[:storage_pool_id])
@@ -599,7 +491,8 @@ module Dcmgr
               raise UndefinedRequiredParameter
             end
 
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.values[:node_id]}", 'create_volume', v.canonical_uuid)
+            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)
           end
         end
@@ -608,9 +501,12 @@ module Dcmgr
           description 'Delete the volume'
           # params id, string, required
           control do
-            Models::Volume.lock!
             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"
 
             begin
               v  = Models::Volume.delete_volume(@account.canonical_uuid, volume_id)
@@ -621,6 +517,7 @@ module Dcmgr
             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)
             response_to([v.canonical_uuid])
           end
@@ -644,6 +541,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)
 
             response_to(v.to_api_document)
@@ -663,46 +561,39 @@ module Dcmgr
             raise DetachVolumeFailure, "boot device can not be detached" if v.boot_dev == 1
             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)
             response_to(v.to_api_document)
           end
         end
 
-        operation :status, :method =>:get, :member =>true do
-          description 'Show the status'
-          control do
-            vl = [{ :id => 1, :uuid => 'vol-xxxxxxx', :status => 1 },
-                  { :id => 2, :uuid => 'vol-xxxxxxx', :status => 0 },
-                  { :id => 3, :uuid => 'vol-xxxxxxx', :status => 3 },
-                  { :id => 4, :uuid => 'vol-xxxxxxx', :status => 2 },
-                  { :id => 5, :uuid => 'vol-xxxxxxx', :status => 4 }]
-            respond_to {|f|
-              f.json { vl.to_json}
-            }
-          end
-        end
       end
-
+      
+      get '/api/volume_snapshots/upload_destination' do
+        c = StorageService::snapshot_repository_config.dup
+        tmp = c['local']
+        c.delete('local')
+        results = {}
+        results = c.collect {|item| {
+          :destination_id => item[0],
+          :destination_name => item[1]["display_name"]
+          }
+        }
+        results.unshift({
+          :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 limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-
-            total_vs = Models::VolumeSnapshot.where(:account_id => @account.canonical_uuid)
-            partial_vs = total_vs.dup.order(:id)
-            partial_vs = partial_vs.limit(limit, start) if limit.is_a?(Integer)
-            res = [{
-              :owner_total => total_vs.count,
-              :start => start,
-              :limit => limit,
-              :results => partial_vs.all.map { |vs| vs.to_api_document}
-            }]
+            res = select_index(:VolumeSnapshot, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -728,12 +619,15 @@ module Dcmgr
 
             v = find_by_uuid(:Volume, params[:volume_id])
             raise UnknownVolume if v.nil?
-            raise InvalidRequestCredentials unless v.state == "available"
-
+            raise InvalidVolumeState unless v.ready_to_take_snapshot?
             vs = v.create_snapshot(@account.canonical_uuid)
             sp = vs.storage_pool
-
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.node_id}", 'create_snapshot', vs.canonical_uuid)
+            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)
             response_to(vs.to_api_document)
           end
         end
@@ -745,7 +639,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
@@ -755,46 +655,22 @@ module Dcmgr
             raise UnknownVolumeSnapshot if vs.nil?
             sp = vs.storage_pool
 
-            res = Dcmgr.messaging.submit("zfs-handle.#{sp.node_id}", 'delete_snapshot', vs.canonical_uuid)
+            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)
             response_to([vs.canonical_uuid])
           end
         end
 
-        operation :status, :method =>:get, :member =>true do
-          description 'Show the status'
-          control do
-            vs = [{ :id => 1, :uuid => 'snap-xxxxxxx', :status => 1 },
-                  { :id => 2, :uuid => 'snap-xxxxxxx', :status => 0 },
-                  { :id => 3, :uuid => 'snap-xxxxxxx', :status => 3 },
-                  { :id => 4, :uuid => 'snap-xxxxxxx', :status => 2 },
-                  { :id => 5, :uuid => 'snap-xxxxxxx', :status => 4 }]
-            respond_to {|f|
-              f.json { vs.to_json}
-            }
-          end
-        end
       end
 
       collection :netfilter_groups do
         description 'Show lists of the netfilter_groups'
         operation :index do
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-
-            total_ds = Models::NetfilterGroup.where(:account_id=>@account.canonical_uuid)
-            partial_ds = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-            
-            res = [{
-                     :owner_total => total_ds.count,
-                     :start => start,
-                     :limit => limit,
-                     :results=> partial_ds.all.map {|i| i.to_hash }
-                   }]
-            
+            res = select_index(:NetfilterGroup, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -805,7 +681,7 @@ module Dcmgr
             g = find_by_uuid(:NetfilterGroup, params[:id])
             raise OperationNotPermitted unless examine_owner(g)
 
-            response_to(g.to_hash)
+            response_to(g.to_api_document)
           end
         end
 
@@ -826,7 +702,7 @@ module Dcmgr
             raise DuplicatedNetfilterGroup unless g.nil?
 
             g = Models::NetfilterGroup.create_group(@account.canonical_uuid, params)
-            response_to(g.to_hash)
+            response_to(g.to_api_document)
           end
         end
 
@@ -849,10 +725,11 @@ module Dcmgr
             g.save
             g.rebuild_rule
 
+            commit_transaction
             # refresh netfilter_rules
             Dcmgr.messaging.event_publish('hva/netfilter_updated', :args=>[g.canonical_uuid])
 
-            response_to(g.to_hash)
+            response_to(g.to_api_document)
           end
         end
 
@@ -865,9 +742,16 @@ module Dcmgr
             g = find_by_uuid(:NetfilterGroup, params[:id])
 
             raise UnknownNetfilterGroup if g.nil?
-            raise NetfilterGroupNotPermitted if g.account_id != @account.canonical_uuid
+            raise OperationNotPermitted unless examine_owner(g)
+
+            # raise OperationNotPermitted if g.instances.size > 0
+            begin
+              g.destroy
+            rescue => e
+              # logger.error(e)
+              raise OperationNotPermitted
+            end
 
-            g.destroy
             response_to([g.canonical_uuid])
           end
         end
@@ -905,22 +789,8 @@ module Dcmgr
           # params start, fixnum, optional
           # params limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-
-            total_ds = Models::StoragePool.where(:account_id=>@account.canonical_uuid)
-            partial_ds = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|sp| sp.to_hash }
-            }]
-
+            res = select_index(:StoragePool, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -933,7 +803,7 @@ module Dcmgr
             raise UndefinedStoragePoolID if pool_id.nil?
             vs = find_by_uuid(:StoragePool, pool_id)
             raise UnknownStoragePool if vs.nil?
-            response_to(vs.to_hash)
+            response_to(vs.to_api_document)
           end
         end
       end
@@ -944,23 +814,8 @@ module Dcmgr
           # params start, fixnum, optional 
           # params limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-            
-            total_ds = Models::SshKeyPair.where(:account_id=>@account.canonical_uuid)
-            partial_ds = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :filter_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|i| i.to_hash }
-            }]
-            
+            res = select_index(:SshKeyPair, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -972,7 +827,7 @@ module Dcmgr
           control do
             ssh = find_by_uuid(:SshKeyPair, params[:id])
             
-            response_to(ssh.to_hash)
+            response_to(ssh.to_api_document)
           end
         end
         
@@ -987,16 +842,27 @@ module Dcmgr
             savedata = {
               :name=>params[:name],
               :account_id=>@account.canonical_uuid,
-              :public_key=>keydata[:public_key]
+              :public_key=>keydata[:public_key],
+              :finger_print => keydata[:finger_print],
             }
             if params[:download_once] != 'true'
               savedata[:private_key]=keydata[:private_key]
             end
-            ssh = Models::SshKeyPair.create(savedata)
+            
+            if !Models::SshKeyPair.filter(:account_id=>@account.canonical_uuid,
+                                          :name => params[:name]).empty?
+              raise DuplicateSshKeyName, params[:name]
+            end
+              
+            begin
+              ssh = Models::SshKeyPair.create(savedata)
+            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_hash.merge(:private_key=>keydata[:private_key]))
+            response_to(ssh.to_api_document.merge(:private_key=>keydata[:private_key]))
           end
         end
         
@@ -1025,23 +891,8 @@ module Dcmgr
           # params start, fixnum, optional 
           # params limit, fixnum, optional
           control do
-            start = params[:start].to_i
-            start = start < 1 ? 0 : start
-            limit = params[:limit].to_i
-            limit = limit < 1 ? nil : limit
-            
-            total_ds = Models::Network.where(:account_id=>@account.canonical_uuid)
-            partial_ds = total_ds.dup.order(:id)
-            partial_ds = partial_ds.limit(limit, start) if limit.is_a?(Integer)
-
-            res = [{
-              :owner_total => total_ds.count,
-              :filter_total => total_ds.count,
-              :start => start,
-              :limit => limit,
-              :results=> partial_ds.all.map {|i| i.to_hash }
-            }]
-            
+            res = select_index(:Network, {:start => params[:start],
+                                 :limit => params[:limit]})
             response_to(res)
           end
         end
@@ -1053,7 +904,7 @@ module Dcmgr
             nw = find_by_uuid(:Network, params[:id])
             examine_owner(nw) || raise(OperationNotPermitted)
             
-            response_to(nw.to_hash)
+            response_to(nw.to_api_document)
           end
         end
         
@@ -1073,7 +924,7 @@ module Dcmgr
             }
             nw = Models::Network.create(savedata)
                                             
-            response_to(nw.to_hash)
+            response_to(nw.to_api_document)
           end
         end
         
@@ -1160,6 +1011,19 @@ module Dcmgr
            end
          end
       end
+
+      collection :instance_specs do
+        operation :index do
+          description 'Show list of instance template'
+          # params start, fixnum, optional 
+          # params limit, fixnum, optional
+          control do
+            res = select_index(:InstanceSpec, {:start => params[:start],
+                                 :limit => params[:limit]})
+            response_to(res)
+          end
+        end
+      end
       
     end
   end