wakame-vdc-dcmgr 11.06.0 → 11.12.0

data/lib/dcmgr/models/physical_network.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  # Physical network interface
+  class PhysicalNetwork < BaseNew
+
+    one_to_many :network
+
+    def validate
+      super
+    end
+
+    def before_destroy
+      super
+    end
+
+  end
+end

data/lib/dcmgr/models/quota.rb

@@ -3,16 +3,6 @@
 module Dcmgr::Models
   # Per account quota limit for the VDC resources.
   class Quota < BaseNew
-    taggable 'q'
-    
-    inheritable_schema do
-      Fixnum :account_id, :null=>false
-      Float  :instance_total_weight
-      Fixnum :volume_total_size
-
-      index :account_id
-    end
-    with_timestamps
 
     def before_validation
       # sets default quota values from dcmgr.conf.

data/lib/dcmgr/models/request_log.rb

@@ -3,23 +3,8 @@
 module Dcmgr::Models
   class RequestLog < BaseNew
 
-    inheritable_schema do
-      String :request_id, :null=>false, :size=>40, :unique=>true
-      String :frontend_system_id, :null=>false, :size=>40
-      String :account_id, :null=>false, :size=>40
-      String :requester_token, :null=>true, :size=>100
-      # HTTP Request Content
-      String :request_method, :null=>false, :size=>10
-      String :api_path, :null=>false
-      Text   :params, :null=>false
-      # HTTP Response Content
-      Fixnum :response_status, :null=>false
-      Text   :response_msg, :null=>true
-      Time :requested_at, :null=>false
-      Fixnum :requested_at_usec, :null=>false, :unsigned=>true
-      Time :responded_at, :null=>false
-      Fixnum :responded_at_usec, :null=>false, :unsigned=>true
-    end
+    plugin :serialization
+    serialize_attributes :yaml, :params
 
     def after_initialize
       super
@@ -30,10 +15,10 @@ module Dcmgr::Models
     end
 
     def before_create
-      super
       t = Time.now
       self[:responded_at] = t
       self[:responded_at_usec] = t.usec
+      super
     end
 
   end

data/lib/dcmgr/models/security_group.rb

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class SecurityGroup < AccountResource
+    taggable 'sg'
+
+    one_to_many :security_group_rules
+    many_to_many :instances,:join_table => :instance_security_groups
+
+    def to_hash
+      super.merge({
+                    :rule => rule.to_s,
+                    :rules => security_group_rules.map { |rule| rule.to_hash },
+                  })
+    end
+
+    def to_api_document
+      super.merge({
+                    :rule => rule.to_s,
+                    :rules => security_group_rules.map { |rule| rule.to_hash },
+                  })
+    end
+    
+    def after_save
+      super
+      self.rebuild_rule
+    end
+
+    def flush_rule
+      SecurityGroupRule.filter(:security_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
+        SecurityGroupRule.create(:security_group_id => self.id,
+                                 :permission         => permission)
+
+      }
+    end
+
+  end
+end

