wakame-vdc-agents 10.11.0 → 10.12.0

data/bin/nsa

@@ -14,7 +14,7 @@ end
 
 require File.expand_path('../../config/path_resolver', __FILE__)
 
-
+require 'erb'
 require 'eventmachine'
 
 class SuperviseDnsmasq < Isono::NodeModules::Base
@@ -29,8 +29,22 @@ class SuperviseDnsmasq < Isono::NodeModules::Base
     if manifest.config.network_name.nil?
       abort("network_name is not set yet in nsa.conf")
     end
+
+    # check the dnsmasq binary version
+    @conf_ver_253 = false
+    if `#{manifest.config.dnsmasq_bin_path} -version`.split("\n").first =~ /Dnsmasq version ([\d\.]+)/
+      verstr = $1.split('.')
+      if verstr[0].to_i == 2 && verstr[1].to_i >= 53
+        @conf_ver_253 = true
+      end
+      logger.info("Using dnsmasq v#{verstr}: configuration version #{@conf_ver_253 ? '>= 2.53' : '< 2.53'}")
+    else
+      logger.warn("Failed to detect dnsmasq binary version")
+    end
+    
     
-    opts = sprintf("-k --no-hosts --no-resolv --addn-hosts=%s --dhcp-hostsfile=%s --conf-file=%s",
+    opts = sprintf("-k --no-hosts --no-resolv --leasefile-ro --dhcp-leasefile=/dev/null " +
+                   "--addn-hosts=%s --dhcp-hostsfile=%s --conf-file=%s",
                    config_section.dhcp_hosts_conf + ".hosts",
                    config_section.dhcp_hosts_conf + ".dhcp",
                    config_section.dhcp_hosts_conf
@@ -85,42 +99,58 @@ class SuperviseDnsmasq < Isono::NodeModules::Base
     # load entier macaddr,ipaddr pairs for all instances from collector.
     confdata = rpc.request('hva-collector', 'get_dhcp_conf', manifest.config.network_name)
 
-    require 'erb'
-    
-    File.open(config_section.dhcp_hosts_conf, 'w') { |f|
-      f << ERB.new(<<'_EOS_', nil, '-').result(binding)
-#interface=eth0
+      render_conf(config_section.dhcp_hosts_conf, binding, <<'_EOS_') 
 server=8.8.8.8
-dhcp-range=<%= confdata[:ipv4_gw] %>,static,<%= confdata[:netmask] %>
-dhcp-option=option:netmask,<%= confdata[:netmask] %>
-dhcp-option=option:router,<%= confdata[:ipv4_gw] %>
-dhcp-option=option:dns-server,<%= confdata[:dns_server] %>
-dhcp-option=option:domain-name,<%= confdata[:domain_name] %>
-#dhcp-option=option:domain-search,<%= confdata[:domain_name] %>
-<%- confdata[:mac2addr].each { |i| -%>
-#dhcp-host=<%= i[:mac_addr] %>,<%= i[:ipaddr] %>
+log-facility=/var/log/dnsmasq.log
+#log-queries
+log-dhcp
+<%- confdata.each { |nwid, v| -%>
+<%- if @conf_ver_253 -%>
+dhcp-range=set:<%= nwid %>,<%= v[:ipv4_first] %>,static,<%= v[:netmask] %>
+dhcp-option=tag:<%= nwid %>,option:netmask,<%= v[:netmask] %>
+dhcp-option=tag:<%= nwid %>,option:router,<%= v[:ipv4_gw] %>
+dhcp-option=tag:<%= nwid %>,option:dns-server,<%= v[:dns_server] %>
+dhcp-option=tag:<%= nwid %>,option:domain-name,<%= v[:domain_name] %>
+#dhcp-option=tag:<%= nwid %>,option:domain-search,<%= v[:domain_name] %>
+<%- else # if @conf_ver_253 -%>
+dhcp-range=net:<%= nwid %>,<%= v[:ipv4_first] %>,static,<%= v[:netmask] %>
+dhcp-option=<%= nwid %>,option:netmask,<%= v[:netmask] %>
+dhcp-option=<%= nwid %>,option:router,<%= v[:ipv4_gw] %>
+dhcp-option=<%= nwid %>,option:dns-server,<%= v[:dns_server] %>
+dhcp-option=<%= nwid %>,option:domain-name,<%= v[:domain_name] %>
+#dhcp-option=<%= nwid %>,option:domain-search,<%= v[:domain_name] %>
+<%- end # if @conf_ver_253 -%>
+<%- v[:mac2addr].each { |i| -%>
+#dhcp-host=<%= i[:mac_addr] %>,net:<%= nwid %>,<%= i[:ipaddr] %>
 <%- } -%>
-<%- confdata[:addr2host].each { |i| -%>
+<%- v[:addr2host].each { |i| -%>
 #address=/<%= i[:hostname] %>/<%= i[:ipaddr] %>
 <%- } -%>
+<%- } -%>
 _EOS_
-    }
 
-    File.open(config_section.dhcp_hosts_conf + ".dhcp", 'w') { |f|
-      f << ERB.new(<<'_EOS_', nil, '-').result(binding)
-<%- confdata[:mac2addr].each { |i| -%>
-<%= i[:mac_addr] %>,<%= i[:ipaddr] %>
+    render_conf(config_section.dhcp_hosts_conf + ".dhcp", binding, <<'_EOS_') 
+<%- confdata.each { |nwid, v| -%>
+<%-   v[:mac2addr].each { |i| -%>
+<%= i[:mac_addr] %>,net:<%= nwid %>,<%= i[:ipaddr] %>,infinite
+<%-   } -%>
 <%- } -%>
 _EOS_
-    }    
 
-    File.open(config_section.dhcp_hosts_conf + ".hosts", 'w') { |f|
-      f << ERB.new(<<'_EOS_', nil, '-').result(binding)
-<%- confdata[:addr2host].each { |i| -%>
+    render_conf(config_section.dhcp_hosts_conf + ".hosts", binding, <<'_EOS_')
+<%- confdata.each { |nwid, v| -%>
+<%-   v[:addr2host].each { |i| -%>
 <%= i[:ipaddr] %>  <%= i[:hostname] %>
+<%-   } -%>
 <%- } -%>
 _EOS_
-    }    
+  end
+
+  private
+  def render_conf(file, bind, templ)
+    File.open(file, 'w') { |f|
+      f << ERB.new(templ, nil, '-').result(bind)
+    }
   end
 end
 

data/bin/sta

@@ -19,9 +19,13 @@ class ZfsHandler < EndpointBuilder
     volume_id = request.args[0]
     job = Dcmgr::Stm::VolumeContext.new(volume_id)
     data = rpc.request('sta-collector', 'get_volume', volume_id)
-    sdata = rpc.request('sta-collector', 'get_snapshot', data[:snapshot_id]) unless data[:snapshot_id].nil?
-    logger.info("creating new volume #{volume_id}")
     raise "Invalid volume state: #{data[:state]}" unless data[:state].to_s == 'registering'
+
+    unless data[:snapshot_id].nil?
+      sdata = rpc.request('sta-collector', 'get_snapshot', data[:snapshot_id])
+      raise "Invalid snapshot state: #{sdata[:state]}" unless sdata[:state].to_s == 'available'
+    end
+    logger.info("creating new volume #{volume_id}")
     job.stm.state=data[:state].to_sym
     job.stm.on_create
 
@@ -119,6 +123,7 @@ class ZfsHandler < EndpointBuilder
     sdata = rpc.request('sta-collector', 'get_snapshot', snapshot_id) unless snapshot_id.nil?
     data = rpc.request('sta-collector', 'get_volume', sdata[:origin_volume_id])
     logger.info("create new snapshot: #{snapshot_id}")
+    raise "Invalid volume state: #{data[:state]}" unless data[:state].to_s == 'available'
     job.stm.state=sdata[:state].to_sym
     job.stm.on_create
 
@@ -144,14 +149,16 @@ class ZfsHandler < EndpointBuilder
   job :delete_snapshot do
     snapshot_id = request.args[0]
     job = Dcmgr::Stm::SnapshotContext.new(snapshot_id)
-    sdata = rpc.request('sta-collector', 'get_snapshot', snapshot_id) unless snapshot_id.nil?
+    sdata = rpc.request('sta-collector', 'get_snapshot', snapshot_id)
     data = rpc.request('sta-collector', 'get_volume', sdata[:origin_volume_id])
     logger.info("deleting snapshot: #{snapshot_id}")
     raise "Invalid snapshot state: #{sdata[:state]}" unless sdata[:state].to_s == 'deleting'
     job.stm.state=sdata[:state].to_sym
     job.stm.on_delete
 
-    snap_delete = `rm -rf #{data[:storage_pool][:snapshot_base_path]}/#{sdata[:account_id]}/#{sdata[:uuid]}.zsnap`
+    system("rm -rf #{data[:storage_pool][:snapshot_base_path]}/#{sdata[:account_id]}/#{sdata[:uuid]}.zsnap")
+    raise "snapshot has not be deleted" if $?.exitstatus != 0
+
     rpc.request('sta-collector', 'update_snapshot', job.to_hash)
     logger.info("deleted snapshot: #{snapshot_id}")
   end

data/config/hva.conf.example

@@ -8,3 +8,12 @@ config.vm_data_dir = "/home/demo/vm"
 # netfilter
 config.enable_ebtables = true
 config.enable_iptables = true
+
+# physical nic index
+config.hv_ifindex      = 2 # ex. /sys/class/net/eth0/ifindex => 2
+
+# bridge device name prefix
+config.bridge_prefix   = 'br'
+
+# bridge device name novlan
+config.bridge_novlan   = 'br0'

data/config/nsa.conf.example

@@ -5,5 +5,5 @@
 # path for dnsmaq binary
 config.dnsmasq_bin_path='/usr/sbin/dnsmasq'
 
-# network name to distribute dhcp/dns managed by this nsa
-config.network_name='network1'
+# UUID of Network or NetworkPool to be delivered DHCP.
+config.network_name='tag-xxxxxx'

data/lib/dcmgr.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 module Dcmgr
-  VERSION='10.11.0'
+  VERSION='10.12.0'
 
   class << self
     def conf
@@ -73,7 +73,9 @@ module Dcmgr
                           :StoragePool,:Volume,:VolumeSnapshot,
                           :InstanceNetfilterGroup,
                           :InstanceSpec, :InstanceNic, :Network, :IpLease,
-                          :SshKeyPair].freeze
+                          :SshKeyPair, :History, :HostnameLease, :MacLease,
+                          :VlanLease,
+                         ].freeze
     autoload :BaseNew, 'dcmgr/models/base_new'
     autoload :Account, 'dcmgr/models/account'
     autoload :Tag, 'dcmgr/models/tag'
@@ -95,6 +97,10 @@ module Dcmgr
     autoload :IpLease, 'dcmgr/models/ip_lease'
     autoload :InstanceNetfilterGroup, 'dcmgr/models/instance_netfilter_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'
   end
 
   module Endpoints
@@ -105,6 +111,7 @@ module Dcmgr
   module NodeModules
     autoload :StaCollector, 'dcmgr/node_modules/sta_collector'
     autoload :HvaCollector, 'dcmgr/node_modules/hva_collector'
+    autoload :InstanceHA, 'dcmgr/node_modules/instance_ha'
   end
 
   module Stm
@@ -112,4 +119,10 @@ module Dcmgr
     autoload :SnapshotContext, 'dcmgr/stm/snapshot_context'
     autoload :Instance, 'dcmgr/stm/instance'
   end
+
+  module Helpers
+    autoload :CliHelper, 'dcmgr/helpers/cli_helper'
+  end
+
+  autoload :Tags, 'dcmgr/tags'
 end

data/lib/dcmgr/endpoints/core_api.rb

@@ -110,6 +110,7 @@ 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'
         vs.create_volume(account_id)
       end
         
@@ -131,9 +132,7 @@ module Dcmgr
         operation :show do
           control do
             a = find_account(params[:id])
-            respond_to { |f|
-              f.json { a.to_hash_document.to_json }
-            }
+            response_to(a.to_hash)
           end
         end
 
@@ -141,9 +140,7 @@ module Dcmgr
           description 'Register a new account'
           control do
             a = Models::Account.create()
-            respond_to { |f|
-              f.json { a.to_hash_document.to_json }
-            }
+            response_to(a.to_hash)
           end
         end
 
@@ -156,9 +153,7 @@ module Dcmgr
             a = find_account(params[:id])
             a.destroy
 
-            respond_to { |f|
-              f.json { {} }
-            }
+            response_to([a.canonical_uuid])
           end
         end
 
@@ -271,9 +266,7 @@ module Dcmgr
               :results=> partial_ds.all.map {|i| i.to_api_document }
             }]
             
-            respond_to { |f|
-              f.json {res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -281,30 +274,94 @@ module Dcmgr
           description 'Runs a new VM instance'
           # param :image_id, string, :required
           # param :instance_spec_id, string, :required
-          # param :host_pool_id, string, :optional
+          # param :host_id, string, :optional
           # param :host_name, string, :optional
           # param :user_data, string, :optional
           # param :nf_group, array, :optional
           # param :ssh_key, string, :optional
+          # param :network_id, string, :optional
+          # param :ha_enabled, string, :optional
           control do
             Models::Instance.lock!
             
             wmi = find_by_uuid(:Image, params[:image_id])
             spec = find_by_uuid(:InstanceSpec, (params[:instance_spec_id] || 'is-kpf0pasc'))
 
-            if params[:host_pool_id]
-              hp = Models::HostPool[params[:host_pool_id]]
-              raise OutOfHostCapacity unless hp.check_capacity(spec)
+            # 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
-              # TODO: schedule a host pool owned by SharedPool account.
+              # Pattern 3rd
+              pool = Tags::HostPool[Dcmgr.conf.default_shared_host_pool]
+              hostnode = pool.pick(spec)
             end
-            
-            raise UnknownHostPool, "Could not find host pool: #{params[:host_pool_id]}" if hp.nil?
+            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
+            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 = hp.create_instance(@account, wmi, spec) do |i|
+            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)}
               i.user_data = params[:user_data] || ''
+              # set only when not nil as the table column has not null
+              # condition.
+              if params[:hostname]
+                if Models::Instance::ValidationMethods.hostname_uniqueness(@account.canonical_uuid,
+                                                                           params[:hostname])
+                  i.hostname = params[:hostname]
+                else
+                  raise DuplicateHostname
+                end
+              end
 
               if params[:ssh_key]
                 ssh_key_pair = Models::SshKeyPair.find(:account_id=>@account.canonical_uuid,
@@ -315,6 +372,10 @@ module Dcmgr
                   i.ssh_key_pair_id = ssh_key_pair.canonical_uuid
                 end
               end
+
+              if params[:ha_enabled] == 'true'
+                i.ha_enabled = 1
+              end
             end
 
             unless params[:nf_group].is_a?(Array)
@@ -328,17 +389,17 @@ module Dcmgr
               snapshot_id = wmi.source[:snapshot_id]
               vol = create_volume_from_snapshot(@account.canonical_uuid, snapshot_id)
 
+              vol.boot_dev = 1
               vol.instance = inst
               vol.save
-              res = Dcmgr.messaging.submit("kvm-handle.#{hp.node_id}", 'run_vol_store', inst.canonical_uuid, vol.canonical_uuid)
+              res = Dcmgr.messaging.submit("kvm-handle.#{hostnode.node_id}", 'run_vol_store', inst.canonical_uuid, vol.canonical_uuid)
             when Models::Image::BOOT_DEV_LOCAL
-              res = Dcmgr.messaging.submit("kvm-handle.#{hp.node_id}", 'run_local_store', inst.canonical_uuid)
+              res = Dcmgr.messaging.submit("kvm-handle.#{hostnode.node_id}", 'run_local_store', inst.canonical_uuid)
             else
               raise "Unknown boot type"
             end
-            respond_to { |f|
-              f.json { inst.to_api_document.to_json }
-            }
+            
+            response_to(inst.to_api_document)
           end
         end
 
@@ -348,9 +409,7 @@ module Dcmgr
             i = find_by_uuid(:Instance, params[:id])
             raise UnknownInstance if i.nil?
             
-            respond_to { |f|
-              f.json { i.to_api_document.to_json }
-            }
+            response_to(i.to_api_document)
           end
         end
 
@@ -364,9 +423,7 @@ module Dcmgr
               raise OperationNotPermitted
             end
             res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'terminate', i.canonical_uuid)
-            respond_to { |f|
-              f.json { i.canonical_uuid }
-            }
+            response_to([i.canonical_uuid])
           end
         end
 
@@ -407,9 +464,7 @@ module Dcmgr
               :results=> partial_ds.all.map {|i| i.to_hash }
             }]
             
