wakame-vdc-dcmgr 10.12.0 → 11.06.0

data/lib/dcmgr/endpoints/core_api_mock.rb

@@ -241,6 +241,43 @@ module Dcmgr
       end
       
       collection :instances do
+        operation :index do
+          description 'Show list of instances'
+          control do
+            start = params[:start].to_i
+            start = start < 1 ? 0 : start
+            limit = params[:limit].to_i
+            limit = limit < 1 ? 10 : limit
+
+            partial_ds = (1..30).collect { |i| {
+                 :id => "i-123456" + ('%02d' % i).to_s,
+                 :image_id => 'wmi-12345678',
+                 :cpu_cores => 1,
+                 :memory_size => 256,
+                 :network => [{
+                   :ipaddr => '192.168.0.%d' % i,
+                  }],
+                :state => 'running',
+                :status => 'running'
+              }
+            }
+
+            total = partial_ds.count
+            partial_ds = pagenate(partial_ds,params[:start],params[:limit])
+
+            res = [{
+              :owner_total => total,
+              :start => start,
+              :limit => limit,
+              :results=> partial_ds
+            }]
+
+            respond_to { |f|
+              f.json {res.to_json}
+            }
+          end
+        end
+      
         operation :create do
           description 'Runs a new instance'
           # param :image_id, :required
@@ -267,11 +304,23 @@ module Dcmgr
         end
 
         operation :show do
-          #param :account_id, :string, :optional
           control do
-            i = Modles::Instance[params[:id]]
+            i = {
+                :id => params[:id],
+                :image_id => 'wmi-12345678',
+                :cpu_cores => 1,
+                :memory_size => 256,
+                :network => [{
+                  :ipaddr => '192.168.0.1',
+                }],
+                :state => 'running',
+                :status => 'running',
+                :ssh_key_pair => nil,
+                :netfilter_group => {},
+                :created_at => "Wed Oct 27 16:58:24 +0900 2010",
+            }
             respond_to { |f|
-              f.json { i.to_hash_document.to_json }
+              f.json { i.to_json }
             }
           end
         end

data/lib/dcmgr/endpoints/errors.rb

@@ -2,14 +2,31 @@
 
 module Dcmgr
   module Endpoints
-    def self.define_error(class_name, status_code, &blk)
+    def self.define_error(class_name, status_code, error_code, &blk)
       c = Class.new(APIError)
       c.status_code(status_code)
+      c.error_code(error_code)
       c.instance_eval(&blk) if blk
+      self.set_error_code_type(error_code, c)
       self.const_set(class_name.to_sym, c)
     end
 
+    @error_code_map = {}
+    def self.set_error_code_type(error_code, klass)
+      raise TypeError unless klass < APIError
+      if @error_code_map.has_key?(error_code)
+        if @error_code[error_code] == klass
+        else
+          raise "Duplicate Error Code Registration: #{klass}, code=#{error_code}"
+        end
+      else
+        @error_code_map[error_code]=klass
+      end
+    end
+
     class APIError < StandardError
+      
+      # HTTP status code of the error.
       def self.status_code(code=nil)
         if code
           @status_code = code
@@ -17,43 +34,67 @@ module Dcmgr
         @status_code || raise("@status_code for the class is not set")
       end
 
+      # Internal error code of the error.
+      def self.error_code(code=nil)
+        if code
+          @error_code = code
+        end
+        @error_code || raise("@error_code for the class is not set")
+      end
+
       def status_code
         self.class.status_code
       end
+
+      def error_code
+        self.class.error_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)
-    define_error(:DetachVolumeFailure, 400)
-    define_error(:AttachVolumeFailure, 400)
-    define_error(:InvalidInstanceState, 400)
-    define_error(:DuplicateHostname, 400)
+    define_error(:UnknownUUIDResource, 404, '100')
+    define_error(:UnknownMember, 400, '101')
+    define_error(:InvalidCredentialHeaders, 400, '102')
+    define_error(:InvalidRequestCredentials, 400, '103')
+    define_error(:DisabledAccount, 403, '104')
+    define_error(:OperationNotPermitted, 403, '105')
+    define_error(:UndefinedVolumeSize, 400, '106')
+    define_error(:StoragePoolNotPermitted, 403, '107')
+    define_error(:UnknownStoragePool, 404, '108')
+    define_error(:OutOfDiskSpace, 400, '109')
+    define_error(:DatabaseError, 400, '110')
+    define_error(:UndefinedVolumeID, 400, '111')
+    define_error(:InvalidDeleteRequest, 400, '112')
+    define_error(:UnknownVolume, 404, '113')
+    define_error(:UnknownHostPool, 404, '114')
+    define_error(:UnknownInstance, 404, '115')
+    define_error(:UndefindVolumeSnapshotID, 400, '116')
+    define_error(:UnknownVolumeSnapshot, 404, '117')
+    define_error(:UndefinedRequiredParameter, 400, '118')
+    define_error(:InvalidVolumeSize, 400, '119')
+    define_error(:OutOfHostCapacity, 400, '120')
+    define_error(:UnknownSshKeyPair, 404, '121')
+    define_error(:UndefinedStoragePoolID, 400, '122')
+    define_error(:DetachVolumeFailure, 400, '123')
+    define_error(:AttachVolumeFailure, 400, '124')
+    define_error(:InvalidInstanceState, 400, '125')
+    define_error(:DuplicateHostname, 400, '126')
+    define_error(:UnknownImageID, 404, '127')
+    define_error(:UnknownInstanceSpec, 404, '128')
+    define_error(:UnknownNetworkID, 404, '129')
+    define_error(:OutOfNetworkCapacity, 400, '130')
+    define_error(:InvalidVolumeSnapshotState, 400, '131')
+
 
     # netfilter_group
