wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/models/host_pool.rb

@@ -1,122 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'isono'
-
-module Dcmgr::Models
-  class HostPool < AccountResource
-    taggable 'hp'
-    with_timestamps
-
-    HYPERVISOR_XEN_34='xen-3.4'
-    HYPERVISOR_XEN_40='xen-4.0'
-    HYPERVISOR_KVM='kvm'
-
-    ARCH_X86=:x86.to_s
-    ARCH_X86_64=:x86_64.to_s
-
-    SUPPORTED_ARCH=[ARCH_X86, ARCH_X86_64]
-    SUPPORTED_HYPERVISOR=[HYPERVISOR_KVM]
-
-    inheritable_schema do
-      String :node_id, :size=>80, :null=>true
-      
-      String :arch, :size=>10, :null=>false # :x86, :x86_64
-      String :hypervisor, :size=>30, :null=>false
-
-      Fixnum :offering_cpu_cores,   :null=>false, :unsigned=>true
-      Fixnum :offering_memory_size, :null=>false, :unsigned=>true
-
-      index :node_id
-    end
-    
-    one_to_many :instances
-    many_to_one :node, :class=>Isono::Models::NodeState, :key=>:node_id, :primary_key=>:node_id
-
-    def after_initialize
-      super
-    end
-
-    def validate
-      super
-      # for compatibility: hva.xxx or hva-xxxx
-      unless self.node_id =~ /^hva[-.]/
-        errors.add(:node_id, "is invalid ID: #{self.node_id}")
-      end
-
-      if (h = self.class.filter(:node_id=>self.node_id).first) && h.id != self.id
-        errors.add(:node_id, " #{self.node_id} is already been associated to #{h.canonical_uuid} ")
-      end
-      
-      unless SUPPORTED_ARCH.member?(self.arch)
-        errors.add(:arch, "unknown architecture type: #{self.arch}")
-      end
-
-      unless self.offering_cpu_cores > 0
-        errors.add(:offering_cpu_cores, "it must have digit more than zero")
-      end
-      unless self.offering_memory_size > 0
-        errors.add(:offering_memory_size, "it must have digit more than zero")
-      end
-    end
-
-    def to_hash
-      super.merge(:status=>self.status)
-    end
-
-    # Check if the resources exist depending on the HostPool.
-    # @return [boolean] 
-    def depend_resources?
-      !self.instances_dataset.runnings.empty?
-    end
-    
-    # Factory method for Instance model to run on this HostPool.
-    # @param [Models::Account] account
-    # @param [Models::Image] image
-    # @param [Models::InstanceSpec] spec
-    # @param [Models::Network] network
-    # @return [Models::Instance] created new Instance object.
-    def create_instance(account, image, spec, network, &blk)
-      raise ArgumentError unless image.is_a?(Image)
-      raise ArgumentError unless spec.is_a?(InstanceSpec)
-      raise ArgumentError unless network.is_a?(Network)
-      i = Instance.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.host_pool = self
-      i.save
-
-      vnic = i.add_nic(network)
-      IpLease.lease(vnic, network)
-      
-      #Lease the nat ip in case there is an outside network mapped
-      nat_network = Network.find(:id => vnic[:nat_network_id])
-      IpLease.lease(vnic,nat_network) unless nat_network.nil? 
-      i
-    end
-
-    def status
-      node.nil? ? :offline : node.state
-    end
-
-    # Returns true/false if the host pool has enough capacity to run the spec.
-    # @param [InstanceSpec] spec 
-    def check_capacity(spec)
-      raise TypeError unless spec.is_a?(InstanceSpec)
-      inst_on_hp = self.instances_dataset.lives.all
-
-      (self.offering_cpu_cores >= inst_on_hp.inject(0) {|t, i| t += i.cpu_cores } + spec.cpu_cores) &&
-        (self.offering_memory_size >= inst_on_hp.inject(0) {|t, i| t += i.memory_size } + spec.memory_size)
-    end
-    
-    def to_api_document
-      h = to_hash
-      h.delete(:node_id)
-      h
-    end
-    
-  end
-end

data/lib/dcmgr/models/instance_netfilter_group.rb

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Dcmgr::Models
-  class InstanceNetfilterGroup < BaseNew
-
-    inheritable_schema do
-      Fixnum :instance_id, :null=>false
-      Fixnum :netfilter_group_id, :null=>false
-    end
-#    with_timestamps
-
-    many_to_one :instance
-    many_to_one :netfilter_group
-  end
-
-end

data/lib/dcmgr/models/netfilter_group.rb

@@ -1,89 +0,0 @@
-# -*- 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
-    many_to_many :instances,:join_table => :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_api_document
-      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 before_destroy
-      return false if self.instances.size > 0
-
-      self.flush_rule
-      super
-    end
-    alias :destroy_group :destroy
-
-    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
-
-  end
-end

