wakame 0.5.0 → 0.5.1

data/lib/wakame/command/start_service.rb

@@ -1,7 +1,7 @@
 class Wakame::Command::StartService
   include Wakame::Command
 
-  command_name='start_service'
+  command_name 'start_service'
 
   def run
     svc = service_cluster.find_service(params[:service_id])

data/lib/wakame/command/status.rb

@@ -14,9 +14,12 @@ class Wakame::Command::Status
         :cloud_hosts=>{}
       }
 
-      res[:agent_pool] = AgentPool.instance.dump_attrs
-      AgentPool.instance.group_active.keys.each { |id|
-        res[:agents][id] = Agent.find(id).dump_attrs
+      res[:agent_pool] = {
+        :group_active => Wakame::Models::AgentPool.instance.group_active,
+        :group_observed => Wakame::Models::AgentPool.instance.group_observed
+      }
+      Wakame::Models::AgentPool.instance.dataset.all.each { |row|
+        res[:agents][row[:agent_id]] = Agent.find(row[:agent_id]).dump_attrs
       }
 
       cluster_id = master.cluster_manager.clusters.first
@@ -35,7 +38,6 @@ class Wakame::Command::Status
           res[:cloud_hosts][id]=CloudHost.find(id).dump_attrs
         }
       end
-#p res[:cluster]
       res
     }
 

data/lib/wakame/command/stop_service.rb

@@ -1,7 +1,7 @@
 class Wakame::Command::StopService
   include Wakame::Command
 
-  command_name='stop_service'
+  command_name 'stop_service'
 
   # terminate
   # service_id or resource_name

data/lib/wakame/configuration.rb

@@ -22,6 +22,7 @@ module Wakame
 
     def initialize(env=WAKAME_ENV)
       super(PARAMS)
+
       if root_path.nil?
         root_path = Object.const_defined?(:WAKAME_ROOT) ? WAKAME_ROOT : '../'
       end
@@ -44,6 +45,10 @@ module Wakame
       ::WAKAME_ROOT
     end
 
+    def cluster_env
+      ENV['WAKAME_CLUSTER_ENV'] ? ENV['WAKAME_CLUSTER_ENV'] : 'development'
+    end
+
     def tmp_path
       File.join(root_path, 'tmp')
     end

data/lib/wakame/event.rb

@@ -28,19 +28,58 @@ module Wakame
 
     end
 
+    class ClusterFrozen < Base
+      attr_reader :cluster_id
+      def initialize(cluster_id)
+        super()
+        @cluster_id = cluster_id
+      end
+
+      def log_message
+        "#{@cluster_id}, frozen"
+      end
+    end
+
+    class ClusterUnfrozen < Base
+      attr_reader :cluster_id
+      def initialize(cluster_id)
+        super()
+        @cluster_id = cluster_id
+      end
+
+      def log_message
+        "#{@cluster_id}, unfrozen"
+      end
+    end
+
     class ServiceStatus < Base
-      attr_reader :instance_id, :property
-      def initialize(instance_id, property)
+      attr_reader :instance_id
+      def initialize(instance_id)
         super()
         @instance_id = instance_id
-        @property = property
       end
     end
 
+    # Event class for the change of ServiceInstance#status
     class ServiceStatusChanged < ServiceStatus
       attr_reader :status, :previous_status
-      def initialize(instance_id, property, new_status, prev_status)
-        super(instance_id, property)
+      def initialize(instance_id, new_status, prev_status)
+        super(instance_id)
+        @status = new_status
+        @previous_status = prev_status
+      end
+
+      def log_message
+        "#{instance_id}, #{@previous_status} -> #{@status}"
+      end
+    end
+
+
+    # Event class for the change of ServiceInstance#monitor_status
+    class ServiceMonitorStatusChanged < ServiceStatus
+      attr_reader :status, :previous_status
+      def initialize(instance_id, new_status, prev_status)
+        super(instance_id)
         @status = new_status
         @previous_status = prev_status
       end
@@ -56,12 +95,34 @@ module Wakame
     end
     class ServiceFailed < ServiceStatus
       attr_reader :message
-      def initialize(instance_id, property, message)
-        super(instance_id, property)
+      def initialize(instance_id, message)
+        super(instance_id)
         @message = message
       end
     end
 