data/lib/dcmgr/models/security_group_rule.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+
+require 'strscan'
+require 'ipaddress'
+
+module Dcmgr::Models
+  class SecurityGroupRule < BaseNew
+
+    many_to_one :security_group
+
+    def to_hash
+      {
+        :permission => permission,
+        
+      }.merge(self.class.parse_rule(self.permission))
+    end
+
+
+    def validate
+      super
+
+      self.class.parse_rule(self.permission)
+    end
+
+    def self.parse_rule(rule)
+      rule = rule.strip.gsub(/[\s\t]+/, '')
+      from_group = false
+      
+      # ex.
+      # "tcp:22,22,ip4:0.0.0.0"
+      # "udp:53,53,ip4:0.0.0.0"
+      # "icmp:-1,-1,ip4:0.0.0.0"
+      
+      # 1st phase
+      # ip_tport    : tcp,udp? 1 - 16bit, icmp: -1
+      # id_port has been separeted in first phase.
+      from_pair, ip_tport, source_pair = rule.split(',')
+      
+      next if from_pair.nil?
+      next if ip_tport.nil?
+      next if source_pair.nil?
+      
+      # 2nd phase
+      # ip_protocol : [ tcp | udp | icmp ]
+      # ip_fport    : tcp,udp? 1 - 16bit, icmp: -1
+      ip_protocol, ip_fport = from_pair.split(':')
+      
+      # protocol    : [ ip4 | ip6 | security_group_uuid ]
+      # ip_source   : ip4? xxx.xxx.xxx.xxx./[0-32], ip6? (not yet supprted)
+      protocol, ip_source = source_pair.split(':')
+      
+      s = StringScanner.new(protocol)
+      until s.eos?
+        case
+        when s.scan(/ip6/)
+          # TODO#FUTURE: support IPv6 address format
+          next
+        when s.scan(/ip4/)
+          # IPAddress doesn't support prefix '0'.
+          ip_addr, prefix = ip_source.split('/', 2)
+          if prefix.to_i == 0
+            ip_source = ip_addr
+          end
+        when s.scan(/sg-\w+/)
+          from_group = true
+        else
+          raise "Unexpected protocol '#{s.peep(20)}'"
+        end
+      end
+      
+      if from_group == false
+        #p "from_group:(#{from_group}) ip_source -> #{ip_source}"
+        ip = IPAddress(ip_source)
+        ip_source = case ip.u32
+                    when 0
+                      "#{ip.address}/0"
+                    else
+                      "#{ip.address}/#{ip.prefix}"
+                    end
+      else
+        ip_source = protocol
+        protocol = nil
+      end
+      
+      case ip_protocol
+      when 'tcp', 'udp'
+        ip_fport = ip_fport.to_i
+        ip_tport = ip_tport.to_i
+        
+        # validate port range
+        [ ip_fport, ip_tport ].each do |port|
+          raise "Out of range port number: #{port}" unless port >= 1 && port <= 65535
+        end
+        
+        if !(ip_fport <= ip_tport)
+          raise "Invalid IP port range: #{ip_fport} <= #{ip_tport}"
+        end
+        
+        {
+          :ip_protocol => ip_protocol,
+          :ip_fport    => ip_fport,
+          :ip_tport    => ip_tport,
+          :protocol    => protocol,
+          :ip_source   => ip_source,
+        }
+      when 'icmp'
+        # via http://docs.amazonwebservices.com/AWSEC2/latest/CommandLineReference/
+        #
+        # For the ICMP protocol, the ICMP type and code must be specified.
+        # This must be specified in the format type:code where both are integers.
+        # Type, code, or both can be specified as -1, which is a wildcard.
+        
+        icmp_type = ip_fport.to_i
+        icmp_code = ip_tport.to_i
+        
+        # icmp_type
+        case icmp_type
+        when -1
+        when 0, 3, 5, 8, 11, 12, 13, 14, 15, 16, 17, 18
+        else
+          raise "Unsupported ICMP type number: #{icmp_type}"
+        end
+        
+        # icmp_code
+        case icmp_code
+        when -1
+        when 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+          # when icmp_type equals -1 icmp_code must equal -1.
+          next if icmp_type == -1
+        else
+          raise "Unsupported ICMP code number: #{icmp_code}"
+        end
+        
+        {
+          :ip_protocol => ip_protocol,
+          :icmp_type   => ip_tport.to_i, # ip_tport.to_i, # -1 or 0,       3,    5,       8,        11, 12, 13, 14, 15, 16, 17, 18
+          :icmp_code   => ip_fport.to_i, # ip_fport.to_i, # -1 or 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+          :protocol    => protocol,
+          :ip_source   => ip_source,
+        }
+      end
+    end
+    
+  end
+end

data/lib/dcmgr/models/ssh_key_pair.rb

@@ -7,32 +7,20 @@ module Dcmgr::Models
   class SshKeyPair < AccountResource
     taggable 'ssh'
 
