wakame-vdc-agents 10.11.0 → 10.12.0

data/lib/dcmgr/models/instance_nic.rb

@@ -3,18 +3,19 @@
 module Dcmgr::Models
   # Network interface for running instance.
   class InstanceNic < BaseNew
-    taggable 'nic'
+    taggable 'vif'
 
     inheritable_schema do
       Fixnum :instance_id, :null=>false
-      String :vif, :null=>false, :size=>50
+      Fixnum :network_id, :null=>false
       String :mac_addr, :null=>false, :size=>12
       
-      index :mac_addr, {:unique=>true}
+      index :mac_addr
     end
     with_timestamps
 
     many_to_one :instance
+    many_to_one :network
     one_to_one :ip, :class=>IpLease
 
     def to_hash
@@ -24,28 +25,32 @@ module Dcmgr::Models
     end
 
     def before_validation
-      super
-      m = normalize_mac_addr(self[:mac_addr])
-      if m.size == 6
-        # mac_addr looks like to only have vendor ID part so that
-        # generate unique value for node ID part.
-        mvendor = m
-        begin
-          m = mvendor + ("%02x%02x%02x" % [rand(0xff),rand(0xff),rand(0xff)])
-        end while self.class.find(:mac_addr=> m)
-        self[:mac_addr] = m
+      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()
       end
-      true
+      self[:mac_addr] = newlease.mac_addr if newlease
+      
+      super
     end
 
-    def validate
+    def before_destroy
+      MacLease.find(:mac_addr=>self.mac_addr).destroy
+      ip && ip.destroy
       super
+    end
 
-      unless self.mac_addr.size == 12
-        errors.add(:mac_addr, "Invalid mac address length: #{self.mac_addr}")
-      end
+    def validate
+      super
 
-      unless self.mac_addr =~ /^[0-9a-f]{12}$/
+      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
     end

data/lib/dcmgr/models/instance_spec.rb

@@ -14,8 +14,28 @@ module Dcmgr::Models
     end
     with_timestamps
 
+    # serialization plugin must be defined at the bottom of all class
+    # method calls.
+    # Possible column data:
+    #   hypervisor=kvm:
+    # {:block_driver=>'virtio', :nic_driver=>'virtio'}
+    plugin :serialization
+    serialize_attributes :yaml, :config
+
+    def before_validate
+      default_config =
+        case self.hypervisor
+        when HostPool::HYPERVISOR_KVM
+          {:block_driver=>'virtio', :nic_driver=>'virtio'}
+        end
+
+      self.config = default_config.merge(self.config || {})
+      super
+    end
+
     def to_hash
-      super.merge({:config=>config.to_s})
+      super.merge({:config=>self.config, # yaml -> Hash
+                  })
     end
   end
 end

data/lib/dcmgr/models/ip_lease.rb

@@ -5,35 +5,48 @@ require 'ipaddress'
 module Dcmgr::Models
   # IP address lease information
   class IpLease < BaseNew
-
+    TYPE_AUTO=0
+    TYPE_RESERVED=1
+    TYPE_MANUAL=2
+    
     inheritable_schema do
-      Fixnum :instance_nic_id, :null=>false
+      Fixnum :instance_nic_id
       Fixnum :network_id, :null=>false
       String :ipv4, :size=>50
+      Fixnum :type, :null=>false, :default=>TYPE_AUTO
+      Text :description
       
-      index :ipv4, {:unique=>true}
+      index [:network_id, :ipv4], {:unique=>true}
     end
     with_timestamps
 
     many_to_one :instance_nic
     many_to_one :network
 
-    def self.lease(instance_nic)
+    def validate
+      # validate ipv4 syntax
+      begin
+        addr = IPAddress::IPv4.new("#{self.ipv4}")
+        # validate if ipv4 is in the range of network_id.
+        unless network.ipaddress.network.include?(addr)
+          errors.add(:ipv4, "IP address #{addr} is out of range: #{network.canonical_uuid})")
+        end
+      rescue => e
+        errors.add(:ipv4, "Invalid IP address syntax: #{self.ipv4} (#{e})")
+      end
+    end
+
+    def self.lease(instance_nic, network)
       raise TypeError unless instance_nic.is_a?(InstanceNic)
-      # TODO: consider the case of multiple nics on multiple network.
-      network = instance_nic.instance.host_pool.network
-      gwaddr = IPAddress::IPv4.new("#{network.ipv4_gw}/#{network.prefix}")
+      raise TypeError unless network.is_a?(Network)
+      
+      gwaddr = network.ipaddress
       reserved = [gwaddr]