-    define_error(:UndefinedNetfilterGroup, 400)
-    define_error(:UnknownNetfilterGroup, 400)
-    define_error(:NetfilterGroupNotPermitted, 400)
-    define_error(:DuplicatedNetfilterGroup, 400)
+    define_error(:UndefinedNetfilterGroup, 400, '132')
+    define_error(:UnknownNetfilterGroup, 400, '133')
+    define_error(:NetfilterGroupNotPermitted, 400, '134')
+    define_error(:DuplicatedNetfilterGroup, 400, '135')
+
+    define_error(:DuplicateSshKeyName, 400, '136')
+    define_error(:InvalidImageID, 400, '137')
+    define_error(:InvalidInstanceSpec, 400, '138')
+    define_error(:UndefinedInstanceID, 404, '139')
+    define_error(:InvalidVolumeState, 400, '140')
   end
 end

data/lib/dcmgr/endpoints/metadata.rb

@@ -2,6 +2,7 @@
 
 require 'extlib'
 require 'sinatra/base'
+require 'sinatra/sequel_transaction'
 require 'yaml'
 require 'json'
 
@@ -21,29 +22,25 @@ module Dcmgr
   module Endpoints
     class Metadata < Sinatra::Base
       include Dcmgr::Logger
+      register Sinatra::SequelTransaction
 
       disable :sessions
       disable :show_exceptions
 
-      LATEST_PROVIDER_VER_ID='2010-11-01'
+      LATEST_PROVIDER_VER_ID='2011-05-19'
       
       get '/' do
         ''
       end
 
+      get '/:version/meta-data/:data' do
+        get_data(params)
+      end
+
       get '/:version/metadata.*' do
       #get %r!\A/(\d{4}-\d{2}-\d{2})/metadata.(\w+)\Z! do
-        v = params[:version]
+        v = parse_version 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)
@@ -68,7 +65,47 @@ module Dcmgr
                end
       end
 