-    inheritable_schema do
-      String :name, :size=>100, :null=>false
-      String :finger_print, :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.
+      super
     end
 
-    # 
+    #
     # @return [Hash] {:private_key=>'pkey string',
     #                 :public_key=>'pubkey string'}
-    def self.generate_key_pair()
+    def self.generate_key_pair(name)
       pkey = File.expand_path(randstr, Dir.tmpdir)
       pubkey = pkey + '.pub'
       begin
-        system("ssh-keygen -q -t rsa -C '' -N '' -f %s >/dev/null" % [pkey])
+        system("ssh-keygen -q -t rsa -C '%s' -N '' -f %s >/dev/null" % [name, pkey])
         unless $?.exitstatus == 0
           raise "Failed to run ssh-keygen: exitcode=#{$?.exitstatus}"
         end
@@ -43,7 +31,7 @@ module Dcmgr::Models
           raise "Failed to collect finger print value"
         end
         fp = fp.split(/\s+/)[1]
-        
+
         {:private_key=>IO.read(pkey),
           :public_key=>IO.read(pubkey),
           :finger_print => fp}
@@ -56,13 +44,22 @@ module Dcmgr::Models
     end
 
     def to_api_document
-      to_hash
+      super
+    end
+
+    def self.entry_new(account, &blk)
+      raise ArgurmentError unless account.is_a?(Account)
+
+      ssh = self.new &blk
+      ssh.account_id = account.canonical_uuid
+
+      ssh
     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 → storage_node.rb}

@@ -1,26 +1,26 @@
 # -*- coding: utf-8 -*-
 
+require 'isono/models/node_state'
+
 module Dcmgr::Models
-  class StoragePool < AccountResource
-    taggable 'sp'
+  class StorageNode < AccountResource
+    taggable 'sn'
 
-    inheritable_schema do
-      String :node_id, :null=>false
-      String :export_path, :null=>false
-      Fixnum :offering_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
+    BACKINGSTORE_ZFS = 'zfs'
+    BACKINGSTORE_RAW = 'raw'
 
-      index :node_id
-    end
-    with_timestamps
+    SUPPORTED_BACKINGSTORE = [BACKINGSTORE_ZFS, BACKINGSTORE_RAW]
 
     one_to_many :volumes
     one_to_many :volume_snapshots
     
     many_to_one :node, :class=>Isono::Models::NodeState, :key=>:node_id, :primary_key=>:node_id
+
+    def_dataset_method(:online_nodes) do
+      # SELECT * FROM `storage_nodes` WHERE ('node_id' IN (SELECT `node_id` FROM `node_states` WHERE (`state` = 'online')))
+      r = Isono::Models::NodeState.filter(:state => 'online').select(:node_id)
+      filter(:node_id => r)
+    end
     
     def before_validation
       export_path = self.export_path
@@ -29,6 +29,7 @@ module Dcmgr::Models
         export_path.shift
         self.export_path = export_path.join('/')
       end
+      super
     end
 
     def self.create_pool(params)
@@ -48,17 +49,6 @@ module Dcmgr::Models
       }
     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
-
     # Show status of the agent.
     def status
       node.nil? ? :offline : node.state
@@ -69,9 +59,29 @@ module Dcmgr::Models
     end
 
     def to_api_document
-      h = to_hash
+      h = super()
+      h.merge!(:status=>self.status)
       h.delete(:node_id)
       h
     end
+
+    # Returns total disk usage of associated volumes.
+    def disk_usage
+      volumes_dataset.lives.sum(:size).to_i
+    end
+
+    # Returns available space of the storage node.
+    def free_disk_space
+      self.offering_disk_space - self.disk_usage
+    end
+
+    # Check the free resource capacity across entire local VDC domain.
+    def self.check_domain_capacity?(size, num=1)
+      alives_size = Volume.dataset.lives.filter.sum(:size).to_i
+      avail_size = self.online_nodes.sum(:offering_disk_space).to_i - alives_size
+      
+      (avail_size >= size * num.to_i)
+    end
+    
   end
 end