wakame-vdc-agents 10.11.0

data/lib/dcmgr/endpoints/errors.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Endpoints
+    def self.define_error(class_name, status_code, &blk)
+      c = Class.new(APIError)
+      c.status_code(status_code)
+      c.instance_eval(&blk) if blk
+      self.const_set(class_name.to_sym, c)
+    end
+
+    class APIError < StandardError
+      def self.status_code(code=nil)
+        if code
+          @status_code = code
+        end
+        @status_code || raise("@status_code for the class is not set")
+      end
+
+      def status_code
+        self.class.status_code
+      end
+    end
+
+    define_error(:UnknownUUIDResource, 404)
+    define_error(:UnknownMember, 400)
+    define_error(:InvalidCredentialHeaders, 400)
+    define_error(:InvalidRequestCredentials, 400)
+    define_error(:DisabledAccount, 403)
+    define_error(:OperationNotPermitted, 403)
+    define_error(:UndefinedVolumeSize, 400)
+    define_error(:StoragePoolNotPermitted, 403)
+    define_error(:UnknownStoragePool, 404)
+    define_error(:OutOfDiskSpace, 400)
+    define_error(:DatabaseError, 400)
+    define_error(:UndefinedVolumeID, 400)
+    define_error(:InvalidDeleteRequest, 400)
+    define_error(:UnknownVolume, 404)
+    define_error(:UnknownHostPool, 404)
+    define_error(:UnknownInstance, 404)
+    define_error(:UndefindVolumeSnapshotID, 400)
+    define_error(:UnknownVolumeSnapshot, 404)
+    define_error(:UndefinedRequiredParameter, 400)
+    define_error(:InvalidVolumeSize, 400)
+    define_error(:OutOfHostCapacity, 400)
+    define_error(:UnknownSshKeyPair, 404)
+    define_error(:UndefinedStoragePoolID, 400)
+
+    # netfilter_group
+    define_error(:UndefinedNetfilterGroup, 400)
+    define_error(:UnknownNetfilterGroup, 400)
+    define_error(:NetfilterGroupNotPermitted, 400)
+    define_error(:DuplicatedNetfilterGroup, 400)
+  end
+end

