wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/models/instance_security_group.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class InstanceSecurityGroup < BaseNew
+
+    many_to_one :instance
+    many_to_one :security_group
+  end
+end

data/lib/dcmgr/models/instance_spec.rb

@@ -4,54 +4,186 @@ module Dcmgr::Models
   class InstanceSpec < AccountResource
     taggable 'is'
 
-    inheritable_schema do
-      String :name, :null=>false
-      String :hypervisor, :null=>false
-      String :arch, :null=>false
-      
-      Fixnum :cpu_cores, :null=>false, :unsigned=>true
-      Fixnum :memory_size, :null=>false, :unsigned=>true
-      Float  :quota_weight, :null=>false, :default=>1.0
-      Text :config, :null=>false, :default=>''
-      Text :storage, :null=>false, :default=>''
-
-      index [:account_id, :name], {:unique=>true}
-    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
-    # hypervisor=kvm:
-    # { 'sdc'  => {:type=>:vdcvol, :size=>100, :dev=>'/dev/sdc'},
-    #   'eph1' => {:type=>:ephemeral, :size=>1000, :dev=>'/dev/sdb'}}
-    serialize_attributes :yaml, :storage
-
-    def before_validate
-      default_config =
-        case self.hypervisor
-        when HostPool::HYPERVISOR_KVM
-          {:block_driver=>'virtio', :nic_driver=>'virtio'}
-        end
+    # initial attached virtual interface definition: 
+    # {
+    #   'vif1' => {
+    #     :index => 0,     # (>=0) required and unique
+    #     :bandwidth=>512, # (kbps) required
+    #   },
+    #   'vif2' => {
+    #     :index => 10,    # (>=0) required and unique
+    #     :bandwidth=>50000, # (kbps) required
+    #   },
+    # }
+    serialize_attributes :yaml, :vifs
+    # initial attached disk definition:
+    # {
+    #  # blank disk image file on host OS for swap device.
+    #  'swap1' => {
+    #    :index => 0,      # (>=0) required and unique
+    #    :type  => :local, # required
+    #    :size  => 100,    # (MB) required
+    #  },
+    #  # attach volume disk from snapshot.
+    #  'volume1' => {
+    #    :index => 1,      # (>=0) required and unique
+    #    :type => :volume, # required
+    #    :snapshot_id => 'snap-xxxxxx', # required
+    #  },
+    #  # attach blank volume disk.
+    #  'volume2' => {
+    #    :index => 5,      # (>=0) required and unique
+    #    :type => :volume, # required
+    #    :size => 100,     # (MB) required
+    #  },
+    # }
+    serialize_attributes :yaml, :drives
+
+    def before_validation
+      default_config = {}
 
       self.config = default_config.merge(self.config || {})
+
+      # Set empty hash for
+      self.vifs ||= {}
+      self.drives ||= {}
+      super
+    end
+
+    def validate
+      super
+
+      # uniquness check for :index
+      unless self.vifs.values.map {|i| i[:index] }.uniq.size == self.vifs.size
+        errors.add(:vifs, "duplicate index value.")
+      end
+      unless self.drives.values.map {|i| i[:index] }.uniq.size == self.drives.size
+        errors.add(:drives, "duplicate index value.")
+      end
+    end
+
+    def before_destroy
+      if !Instance.alives.filter(:instance_spec_id=>self.id).empty?
+        raise "There are one or more running instances refers this record."
+      end
+      
       super
     end
 
     def to_hash
       super.merge({:config=>self.config, # yaml -> Hash
-                    :storage => self.storage, # yaml -> Hash
+                    :vifs => self.vifs, # yaml -> Hash
+                    :drives => self.drives, # yaml -> Hash
                   })
     end
 
     def to_api_document
-      doc = to_hash
+      doc = super()
       doc.delete(:config)
       doc
     end