-      reserved << IPAddress::IPv4.new(network.dhcp_server)
-      reserved << IPAddress::IPv4.new(network.dns_server)
-      if network.metadata_server
-        reserved << IPAddress::IPv4.new(network.metadata_server)
-      end
       reserved = reserved.map {|i| i.to_u32 }
       # use SELECT FOR UPDATE to lock rows within same network.
-      addrs = (gwaddr.first.to_u32 .. gwaddr.last.to_u32).to_a -
+      addrs = (gwaddr.network.first.to_u32 .. gwaddr.network.last.to_u32).to_a -
         reserved - network.ip_lease_dataset.for_update.all.map {|i| IPAddress::IPv4.new(i.ipv4).to_u32 }
-      raise "Out of IP address in this network segment: #{gwaddr.network.to_s}/#{gwaddr.prefix}" if addrs.empty?
+      raise "Out of free IP address in this network segment: #{gwaddr.network.to_s}/#{gwaddr.prefix}" if addrs.empty?
       
       leaseaddr = IPAddress::IPv4.parse_u32(addrs[rand(addrs.size).to_i])
       create(:ipv4=>leaseaddr.to_s, :network_id=>network.id, :instance_nic_id=>instance_nic.id)

data/lib/dcmgr/models/mac_lease.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  # MAC address lease information
+  class MacLease < BaseNew
+
+    inheritable_schema do
+      String :mac_addr, :size=>12, :fixed=>true, :null=>false
+      
+      index :mac_addr, {:unique=>true}
+    end
+    with_timestamps
+
+    # dynamically assign new MAC address.
+    def self.lease(vendor_id='00ff01')
+      begin
+        m = vendor_id + ("%02x%02x%02x" % [rand(0xff),rand(0xff),rand(0xff)])
+      end while self.find(:mac_addr=> m)
+      create(:mac_addr=>m)
+    end
+  end
+end

data/lib/dcmgr/models/netfilter_group.rb

@@ -49,10 +49,11 @@ module Dcmgr::Models
       NetfilterRule.filter(:netfilter_group_id => self.id).destroy
     end
 
-    def destroy_group
+    def before_destroy
       self.flush_rule
-      self.destroy
+      super
     end
+    alias :destroy_group :destroy
 
     def rebuild_rule
       self.flush_rule

data/lib/dcmgr/models/network.rb

@@ -1,32 +1,69 @@
 # -*- coding: utf-8 -*-
 
+require 'ipaddress'
+
 module Dcmgr::Models
-  # Network definitions in the DC.
-  class Network < BaseNew
+  # IP network definitions.
+  class Network < AccountResource
+    taggable 'nw'
 
     inheritable_schema do
-      String :name, :null=>false
       String :ipv4_gw, :null=>false
       Fixnum :prefix, :null=>false, :default=>24, :unsigned=>true
-      String :domain_name, :null=>false
-      String :dns_server, :null=>false
-      String :dhcp_server, :null=>false
+      String :domain_name
+      String :dns_server
+      String :dhcp_server
       String :metadata_server
+      Fixnum :vlan_lease_id, :null=>false
       Text :description
-      index :name, {:unique=>true}
     end
     with_timestamps
 
-    many_to_one :host_pool
     one_to_many :ip_lease
+    many_to_one :vlan_lease
 
     def validate
       super
+      
+      # validate ipv4 syntax
+      begin
+        IPAddress::IPv4.new("#{self.ipv4_gw}")
+      rescue => e
+        errors.add(:ipv4_gw, "Invalid IP address syntax: #{self.ipv4_gw}")
+      end
+
+      unless (1..31).include?(self.prefix.to_i)
+        errors.add(:prefix, "prefix must be 1-31: #{self.prefix}")
+      end
     end
 
     def to_hash
-      values.dup.merge({:description=>description.to_s})
+      h = super
+      h.delete(:vlan_lease_id)
+      h.merge({
+                :description=>description.to_s,
+                :vlan_id => vlan_lease.tag_id,
+              })
+    end
+
+    def ipaddress
+      IPAddress::IPv4.new("#{self.ipv4_gw}/#{self.prefix}")
+    end
+
+    # check if the given IP addess is in the range of this network.
+    # @param [String] ipaddr IP address
+    def include?(ipaddr)
+      ipaddr = ipaddr.is_a?(IPAddress::IPv4) ? ipaddr : IPAddress::IPv4.new(ipaddr)
+      self.ipaddress.network.include?(ipaddr)
+    end
+
+    # register reserved IP address in this network
+    def add_reserved(ipaddr)
+      add_ip_lease(:ipv4=>ipaddr, :type=>IpLease::TYPE_RESERVED)
+    end
+
+    def available_ip_nums
+      self.ipaddress.hosts.size - self.ip_lease_dataset.count
     end