data/lib/dcmgr/endpoints/metadata.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+
+require 'extlib'
+require 'sinatra/base'
+require 'yaml'
+require 'json'
+
+require 'dcmgr'
+
+# Metadata service endpoint for running VMs.
+# The running VM can not identify itself that who or where i am. The service supplies these information from somewhere
+# out of the VM. It publishes some very crucial information to each VM so that the access control to this service is 
+# mandated at both levels, the network and the application itself.
+# 
+# The concept of the service is similar with Amazon EC2's Metadata service given via http://169.254.169.254/. The 
+# difference is the URI structure. This gives the single point URI as per below:
+#   http://metadata.server/[version]/meatadata.[format]
+# It will return a document which results in a syntax specified in the last extension field. The document contains 
+# over all information that the VM needs for self recoginition.
+module Dcmgr
+  module Endpoints
+    class Metadata < Sinatra::Base
+      include Dcmgr::Logger
+
+      disable :sessions
+      disable :show_exceptions
+
+      LATEST_PROVIDER_VER_ID='2010-11-01'
+      
+      get '/' do
+        ''
+      end
+
+      get '/:version/metadata.*' do
+      #get %r!\A/(\d{4}-\d{2}-\d{2})/metadata.(\w+)\Z! do
+        v = params[:version]
+        ext = params[:splat][0]
+        v = case v
+            when 'latest'
+              LATEST_PROVIDER_VER_ID
+            when /\A\d{4}-\d{2}-\d{2}\Z/
+              v
+            else
+              raise "Invalid syntax in the version"  
+            end
+        v = v.gsub(/-/, '')
+        
+        hash_doc = begin
+                     self.class.find_const("Provider_#{v}").new.document(request.ip)
+                   rescue NameError => e
+                     raise e if e.is_a? NoMethodError
+                     logger.error("ERROR: Unsupported metadata version: #{v}")
+                     logger.error(e)
+                     error(404, "Unsupported metadata version: #{v}")
+                   rescue UnknownSourceIpError => e
+                     error(404, "Unknown source IP: #{e.message}")
+                   end
+
+        return case ext
+               when 'json'
+                 JSON.dump(hash_doc)
+               when 'sh'
+                 shell_dump(hash_doc)
+               when 'yaml'
+                 YAML.dump(hash_doc)
+               else
+                 raise "Unsupported format: .#{ext}"
+               end
+      end
+
+      private 
+      def shell_dump(hash)
+        # TODO: values to be shell escaped
+        hash.map {|k,v|
+          "#{k.to_s.upcase}='#{v}'"
+        }.join("\n")
+      end
+
+      class UnknownSourceIpError < StandardError; end
+
+      # Base class for Metadata provider
+      class Provider
+        # Each Metadata provider returns a Hash data for a VM along with the src_ip
+        # @param [String] src_ip Source IP address who requested to the Meatadata service.
+        # @return [Hash] Details for the VM
+        def document(src_ip)
+          raise NotImplementedError
+        end
+      end
+
+      # 2010-11-01 version of metadata provider
+      class Provider_20101101 < Provider
+        # {:cpu_cores=>1,
+        #  :memory_size=>100,
+        #  :state=>'running',
+        #  :user_data=>'......',
+        #  :network => [{
+        #    :ip=>'192.168.1.1',
+        #    :name=>'xxxxxx'
+        #  }]
+        # }
+        def document(src_ip)
+          ip = Models::IpLease.find(:ipv4=>src_ip)
+          if ip.nil? || ip.instance_nic.nil?
+            raise UnknownSourceIpError, src_ip
+          end
+          inst = ip.instance_nic.instance
+          ret = {
+            :instance_id=>inst.canonical_uuid,
+            :cpu_cores=>inst.cpu_cores,
+            :memory_size=>inst.memory_size,
+            :state => inst.state,
+            :user_data=>inst.user_data.to_s,
+          }
+          # IP/network values
+          ret[:network] = inst.nic.map { |nic|
+            {:ip=>nic.ip.ipv4,
+              :name=>nic.ip.network.name,
+            }
+          }
+          ret[:volume] = inst.volume.map { |v|
+          }
+          ret
+        end
+      end
+
+    end
+  end
+end

data/lib/dcmgr/logger.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+require 'logger'
+
+module Dcmgr
+  module Logger
+
+    @logdev = ::Logger::LogDevice.new(STDOUT)
+
+    def self.default_logdev
+      @logdev
+    end
+
+    # Factory method for ::Logger
+    def self.create(name=nil)
+      l = ::Logger.new(default_logdev)
+      l.progname = name
+      l
+    end
+    
+    def self.included(klass)
+      klass.class_eval {
+
+        @class_logger = Logger.create(self.to_s.split('::').last)
+
+        def self.logger
+          @class_logger
+        end
+
+        def logger
+          self.class.logger
+        end
+
+        def self.logger_name
+          @class_logger.progname
+        end
+
+        def self.logger_name=(name)
+          @class_logger.progname = name
+        end
+      }
+    end
+    
+  end
+end