+
+    # Modify methods for vifs,drives hash parameters.
+    def add_vif(name, index, bandwidth)
+      raise "Duplicate interface name: #{name}" if self.vifs.has_key?(name)
+      self.vifs[name]={
+        :index => index,
+        :bandwidth => bandwidth,
+      }
+      self.changed_columns << :vifs
+      self
+    end
+
+    def update_vif_index(name, new_index)
+      raise "Unknown interface name: #{name}" if !self.vifs.has_key?(name)
+      self.vifs[name][:index]=new_index
+      self.changed_columns << :vifs
+      self
+    end
+
+    def update_vif_bandwidth(name, bandwidth)
+      raise "Unknown interface name: #{name}" if !self.vifs.has_key?(name)
+      self.vifs[name][:bandwidth]=bandwidth
+      self.changed_columns << :vifs
+      self
+    end
+
+    def remove_vif(name)
+      self.vifs.delete(name)
+      self.changed_columns << :vifs
+      self
+    end
+    
+    def add_local_drive(name, index, size)
+      raise "Duplicate drive name: #{name}" if self.drives.has_key?(name)
+      self.drives[name] = {
+        :index => index,
+        :type => :local,
+        :size => size,
+      }
+      self.changed_columns << :drives
+      self
+    end
+
+    def add_volume_drive(name, index, size)
+      raise "Duplicate drive name: #{name}" if self.drives.has_key?(name)
+      self.drives[name] = {
+        :index => index,
+        :type => :volume,
+        :size => size,
+      }
+      self.changed_columns << :drives
+      self
+    end
+
+    def add_volume_drive_from_snapshot(name, index, snapshot_id)
+      raise "Duplicate drive name: #{name}" if self.drives.has_key?(name)
+      self.drives[name] = {
+        :index => index,
+        :type => :volume,
+        :snapshot_id => snapshot_id,
+      }
+      self.changed_columns << :drives
+      self
+    end
+    
+    def update_drive_index(name, new_index)
+      raise "Unknown drive name: #{name}" if !self.drives.has_key?(name)
+      drive = self.drives[name]
+      drive[:index] = new_index
+      self.changed_columns << :drives
+      self
+    end
+
+    def update_drive_snapshot_id(name, snapshot_id)
+      raise "Unknown drive name: #{name}" if !self.drives.has_key?(name)
+      drive = self.drives[name]
+      raise "Snapshot ID can only be set to volume drive" if !(drive[:type] == :volume)
+      drive.delete(:size)
+      # TODO: syntax check for snapshot_id
+      drive[:snapshot_id] = snapshot_id
+      self.changed_columns << :drives
+      self
+    end
+
+    def update_drive_size(name, size)
+      raise "Unknown drive name: #{name}" if !self.drives.has_key?(name)
+      drive = self.drives[name]
+      drive.delete(:snapshot_id) if drive[:type] == :volume
+      drive[:size] = size
+      self.changed_columns << :drives
+      self
+    end
+
+    def remove_drive(name)
+      self.drives.delete(name)
+      self.changed_columns << :drives
+      self
+    end
+    
   end
 end

data/lib/dcmgr/models/ip_lease.rb

@@ -15,18 +15,6 @@ module Dcmgr::Models
       TYPE_MANUAL=>'manual'
     }
     
-    inheritable_schema do
-      Fixnum :instance_nic_id
-      Fixnum :network_id, :null=>false
-      String :ipv4, :size=>50
-      Fixnum :alloc_type, :null=>false, :default=>TYPE_AUTO
-      Text :description
-      
-      index [:network_id, :ipv4], {:unique=>true}
-      index [:instance_nic_id, :network_id]
-    end
-    with_timestamps
-
     many_to_one :instance_nic
     many_to_one :network
 
@@ -35,7 +23,7 @@ module Dcmgr::Models
       begin
         addr = IPAddress::IPv4.new("#{self.ipv4}")
         # validate if ipv4 is in the range of network_id.
-        unless network.ipaddress.network.include?(addr)
+        unless network.include?(addr)
           errors.add(:ipv4, "IP address #{addr} is out of range: #{network.canonical_uuid})")
         end
       rescue => e
@@ -54,8 +42,8 @@ module Dcmgr::Models
     #    if the IpLease has a pair NAT address it will return
     #    outside IpLease.
     def nat_outside_lease
-      if self.network.nat_network_id
-        self.class.find(:instance_nic_id=>self.instance_nic.id, :network_id=>self.network.nat_network_id)
+      if self.instance_nic.nat_network_id
+        self.class.find(:instance_nic_id=>self.instance_nic.id, :network_id=>self.instance_nic.nat_network_id)
       else
         nil
       end
@@ -65,7 +53,7 @@ module Dcmgr::Models
     # @return [IpLease,nil] IpLease (outside) will return inside
     #     IpLease.
     def nat_inside_lease
-      if self.network.nat_network_id.nil?
+      if self.instance_nic.nat_network_id.nil?
         self.class.find(:instance_nic_id=>self.instance_nic.id, :network_id=>nil)
       else
         nil
@@ -75,14 +63,15 @@ module Dcmgr::Models
     def self.lease(instance_nic, network)
       raise TypeError unless instance_nic.is_a?(InstanceNic)
       raise TypeError unless network.is_a?(Network)
-      
-      gwaddr = network.ipaddress
-      reserved = [gwaddr]
+
+      reserved = []
+      reserved << network.ipv4_gw_ipaddress if network.ipv4_gw
+      reserved << IPAddress::IPv4.new(network.dhcp_server) if network.dhcp_server
       reserved = reserved.map {|i| i.to_u32 }
       # use SELECT FOR UPDATE to lock rows within same network.
