wakame-vdc-agents 11.06.0 → 11.12.0

data/lib/dcmgr/models/instance.rb

@@ -1,55 +1,29 @@
 # -*- coding: utf-8 -*-
 
 module Dcmgr::Models
-  # Model class which represents Virtual Machine or Isolated Instace
-  # running on HostPool.
-  #
-  # @exmaple Create new instance
-  #  hp = HostPool['hp-xxxxx']
-  #  inst = hp.create_instance()
+  # Model class for running virtual instance.
   class Instance < AccountResource
     taggable 'i'
 
-    inheritable_schema do
-      Fixnum :host_pool_id, :null=>false
-      Fixnum :image_id, :null=>false
-      Fixnum :instance_spec_id, :null=>false
-      String :state, :size=>20, :null=>false, :default=>:init.to_s
-      String :status, :size=>20, :null=>false, :default=>:init.to_s
-      String :hostname, :null=>false, :size=>32
-      # TODO: remove ssh_key_pair_id column
-      String :ssh_key_pair_id
-      Fixnum :ha_enabled, :null=>false, :default=>0
-      Float  :quota_weight, :null=>false, :default=>0.0
-      Fixnum :cpu_cores, :null=>false, :unsigned=>true
-      Fixnum :memory_size, :null=>false, :unsigned=>true
-      
-      Text :user_data, :null=>false, :default=>''
-      Text :runtime_config, :null=>false, :default=>''
-      Text :ssh_key_data, :null=>true
-
-      Time :terminated_at
-      index :state
-      index :terminated_at
-    end
-    with_timestamps
-    
     many_to_one :image
     many_to_one :instance_spec
     alias :spec :instance_spec
-    many_to_one :host_pool
+    many_to_one :host_node
     one_to_many :volume
     one_to_many :instance_nic
     alias :nic :instance_nic
-    many_to_many :netfilter_groups, :join_table=>:instance_netfilter_groups
+    many_to_many :security_groups, :join_table=>:instance_security_groups
     # TODO: remove ssh_key_pair_id column
     many_to_one :ssh_key_pair
 
     plugin ArchiveChangedColumn, :histories
     
     subset(:lives, {:terminated_at => nil})
+    subset(:runnings, {:state => 'running'})
+    subset(:stops, {:state => 'stopped'})
 
-    RECENT_TERMED_PERIOD=(60 * 15)
+    #RECENT_TERMED_PERIOD=(60 * 15)
+    RECENT_TERMED_PERIOD = Dcmgr.conf.recent_terminated_instance_period
     # lists the instances which alives and died within
     # RECENT_TERMED_PERIOD sec.
     # it was difficult for me to write exprs in virtual row syntax as
@@ -62,11 +36,12 @@ module Dcmgr::Models
     # method calls.
     # Possible column data:
     #   kvm:
-    # {:vnc_port=>11, :telnet_port=>1111}
+    # {:vnc_port=>11}
     plugin :serialization
     serialize_attributes :yaml, :runtime_config
     # equal to SshKeyPair#to_hash
     serialize_attributes :yaml, :ssh_key_data
+    serialize_attributes :yaml, :request_params
 
     module ValidationMethods
       def self.hostname_uniqueness(account_id, hostname)
@@ -74,8 +49,12 @@ module Dcmgr::Models
       end
     end
 
+    class HostError < RuntimeError; end
+
     def validate
       super
+      # do not run validation if the row is maked as deleted.
+      return true if self.terminated_at
 
       unless self.hostname =~ /\A[0-9a-z][0-9a-z\-]{0,31}\Z/
         errors.add(:hostname, "Invalid hostname syntax")
@@ -100,20 +79,6 @@ module Dcmgr::Models
         end
         @update_hostname = true
       end
-      
-      # check runtime_config column
-      case self.hypervisor
-      when HostPool::HYPERVISOR_KVM
-        r1 = self.runtime_config
-        self.host_pool.instances.each { |i|
-          next true if i.id == self.id
-          r2 = i.runtime_config
-          unless r1[:vnc_port] != r2[:vnc_port] && r1[:telnet_port] != r2[:telnet_port]
-            errors.add(:runtime_config, "#{self.canonical_uuid}.runtime_config conflicted with #{i.canonical_uuid}")
-            break
-          end
-        }
-      end
     end
 
     def before_validation
@@ -145,7 +110,7 @@ module Dcmgr::Models
       # sum() returns nil if there is no instance rows.
       lives_weight = self.class.filter(:account_id=>self.account_id).lives.sum(:quota_weight) || 0.0
       unless lives_weight <= self.account.quota.instance_total_weight