data/lib/dcmgr/models/netfilter_rule.rb

@@ -1,21 +0,0 @@
-# -*- 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/scheduler/find_last.rb

@@ -1,16 +0,0 @@
-
-module Dcmgr
-  module PhysicalHostScheduler
-    # This is a simple host scheduler which gets back a host found
-    # at the top of hosts list.
-    class FindLast
-      def assign_to_instance(hosts, instance)
-        Dcmgr::logger.debug "assign to instance (%d hosts)" % hosts.length
-p 'hosts'
-p hosts
-        return hosts.last
-        raise NoPhysicalHostError.new("can't assign physical host")
-      end
-    end
-  end
-end

data/lib/dcmgr/scheduler/find_random.rb

@@ -1,16 +0,0 @@
-
-module Dcmgr
-  module PhysicalHostScheduler
-    # This is a simple host scheduler which gets back a host found
-    # at the top of hosts list.
-    class FindRandom
-      def assign_to_instance(hosts, instance)
-        Dcmgr::logger.debug "assign to instance (%d hosts)" % hosts.length
-        hvc_host = hosts[ rand(hosts.length) ]
-p 'hvc_host'
-p hvc_host
-        raise NoPhysicalHostError.new("can't assign physical host")
-      end
-    end
-  end
-end

data/lib/dcmgr/stm/instance.rb

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'statemachine'
-
-module Dcmgr::Stm
-  class Instance
-    STM = Statemachine.build {
-      startstate :pending
-      superstate :instance_condition do
-        trans :pending, :on_create, :starting
-        trans :starting, :on_started, :running
-        trans :running, :on_shutdown, :shuttingdown
-        trans :shuttingdown, :on_terminated, :terminated
-        
-        event :on_fail, :failed
-      end
-      
-      trans :failed, :on_fail, :failed
-    }
-    
-    def initialize
-    end
-    
-  end
-end

data/lib/dcmgr/stm/snapshot_context.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'statemachine'
-
-module Dcmgr::Stm
-  class SnapshotContext < OpenStruct
-
-    attr_reader :stm
-
-    def initialize(snapshot_id=nil)
-      super({:snapshot_id=>snapshot_id})
-      @stm = Statemachine.build {
-        trans :registering, :on_create, :creating
-        trans :creating, :on_create, :available
-        trans :available, :on_delete, :deleting
-        trans :deleting, :on_delete, :deleted
-
-        trans :registering, :on_fail, :failed
-        trans :creating, :on_fail, :failed
-        trans :available, :on_fail, :failed
-        trans :deleting, :on_fail, :failed
-      }
-      @stm.context = self
-    end
-
-    def state
-      @stm.state
-    end
-
-    def to_hash
-      @table.dup.merge({:state=>@stm.state})
-    end
-  end
-end

data/lib/dcmgr/stm/volume_context.rb

@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'statemachine'
-
-module Dcmgr::Stm
-  class VolumeContext < OpenStruct
-    attr_reader :stm
-
-    def initialize(volume_id=nil)
-      super({:volume_id => volume_id,
-              :export_path => nil,
-              :transport_information => nil,
-              :instance_id => nil,
-              :host_device_name => nil,
-              :guest_device_name => nil,
-              :deleted_at => nil,
-              :attached_at => nil,
-              :detached_at => nil,
-            })
-      @stm = Statemachine.build {
-        startstate :registering
-        superstate :volume_condition do
-          trans :registering, :on_create, :creating
-          trans :creating, :on_register, :available
-          trans :available, :on_attach, :attaching
-          trans :attaching, :on_attach, :attached
-          trans :attached, :on_detach, :detaching
-          trans :detaching, :on_detach, :available
-
-          event :on_fail, :failed
-          event :on_deregister, :deregistering
-        end
-
-        trans :failed, :on_create, :creating
-        trans :failed, :on_register, :available
-        trans :failed, :on_fail, :failed
-        trans :failed, :on_deregister, :deleting
-        trans :failed, :on_delete, :deleted
-        trans :deregistering, :on_delete, :deleting
-        trans :deleting, :on_delete, :deleted
-        trans :deleted, :on_delete, :deleted
-      }
-      @stm.context = self
-    end
-
-    def state
-      @stm.state
-    end
-    
-    def to_hash(hash={})
-      @table.dup.merge({:state=>@stm.state}).merge(hash)
-    end
-
-    def on_delete
-      self.deleted_at = Time.now
-    end
-
-    def on_attach
-      self.attached_at = Time.now
-    end
-
-    def on_detach
-      self.detached_at = Time.now
-    end
-  end
-end