-      addrs = (gwaddr.network.first.to_u32 .. gwaddr.network.last.to_u32).to_a -
+      addrs = network.ipv4_u32_dynamic_range_array - 
         reserved - network.ip_lease_dataset.for_update.all.map {|i| IPAddress::IPv4.new(i.ipv4).to_u32 }
-      raise "Out of free IP address in this network segment: #{gwaddr.network.to_s}/#{gwaddr.prefix}" if addrs.empty?
+      raise "Run out of dynamic IP addresses from the network segment: #{network.ipv4_network.to_s}/#{network.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

@@ -4,19 +4,38 @@ 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}
+    # register MAC address.
+    # @params [String] 6 or 12 length of HEX value in string.
+    def self.lease(mac_addr)
+      case mac_addr.size
+      when 12
+      when 6
+        # Assign bottom 6 device ID dynamically.
+        vendor_id = mac_addr.dup
+        begin
+          mac_addr = vendor_id + ("%02x%02x%02x" % [rand(0xff),rand(0xff),rand(0xff)])
+        end while self.find(:mac_addr=> mac_addr)
+      else
+        raise ArgumentError, "Invalid MAC address string: 6 or 12 length of HEX value is needed."
+      end
+      create(:mac_addr=>mac_addr)
     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)
+    # show default vendor ID for the hypervisor.
+    # The virtual interface can be applied any valid MAC address. But using
+    # the well known vendor IDs for hypervisor have some benefits. For
+    # example, 70-persistent-net.rules issue can be avoided with newer
+    # udev release.
+    def self.default_vendor_id(hypervisor)
+      case hypervisor.to_sym
+      when :kvm
+        '525400'
+      when :lxc
+        # LXC is not known with the specific vendor ID. This may be wrong.
+        '525400'
+      else
+        raise "Unknown hypervisor name: #{hypervisor}"
+      end
     end
   end
 end

data/lib/dcmgr/models/network.rb

@@ -7,22 +7,6 @@ module Dcmgr::Models
   class Network < AccountResource
     taggable 'nw'
 
-    inheritable_schema do
-      String :ipv4_gw, :null=>false
-      Fixnum :prefix, :null=>false, :default=>24, :unsigned=>true
-      String :domain_name
-      String :dns_server
-      String :dhcp_server
-      String :metadata_server
-      Fixnum :metadata_server_port
-      Fixnum :bandwidth #in Mbit/s
-      Fixnum :vlan_lease_id, :null=>false, :default=>0
-      Fixnum :nat_network_id
-      Text :description
-      index :nat_network_id
-    end
-    with_timestamps
-
     module IpLeaseMethods
       def add_reserved(ipaddr, description=nil)
         model.create(:network_id=>model_object.id,
@@ -37,19 +21,51 @@ module Dcmgr::Models
     many_to_one :nat_network, :key => :nat_network_id, :class => self
     one_to_many :inside_networks, :key => :nat_network_id, :class => self
 
+    one_to_many :dhcp_range
+    many_to_one :physical_network
+
+    def before_validation
+      self.link_interface ||= "br-#{self[:uuid]}"
+      super
+    end
+
     def validate
       super
       
+      unless (1..31).include?(self.prefix.to_i)
+        errors.add(:prefix, "prefix must be 1-31: #{self.prefix}")
+      end
+
+      network_addr = begin
+                       IPAddress::IPv4.new("#{self.ipv4_network}/#{self.prefix}").network
+                     rescue => e
+                       errors.add(:ipv4_network, "Invalid IP address syntax: #{self.ipv4_network}")
+                     end
       # validate ipv4 syntax
-      begin
-        IPAddress::IPv4.new("#{self.ipv4_gw}")
-      rescue => e
-        errors.add(:ipv4_gw, "Invalid IP address syntax: #{self.ipv4_gw}")
+      if self.ipv4_gw
+        begin
+          if !network_addr.include?(IPAddress::IPv4.new("#{self.ipv4_gw}"))
+            errors.add(:ipv4_gw, "Out of network address range: #{network_addr.to_s}")
+          end
+        rescue => e
+          errors.add(:ipv4_gw, "Invalid IP address syntax: #{self.ipv4_gw}")
+        end
+      end
+      
+      if self.dhcp_server
+        begin
+          if !network_addr.include?(IPAddress::IPv4.new("#{self.dhcp_server}"))
+            errors.add(:dhcp_server, "Out of network address range: #{network_addr.to_s}")
+          end
+        rescue => e
+          errors.add(:dhcp_server, "Invalid IP address syntax: #{self.dhcp_server}")
+        end
       end
 
-      unless (1..31).include?(self.prefix.to_i)
-        errors.add(:prefix, "prefix must be 1-31: #{self.prefix}")
+      if self.link_interface.size > 16
+        errors.add(:link_interface, "Can not be the character lenth more than 16(=IF_NAMESIZ) ASCII characters.")
       end
+      
     end
 
     def to_hash
@@ -60,6 +76,11 @@ module Dcmgr::Models
                 :description=>description.to_s,
                 :vlan_id => vlan_lease.nil? ? 0 : vlan_lease.tag_id,
               })