-            respond_to { |f|
-              f.json {res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -421,9 +476,7 @@ module Dcmgr
             unless examine_owner(i)
               raise OperationNotPermitted
             end
-            respond_to { |f|
-              f.json { i.to_hash.to_json }
-            }
+            response_to(i.to_hash)
           end
         end
 
@@ -437,6 +490,7 @@ module Dcmgr
             else
               raise OperationNotPermitted
             end
+            response_to([i.canonical_uuid])
           end
         end
       end
@@ -461,9 +515,7 @@ module Dcmgr
               :results=> partial_ds.all.map {|i| i.to_hash }
             }]
             
-            respond_to { |f|
-              f.json {res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -474,9 +526,7 @@ module Dcmgr
             hp = find_by_uuid(:HostPool, params[:id])
             raise OperationNotPermitted unless examine_owner(hp)
             
-            respond_to { |f|
-              f.json { hp.to_hash.to_json }
-            }
+            response_to(hp.to_hash)
           end
         end
       end
@@ -499,11 +549,9 @@ module Dcmgr
               :owner_total => total_v.count,
               :start => start,
               :limit => limit,
-              :results => partial_v.all.map { |v| v.to_hash_document}
+              :results => partial_v.all.map { |v| v.to_api_document}
             }]
-            respond_to { |f|
-              f.json { res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -514,9 +562,7 @@ module Dcmgr
             volume_id = params[:id]
             raise UndefinedVolumeID if volume_id.nil?
             v = find_by_uuid(:Volume, volume_id)
-            respond_to { |f|
-              f.json { v.to_hash_document.to_json}
-            }
+            response_to(v.to_api_document)
           end
         end
 
@@ -531,8 +577,10 @@ module Dcmgr
               v = create_volume_from_snapshot(@account.canonical_uuid, params[:snapshot_id])
               sp = v.storage_pool
             elsif params[:volume_size]
-              raise InvalidVolumeSize 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)
+              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
@@ -552,9 +600,7 @@ module Dcmgr
             end
 
             res = Dcmgr.messaging.submit("zfs-handle.#{sp.values[:node_id]}", 'create_volume', v.canonical_uuid)
-            respond_to { |f|
-              f.json { v.to_hash_document.to_json}
-            }
+            response_to(v.to_api_document)
           end
         end
 
@@ -576,9 +622,7 @@ module Dcmgr
             sp = v.storage_pool
 
             res = Dcmgr.messaging.submit("zfs-handle.#{sp.values[:node_id]}", 'delete_volume', v.canonical_uuid)
-            respond_to { |f|
-              f.json { v.to_hash_document.to_json}
-            }
+            response_to([v.canonical_uuid])
           end
         end
 
@@ -592,17 +636,17 @@ module Dcmgr
             
             i = find_by_uuid(:Instance, params[:instance_id])
             raise UnknownInstance if i.nil?
+            raise InvalidInstanceState unless i.live? && i.state == 'running'
 
             v = find_by_uuid(:Volume, params[:id])
             raise UnknownVolume if v.nil?
+            raise AttachVolumeFailure, "Volume is attached to running instance." if v.instance
 
             v.instance = i
             v.save
             res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'attach', i.canonical_uuid, v.canonical_uuid)
 
