wakame-vdc-dcmgr 10.11.0

data/lib/dcmgr/models/instance_nic.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  # Network interface for running instance.
+  class InstanceNic < BaseNew
+    taggable 'nic'
+
+    inheritable_schema do
+      Fixnum :instance_id, :null=>false
+      String :vif, :null=>false, :size=>50
+      String :mac_addr, :null=>false, :size=>12
+      
+      index :mac_addr, {:unique=>true}
+    end
+    with_timestamps
+
+    many_to_one :instance
+    one_to_one :ip, :class=>IpLease
+
+    def to_hash
+      h = values.dup.merge(super)
+      h.delete(:instance_id)
+      h
+    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
+      end
+      true
+    end
+
+    def validate
+      super
+
+      unless self.mac_addr.size == 12
+        errors.add(:mac_addr, "Invalid mac address length: #{self.mac_addr}")
+      end
+
+      unless self.mac_addr =~ /^[0-9a-f]{12}$/
+        errors.add(:mac_addr, "Invalid mac address syntax: #{self.mac_addr}")
+      end
+    end
+
+    def pretty_mac_addr(delim=':')
+      self.mac_addr.unpack('A2'*6).join(delim)
+    end
+
+    private
+    def normalize_mac_addr(str)
+      str = str.downcase.gsub(/[^0-9a-f]/, '')
+      raise "invalid mac address data: #{str}" if str.size > 12
+      # TODO: put more checks on the mac address.
+      #       i.e. single 0 to double 00
+      str
+    end
+    
+    
+  end
+end

data/lib/dcmgr/models/instance_spec.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class InstanceSpec < AccountResource
+    taggable 'is'
+
+    inheritable_schema do
+      String :hypervisor, :null=>false
+      String :arch, :null=>false
+      
+      Fixnum :cpu_cores, :null=>false, :unsigned=>true
+      Fixnum :memory_size, :null=>false, :unsigned=>true
+      Text :config, :null=>false, :default=>''
+    end
+    with_timestamps
+
+    def to_hash
+      super.merge({:config=>config.to_s})
+    end
+  end
+end

data/lib/dcmgr/models/ip_lease.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+require 'ipaddress'
+
+module Dcmgr::Models
+  # IP address lease information
+  class IpLease < BaseNew
+
+    inheritable_schema do
+      Fixnum :instance_nic_id, :null=>false
+      Fixnum :network_id, :null=>false
+      String :ipv4, :size=>50
+      
+      index :ipv4, {:unique=>true}
+    end
+    with_timestamps
+
+    many_to_one :instance_nic
+    many_to_one :network
+
+    def self.lease(instance_nic)
+      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}")
+      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 -
+        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?
+      
+      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)
+    end
+  end
+end

data/lib/dcmgr/models/netfilter_group.rb

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class NetfilterGroup < AccountResource
+    taggable 'ng'
+    with_timestamps
+
+    inheritable_schema do
+      String :name, :null=>false
+      String :description
+      Text   :rule
+      index [:account_id, :name], {:unique=>true}
+    end
+
+    one_to_many :netfilter_rules
+    one_to_many :instance_netfilter_groups
+
+    def to_hash
+      h = super
+      h = h.merge({
+                    :rule => rule.to_s,
+                    :rules => netfilter_rules.map { |rule| rule.to_hash },
+                  })
+      #{
+      #:id => self.canonical_uuid,
+      #:name => name,
+      #:description => description,
+      #:rules => netfilter_rules.map { |rule| rule.to_hash },
+      #}
+    end
+
+    def to_tiny_hash
+      {
+        :name => self.name,
+        :uuid => self.canonical_uuid,
+      }
+    end
+
+    def self.create_group(account_id, params)
+      grp = self.create(:account_id  => account_id,
+                        :name        => params[:name],
+                        :rule        => params[:rule],
+                        :description => params[:description])
+      grp.build_rule
+      grp
+    end
+
+    def flush_rule
+      NetfilterRule.filter(:netfilter_group_id => self.id).destroy
+    end
+
+    def destroy_group
+      self.flush_rule
+      self.destroy
+    end
+
+    def rebuild_rule
+      self.flush_rule
+      self.build_rule
+    end
+
+    def build_rule
+      return if self.rule.nil?
+
+      self.rule.split("\n").each { |permission|
+        # [ToDo]
+        # to make strong parser
+        next if permission =~ /\A#/
+        next if permission.length == 0
+
+        # [format] protocol,source,destination
+        # - protocol: tcp|udp|icmp
+        # - source: IPAddr|CIDR|Owner:Group
+        # - destination: port|icmp-type
+        NetfilterRule.create(:netfilter_group_id => self.id,
+                             :permission         => permission)
+
+      }
+    end
+
+    def instances
+      self.instance_netfilter_groups.map { |instance_netfilter_group|
+        instance_netfilter_group.instance
+      }
+    end
+
+  end
+end