+    class ServicePropagated < ServiceStatus
+    end
+    class ServiceDestroied < ServiceStatus
+    end
+
+    class AgentMappedCloudHost < Base
+      attr_reader :agent_id, :cloud_host_id
+      def initialize(cloud_host_id, agent_id)
+        super()
+        @agent_id = agent_id
+        @cloud_host_id = cloud_host_id
+      end
+    end
+    class AgentUnmappedCloudHost < Base
+      attr_reader :agent_id, :cloud_host_id
+      def initialize(cloud_host_id, agent_id)
+        super()
+        @agent_id = agent_id
+        @cloud_host_id = cloud_host_id
+      end
+    end
+
     class AgentEvent < Base
       attr_reader :agent
       def initialize(agent)
@@ -100,20 +161,20 @@ module Wakame
       end
     end
 
-    class ServiceUnboundHost < Base
-      attr_reader :service, :host
-      def initialize(service, host)
+    class ServiceUnboundCloudHost < Base
+      attr_reader :svc_id, :cloud_host_id
+      def initialize(svc_id, cloud_host_id)
         super()
-        @service = service
-        @host = host
+        @svc_id = svc_id
+        @cloud_host_id = cloud_host_id
       end
     end
-    class ServiceBoundHost < Base
-      attr_reader :service, :host
-      def initialize(service, host)
+    class ServiceBoundCloudHost < Base
+      attr_reader :svc_id, :cloud_host_id
+      def initialize(svc_id, cloud_host_id)
         super()
-        @service = service
-        @host = host
+        @svc_id = svc_id
+        @cloud_host_id = cloud_host_id
       end
     end
 
@@ -135,22 +196,6 @@ module Wakame
       end
     end
 
-    class ServiceDestroied < Base
-      attr_reader :service
-      def initialize(svc_inst)
-        super()
-        @service = svc_inst
-      end
-    end
-
-    class ServicePropagated < Base
-      attr_reader :service
-      def initialize(svc_inst)
-        super()
-        @service = svc_inst
-      end
-    end
-
     class CommandReceived < Base
       attr_reader :command
       def initialize(command)
@@ -197,6 +242,13 @@ module Wakame
     class JobStart < JobEvent
     end
     class JobComplete < JobEvent
+      attr_reader :status
+      def initialize(job_id, status)
+        super(job_id)
+        @status = status
+      end
+    end
+    class JobSuccess < JobEvent
     end
     class JobFailed < JobEvent
       attr_reader :exception

data/lib/wakame/event_dispatcher.rb

@@ -100,8 +100,8 @@ module Wakame
     def fire_event(event_obj)
       raise ArgumentError unless event_obj.is_a?(Event::Base)
 
-      if Wakame.log.level == 'DEBUG' && !FIRE_EVENT_LOG_IGNORE_EVENTS.member?(event_obj.class)
-        Wakame.log.debug("Event #{event_obj.class} has been fired:" + (event_obj.log_message.nil? ? "" : event_obj.log_message) )
+      if Wakame.log.level == 0 && !FIRE_EVENT_LOG_IGNORE_EVENTS.member?(event_obj.class)
+        Wakame.log.debug("Event #{event_obj.class} has been fired:" + (event_obj.log_message.nil? ? '' : (' ' + event_obj.log_message)) )
       end
       tlist = @event_handlers[event_obj.class]
       return if tlist.nil?

data/lib/wakame/initializer.rb

@@ -13,6 +13,10 @@ module Wakame
       def instance
         @instance
       end
+
+      def loaded_classes
+        @loaded_classes ||= []
+      end
     end
 
     attr_reader :configuration
@@ -28,7 +32,7 @@ module Wakame
     end
 
     def process_master
-      process
+      require 'wakame/master'
       setup_database
       load_resources
       load_core_commands
@@ -37,8 +41,9 @@ module Wakame
     end
     
     def process_agent
-      process
+      require 'wakame/agent'
       load_actors
+      load_monitors
     end
     
     def process_cli
@@ -86,16 +91,9 @@ module Wakame
 #         end
 #       }
 
-      $LOAD_PATH.each{ |d|
-        Dir.glob("#{d}/wakame/command/**/*.rb").each{ |f|
-          f =~ %r{(wakame/command/.+)\.rb\Z}
-          require "#{$1}"
-        }
-      }
-      
-      #%w(launch_cluster shutdown_cluster status action_status actor).each { |f|
-      #  require "wakame/command/#{f}"
-      #}
+      load_framework('wakame/command/**/*.rb', lambda{ |f|
+                       Wakame.log.debug("Loading Core Commands: #{f}")
+                     })
     end
 
 