-            respond_to { |f|
-              f.json { v.to_hash_document.to_json}
-            }
+            response_to(v.to_api_document)
           end
         end
 
@@ -614,11 +658,13 @@ module Dcmgr
 
             v = find_by_uuid(:Volume, params[:id])
             raise UnknownVolume if v.nil?
+            raise DetachVolumeFailure, "Volume is not attached to any instance." if v.instance.nil?
+            # the volume as the boot device can not be detached.
+            raise DetachVolumeFailure, "boot device can not be detached" if v.boot_dev == 1
             i = v.instance
+            raise InvalidInstanceState unless i.live? && i.state == 'running'
             res = Dcmgr.messaging.submit("kvm-handle.#{i.host_pool.node_id}", 'detach', i.canonical_uuid, v.canonical_uuid)
-            respond_to { |f|
-              f.json {v.to_hash_document.to_json}
-            }
+            response_to(v.to_api_document)
           end
         end
 
@@ -655,11 +701,9 @@ module Dcmgr
               :owner_total => total_vs.count,
               :start => start,
               :limit => limit,
-              :results => partial_vs.all.map { |vs| vs.to_hash_document}
+              :results => partial_vs.all.map { |vs| vs.to_api_document}
             }]
-            respond_to { |f|
-              f.json { res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -670,9 +714,7 @@ module Dcmgr
             snapshot_id = params[:id]
             raise UndefinedVolumeSnapshotID if snapshot_id.nil?
             vs = find_by_uuid(:VolumeSnapshot, snapshot_id)
-            respond_to { |f|
-              f.json { vs.to_hash_document.to_json}
-            }
+            response_to(vs.to_api_document)
           end
         end
 
@@ -686,14 +728,13 @@ module Dcmgr
 
             v = find_by_uuid(:Volume, params[:volume_id])
             raise UnknownVolume if v.nil?
+            raise InvalidRequestCredentials unless v.state == "available"
 
             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)
-            respond_to { |f|
-              f.json { vs.to_hash_document.to_json}
-            }
+            response_to(vs.to_api_document)
           end
         end
 
@@ -705,15 +746,17 @@ module Dcmgr
             snapshot_id = params[:id]
             raise UndefindVolumeSnapshotID if snapshot_id.nil?
 
-            vs = find_by_uuid(:VolumeSnapshot, snapshot_id)
+            begin
+              vs  = Models::VolumeSnapshot.delete_snapshot(@account.canonical_uuid, snapshot_id)
+            rescue Models::VolumeSnapshot::RequestError => e
+              logger.error(e)
+              raise InvalidDeleteRequest
+            end
             raise UnknownVolumeSnapshot if vs.nil?
-            vs = vs.delete_snapshot
             sp = vs.storage_pool
 
             res = Dcmgr.messaging.submit("zfs-handle.#{sp.node_id}", 'delete_snapshot', vs.canonical_uuid)
-            respond_to { |f|
-              f.json { vs.to_hash_document.to_json }
-            }
+            response_to([vs.canonical_uuid])
           end
         end
 
@@ -752,9 +795,7 @@ module Dcmgr
                      :results=> partial_ds.all.map {|i| i.to_hash }
                    }]
             