data/lib/dcmgr/models/netfilter_rule.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class NetfilterRule < BaseNew
+    with_timestamps
+
+    inheritable_schema do
+      Fixnum :netfilter_group_id, :null=>false
+      String :permission, :null=>false
+    end
+
+    many_to_one :netfilter_group
+
+    def to_hash
+      {
+        :permission => permission,
+      }
+    end
+
+  end
+end

data/lib/dcmgr/models/network.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  # Network definitions in the DC.
+  class Network < BaseNew
+
+    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 :metadata_server
+      Text :description
+      index :name, {:unique=>true}
+    end
+    with_timestamps
+
+    many_to_one :host_pool
+    one_to_many :ip_lease
+
+    def validate
+      super
+    end
+
+    def to_hash
+      values.dup.merge({:description=>description.to_s})
+    end
+    
+  end
+end

data/lib/dcmgr/models/physical_host.rb

@@ -0,0 +1,67 @@
+module Dcmgr
+  module Models
+    class PhysicalHost < Base
+      set_dataset :physical_hosts
+      set_prefix_uuid 'PH'
+
+      one_to_many :hv_agents
+      
+      many_to_many :tags, :join_table=>:tag_mappings, :left_key=>:target_id, :conditions=>{:target_type=>TagMapping::TYPE_PHYSICAL_HOST}
+      many_to_many :location_tags, :class=>:Tag, :right_key=>:tag_id, :join_table=>:tag_mappings, :left_key=>:target_id, :conditions=>{:target_type=>TagMapping::TYPE_PHYSICAL_HOST_LOCATION}
+
+      many_to_one :relate_user, :class=>:User
+
+      def self.enable_hosts
+        filter(~:id => TagMapping.filter(:target_type=>TagMapping::TYPE_PHYSICAL_HOST).select(:target_id)).order_by(:id).all
+      end
+
+      def self.assign(instance)
+        Dcmgr::scheduler.assign_to_instance(enable_hosts, instance)
+      end
+      
+      def before_create
+        super
+      end
+
+      def after_create
+        super
+        TagMapping.create(:tag_id=>Tag.system_tag(:STANDBY_INSTANCE).id,
+                          :target_type=>TagMapping::TYPE_PHYSICAL_HOST,
+                          :target_id=>self.id)
+      end
+
+      def instances
+        self.hv_agents.map{|hva| hva.instances}.flatten
+      end
+
+      def create_location_tag(name, account)
+        TagMapping.create(:tag_id=>Tag.create(:name=>name, :account=>account).id,
+                          :target_type=>TagMapping::TYPE_PHYSICAL_HOST_LOCATION,
+                          :target_id=>self.id)
+      end
+
+      def space_cpu_mhz
+        setup_space unless @space_cpu_mhz
+        @space_cpu_mhz
+      end
+
+      def setup_space
+        
+        need_cpu_mhz = instances.inject(0) {|v, ins| v + ins.need_cpu_mhz}
+        space_cpu_mhz = cpu_mhz - need_cpu_mhz
+        # 10 % down
+        @space_cpu_mhz = space_cpu_mhz * 0.9
+        
+        need_memory = instances.inject(0) {|v, ins| v + ins.need_memory}
+        space_memory = memory - need_memory
+        # 10 % down
+        @space_memory = space_memory * 0.9
+      end
+      
+      def space_memory
+        setup_space unless @space_memory
+        @space_memory
+      end
+    end
+  end
+end

data/lib/dcmgr/models/request_log.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class RequestLog < BaseNew
+
+    inheritable_schema do
+      String :request_id, :null=>false, :size=>40, :unique=>true
+      Fixnum :frontend_system_id, :null=>false
+      Fixnum :account_id, :null=>false
+      String :requester_symbol, :null=>false, :size=>100
+      # HTTP Response Code
+      Fixnum :response_status, :null=>false
+      String :response_msg
+      String :api_path, :null=>false
+      String :params, :null=>false
+      Time :requested_at
+      Time :responsed_at
+    end
+
+    def after_initialize
+      self[:request_id] #
+    end
+    
+  end
+end

data/lib/dcmgr/models/ssh_key_pair.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+require 'tmpdir'
+
+module Dcmgr::Models
+  # SSH Key database for account.
+  class SshKeyPair < AccountResource
+    taggable 'ssh'
+
+    inheritable_schema do
+      String :name, :size=>100, :null=>false
+      Text :public_key, :null=>false
+      Text :private_key, :null=>true
+      
+      index [:account_id, :name], {:unique=>true}
+    end
+    with_timestamps
+
+    def validate
+    end
+
+    def before_destroy
+      # TODO: check running instances which are associated to ssh key
+      # pairs. reject deletion if exist.
+    end
+
+    # 
+    # @return [Hash] {:private_key=>'pkey string',
+    #                 :public_key=>'pubkey string'}
+    def self.generate_key_pair()
+      pkey = File.expand_path(randstr, Dir.tmpdir)
+      pubkey = pkey + '.pub'
+      begin
+        system("ssh-keygen -q -t rsa -C '' -N '' -f %s >/dev/null" % [pkey])
+        unless $?.exitstatus == 0
+          raise "Failed to run ssh-keygen: exitcode=#{$?.exitstatus}"
+        end
+        
+        {:private_key=>IO.read(pkey),
+          :public_key=>IO.read(pubkey)}
+      rescue
+        # clean up tmp key files
+        [pkey, pubkey].each { |i|
+          File.unlink(i) if File.exist?(i)
+        }
+      end
+    end
+
+    private
+    def self.randstr
+      Array.new(10) {  (('a'..'z').to_a + (0..9).to_a)[rand(36)] }.join
+    end
+    
+  end
+end