-    
   end
 end

data/lib/dcmgr/models/storage_pool.rb

@@ -29,6 +29,8 @@ module Dcmgr::Models
       String :storage_type, :null=>false
       String :ipaddr, :null=>false
       String :snapshot_base_path, :null=>false
+
+      index :node_id
     end
 
     one_to_many :volumes
@@ -45,12 +47,6 @@ module Dcmgr::Models
       end
     end
 
-    def to_hash_document
-      h = self.values.dup
-      h[:id] = h[:uuid] = self.canonical_uuid
-      h
-    end
-
     def state_machine
       model = self
       st = Statemachine.build do

data/lib/dcmgr/models/tag.rb

@@ -1,27 +1,59 @@
 # -*- coding: utf-8 -*-
 
 module Dcmgr::Models
-  class Tag < BaseNew
+  # Tag is a label which groups arbitrary resource(s) having canonical
+  # uuid. A tag object consists of three items: Account ID, Type, Name
+  # 
+  # Account ID is top level scope that represents the owner of the
+  # tag. Each tag instance is created in the scope of the account.
+  # 
+  # Type field is second level scope to filter the object out to be
+  # labeled. If the tag is only for grouping resource A, it will fail
+  # at labling the tag other than resource A.
+  #
+  # Name represents the instance ID of the tag. This is a string that
+  # must be unique in the scope of Account ID and Type.
+  # Below is Type & Name matrix in single account:
+  # TypeA, name1
+  # TypeA, name1 # can not create
+  # TypeB, name2 # ok
+  # TypeB, name1 # nop
+  # 
+  # The resource can be labeled is called "Taggable" resource. The
+  # model framework is provided to declare simply.
+  # 
+  # class A < Dcmgr::Models::Base
+  #   taggable 'xxx'
+  # end
+  #
+  # @example Retrieve tag
+  # t = Tag.declare(account_id, :NetworkPool, 'xxxxx')
+  # t.mapped_uuids # => ['nw-11111', 'nw-22222' ,'nw-33333']
+  #
+  # @example Lable a tag from tag
+  # t = Tag.declare(account_id, :NetworkPool, 'nwgroup1')
+  # t.lable('nw-xxxxx')
+  # t.lable('nw-yyyyy')
+  # 
+  # @example Label a tag from resource
+  # t = Tag.declare(account_id, :NetworkPool, 'nwgroup1')
+  # nw = Network['nw-44444']
+  # nw.label_tag(t)
+  # nw.label_tag('tag-xxxxx')
+  class Tag < AccountResource
     taggable('tag')
-    with_timestamps
-    plugin :single_table_inheritance, :type_id, :model_map=>{}
-    plugin :subclasses
-    
+
     inheritable_schema do
-      Fixnum :account_id, :null=>false
-      index :account_id
-      Fixnum :owner_id
-      String :name, :fixed=>true, :size=>200, :null=>false
       Fixnum :type_id, :null=>false
+      String :name, :null=>false
       String :attributes
-    end
 
-    TYPE_NORMAL = 0
-    TYPE_AUTH = 1
+      index [:account_id, :type_id, :name], {:unique=>true}
+    end
+    with_timestamps
 
     many_to_one :account
     