-        raise "Out of quota limit: #{self.account_id}'s current weight capacity: #{lives_weight} (<= #{self.account.quota.instance_total_weight})"
+        raise HostError, "Out of quota limit: #{self.account_id}'s current weight capacity: #{lives_weight} (<= #{self.account.quota.instance_total_weight})"
       end
 
       super
@@ -154,7 +119,7 @@ module Dcmgr::Models
     def before_destroy
       HostnameLease.filter(:account_id=>self.account_id, :hostname=>self.hostname).destroy
       self.instance_nic.each { |o| o.destroy }
-      self.remove_all_netfilter_groups
+      self.remove_all_security_groups
       self.volume.each { |v|
         v.instance_id = nil
         v.state = :available
@@ -163,9 +128,9 @@ module Dcmgr::Models
       super
     end
 
-    # override Sequel::Model#_delete not to delete rows but to set
+    # override Sequel::Model#delete not to delete rows but to set
     # delete flags.
-    def _delete
+    def delete
       self.terminated_at ||= Time.now
       self.state = :terminated if self.state != :terminated
       self.status = :offline if self.status != :offline
@@ -177,12 +142,15 @@ module Dcmgr::Models
     def to_hash
       h = super
       h.merge!({:user_data => user_data.to_s, # Sequel::BLOB -> String
-                    :runtime_config => self.runtime_config, # yaml -> hash
-                    :image=>image.to_hash,
-                    :host_pool=>host_pool.to_hash,
-                    :instance_nics=>instance_nic.map {|n| n.to_hash },
-                    :ips => instance_nic.map { |n| n.ip.map {|i| unless i.is_natted? then i.ipv4 else nil end} if n.ip }.flatten.compact,
-                    :nat_ips => instance_nic.map { |n| n.ip.map {|i| if i.is_natted? then i.ipv4 else nil end} if n.ip }.flatten.compact,
+                 :runtime_config => self.runtime_config, # yaml -> hash
+                 :ssh_key_data => self.ssh_key_data, # yaml -> hash
+                 :image=>image.to_hash,
+                 :host_node=> (host_node.nil? ? nil : host_node.to_hash),
+                 :instance_nics=>instance_nic.map {|n| n.to_hash },
+                 :ips => instance_nic.map { |n| n.ip.map {|i| unless i.is_natted? then i.ipv4 else nil end} if n.ip }.flatten.compact,
+                 :nat_ips => instance_nic.map { |n| n.ip.map {|i| if i.is_natted? then i.ipv4 else nil end} if n.ip }.flatten.compact,
+                 :security_groups => self.security_groups.map {|n| n.canonical_uuid },
+                 :vif=>[],
               })
       h.merge!({:instance_spec=>instance_spec.to_hash}) unless instance_spec.nil?
       h[:volume]={}
@@ -191,6 +159,25 @@ module Dcmgr::Models
           h[:volume][v.canonical_uuid] = v.to_hash
         }
       end
+      if self.instance_nic
+        self.instance_nic.each { |vif|
+          ent = vif.to_hash.merge({
+            :vif_id=>vif.canonical_uuid,
+          })
+          direct_lease = vif.direct_ip_lease.first
+          if direct_lease.nil?
+          else
+            outside_lease = direct_lease.nat_outside_lease
+            ent[:ipv4] = {
+              :network => vif.network.nil? ? nil : vif.network.to_hash,
+              :address=> direct_lease.ipv4,
+              :nat_network => vif.nat_network.nil? ? nil : vif.nat_network.to_hash,
+              :nat_address => outside_lease.nil? ? nil : outside_lease.ipv4,
+            }
+          end
+          h[:vif] << ent
+        }
+      end
       h
     end
 
@@ -205,7 +192,7 @@ module Dcmgr::Models
     #   :network => [{:network_name=>'nw-xxxxxxx', :ipaddr=>'111.111.111.111'}]
     #   :volume => [{'uuid'=>{:guest_device_name=>,}]
     #   :ssh_key_pair => 'xxxxx',
-    #   :netfilter_group => ['rule1', 'rule2']
+    #   :security_groups => ['rule1', 'rule2']
     #   :created_at
     #   :state
     #   :status