data/lib/dcmgr/models/storage_pool.rb

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+require 'statemachine'
+
+module Dcmgr::Models
+  class StoragePool < AccountResource
+    taggable 'sp'
+    with_timestamps
+
+    STATAS_TYPE_REGISTERING = "registering"
+    STATAS_TYPE_ONLINE = "online"
+    STATAS_TYPE_DEGRADE = "degrade"
+    STATAS_TYPE_FAILED = "failed"
+    STATAS_TYPE_DEREGISTERED = "deregistered"
+
+    STATUS_MSGS = {
+      STATAS_TYPE_REGISTERING => :registering,
+      STATAS_TYPE_ONLINE => :online,
+      STATAS_TYPE_DEGRADE => :degrade,
+      STATAS_TYPE_FAILED => :failed,
+      STATAS_TYPE_DEREGISTERED => :deregistered
+    }
+    
+    inheritable_schema do
+      String :node_id, :null=>false
+      String :export_path, :null=>false
+      String :status, :null=>false, :default=>STATAS_TYPE_REGISTERING
+      Fixnum :offerring_disk_space, :null=>false, :unsigned=>true
+      String :transport_type, :null=>false
+      String :storage_type, :null=>false
+      String :ipaddr, :null=>false
+      String :snapshot_base_path, :null=>false
+    end
+
+    one_to_many :volumes
+    one_to_many :volume_snapshots
+    
+    many_to_one :storage_agents
+    
+    def before_validation
+      export_path = self.export_path
+      if export_path =~ /^(\/[a-z0-9]+)+$/
+        export_path = export_path.split('/')
+        export_path.shift
+        self.export_path = export_path.join('/')
+      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
+        superstate :storage_condition do
+          trans :registering, :on_success, :online
+          trans :registering, :on_error, :degrade
+          trans :online, :on_success, :online
+          trans :online, :on_error, :degrade
+          trans :degrade, :on_success, :online
+          trans :degrade, :on_error, :degrade
+
+          event :on_fail, :failed
+          event :on_deregistered, :deregistered
+        end
+
+        trans :failed, :on_success, :online
+        trans :failed, :on_error, :degrade
+        trans :failed, :on_deregistered, :deregistered
+
+        on_entry_of :registering, proc {
+          model.status = STATAS_TYPE_REGISTERING
+        }
+
+        on_entry_of :online, proc {
+          model.status = STATAS_TYPE_ONLINE
+        }
+
+        on_entry_of :degrade, proc {
+          model.status = STATAS_TYPE_DEGRADE
+        }
+
+        on_entry_of :failed, proc {
+          model.status = STATAS_TYPE_FAILED
+        }
+
+        on_entry_of :deregistered, proc {
+          model.status = STATAS_TYPE_DEREGISTERED
+        }
+      end
+
+      if self[:status]
+        if st.has_state(STATUS_MSGS[self[:status]].to_sym)
+          st.state = STATUS_MSGS[self[:status]].to_sym
+        else
+          raise "Unknown state: #{self[:status]}"
+        end
+      else
+        st.reset
+      end
+      st
+    end
+
+    def self.create_pool(params)
+      self.create(:account_id => params[:account_id],
+                  :node_id => params[:node_id],
+                  :offerring_disk_space => params[:offerring_disk_space],
+                  :transport_type => params[:transport_type],
+                  :storage_type => params[:storage_type],
+                  :export_path => params[:export_path],
+                  :ipaddr => params[:ipaddr],
+                  :snapshot_base_path => params[:snapshot_base_path])
+    end
+
+    def self.get_lists(uuid)
+      self.dataset.where(:account_id => uuid).all.map{|row|
+        row.values
+      }
+    end
+
+    # def find_private_pool(account_id, uuid)
+    #   sp = self.dataset.where(:account_id=>account_id).where(:uuid=>uuid)
+    # end
+
+    def create_volume(account_id, size, snapshot_id=nil)
+      v = Volume.create(:account_id => account_id,
+                        :storage_pool_id => self.id,
+                        :snapshot_id => snapshot_id,
+                        :size =>size)
+    end
+  end
+end