-            respond_to { |f|
-              f.json {res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -762,12 +803,9 @@ module Dcmgr
           description 'Show the netfilter_groups'
           control do
             g = find_by_uuid(:NetfilterGroup, params[:id])
-            p params[:id]
             raise OperationNotPermitted unless examine_owner(g)
 
-            respond_to { |f|
-              f.json { g.to_hash.to_json }
-            }
+            response_to(g.to_hash)
           end
         end
 
@@ -788,9 +826,7 @@ module Dcmgr
             raise DuplicatedNetfilterGroup unless g.nil?
 
             g = Models::NetfilterGroup.create_group(@account.canonical_uuid, params)
-            respond_to { |f|
-              f.json { g.to_hash.to_json }
-            }
+            response_to(g.to_hash)
           end
         end
 
@@ -816,9 +852,7 @@ module Dcmgr
             # refresh netfilter_rules
             Dcmgr.messaging.event_publish('hva/netfilter_updated', :args=>[g.canonical_uuid])
 
-            respond_to { |f|
-              f.json { g.to_hash.to_json }
-            }
+            response_to(g.to_hash)
           end
         end
 
@@ -833,9 +867,8 @@ module Dcmgr
             raise UnknownNetfilterGroup if g.nil?
             raise NetfilterGroupNotPermitted if g.account_id != @account.canonical_uuid
 
-            respond_to { |f|
-              f.json { g.destroy_group.values.to_json }
-            }
+            g.destroy
+            response_to([g.canonical_uuid])
           end
         end
 
@@ -861,9 +894,7 @@ module Dcmgr
               }
             end
 
-            respond_to { |f|
-              f.json { rules.to_json }
-            }
+            response_to(rules)
           end
         end
       end
@@ -887,12 +918,10 @@ module Dcmgr
               :owner_total => total_ds.count,
               :start => start,
               :limit => limit,
-              :results=> partial_ds.all.map {|sp| sp.to_hash_document }
+              :results=> partial_ds.all.map {|sp| sp.to_hash }
             }]
 