@@ -214,8 +201,10 @@ module Dcmgr::Models
     def to_api_document
       h = {
         :id => canonical_uuid,
+        :host_node   => self.host_node && self.host_node.canonical_uuid,
         :cpu_cores   => cpu_cores,
         :memory_size => memory_size,
+        :arch        => spec.arch,
         :image_id    => image.canonical_uuid,
         :created_at  => self.created_at,
         :state => self.state,
@@ -223,66 +212,60 @@ module Dcmgr::Models
         :ssh_key_pair => nil,
         :network => [],
         :volume => [],
-        :netfilter_group => [],
+        :security_groups => self.security_groups.map {|n| n.canonical_uuid },
         :vif => [],
+        :hostname => hostname,
+        :ha_enabled => ha_enabled,
+        :instance_spec_id => instance_spec.canonical_uuid,
       }
       if self.ssh_key_data
-        h[:ssh_key_pair] = self.ssh_key_data[:name]
+        h[:ssh_key_pair] = self.ssh_key_data[:uuid]
       end
 
-      if instance_nic
-        instance_nic.each { |n|
-          direct_lease_ds = n.direct_ip_lease_dataset
-          next if direct_lease_ds.first.nil?
-          outside_lease_ds = n.nat_ip_lease_dataset
-          
+      instance_nic.each { |vif|
+        direct_lease_ds = vif.direct_ip_lease_dataset
+        if direct_lease_ds.first
+          outside_lease_ds = vif.nat_ip_lease_dataset
+
           h[:network] << {
-            :network_name => n.network.canonical_uuid,
+            :network_name => vif.network.canonical_uuid,
             :ipaddr => direct_lease_ds.all.map {|lease| lease.ipv4 }.compact,
-            :nat_ipaddr => outside_lease_ds.all.map {|lease| lease.ipv4 }.compact
+            :dns_name => vif.network.domain_name && self.fqdn_hostname,
+            :nat_network_name => vif.nat_network && vif.nat_network.canonical_uuid,
+            :nat_ipaddr => outside_lease_ds.all.map {|lease| lease.ipv4 }.compact,
+            :nat_dns_name => vif.nat_network && vif.nat_network.domain_name && self.nat_fqdn_hostname,
           }
-        }
-      end
+        end
 
-      if instance_nic
-        instance_nic.each { |vif|
-          ent = {
-            :vif_id=>vif.canonical_uuid,
-          }
-          direct_lease = vif.direct_ip_lease.first
-          if direct_lease.nil?
-          else
-            outside_lease = direct_lease.nat_outside_lease
-            ent[:ipv4] = {
-              :address=> direct_lease.ipv4,
-              :nat_address => outside_lease.nil? ? nil : outside_lease.ipv4,
-            }
-          end
-          h[:vif] << ent
+        ent = {
+          :vif_id=>vif.canonical_uuid,
         }
-      end
-      
-      if self.volume
-        self.volume.each { |v|
-          h[:volume] << {
-            :vol_id => v.canonical_uuid,
-            :guest_device_name=>v.guest_device_name,
-            :state=>v.state,
+        direct_lease = direct_lease_ds.first
+        if direct_lease.nil?
+        else
+          outside_lease = direct_lease.nat_outside_lease
+          ent[:ipv4] = {
+            :address=> direct_lease.ipv4,
+            :nat_address => outside_lease.nil? ? nil : outside_lease.ipv4,
           }
-        }
-      end
+        end
+        h[:vif] << ent
+      }
 
-      if self.netfilter_groups
-        self.netfilter_groups.each { |n|
-          h[:netfilter_group] << n.name
+      self.volume.each { |v|
+        h[:volume] << {
+          :vol_id => v.canonical_uuid,
+          :guest_device_name=>v.guest_device_name,
+          :state=>v.state,
         }
-      end
+      }
+
       h
     end
 
     # Returns the hypervisor type for the instance.
     def hypervisor
-      self.host_pool.hypervisor
+      self.instance_spec.hypervisor
     end
 
     # Returns the architecture type of the image
@@ -294,30 +277,36 @@ module Dcmgr::Models
       self.instance_spec.config
     end
 
-    def add_nic(network, vendor_id=nil)
-      # TODO: get default vendor ID based on the hypervisor.
-      vendor_id ||= '00:ff:f1'
-      nic = InstanceNic.new(:mac_addr=>vendor_id)
-      nic.network = network
-      nic.nat_network = network.nat_network
+    def add_nic(vif_template)
+      # Choose vendor ID of mac address.
+      vendor_id = if vif_template[:vendor_id]
+                    vif_template[:vendor_id]
+                  elsif Dcmgr.conf.mac_address_vendor_id
+                    Dcmgr.conf.mac_address_vendor_id
+                  else
+                    MacLease.default_vendor_id(self.instance_spec.hypervisor)
+                  end
+      m = MacLease.lease(vendor_id)
+      nic = InstanceNic.new(:mac_addr=>m.mac_addr)
       nic.instance = self
+      nic.device_index = vif_template[:index]
       nic.save
     end
 
-    # Join this instance to the list of netfilter group using group's uuid.
-    # @param [String,Array] netfilter_group_uuids 
-    def join_netfilter_group(netfilter_group_uuids)
-      netfilter_group_uuids = [netfilter_group_uuids] if netfilter_group_uuids.is_a?(String)
-      joined_group_uuids = self.netfilter_groups.map { |netfilter_group|
-        netfilter_group.canonical_uuid
+    # Join this instance to the list of security group using group's uuid.
+    # @param [String,Array] security_group_uuids 
+    def join_security_group(security_group_uuids)
+      security_group_uuids = [security_group_uuids] if security_group_uuids.is_a?(String)
+      joined_group_uuids = self.security_groups.map { |security_group|
+        security_group.canonical_uuid
       }
-      target_group_uuids = netfilter_group_uuids.uniq - joined_group_uuids.uniq
+      target_group_uuids = security_group_uuids.uniq - joined_group_uuids.uniq
       target_group_uuids.uniq!
 
       target_group_uuids.map { |target_group_uuid|
-        if ng = NetfilterGroup[target_group_uuid]
-          InstanceNetfilterGroup.create(:instance_id => self.id,
-                                        :netfilter_group_id => ng.id)
+        if sg = SecurityGroup[target_group_uuid]
+          InstanceSecurityGroup.create(:instance_id => self.id,
+                                       :security_group_id => sg.id)
         end
       }
     end
@@ -326,15 +315,12 @@ module Dcmgr::Models
       self.instance_nic.map { |nic| nic.ip }
     end
 
-#    def netfilter_group_instances
-#      instances = self.netfilter_groups.map { |g| g.instances }
-#
-#      instances.flatten!.uniq! if instances.size > 0
-#      instances
-#    end
-
     def fqdn_hostname
-      sprintf("%s.%s.%s", self.hostname, self.account.uuid, self.nic.first.network.domain_name)
+      self.nic.first.fqdn_hostname
+    end
+
+    def nat_fqdn_hostname
+      self.nic.first.nat_fqdn_hostname
     end
 
     # Retrieve all networks belong to this instance
@@ -351,21 +337,6 @@ module Dcmgr::Models
       }
     end
 
-    # Join this instance to the list of netfilter group using group name. 
-    # @param [String] account_id uuid of current account.
-    # @param [String,Array] nfgroup_names 
-    def join_nfgroup_by_name(account_id, nfgroup_names)
-      nfgroup_names = [nfgroup_names] if nfgroup_names.is_a?(String)
-
-      uuids = nfgroup_names.map { |n|
-        ng = NetfilterGroup.for_update.filter(:account_id=>account_id,
-                                              :name=>n).first
-        ng.nil? ? nil : ng.canonical_uuid
-      }
-      # clean up nils
-      join_netfilter_group(uuids.compact.uniq)
-    end
-
     def self.lock!
       super()
       Image.lock!
@@ -374,8 +345,6 @@ module Dcmgr::Models
       Volume.lock!
       VolumeSnapshot.lock!
       IpLease.lock!
-      HostnameLease.lock!
-      Network.lock!
     end
 
     def live?
@@ -385,9 +354,34 @@ module Dcmgr::Models
     def set_ssh_key_pair(ssh_key_pair)
       raise ArgumentError unless ssh_key_pair.is_a?(SshKeyPair)
       self.ssh_key_data = ssh_key_pair.to_hash
+      # Do not copy private key.
+      self.ssh_key_data.delete(:private_key)
       # TODO: remove ssh_key_pair_id column
       self.ssh_key_pair_id = ssh_key_pair.canonical_uuid
     end
-    
+
+
+    # Factory method for Models::Instance object.
+    # This method helps to set association values have to be
+    # set mandatry until initial save to the database.
+    def self.entry_new(account, image, spec, params, &blk)
+      raise ArgumentError unless account.is_a?(Account)
+      raise ArgumentError unless image.is_a?(Image)
+      raise ArgumentError unless spec.is_a?(InstanceSpec)
+      # Mash is passed in some cases.
+      raise ArgumentError unless params.class == ::Hash
+
+      i = self.new &blk
+      i.account_id = account.canonical_uuid
+      i.image = image
+      i.instance_spec = spec
+      i.cpu_cores = spec.cpu_cores
+      i.memory_size = spec.memory_size
+      i.quota_weight = spec.quota_weight
+      i.request_params = params.dup
+
+      i
+    end
+
   end
 end

data/lib/dcmgr/models/instance_nic.rb

@@ -5,18 +5,6 @@ module Dcmgr::Models
   class InstanceNic < BaseNew
     taggable 'vif'
 
-    inheritable_schema do
-      Fixnum :instance_id, :null=>false
-      Fixnum :network_id, :null=>false
-      Fixnum :nat_network_id
-      Fixnum :bandwidth_group_id
-      String :mac_addr, :null=>false, :size=>12
-      
-      index :mac_addr
-    end
-    with_timestamps
-
-    many_to_one :bandwidth_group
     many_to_one :instance
     many_to_one :nat_network, :key => :nat_network_id, :class => Network
     many_to_one :network
@@ -27,48 +15,83 @@ module Dcmgr::Models
     one_to_many(:nat_ip_lease, :class=>IpLease, :read_only=>true) do |ds|
       ds.where(:network_id=>self.nat_network_id)
     end
+    
+    subset(:alives, {:deleted_at => nil})
 
-    def to_hash
-      h = values.dup.merge(super)
-      h.delete(:instance_id)
-      h
+    def to_api_document
+      hash = super
+      hash.delete(instance_id)
+      hash
+    end
+
+    def release_ip_lease
+      ip_dataset.destroy
+    end
+
+    #Override the delete method to keep the row and just mark it as deleted
+    def delete
+      self.deleted_at ||= Time.now
+      self.save
     end
 
     def before_validation
-      newlease=nil
-      m = self[:mac_addr] = normalize_mac_addr(self[:mac_addr])
-      if m
-        if m.size == 6
-          newlease = MacLease.lease(m)
-        else
-          MacLease.create(:mac_addr=>m)
-        end
-      else
-        newlease = MacLease.lease()
+      self[:mac_addr] = normalize_mac_addr(self[:mac_addr])
+
+      # set maximum index number if the nic has no index value and
+      # is attached to instance.
+      if self.instance_id && self.device_index.nil?
+        max_idx = self.class.alives.filter(:instance_id=>self.instance_id).max(:device_index)
+        self.device_index = max_idx.nil? ? 0 : (max_idx + 1)
       end
-      self[:mac_addr] = newlease.mac_addr if newlease
       
       super
     end
 
     def before_destroy
-      MacLease.find(:mac_addr=>self.mac_addr).destroy
-      ip_dataset.destroy
+      maclease = MacLease.find(:mac_addr=>self.mac_addr)
+      maclease.destroy if maclease
+      release_ip_lease
       super
     end
 
     def validate
       super
 
+      # do not run validation if the row is maked as deleted.
+      return true if self.deleted_at
+
       unless self.mac_addr.size == 12 && self.mac_addr =~ /^[0-9a-f]{12}$/
         errors.add(:mac_addr, "Invalid mac address syntax: #{self.mac_addr}")
       end
+      if MacLease.find(:mac_addr=>self.mac_addr).nil?
+        errors.add(:mac_addr, "MAC address is not on the MAC lease database.")
+      end
+
+      # find duplicate device index.
+      if self.instance_id
+        idx = self.class.alives.filter(:instance_id=>self.instance_id).select(:device_index).all
+        if idx.uniq.size != idx.size
+          errors.add(:device_index, "Duplicate device index.")
+        end
+      end
     end
 
     def pretty_mac_addr(delim=':')
       self.mac_addr.unpack('A2'*6).join(delim)
     end
 
+    def fqdn_hostname
+      raise "Instance is not associated: #{self.canonical_uuid}" if self.instance.nil?
+      raise "Network is not associated: #{self.canonical_uuid}" if self.network.nil?
+      sprintf("%s.%s.%s", self.instance.hostname, self.instance.account.uuid, self.network.domain_name)
+    end
+
+    def nat_fqdn_hostname
+      raise "Instance is not associated: #{self.canonical_uuid}" if self.instance.nil?
+      raise "Network is not associated: #{self.canonical_uuid}" if self.network.nil?
+      sprintf("%s.%s.%s", self.instance.hostname, self.instance.account.uuid, self.nat_network.domain_name)
+    end
+
     private
     def normalize_mac_addr(str)
       str = str.downcase.gsub(/[^0-9a-f]/, '')