wakame-vdc-agents 10.11.0

data/lib/dcmgr/models/tag.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class Tag < BaseNew
+    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 :attributes
+    end
+
+    TYPE_NORMAL = 0
+    TYPE_AUTH = 1
+
+    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)
+          !self.filter(:uuid=>canonical_uuid).empty?
+        end
+      }
+      ds
+    end
+
+    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)
+        @tag = tag
+        @taggable = taggable
+      end
+      #TODO: show @tag and @taggable info to the error message.
+    end
+    class TagAlreadyLabeled < StandardError; end
+    class TagAlreadyUnlabeled < StandardError; end
+
+    def labeled?(canonical_uuid)
+      # TODO: check if the uuid exists
+      
+      !TagMapping.filter(:uuid=>canonical_uuid, :tag_id=>self.pk).empty?
+    end
+    
+    def label(canonical_uuid)
+      tgt = Taggable.find(canonical_uuid)
+      
+      raise(UnacceptableTagType, self, tgt) if accept_mapping?(tgt)
+      raise(TagAlreadyLabeled) if labeled?(canonical_uuid)
+      TagMapping.create(:uuid=>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
+      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
+
+    def self.find_tag_class(name)
+      self.subclasses.find { |m|
+        m.to_s.sub(/^#{self.class}::/, '') == 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)
+    def accept_mapping?(taggable_obj)
+      raise NotImplementedError 
+    end
+
+    def after_initialize
+      super
+      self[:type_id] = self.class.type_id
+    end
+
+  end
+end
+

data/lib/dcmgr/models/tag_mapping.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class TagMapping < BaseNew
+    TYPE_ACCOUNT = 0
+    TYPE_TAG = 1
+    TYPE_USER = 2
+    TYPE_INSTANCE = 3
+    TYPE_INSTANCE_IMAGE = 4
+    TYPE_HV_CONTROLLER = 5
+    TYPE_HV_AGENT = 6
+    TYPE_PHYSICAL_HOST = 7
+    TYPE_PHYSICAL_HOST_LOCATION = 8
+    TYPE_IMAGE_STORAGE_HOST = 9
+    TYPE_IMAGE_STORAGE = 10
+
+    inheritable_schema do
+      Fixnum :tag_id, :null=>false
+      index :tag_id
+      String :uuid, :null=>false, :fixed=>true, :size=>20
+      index :uuid
+    end
+    
+    many_to_one :tag
+
+  end
+end
+

data/lib/dcmgr/models/volume.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+require 'statemachine'
+
+module Dcmgr::Models
+  class Volume < AccountResource
+    taggable 'vol'
+
+    STATUS_TYPE_REGISTERING = "registering"
+    STATUS_TYPE_ONLINE = "online"
+    STATUS_TYPE_OFFLINE = "offline"
+    STATUS_TYPE_FAILED = "failed"
+
+    STATE_TYPE_REGISTERING = "registering"
+    STATE_TYPE_CREATING = "creating"
+    STATE_TYPE_AVAILABLE = "available"
+    STATE_TYPE_ATTATING = "attating"
+    STATE_TYPE_ATTACHED = "attached"
+    STATE_TYPE_DETACHING = "detaching"
+    STATE_TYPE_FAILED = "failed"
+    STATE_TYPE_DEREGISTERING = "deregistering"
+    STATE_TYPE_DELETING = "deleting"
+    STATE_TYPE_DELETED = "deleted"
+
+    inheritable_schema do
+      Fixnum :storage_pool_id, :null=>false
+      String :status, :null=>false, :default=>STATUS_TYPE_REGISTERING
+      String :state, :null=>false, :default=>STATE_TYPE_REGISTERING
+      Fixnum :size, :null=>false
+      Fixnum :instance_id
+      String :snapshot_id
+      String :host_device_name
+      String :guest_device_name
+      String :export_path, :null=>false
+      Text :transport_information
+      Time :deleted_at
+      Time :attached_at
+      Time :detached_at
+      index :storage_pool_id
+      index :instance_id
+      index :snapshot_id
+    end
+    with_timestamps
+
+    # serialization plugin must be defined at the bottom of all class
+    # method calls.
+    # Possible column data:
+    # iscsi:
+    # {:iqn=>'iqn.1986-03.com.sun:02:a1024afa-775b-65cf-b5b0-aa17f3476bfc', :lun=>0}
+    plugin :serialization, :yaml, :transport_information
+    
+    many_to_one :storage_pool
+    many_to_one :instance
+
+    class DiskError < RuntimeError; end
+    class RequestError < RuntimeError; end
+
+    def before_create
+      # check the volume size
+      sp = self.storage_pool
+      volume_size = Volume.dataset.where(:storage_pool_id=> self.storage_pool_id).get{sum(:size)}
+      total_size = sp.offerring_disk_space - volume_size.to_i
+      if self.size > total_size
+        raise DiskError, "out of disk space"
+      end
+
+      super
+    end
+
+    def before_save
+      self.updated_at = Time.now
+      super
+    end
+
+    def self.get_list(account_id, *args)
+      data = args.first
+      vl = self.dataset.where(:account_id=>account_id)
+      vl = vl.limit(data[:limit], data[:start]) if data[:start] && data[:limit]
+      if data[:target] && data[:sort]
+        vl = case data[:sort]
+             when 'desc'
+               vl.order(data[:target].to_sym.desc)
+             when 'asc'
+               vl.order(data[:target].to_sym.asc)
+             end
+      end
+      if data[:target] && data[:filter]
+        filter = case data[:target]
+                 when 'uuid'
+                   data[:filter].split('vol-').last
+                 else
+                   data[:filter]
+                 end
+        vl = vl.grep(data[:target].to_sym, "%#{filter}%")
+      end
+      vl.all.map{|row|
+        row.to_hash_document
+      }
+    end
+
+    def self.delete_volume(account_id, uuid)
+      v = self.dataset.where(:account_id=>account_id).where(:uuid=>uuid.split('-').last).first
+      if v.state.to_sym != :available
+        raise RequestError, "invalid delete request"
+      end
+      v.state = :deregistering
+      v.save_changes
+      v
+    end
+
+    def merge_pool_data
+      v = self.to_hash_document
+      v.merge(:storage_pool=>storage_pool.to_hash_document)
+    end
+
+    def to_hash_document
+      h = self.values.dup
+      h[:id] = h[:uuid] = h[:export_path] = self.canonical_uuid
+      # yaml -> hash translation
+      h[:transport_information]=self.transport_information
+      h
+    end
+
+    def create_snapshot(account_id)
+      vs = VolumeSnapshot.create(:account_id=>account_id,
+                                 :storage_pool_id=>self.storage_pool_id,
+                                 :origin_volume_id=>self.canonical_uuid,
+                                 :size=>self.size)
+    end
+  end
+end

data/lib/dcmgr/models/volume_snapshot.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class VolumeSnapshot < AccountResource
+    taggable 'snap'
+
+    STATE_TYPE_REGISTERING = "registering"
+    STATE_TYPE_CREATING = "creating"
+    STATE_TYPE_AVAILABLE = "available"
+    STATE_TYPE_FAILED = "failed"
+    STATE_TYPE_DELETING = "deleting"
+    STATE_TYPE_DELETED = "deleted"
+
+    inheritable_schema do
+      Fixnum :storage_pool_id, :null=>false
+      String :origin_volume_id, :null=>false
+      Fixnum :size, :null=>false
+      Fixnum :status, :null=>false, :default=>0
+      String :state, :null=>false, :default=>STATE_TYPE_REGISTERING
+      index :storage_pool_id
+    end
+    with_timestamps
+
+    many_to_one :storage_pool
+
+    def to_hash_document
+      h = self.values.dup
+      h[:id] = h[:uuid] = self.canonical_uuid
+      h
+    end
+
+    # create volume inherite from this snapshot for the account.
+    # limitation: inherit volume is created on same storage_pool.
+    def create_volume(account_id)
+      storage_pool.create_volume(account_id, self.size, self.canonical_uuid)
+    end
+
+    def origin_volume
+      Volume[origin_volume_id]
+    end
+
+    def delete_snapshot
+      self.state = STATE_TYPE_DELETING
+      self.save_changes
+    end
+  end
+end

data/lib/dcmgr/node_modules/hva_collector.rb

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+require 'isono'
+require 'ipaddress'
+
+module Dcmgr
+  module NodeModules
+    class HvaCollector < Isono::NodeModules::Base
+      include Isono::NodeModules
+
+      initialize_hook do
+        rpc = RpcChannel.new(node)
+        app = Isono::Rack::ObjectMethod.new(myinstance)
+        rpc.register_endpoint('hva-collector', Isono::Rack.build do
+                                use Isono::Rack::DataStore
+                                run proc { |req, res|
+                                  Thread.current[Models::BaseNew::LOCK_TABLES_KEY] = {}
+                                  app.call(req, res)
+                                }
+                              end)
+      end
+
+      terminate_hook do
+      end
+
+      def get_instance(instance_id)
+        Models::Instance.lock!
+        inst = Models::Instance[instance_id]
+        raise "UnknownInstanceID" if inst.nil?
+
+        ret = inst.to_hash
+        ret
+      end
+
+      def update_instance(instance_id, data)
+        Models::Instance.lock!
+        inst = Models::Instance[instance_id]
+        inst.set_fields(data, [:state]).save
+        # do not respond model object.
+        nil
+      end
+
+      def get_netfilter_groups_of_instance(instance_id)
+        Models::Instance.lock!
+        inst = Models::Instance[instance_id]
+        raise "UnknownInstanceID" if inst.nil?
+
+        inst.netfilter_groups.map { |g| g.to_hash }
+      end
+
+      def get_group_instance_ipv4s(instance_id)
+        Models::Instance.lock!
+        inst = Models::Instance[instance_id]
+        raise "UnknownInstanceID" if inst.nil?
+
+        insts = inst.netfilter_group_instances
+        ips = insts.map { |instance|
+          next if instance.nil?
+          instance.ips.map { |ip| ip.ipv4 unless ip.nil? }
+        }
+
+        ips.flatten! if ips.size > 0
+        ips.compact
+      end
+
+      def get_network(network_id)
+        Models::Network.lock!
+        network = Models::Network[network_id]
+        raise "UnknownNetworkID" if network.nil?
+        network.to_hash
+      end
+
+      def get_networks
+        Models::Network.lock!
+        networks = Models::Network.all
+        networks.map { |network|
+          network.to_hash
+        }
+      end
+
+      def get_dhcp_conf(network_name)
+        Models::Network.lock!
+        network = Models::Network.find(:name=>network_name)
+        raise "Unknown network name: #{network_name}" if network.nil?
+        prefix = IPAddress::Prefix32.new(network.prefix)
+        h = {
+          :ipv4_gw=>network.ipv4_gw,
+          :netmask => prefix.to_ip,
+          :prefix => network.prefix,
+          :dns_server=> network.dns_server,
+          :domain_name => network.domain_name,
+          :mac2addr => [],
+          :addr2host=> [],
+        }
+        
+        network.ip_lease.each { |ip|
+          # ignore IPs unbound to vnic.
+          next if ip.instance_nic.nil? || ip.instance_nic.instance.nil?
+          
+          h[:mac2addr] << {
+            :mac_addr => ip.instance_nic.pretty_mac_addr,
+            :ipaddr   => ip.ipv4
+          }
+          h[:addr2host] << {
+            :hostname => ip.instance_nic.instance.fqdn_hostname,
+            :ipaddr   => ip.ipv4
+          }
+        }
+
+        h
+      end
+
+      def get_instances_of_netfilter_group(netfilter_group_id)
+        Models::NetfilterGroup.lock!
+        g = Models::NetfilterGroup[netfilter_group_id]
+        raise "UnknownNetfilterGroupID" if g.nil?
+        inst_maps = g.instances.map { |instance| instance.to_hash unless instance.nil? }
+        inst_maps.compact
+      end
+
+      def get_alive_instances(node_id)
+        Models::HostPool.lock!
+        hp = Models::HostPool.find(:node_id => node_id)
+        raise "UnknownNodeID", node_id if hp.nil?
+
+        inst_on_hp = hp.instances_dataset.lives.all.map { |inst|
+          inst.to_hash
+        }
+        inst_on_hp.uniq! if inst_on_hp.size > 0
+        inst_on_hp
+      end
+
+    end
+  end
+end