data/lib/dcmgr/models/account.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  class Account < BaseNew
+    taggable 'a'
+    with_timestamps
+    plugin :single_table_inheritance, :uuid, :model_map=>{}
+    plugin :subclasses
+
+    # pk has to be overwritten by the STI subclasses.
+    unrestrict_primary_key
+
+    DISABLED=0
+    ENABLED=1
+    
+    inheritable_schema do
+      String :description, :size=>100
+      Fixnum :enabled, :default=>ENABLED, :null=>false
+    end
+
+    one_to_many  :tags
+
+    def disable?
+      self.enabled == DISABLED
+    end
+
+    def enable?
+      self.enabled == ENABLED
+    end
+
+    def to_hash_document
+      h = self.values.dup
+      h[:id] = h[:uuid] = self.canonical_uuid
+      h
+    end
+
+
+    # STI class variable setter, getter methods.
+    class << self
+      def default_values
+        @default_values ||= {}
+      end
+
+      def pk(pk=nil)
+        if pk
+          default_values[:id] = pk
+        end
+        default_values[:id]
+      end
+      
+      def uuid(uuid=nil)
+        if uuid.is_a?(String)
+          uuid = uuid.downcase
+          if uuid !~ /^[a-z0-9]{8}$/
+            raise "Invalid syntax of uuid: #{uuid}"
+          end
+          default_values[:uuid] = uuid
+        end
+        default_values[:uuid] || raise("#{self}.uuid is unset. Set the unique number")
+      end
+
+      def description(description=nil)
+        if description
+          default_values[:description] = description
+        end
+        default_values[:description]
+      end
+    end
+
+    module SystemAccount
+      def self.define_account(class_name, &blk)
+        unless class_name.is_a?(Symbol) || class_name.is_a?(String)
+          raise ArgumentError
+        end
+
+        c = Class.new(Account, &blk)
+        self.const_set(class_name.to_sym, c)
+        Account.sti_model_map[c.uuid] = c
+        Account.sti_key_map[c.to_s] = c.uuid
+        c
+      end
+    end
+
+    install_data_hooks do
+      Account.subclasses.each { |m|
+        Account.create(m.default_values.dup)
+      }
+    end
+
+    SystemAccount.define_account(:DatacenterAccount) do
+      pk 100
+      uuid '00000000'
+      description 'datacenter system account'
+
+      # DatacenterAccount never be disabled
+      def before_save
+        super
+        self.enabled = Account::ENABLED
+      end
+    end
+    
+  end
+end
+

data/lib/dcmgr/models/account_resource.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr::Models
+  # Base class for the model class which belongs to a specific account.
+  class AccountResource < BaseNew
+
+    inheritable_schema do
+      String :account_id, :null=>false, :index=>true
+    end
+
+    def account
+      Account[self.account_id]
+    end
+
+  end
+end

data/lib/dcmgr/models/base.rb

@@ -0,0 +1,69 @@
+require 'sequel'
+
+module Dcmgr
+  module Models
+    class InvalidUUIDError < StandardError; end
+    class DuplicateUUIDError < StandardError; end
+
+    module UUIDMethods
+      module ClassMethods
+        # override [] method. add search by uuid String
+        def [](*args)
+          if args.size == 1 and args[0].is_a? String
+            super(:uuid=>trim_uuid(args[0]))
+          else
+            super(*args)
+          end
+        end
+        
+        def trim_uuid(p_uuid)
+          if p_uuid and p_uuid.length == self.prefix_uuid.length + 9
+            return p_uuid[(self.prefix_uuid.length+1), p_uuid.length]
+          end
+          raise InvalidUUIDError, "invalid uuid: #{p_uuid}"
+        end
+
+        def set_prefix_uuid(prefix_uuid)
+          @prefix_uuid = prefix_uuid
+        end
+
+        attr_reader :prefix_uuid
+      end
+      
+      def generate_uuid
+        "%08x" % rand(16 ** 8)
+      end
+
+      def setup_uuid
+        self.uuid = generate_uuid unless self.values[:uuid]
+      end
+
+      def before_create
+        setup_uuid
+      end
+
+      def save(*columns)
+        super
+      rescue Sequel::DatabaseError => e
+        Dcmgr.logger.info "db error: %s" % e
+        Dcmgr.logger.info "  " + e.backtrace.join("\n  ")
+
+        raise DuplicateUUIDError if /^Mysql::Error: Duplicate/ =~ e.message
+        raise e
+      end
+
+      def uuid
+        "%s-%s" % [self.class.prefix_uuid, self.values[:uuid]]
+      end
+
+      def to_s
+        uuid
+      end
+    end
+
+    class Base < Sequel::Model
+      include UUIDMethods
+      extend UUIDMethods::ClassMethods
+    end
+  end
+end