+      if self.physical_network
+        h[:physical_network] = self.physical_network.to_hash
+      end
+     
+      h
     end
 
     def before_destroy
@@ -78,14 +99,19 @@ module Dcmgr::Models
     end
 
     def to_api_document
-      to_hash
+      to_hash.merge(:id=>self.canonical_uuid)
     end
 
     def nat_network
       Network.find(:id => self.nat_network_id)
     end
 
-    def ipaddress
+    def ipv4_ipaddress
+      IPAddress::IPv4.new("#{self.ipv4_network}/#{self.prefix}").network
+    end
+
+    def ipv4_gw_ipaddress
+      return nil if self.ipv4_gw.nil?
       IPAddress::IPv4.new("#{self.ipv4_gw}/#{self.prefix}")
     end
 
@@ -93,16 +119,111 @@ module Dcmgr::Models
     # @param [String] ipaddr IP address
     def include?(ipaddr)
       ipaddr = ipaddr.is_a?(IPAddress::IPv4) ? ipaddr : IPAddress::IPv4.new(ipaddr)
-      self.ipaddress.network.include?(ipaddr)
+      self.ipv4_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)
+      raise "Out of subnet range: #{ipaddr} to #{self.ipv4_ipaddress}/#{self.prefix}" if !self.include?(ipaddr)
+      add_ip_lease(:ipv4=>ipaddr.to_s, :type=>IpLease::TYPE_RESERVED)
     end
 
     def available_ip_nums
-      self.ipaddress.hosts.size - self.ip_lease_dataset.count
+      self.ipv4_ipaddress.hosts.size - self.ip_lease_dataset.count
+    end
+
+    def ipv4_u32_dynamic_range_array
+      ary=[]
+      dhcp_range_dataset.each { |r|
+        ary += (r.range_begin.to_u32 .. r.range_end.to_u32).to_a
+      }
+      ary
+    end
+
+    def add_ipv4_dynamic_range(range_begin, range_end)
+      test_inclusion(*validate_range_args(range_begin, range_end)) { |range, op|
+         case op
+         when :coverbegin
+           range.range_end = range_begin
+         when :coverend
+           range.range_begin = range_end
+         when :inccur
+           range.destroy
+         end
+         range.save_changes
+      }
+      
+      self.add_dhcp_range(:range_begin=>range_begin.to_s, :range_end=>range_end.to_s)
+      
+      self
+    end
+
+    def del_ipv4_dynamic_range(range_begin, range_end)
+      test_inclusion(*validate_range_args(range_begin, range_end)) { |range, op|
+        case op
+        when :coverbegin
+          range.range_end = range_begin
+        when :coverend
+          range.range_begin = range_end
+        when :inccur
+          range.destroy
+        when :incnew
+          t = range.range_end
+          range.range_end = range_begin
+          self.add_dhcp_range(:range_begin=>range_end, :range_end=>t)
+        end
+        range.save_changes
+      }
+
+      self
+    end
+
+    private
+    def validate_range_args(range_begin, range_end)
+      if range_begin.is_a?(IPAddress::IPv4)
+        raise "Different prefix length: range_begin" if range_begin.prefix != self.prefix
+      else
+        range_begin = IPAddress::IPv4.new("#{range_begin}/#{self.prefix}")
+      end
+      if range_end.is_a?(IPAddress::IPv4)
+        raise "Different prefix length: range_end" if range_end.prefix != self.prefix
+      else
+        range_end = IPAddress::IPv4.new("#{range_end}/#{self.prefix}")
+      end
+      if !(self.ipv4_ipaddress.include?(range_begin) && self.ipv4_ipaddress.include?(range_end))
+        raise "Given address range is out of the subnet: #{self.ipv4_ipaddress} #{range_begin}-#{range_end}"
+      end
+      if range_begin > range_end
+        t = range_begin
+        range_begin = range_end
+        range_end = t
+      end
+      [range_begin, range_end]
+    end
+
+
+    def test_inclusion(range_begin, range_end, &blk)
+      dhcp_range_dataset.each { |r|
+        op = :outrange
+        if r.range_begin < range_begin && r.range_end > range_begin
+          # range_begin is in the range.
+          if r.range_end < range_end
+            op = :coverbegin
+          else
+            # new range is included in current range.
+            op = :incnew
+          end
+        elsif r.range_begin < range_end && r.range_end > range_end
+          # range_end is in the range.
+          if r.range_begin > range_begin
+            op = :coverend
+          end
+        elsif r.range_begin >= range_begin && r.range_end <= range_end
+          # current range is included in new range.
+          op = :inccur
+        end
+        blk.call(r, op)
+      }
     end
   end
 end