Class: Dcmgr::Models::HostNode

Inherits:
AccountResource show all
Defined in:
lib/dcmgr/models/host_node.rb

Constant Summary collapse

HYPERVISOR_XEN_34 = 
'xen-3.4'
HYPERVISOR_XEN_40 = 
'xen-4.0'
HYPERVISOR_KVM = 
'kvm'
HYPERVISOR_LXC = 
'lxc'
ARCH_X86 = 
:x86.to_s
ARCH_X86_64 = 
:x86_64.to_s
SUPPORTED_ARCH = 
[ARCH_X86, ARCH_X86_64]
SUPPORTED_HYPERVISOR = 
[HYPERVISOR_KVM, HYPERVISOR_LXC]

Constants inherited from BaseNew

BaseNew::LOCK_TABLES_KEY

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from AccountResource

#account

Methods inherited from BaseNew

Proxy, dataset, default_row_lock_mode=, install_data, install_data_hooks, lock!, unlock!, #with_timestamps?

Class Method Details

.check_domain_capacity?(cpu_cores, memory_size, num = 1) ⇒ Boolean

Check the free resource capacity across entire local VDC domain.



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/dcmgr/models/host_node.rb', line 104

def self.check_domain_capacity?(cpu_cores, memory_size, num=1)
  alives_mem_size = Instance.dataset.lives.filter.sum(:memory_size).to_i
  stopped_mem_size = Instance.dataset.lives.filter(:state=>'stopped').sum(:memory_size).to_i
  alives_cpu_cores = Instance.dataset.lives.filter.sum(:cpu_cores).to_i
  stopped_cpu_cores = Instance.dataset.lives.filter(:state=>'stopped').sum(:cpu_cores).to_i
  # instance releases the resources during stopped state normally. however admins may
  # want to manage the reserved resource ratio for stopped
  # instances. "stopped_instance_usage_factor" conf parameter allows its control.
  # 
  # * stopped_instance_usage_factor == 1.0 means that 100% of
  # resources are reserved for stopped instances. all of them will
  # success to start up but utilization of host notes will be dropped.
  # * stopped_instance_usage_factor == 0.5 means that 50% of
  # resources for stopped instances are reserved and rest of 50%
  # may fail to start again.
  usage_factor = (Dcmgr.conf.stopped_instance_usage_factor || 1.0).to_f
  avail_mem_size = self.online_nodes.sum(:offering_memory_size).to_i - ((alives_mem_size - stopped_mem_size) + (stopped_mem_size * usage_factor).floor)
  avail_cpu_cores = self.online_nodes.sum(:offering_cpu_cores).to_i - ((alives_cpu_cores - stopped_cpu_cores) + (stopped_cpu_cores * usage_factor).floor)
  
  (avail_mem_size >= memory_size * num.to_i) && (avail_cpu_cores >= cpu_cores * num.to_i)
end

Instance Method Details

#available_cpu_cores ⇒ Object

Returns available CPU cores.



94
95
96
 
# File 'lib/dcmgr/models/host_node.rb', line 94

def available_cpu_cores
  self.offering_cpu_cores - self.cpu_core_usage
end

#available_memory_size ⇒ Object

Returns available memory size.



99
100
101
 
# File 'lib/dcmgr/models/host_node.rb', line 99

def available_memory_size
  self.offering_memory_size - self.memory_size_usage
end

#check_capacity(spec) ⇒ Object

Returns true/false if the host pool has enough capacity to run the spec.

Raises:

  • (TypeError) 


68
69
70
71
72
73
74
 
# File 'lib/dcmgr/models/host_node.rb', line 68

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

#cpu_core_usage ⇒ Object

Returns reserved CPU cores used by running/scheduled instances.



84
85
86
 
# File 'lib/dcmgr/models/host_node.rb', line 84

def cpu_core_usage
  instances_usage(:cpu_cores)
end

#depend_resources? ⇒ boolean

Check if the resources exist depending on the HostNode.



58
59
60
 
# File 'lib/dcmgr/models/host_node.rb', line 58

def depend_resources?
  !self.instances_dataset.runnings.empty?
end

#memory_size_usage ⇒ Object

Returns reserved memory size used by running/scheduled instances.



89
90
91
 
# File 'lib/dcmgr/models/host_node.rb', line 89

def memory_size_usage
  instances_usage(:memory_size)
end

#status ⇒ Object 



62
63
64
 
# File 'lib/dcmgr/models/host_node.rb', line 62

def status
  node.nil? ? :offline : node.state
end

#to_api_document ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/dcmgr/models/host_node.rb', line 76

def to_api_document
  h = super()
  h.merge!(:status=>self.status)
  h.delete(:node_id)
  h
end

#to_hash ⇒ Object 



52
53
54
 
# File 'lib/dcmgr/models/host_node.rb', line 52

def to_hash
  super.merge(:status=>self.status)
end

#validate ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/dcmgr/models/host_node.rb', line 29

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