-    #one_to_many :tag_mappings, :dataset=>proc{ TagMapping.dataset.filter(:tag_id=>self.id) } do
     one_to_many :mapped_uuids, :class=>TagMapping do |ds|
       ds.instance_eval {
         def exists?(canonical_uuid)
@@ -31,12 +63,18 @@ module Dcmgr::Models
       ds
     end
 
+    # sti plugin has to be loaded at lower position.
+    plugin :subclasses
+    plugin :single_table_inheritance, :type_id,
+         :key_map=>proc {|v| Dcmgr::Tags::MODEL_MAP[v.to_s.split('Dcmgr::Tags::').last.to_sym] },
+         :model_map=>proc {|v| Dcmgr::Tags.const_get(Dcmgr::Tags::KEY_MAP[v]) }
+
     class UnacceptableTagType < StandardError
       def initialize(msg, tag, taggable)
         super(msg)
 
-        raise ArgumentError, "Expected #{Tag.class}: #{tag.class}"  unless tag.is_a?(Tag)
-        raise ArgumentError, "Expected #{Taggable.class}: #{tag.class}"  unless taggable.is_a?(Taggable)
+        raise ArgumentError, "Expected child of #{Tag} but #{tag.class}"  unless tag.is_a?(Tag)
+        raise ArgumentError, "Expected kind of #{Taggable} but #{taggable.class}"  unless taggable.kind_of?(Taggable)
         @tag = tag
         @taggable = taggable
       end
@@ -48,67 +86,59 @@ module Dcmgr::Models
     def labeled?(canonical_uuid)
       # TODO: check if the uuid exists
       
-      !TagMapping.filter(:uuid=>canonical_uuid, :tag_id=>self.pk).empty?
+      !TagMapping.filter(:tag_id=>self.pk, :uuid=>canonical_uuid).empty?
     end
-    
-    def label(canonical_uuid)
-      tgt = Taggable.find(canonical_uuid)
+
+    # Associate the tag to the taggable object.
+    #
+    # @params [Models::Taggable,String] taggable_or_uuid
+    def label(taggable_or_uuid)
+      tgt = case taggable_or_uuid
+            when String
+              Taggable.find(taggable_or_uuid)
+            when Models::Taggable
+              taggable_or_uuid
+            else
+              raise TypeError
+            end
       
-      raise(UnacceptableTagType, self, tgt) if accept_mapping?(tgt)
-      raise(TagAlreadyLabeled) if labeled?(canonical_uuid)
-      TagMapping.create(:uuid=>canonical_uuid, :tag_id=>self.pk)
+      raise(UnacceptableTagType.new("", self, tgt)) unless accept_mapping?(tgt)
+      raise(TagAlreadyLabeled) if labeled?(tgt.canonical_uuid)
+      TagMapping.create(:uuid=>tgt.canonical_uuid, :tag_id=>self.pk)
       self
     end
 
-    def unlabel(canonical_uuid)
-      t = TagMapping.find(:uuid=>canonical_uuid, :tag_id=>self.pk) || raise(TagAlreadyUnlabeled)
-      t.delete
+    def lable_ifnot(t)
+      begin
+        lable(t)
+      rescue TagAlreadyLabeled
+      end
       self
     end
-    
-    #many_to_many :tags, :join_table=>:tag_mappings, :left_key=>:target_id, :conditions=>{:target_type=>TagMapping::TYPE_TAG}
-    
-    #many_to_one :owner, :class=>:User
-    
-    #one_to_many :tag_attributes, :one_to_one=>true
 
+    # Disassociate the tag from the taggable object.
+    # 
+    # @params [Models::Taggable,String] taggable_or_uuid
+    def unlabel(taggable_or_uuid)
+      tgt = case taggable_or_uuid
+            when String
+              Taggable.find(taggable_or_uuid) || raise("Not found Taggable object: #{taggable_or_uuid}")
+            when Models::Taggable
+              taggable_or_uuid
+            else
+              raise TypeError
+            end
+      t = TagMapping.find(:tag_id=>self.pk, :uuid=>tgt.canonical_uuid) || raise(TagAlreadyUnlabeled)
+      t.destroy
+      self
+    end
+    
     def self.find_tag_class(name)
       self.subclasses.find { |m|
-        m.to_s.sub(/^#{self.class}::/, '') == name
+        m == name || m.split('::').last == name
       }
     end
 
-    # STI class variable setter, getter methods.
-    class << self
-      
-      # Declare the integer number for the tag.
-      # 
-      # Also set the value to sti map in class Tag.
-      # class Tag1 < Tag
-      #   type_id 123456
-      # end
-      # 
-      # puts Tag1.type_id # == 123456
-      def type_id(type_id=nil)
-        if type_id.is_a?(Fixnum)
-          @type_id = type_id
-          Tag.sti_model_map[type_id] = self
-          Tag.sti_key_map[self.to_s] = type_id
-        end
-        @type_id || raise("#{self}.type_id is unset. Please set the unique number for the tag instance.")
-      end
-
-
-      # Set or read description of the Tag class.
-      def description(desc=nil)
-        if desc
-          @description = desc
-        end
-        @description
-      end
-
-    end
-
     # Check the object class type before associating to the Tag.
     # Child class must implement this method.
     # @param taggable_obj any object kind_of?(Model::Taggable)
@@ -116,11 +146,19 @@ module Dcmgr::Models
       raise NotImplementedError 
     end
 
-    def after_initialize
+    # model hook
+    def before_destroy
+      return false if !mapped_uuids_dataset.empty?
+      super
+    end
+
+    def self.lock!
       super
-      self[:type_id] = self.class.type_id
+      TagMapping.lock!
     end
 
+    def to_api_document
+      to_hash.merge({:type_id=>self.class.to_s.split('::').last})
+    end
   end
 end
-