data/lib/dcmgr/models/base_new.rb

@@ -0,0 +1,371 @@
+# -*- coding: utf-8 -*-
+
+require 'sequel/model'
+
+
+module Dcmgr::Models
+  class InvalidUUIDError < StandardError; end
+  class UUIDPrefixDuplication < StandardError; end
+    
+  # Sequal::Model plugin to inject the Taggable feature to the model
+  # class.
+  #
+  # Taggable model supports the features below:
+  # - Taggable.uuid_prefix to both set and get uuid_prefix for the model.
+  # - Collision detection for specified uuid_prefix.
+  # - Generate unique value for :uuid column at initialization.
+  # - Add column :uuid if the model is capable of :schema plugin methods.
+  module Taggable
+    UUID_TABLE='abcdefghijklmnopqrstuvwxyz0123456789'.split('').freeze
+    UUID_REGEX=%r/^(\w+)-([#{UUID_TABLE.join}]+)/
+    
+    def self.uuid_prefix_collection
+      @uuid_prefix_collection ||= {}
+    end
+    
+    # Find a taggable model object from the
+    # given canonical uuid.
+    #
+    # # Find an account.
+    # Taggble.find('a-xxxxxxxx')
+    #
+    # # Find a user.
+    # Taggble.find('u-xxxxxxxx')
+    def self.find(uuid)
+      raise ArgumentError, "Invalid uuid syntax: #{uuid}" unless uuid =~ UUID_REGEX
+      upc = uuid_prefix_collection[$1.downcase]
+      raise "Unknown uuid prefix: #{$1.downcase}" if upc.nil?
+      upc[:class].find(:uuid=>$2)
+    end
+
+    # Checks if the uuid object stored in the database.
+    def self.exists?(uuid)
+      !find(uuid).nil?
+    end
+
+    def self.configure(model)
+      model.schema_builders << proc {
+        unless has_column?(:uuid)
+          # add :uuid column with unique index constraint.
+          column(:uuid, String, :size=>8, :null=>false, :fixed=>true, :unique=>true)
+        end
+      }
+    end
+
+    module InstanceMethods
+      # read-only instance method to retrieve @uuid_prefix class
+      # variable.
+      def uuid_prefix
+        self.class.uuid_prefix
+      end
+      
+      def after_initialize
+        super
+        # set random generated uuid value
+        self[:uuid] ||= Array.new(8) do UUID_TABLE[rand(UUID_TABLE.size)]; end.join
+      end
+
+      # Returns canonicalized uuid which has the form of
+      # "{uuid_prefix}-{uuid}".
+      def canonical_uuid
+        "#{self.uuid_prefix}-#{self[:uuid]}"
+      end
+      alias_method :cuuid, :canonical_uuid
+
+      # Put the tag on the object.
+      #
+      # This method just delegates the method call of Tag#label().
+      # @params [Models::Tag,String] tag_or_tag_uuid 'tag-xxxx' is expected when the type is string
+      def label_tag(tag_or_tag_uuid)
+        tag = case tag_or_tag_uuid
+              when String
+                Tag[tag_or_tag_uuid]
+              when Tag
+                tag_or_tag_uuid
+              else
+                raise ArgumentError, "Invalid type: #{tag_or_tag_uuid.class}"
+              end
+        
+        tag.label(self.uuid)
+      end
+
+      # Remove the labeled tag from the object
+      #
+      # This method just delegates the method call of Tag#unlabel().
+      # @params [Models::Tag,String] tag_or_tag_uuid 'tag-xxxx' is expected when the type is string
+      def unlabel_tag(tag_or_tag_uuid)
+        tag = case tag_or_tag_uuid
+              when String
+                Tag[tag_or_tag_uuid]
+              when Tag
+                tag_or_tag_uuid
+              else
+                raise ArgumentError, "Invalid type: #{tag_or_tag_uuid.class}"
+              end
+
+        tag.unlabel(self.uuid)
+      end
+
+      def to_hash()
+        self.values.dup.merge({:id=>canonical_uuid, :uuid=>canonical_uuid})
+      end
+    end
+
+    module ClassMethods
+      # Getter and setter for uuid_prefix of the class.
+      #
+      # @example
+      #   class Model1 < Sequel::Model
+      #     plugin Taggable
+      #     uuid_prefix('m')
+      #   end
+      #   
+      #   Model1.uuid_prefix # == 'm'
+      #   Model1.new.canonical_uuid # == 'm-abcd1234'
+      def uuid_prefix(prefix=nil)
+        if prefix
+          raise UUIDPrefixDuplication, "Found collision for uuid_prefix key: #{prefix}" if Taggable.uuid_prefix_collection.has_key?(prefix)
+          
+          Taggable.uuid_prefix_collection[prefix]={:class=>self}
+          @uuid_prefix = prefix
+        end
+
+        @uuid_prefix || (superclass.uuid_prefix if superclass.respond_to?(:uuid_prefix)) || raise("uuid prefix is unset for:#{self}")
+      end
+
+
+      # Override Model.[] to add lookup by uuid.
+      #
+      # @example
+      #   Account['a-xxxxxx']
+      def [](*args)
+        if args.size == 1 and args[0].is_a? String
+          super(:uuid=>trim_uuid(args[0]))
+        else
+          super(*args)
+        end
+      end
+
+      # Returns the uuid string which is removed prefix part: /^(:?\w+)-/.
+      #
+      # @example
+      #   Account.trim_uuid('a-abcd1234') # = 'abcd1234'
+      # @example Will get InvalidUUIDError as the uuid with invalid prefix has been tried.
+      #   Account.trim_uuid('u-abcd1234') # 'u-' prefix is for User model.
+      def trim_uuid(p_uuid)
+        regex = %r/^#{self.uuid_prefix}-/
+        if p_uuid and p_uuid =~ regex
+          return p_uuid.sub(regex, '')
+        end
+        raise InvalidUUIDError, "Invalid uuid or unsupported uuid: #{p_uuid} in #{self}"
+      end
+
+      # Checks the uuid syntax if it is for the Taggable class.
+      def check_uuid_format(uuid)
+        uuid =~ /^#{self.uuid_prefix}-/
+      end
+    end
+        
+  end
+
+  # Sequel::Model plugin extends :schema plugin to merge the column
+  # definitions in its parent class.
+  #
+  # class Model1 < Sequel::Model
+  #   plugin InheritableSchema
+  #
+  #   inheritable_schema do
+  #     String :col1
+  #   end
+  # end
+  #
+  # class Model2 < Model1
+  #   inheritable_schema do
+  #     String :col2
+  #   end
+  # end
+  #
+  # Model2.create_table!
+  # 
+  # Then the schema for Model2 becomes as follows:
+  #   primary_key :id, :type=>Integer, :unsigned=>true
+  #   String :col1
+  #   String :col2
+  module InheritableSchema
+
+    module ClassMethods
+      # Creates table, using the column information from set_schema.
+      def create_table
+        db.create_table(table_name, :generator=>schema)
+        @db_schema = get_db_schema(true)
+        columns
+      end
+
+      # Drops the table if it exists and then runs
+      # create_table.  Should probably
+      # not be used except in testing.
+      def create_table!
+        drop_table rescue nil
+        create_table
+      end
+
+      # Creates the table unless the table already exists
+      def create_table?
+        create_table unless table_exists?
+      end
+
+      # Drops table.
+      def drop_table
+        db.drop_table(table_name)
+      end
+
+      # Returns true if table exists, false otherwise.
+      def table_exists?
+        db.table_exists?(table_name)
+      end
+
+      def schema
+        builders = []
+        c = self
+        begin
+          builders << c.schema_builders if c.respond_to?(:schema_builders)
+        end while((c = c.superclass) && c != Sequel::Model)
+        
+        builders = builders.reverse.flatten
+        builders.delete(nil)
+
+        schema = Sequel::Schema::Generator.new(db) {
+          primary_key :id, Integer, :null=>false, :unsigned=>true
+        }
+        builders.each { |blk|
+          schema.instance_eval(&blk)
+        }
+        set_primary_key(schema.primary_key_name) if schema.primary_key_name
+        
+        schema
+      end
+      
+      def schema_builders
+        @schema_builders ||= []
+      end
+      
+      def inheritable_schema(name=nil, &blk)
+        set_dataset(db[name || implicit_table_name])
+        self.schema_builders << blk
+      end
+    end
+    
+  end
+  
+
+  class BaseNew < Sequel::Model
+
+    LOCK_TABLES_KEY='__locked_tables'
+    
+    def self.lock!
+      locktbls = Thread.current[LOCK_TABLES_KEY]
+      if locktbls
+        locktbls[self.db.uri.to_s + @dataset.first_source_alias.to_s]=1
+      end
+    end
+    
+    def self.unlock!
+      locktbls = Thread.current[LOCK_TABLES_KEY]
+      if locktbls
+        locktbls.delete(self.db.uri.to_s + @dataset.first_source_alias.to_s)
+      end
+    end
+    
+    def self.dataset
+      locktbls = Thread.current[LOCK_TABLES_KEY]
+      if locktbls && locktbls[self.db.uri.to_s + @dataset.first_source_alias.to_s]
+        @dataset.opts = @dataset.opts.merge({:lock=>:update})
+      else
+        @dataset.opts = @dataset.opts.merge({:lock=>nil})
+      end
+      @dataset
+    end
+    
+    
+    
+    def self.Proxy(klass)
+      colnames = klass.schema.columns.map {|i| i[:name] }
+      colnames.delete_if(klass.primary_key) if klass.restrict_primary_key?
+      s = ::Struct.new(*colnames) do
+        def to_hash
+          n = {}
+          self.each_pair { |k,v|
+            n[k.to_sym]=v
+          }
+          n
+        end
+      end
+      s
+    end
+
+
+    # Callback when the initial data is setup to the database.
+    def self.install_data
+      install_data_hooks.each{|h| h.call }
+    end
+
+    # Add callbacks to setup the initial data. The hooks will be
+    # called when Model1.install_data() is called.
+    # 
+    # class Model1 < Base
+    #   install_data_hooks do
+    #     Model1.create({:col1=>1, :col2=>2})
+    #   end
+    # end
+    def self.install_data_hooks(&blk)
+      @install_data_hooks ||= []
+      if blk
+        @install_data_hooks << blk
+      end
+      @install_data_hooks
+    end
+
+
+    private
+    def self.inherited(klass)
+      super
+
+      klass.plugin InheritableSchema
+      klass.class_eval {
+
+        # Add timestamp columns and set callbacks using Timestamps
+        # plugin.
+        #
+        # class Model1 < Base
+        #   with_timestamps
+        # end
+        def self.with_timestamps
+          self.schema_builders << proc {
+            unless has_column?(:created_at)
+              column(:created_at, Time, :null=>false)
+            end
+            unless has_column?(:updated_at)
+              column(:updated_at, Time, :null=>false)
+            end
+          }
+          
+          self.plugin :timestamps, :update_on_create=>true
+        end
+
+        # Install Taggable module as Sequel plugin and set uuid_prefix.
+        # 
+        # class Model1 < Base
+        #   taggable 'm'
+        # end
+        def self.taggable(uuid_prefix)
+          return if self == BaseNew
+          self.plugin Taggable
+          self.uuid_prefix(uuid_prefix)
+        end
+
+      }
+      
+    end
+    
+  end
+end