-            respond_to { |f|
-              f.json { res.to_json}
-            }
+            response_to(res)
           end
         end
 
@@ -904,9 +933,7 @@ module Dcmgr
             raise UndefinedStoragePoolID if pool_id.nil?
             vs = find_by_uuid(:StoragePool, pool_id)
             raise UnknownStoragePool if vs.nil?
-            respond_to { |f|
-              f.json { vs.to_hash_document.to_json}
-            }
+            response_to(vs.to_hash)
           end
         end
       end
@@ -934,9 +961,7 @@ module Dcmgr
               :results=> partial_ds.all.map {|i| i.to_hash }
             }]
             
-            respond_to { |f|
-              f.json {res.to_json}
-            }
+            response_to(res)
           end
         end
         
@@ -947,9 +972,7 @@ module Dcmgr
           control do
             ssh = find_by_uuid(:SshKeyPair, params[:id])
             
-            respond_to { |f|
-              f.json {ssh.to_hash.to_json}
-            }
+            response_to(ssh.to_hash)
           end
         end
         
@@ -971,11 +994,9 @@ module Dcmgr
             end
             ssh = Models::SshKeyPair.create(savedata)
                                             
-            respond_to { |f|
-              # include private_key data in response even if
-              # it's not going to be stored on DB.
-              f.json {ssh.to_hash.merge(:private_key=>keydata[:private_key]).to_json}
-            }
+            # 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]))
           end
         end
         