-      private 
+      private
+      def get_data(params)
+        v = parse_version params[:version]
+        
+        get_method = params[:data].gsub(/-/,'_')
+        
+        provider = begin
+                     self.class.find_const("Provider_#{v}").new
+                   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
+
+        result = begin
+                   provider.method(get_method).call(request.ip)
+                 rescue NameError => e
+                   raise e if e.is_a? NoMethodError
+                   logger.error("ERROR: Unknown metadata: #{get_method}")
+                   logger.error(e)
+                   error(404, "Unknown metadata: #{get_method}")
+                 end
+
+        result
+      end
+      
+      def parse_version(v)
+        ret = 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
+        ret.gsub(/-/, '')
+      end
+       
       def shell_dump(hash)
         # TODO: values to be shell escaped
         hash.map {|k,v|
@@ -100,11 +137,38 @@ module Dcmgr
         #  }]
         # }
         def document(src_ip)
+          inst = get_instance_from_ip(src_ip)
+          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
+        
+        def get_instance_from_ip(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
+          ip.instance_nic.instance
+        end
+      end
+
+      #This version implements compatibility with amazon EC2
+      class Provider_20110519 < Provider_20101101
+        def document(src_ip)
+          inst = get_instance_from_ip(src_ip)
           ret = {
             :instance_id=>inst.canonical_uuid,
             :cpu_cores=>inst.cpu_cores,
@@ -114,16 +178,99 @@ module Dcmgr
           }
           # IP/network values
           ret[:network] = inst.nic.map { |nic|
-            {:ip=>nic.ip.ipv4,
-              :name=>nic.ip.network.name,
+            nic.ip.map { |ip|
+              {:ip=>ip.ipv4,
+                :uuid=>ip.network.canonical_uuid,
+              }
             }
           }
           ret[:volume] = inst.volume.map { |v|
           }
           ret
         end
-      end
 
+        # EC2 Functions not implemented yet
+        # http://169.254.169.254/latest/meta-data/ami-launch-index
+        # http://169.254.169.254/latest/meta-data/ami-manifest-path
+        # http://169.254.169.254/latest/meta-data/ancestor-ami-ids
+        # http://169.254.169.254/latest/meta-data/block-device-mapping
+        # http://169.254.169.254/latest/meta-data/instance-type/instance-action
+        # http://169.254.169.254/latest/meta-data/instance-type
+        # http://169.254.169.254/latest/meta-data/kernel-id
+        # http://169.254.169.254/latest/meta-data/placement/availability-zone
+        # http://169.254.169.254/latest/meta-data/product-codes
+        # http://169.254.169.254/latest/meta-data/placement
+        # http://169.254.169.254/latest/meta-data/profile
+        # http://169.254.169.254/latest/meta-data/public-hostname
+        # http://169.254.169.254/latest/meta-data/ramdisk-id
+        # http://169.254.169.254/latest/meta-data/reservation-id
+        def wmi_id(src_ip)
+          get_instance_from_ip(src_ip).image.cuuid
+        end
+        alias ami_id wmi_id
+        
+        def mac(src_ip)
+          get_instance_from_ip(src_ip).nic.map { |nic|
+            nic.pretty_mac_addr
+          }.join("\n")
+        end
+        
+        def network(src_ip)
+          get_instance_from_ip(src_ip).nic.map { |nic|
+            nic.ip.map { |ip|
+              ip.network.cuuid
+            }
+          }.join("\n")
+        end
+        
+        def instance_id(src_ip)
+          get_instance_from_ip(src_ip).cuuid
+        end
+        
+        def local_hostname(src_ip)
+          get_instance_from_ip(src_ip).hostname
+        end
+        
+        def local_ipv4(src_ip)
+          get_instance_from_ip(src_ip).nic.map { |nic|
+            nic.ip.map { |ip|
+              unless ip.is_natted?
+                ip.ipv4
+              else
+                nil
+              end
+            }.compact
+          }.join("\n")
+        end
+        
+        def public_ipv4(src_ip)
+          get_instance_from_ip(src_ip).nic.map { |nic|
+            nic.ip.map { |ip|
+              if ip.is_natted?
+                ip.ipv4
+              else
+                nil
+              end
+            }.compact
+          }.join("\n")
+        end
+        
+        def public_keys(src_ip)
+          i = get_instance_from_ip(src_ip)
+          # ssh_key_data is possible to be nil.
+          i.ssh_key_data.nil? ? '' : i.ssh_key_data[:public_key]
+        end
+        
+        def security_groups(src_ip)
+          get_instance_from_ip(src_ip).netfilter_groups.map { |grp|
+            grp.name
+          }.join("\n")
+        end
+        
+        def user_data(src_ip)
+          get_instance_from_ip(src_ip).user_data
+        end
+      end
     end
   end
 end

data/lib/dcmgr/helpers/cli_helper.rb

@@ -71,7 +71,7 @@ module Dcmgr
           raise CommandError.new("Unexpected exit code=#{stat.exitstatus} (expected=#{opts[:expect_exitcode]})", \
             outbuf, errbuf)
         end
-        true
+        {:stdout => outbuf, :stderr => errbuf}
       end
     end
 

data/lib/dcmgr/helpers/nic_helper.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+module Dcmgr
+  module Helpers
+    module NicHelper
+      def find_nic(ifindex = 2)
+        ifindex_map = {}
+        Dir.glob("/sys/class/net/*/ifindex").each do |ifindex_path|
+          device_name = File.split(File.split(ifindex_path).first)[1]
+          ifindex_num = File.readlines(ifindex_path).first.strip
+          ifindex_map[ifindex_num] = device_name
+        end
+        #p ifindex_map
+        ifindex_map[ifindex.to_s]
+      end
+
+      def nic_state(if_name = 'eth0')
+        operstate_path = "/sys/class/net/#{if_name}/operstate"
+        if File.exists?(operstate_path)
+          File.readlines(operstate_path).first.strip
+        end
+      end
+
+      def valid_nic?(nic)
+        ifindex_path = "/sys/class/net/#{nic}/ifindex"
+        if FileTest.exist?(ifindex_path)
+          true
+        else
+          logger.warn("#{nic}: error fetching interface information: Device not found")
+          false
+        end
+      end
+    end
+  end
+end