@@ -130,35 +128,103 @@ module Wakame
     end
 
     def load_actors
-      load_path = File.expand_path('cluster/actors', configuration.root_path)
-      Dir.glob("#{load_path}/*.rb").sort.each do |file|
-        if file =~ %r{\A#{Regexp.escape(load_path)}/([^/]+)\.rb\Z}
-          Wakame.log.debug("Loading Actor: #{file}")
-          load file
-        end
-      end
+      load_framework('wakame/actor/**/*.rb', lambda{ |f|
+                       Wakame.log.debug("Loading Core Actor: #{f}")
+                     })
+
+      load_project('cluster/actors/*.rb', lambda{ |f|
+                     Wakame.log.debug("Loading Project Actor: #{f}")
+                   })
+    end
+
+    def load_monitors
+      load_framework('wakame/monitor/**/*.rb', lambda{ |f|
+                       Wakame.log.debug("Loading Core Monitor: #{f}")
+                     })
+
+      #load_project('cluster/monitors/*.rb', lambda{ |f|
+      #               Wakame.log.debug("Loading Project Monitor: #{f}")
+      #             })
     end
 
     def load_core_triggers
-      $LOAD_PATH.each{ |d|
-        Dir.glob("#{d}/wakame/triggers/**/*.rb").each{ |f|
-          f =~ %r{(wakame/triggers/.+)\.rb\Z}
-          require "#{$1}"
-        }
-      }
+      load_framework("wakame/triggers/**/*.rb", lambda{ |f|
+                       Wakame.log.debug("Loading Core triggers: #{f}")
+                     })
     end
 
     def load_core_actions
-      $LOAD_PATH.each{ |d|
-        Dir.glob("#{d}/wakame/actions/**/*.rb").each{ |f|
-          f =~ %r{(wakame/actions/.+)\.rb\Z}
-          require "#{$1}"
+      load_framework("wakame/actions/**/*.rb", lambda{ |f|
+                       Wakame.log.debug("Loading Core Actions: #{f}")
+                     })
+    end
+
+    def setup_database
+      require 'sequel'
+      
+      #db = Sequel.connect(Wakame.config.status_db_dsn, {:logger=>Wakame.log})
+      #db = Sequel.connect(Wakame.config.status_db_dsn, {:timeout=>15000})
+      db = Sequel.connect(Wakame.config.status_db_dsn)
+      if db.uri  =~ /\Asqlite:/
+        orig_proc = db.pool.connection_proc
+        db.pool.connection_proc = proc { |svr|
+          con = orig_proc.call(svr)
+          con.busy_handler {|data, retries|
+            if retries > 5
+              Wakame.log.fatal("Detected the SQLite's busy lock: #{Thread.current}, data=#{data}, retries=#{retries}")
+              exit 100
+            end
+            sleep 8
+            true
+          }
+          con
         }
+      end
+
+      load_framework('wakame/models/*.rb', 
+                     lambda {|path| self.class.loaded_classes.clear},
+                     lambda {|path|
+                               
+                       self.class.loaded_classes.each { |model_class|
+                         next unless model_class.is_a?(Class) && model_class < Sequel::Model
+                         
+                         model_class.create_table?
+                       }
+
+                     })
+
+
+      if db.table_exists?(:metadata)
+      else
+        db.create_table? :metadata do
+          primary_key :id
+          column :version, :string
+          column :created_at, :datetime
+        end
+        db[:metadata].insert(:version=>'0.4', :created_at=>Time.now)
+      end
+
+    end
+
+    def load_framework(glob_pat, pre_hook=nil, post_hook=nil)
+      if Wakame::Bootstrap.boot_type == Wakame::Bootstrap::VendorBoot
+        rbfiles = Dir.glob(File.expand_path(glob_pat, File.join(configuration.framework_root_path, 'lib')))  
+      else
+        rbfiles = Gem.find_files(glob_pat)
+      end
+      rbfiles.sort.each{ |f|
+        pre_hook.call(f) if pre_hook
+        load f
+        post_hook.call(f) if post_hook
       }
     end
 
-    def setup_database
-      Wakame::StatusDB.adapter
+    def load_project(glob_pat, pre_hook=nil, post_hook=nil)
+      Dir.glob(File.expand_path(glob_pat, configuration.root_path)).sort.each{ |f|
+        (pre_hook.call(f) || next) if pre_hook
+        load f
+        post_hook.call(f) if post_hook
+      }
     end
 
   end

data/lib/wakame/master.rb

@@ -7,346 +7,6 @@ require 'wakame/queue_declare'
 
 module Wakame
 
-  module Manager
-    attr_accessor :master
-
-    def init
-    end
-    
-    def start
-    end
-    
-    def stop
-    end
-    
-    def reload
-    end
-    
-    def terminate
-    end
-  end
-  
-
-  class AgentMonitor
-    include Manager
-    include ThreadImmutable
-
-    def init
-      @agent_timeout = 31.to_f
-      @agent_kill_timeout = @agent_timeout * 2
-      @gc_period = 20.to_f
-
-      Service::AgentPool.reset
-
-      # GC event trigger for agent timer & status
-      @agent_timeout_timer = EM::PeriodicTimer.new(@gc_period) {
-        StatusDB.pass {
-          #Wakame.log.debug("Started agent GC : agents.size=#{@registered_agents.size}")
-          [self.agent_pool.group_active.keys, self.agent_pool.group_observed.keys].flatten.uniq.each { |agent_id|
-            agent = Service::Agent.find(agent_id)
-            #next if agent.status == Service::Agent::STATUS_OFFLINE
-            
-            diff_time = Time.now - agent.last_ping_at_time
-            #Wakame.log.debug "AgentMonitor GC : #{agent_id}: #{diff_time}"
-            if diff_time > @agent_timeout.to_f
-              agent.update_status(Service::Agent::STATUS_TIMEOUT)
-            end
-            
-            if diff_time > @agent_kill_timeout.to_f
-              agent_pool.unregister(agent)
-            end
-          }
-          
-          #Wakame.log.debug("Finished agent GC")
-        }
-      }
-      
-      
-      master.add_subscriber('registry') { |data|
-        data = eval(data)
-        
-        StatusDB.pass {
-          agent_id = data[:agent_id]
-          
-          agent = agent_pool.create_or_find(agent_id)
-          
-          case data[:class_type]
-          when 'Wakame::Packets::Register'
-            agent.root_path = data[:root_path]
-            agent.vm_attr = data[:attrs]
-            agent.save
-            agent_pool.register(agent)
-          when 'Wakame::Packets::UnRegister'
-            agent_pool.unregister(agent)
-          end
-        }
-
-      }
-
-      master.add_subscriber('ping') { |data|
-        ping = eval(data)
-        # Skip the old ping responses before starting master node.
-        next if Time.parse(ping[:responded_at]) < master.started_at
-
-        # Variable update function for the common members
-        set_report_values = proc { |agent|
-          agent.last_ping_at = ping[:responded_at]
-          agent.vm_attr = ping[:attrs]
-
-          agent.renew_reported_services(ping[:services])
-          agent.save
-
-          agent.update_status(Service::Agent::STATUS_ONLINE)
-        }
-        
-        StatusDB.pass { 
-          agent = Service::Agent.find(ping[:agent_id])
-          if agent.nil?
-            agent = Service::Agent.new
-            agent.id = ping[:agent_id]
-            
-            set_report_values.call(agent)
-
-            agent_pool.register_as_observed(agent)
-          else
-            set_report_values.call(agent)
-          end
-          
-          EventDispatcher.fire_event(Event::AgentPong.new(agent))
-        }
-      }
-      
-      master.add_subscriber('agent_event') { |data|
-        response = eval(data)
-        StatusDB.pass {
-          case response[:class_type]
-          when 'Wakame::Packets::StatusCheckResult'
-            svc_inst = Service::ServiceInstance.find(response[:svc_id])
-            if svc_inst
-              svc_inst.monitor_status = response[:status]
-              svc_inst.save
-            else
-              Wakame.log.error("#{self.class}: Unknown service ID: #{response[:svc_id]}")
-            end
-          when 'Wakame::Packets::ServiceStatusChanged'
-            svc_inst = Service::ServiceInstance.find(response[:svc_id])
-            if svc_inst
-              response_time = Time.parse(response[:responded_at])
-              svc_inst.update_status(response[:new_status], response_time, response[:fail_message])
-            end
-          when 'Wakame::Packets::ActorResponse'
-            case response[:status]
-            when Actor::STATUS_RUNNING
-              EventDispatcher.fire_event(Event::ActorProgress.new(response[:agent_id], response[:token], 0))
-            when Actor::STATUS_FAILED
-              EventDispatcher.fire_event(Event::ActorComplete.new(response[:agent_id], response[:token], response[:status], nil))
-            else
-              EventDispatcher.fire_event(Event::ActorComplete.new(response[:agent_id], response[:token], response[:status], response[:opts][:return_value]))
-            end
-          else
-            Wakame.log.warn("#{self.class}: Unhandled agent response: #{response[:class_type]}")
-          end
-        }
-      }
-
-    end
-
-    def terminate
-      @agent_timeout_timer.cancel
-    end
-
-    def agent_pool
-      Service::AgentPool.instance
-    end
-
-   end
-
-
-
-   class ClusterManager
-     include Manager
-
-     class ClusterConfigLoader
-
-       def load(cluster_rb_path=Wakame.config.cluster_config_path)
-         Wakame.log.info("#{self.class}: Loading cluster.rb: #{cluster_rb_path}")
-         @loaded_cluster_names = {}
-
-         eval(File.readlines(cluster_rb_path).join(''), binding)
-
-         # Clear uninitialized cluster data in the store.
-         Service::ServiceCluster.find_all.each { |cluster|
-           cluster.delete unless @loaded_cluster_names.has_key?(cluster.name)
-         }
-
-         @loaded_cluster_names
-       end
-
-
-       private
-       def define_cluster(name, &blk)
-         cluster = Service::ServiceCluster.find(Service::ServiceCluster.id(name))
-         if cluster.nil?
-           cluster = Service::ServiceCluster.new
-           cluster.name = name
-         end
-
-         Service::AgentPool.reset
-         cluster.reset
-
-         blk.call(cluster)
-
-         cluster.save
-
-         Wakame.log.info("#{self.class}: Loaded Service Cluster: #{cluster.name}")
-         @loaded_cluster_names[name]=cluster.id
-       end
-
-     end
-
-     def init
-       # Periodical cluster status updater
-       @status_check_timer = EM::PeriodicTimer.new(5) {
-         StatusDB.pass {
-           clusters.each { |cluster_id|
-             Service::ServiceCluster.find(cluster_id).update_cluster_status
-           }
-         }
-       }
-       
-       # Event based cluster status updater
-       @check_event_tickets = []
-       [Event::ServiceOnline, Event::ServiceOffline, Event::ServiceFailed].each { |evclass|
-         @check_event_tickets << EventDispatcher.subscribe(evclass) { |event|
-           StatusDB.pass {
-             clusters.each { |cluster_id|
-               Service::ServiceCluster.find(cluster_id).update_cluster_status
-             }
-           }
-         }
-       }
-
-     end
-
-     def reload
-     end
-
-     def terminate
-       @status_check_timer.cancel
-       @check_event_tickets.each { |t|
-         EventDispatcher.unsubscribe(t)
-       }
-     end
-
-     def clusters
-       ServiceClusterPool.all.map{|r| r.service_cluster_id }
-     end
-
-     def register(cluster)
-       raise ArgumentError unless cluster.is_a?(Service::ServiceCluster)
-       ServiceClusterPool.register_cluster(cluster.name)
-     end
-
-     def unregister(cluster_id)
-       @clusters.delete(cluster_id)
-     end
-
-     def load_config_cluster
-       ClusterConfigLoader.new.load.each { |name, id|
-         ServiceClusterPool.register_cluster(name)
-       }
-       resolve_template_vm_attr
-     end
-
-
-     private
-     def resolve_template_vm_attr
-       ServiceClusterPool.each_cluster { |cluster|
-         cluster_id = cluster.id
-
-         if cluster.template_vm_attr.nil? || cluster.template_vm_attr.empty?
-           update_template_spec = lambda { |agent|
-             raise ArgumentError unless agent.is_a?(Service::Agent)
-
-             require 'right_aws'
-             ec2 = RightAws::Ec2.new(Wakame.config.aws_access_key, Wakame.config.aws_secret_key)
-             
-             ref_attr = ec2.describe_instances([agent.vm_attr[:instance_id]])
-             ref_attr = ref_attr[0]
-                 
-             cluster = Service::ServiceCluster.find(cluster_id)
-             spec = cluster.template_vm_spec
-             Service::VmSpec::EC2.vm_attr_defs.each { |k, v|
-               spec.attrs[k] = ref_attr[v[:right_aws_key]]
-             }
-             cluster.save
-             
-             Wakame.log.debug("ServiceCluster \"#{cluster.name}\" template_vm_attr based on VM \"#{agent.vm_attr[:instance_id]}\" : #{spec.attrs.inspect}")
-           }
-
-
-           agent_id = Service::AgentPool.instance.group_active.keys.first
-           if agent_id.nil?
-             # Set a single shot event handler to set the template values up from the first connected agent.
-             EventDispatcher.subscribe_once(Event::AgentMonitored) { |event|
-               StatusDB.pass {
-                 update_template_spec.call(event.agent)
-               }
-             }
-           else
-             StatusDB.pass {
-               update_template_spec.call(Service::Agent.find(agent_id))
-             }
-           end
-         end
-
-         if cluster.advertised_amqp_servers.nil?
-           StatusDB.pass {
-             cluster = Service::ServiceCluster.find(cluster_id)
-             cluster.advertised_amqp_servers = master.amqp_server_uri.to_s
-             cluster.save
-             Wakame.log.debug("ServiceCluster \"#{cluster.name}\" advertised_amqp_servers: #{cluster.advertised_amqp_servers}")
-           }
-         end
-
-       }
-     end
-
-
-     class ServiceClusterPool < Sequel::Model
-       plugin :schema
-       
-       def self.initialize_table
-         set_schema do
-           primary_key :id, :type => Integer
-           varchar :service_cluster_id
-         end
-         create_table unless table_exists?
-       end
-       
-       
-       def self.register_cluster(name)
-         id = Service::ServiceCluster.id(name)
-         
-         self.find_or_create(:service_cluster_id=>id)
-       end
-       
-       def self.unregister_cluster(name)
-         id = Service::ServiceCluster.id(name)
-         self.delete(:service_cluster_id=>id)
-       end
-       
-       def self.each_cluster(&blk)
-         self.all.each { |m|
-           cluster = Service::ServiceCluster.find(m.service_cluster_id)
-           blk.call(cluster)
-         }
-       end
-    end
-
-     ServiceClusterPool.initialize_table
-   end
-
    class Master
      include Wakame::AMQPClient
      include Wakame::QueueDeclare
@@ -375,7 +35,7 @@ module Wakame
     end
 
     def register_manager(manager)
-      raise ArgumentError unless manager.kind_of? Manager
+      raise ArgumentError unless manager.kind_of? MasterManager
       manager.master = self
       @managers << manager
       manager
@@ -384,22 +44,39 @@ module Wakame
     # post_setup
     def init
       raise 'has to be put in EM.run context' unless EM.reactor_running?
-      @command_queue = register_manager(CommandQueue.new)
+      @command_queue = register_manager(MasterManagers::CommandQueue.new)
 
       # WorkerThread has to run earlier than other managers.
-      @agent_monitor = register_manager(AgentMonitor.new)
-      @cluster_manager = register_manager(ClusterManager.new)
-      @action_manager = register_manager(ActionManager.new)
+      @agent_monitor = register_manager(MasterManagers::AgentMonitor.new)
+      @cluster_manager = register_manager(MasterManagers::ClusterManager.new)
+      @action_manager = register_manager(MasterManagers::ActionManager.new)
 
       @managers.each {|m|
         Wakame.log.debug("Initializing Manager Module: #{m.class}")
         m.init
       }
 
-      Wakame.log.info("Started master process : WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment}")
+      Wakame.log.info("Started master process : AMQP Server=#{amqp_server_uri.to_s} WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment} WAKAME_CLUSTER_ENV=#{Wakame.config.cluster_env}")
     end
 
 
+    def self.ec2_query_metadata_uri(key)
+      require 'open-uri'
+      open("http://169.254.169.254/2008-02-01/meta-data/#{key}"){|f|
+        return f.readline
+      }
+    end
+
+    def self.ec2_fetch_local_attrs
+      attrs = {}
+      %w[instance-id instance-type local-ipv4 local-hostname public-hostname public-ipv4 ami-id].each{|key|
+        rkey = key.tr('-', '_')
+        attrs[rkey.to_sym]=ec2_query_metadata_uri(key)
+      }
+      attrs[:availability_zone]=ec2_query_metadata_uri('placement/availability-zone')
+      attrs
+    end
+
     private
     def pre_setup
       @started_at = Time.now