@@ -991,14 +1012,155 @@ module Dcmgr
               raise OperationNotPermitted
             end
             
-            respond_to { |f|
-              f.json {ssh.to_hash.to_json}
-            }
+            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 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 }
+            }]
+            
+            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_hash)
+          end
+        end
+        
+        operation :create do
+          description "Create new network"
+          # params :gw required default gateway address of the network
+          # params :prefix optional  netmask bit length. it will be
+          #               set 24 if none.
+          # params :description optional description for the network
+          control do
+            Models::Network.lock!
+            savedata = {
+              :account_id=>@account.canonical_uuid,
+              :ipv4_gw => params[:gw],
+              :prefix => params[:prefix].to_i,
+              :description => params[:description],
+            }
+            nw = Models::Network.create(savedata)
+                                            
+            response_to(nw.to_hash)
+          end
+        end
+        
+        operation :destroy do
+          description "Remove network information"
+          # params :id required
+          control do
+            Models::Network.lock!
+            nw = find_by_uuid(:Network, params[:id])
+            examine_owner(nw) || raise(OperationNotPermitted)
+            nw.destroy
+            
+            response_to([nw.canonical_uuid])
+          end
+        end
+
+        operation :reserve, :method =>:put, :member=>true do
+          description 'Register reserved IP address to the network'
+          # params id, string, required
+          # params ipaddr, [String,Array], required
+          control do
+            Models::IpLease.lock!
+            nw = find_by_uuid(:Network, params[:id])
+            examine_owner(nw) || raise(OperationNotPermitted)
+
+            (ipaddr.is_a?(Array) ? params[:ipaddr] : Array(params[:ipaddr])).each { |ip|
+              nw.add_reserved(ip)
+            }
+            response_to({})
+          end
+        end
+
+        operation :release, :method =>:put, :member=>true do
+          description 'Unregister reserved IP address from the network'
+          # params id, string, required
+          # params ipaddr, [String,Array], required
+          control do
+            Models::IpLease.lock!
+            nw = find_by_uuid(:Network, params[:id])
+            examine_owner(nw) || raise(OperationNotPermitted)
+
+            (ipaddr.is_a?(Array) ? params[:ipaddr] : Array(params[:ipaddr])).each { |ip|
+              nw.delete_reserved(ip)
+            }
+            response_to({})
+          end
+        end
+
+        operation :add_pool, :method=>:put, :member=>true do
+          description 'Label network pool name'
+           # param :name required
+          control do
+            Models::Tag.lock!
+            nw = find_by_uuid(:Network, params[:id])
+            examine_owner(nw) || raise(OperationNotPermitted)
+            nw.label_tag(:NetworkPool, params[:name], @account.canonical_uuid)
+            response_to({})
+          end
+        end
+        
+        operation :del_pool, :method=>:put, :member=>true do
+          description 'Unlabel network pool name'
+          # param :name required
+          control do
+            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
+          control do
+            Models::Tag.lock!
+             nw = find_by_uuid(:Network, params[:id])
+             examine_owner(nw) || raise(OperationNotPermitted)
+
+             res = nw.tags_dataset.filter(:type_id=>Tags.type_id(:NetworkPool)).all.map{|i| i.to_api_document }
+             response_to(res)
+           end
+         end
+      end
+      
     end
   end
 end