aws_metadata 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f47a7ac354bc5131d0a0541230d849359b4be02
-  data.tar.gz: 77b8a99b8ab04b3b6cba8de44ad416f5f9c74ec7
+  metadata.gz: 1f0ca59df969c0d034320866c73989b1c0f3cbb5
+  data.tar.gz: 3fc7e4c98941ddac033aef01b4764e7378d8710f
 SHA512:
-  metadata.gz: f326ea632fbac729bfbf1dac578524da9595bb2672f0e83e7b78536ed5b1137ef6afa33e6c4804ed30f2b4d6ca2b165ccb34baa28943749853c4238618b5ee62
-  data.tar.gz: 9c7685e8d65f6ddf500814623bb56ed441113d943731c52efd4ee8a1e1cc54b95c0b8794e9df317154e1aaf8cc84dd16485e31f72b739eb53ecb2553aae3a915
+  metadata.gz: 6bcda2f9346359f806bb8a0ad052fa965277514f62eafd1afc79ad2f85880eede8d80e84438c44a2ae580339b2545da8b68e3e16b48adc3c6654a20c490b9008
+  data.tar.gz: 119731a5c0fbfa70bd4de71a9ac2466d91dbcfd1aae6e41286a823c53aad55bdf053412cc43cf4146bc5e69f20f84dc2db569c4c318b53cf0f04d0a701a78e6c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    aws_metadata (0.1.5)
+    aws_metadata (0.2.0)
       aws-sdk
 
 GEM

data/README.md

@@ -30,6 +30,27 @@ puts AWS::Instance.dynamic.instance_identity.document.account_id
 puts AWS::Instance.user_data
 ```
 
+AWS::Instance is lazy loaded and only makes calls to 169.254.169.254 for the paths requested.  In other words, the entire
+object hierarchy is not built at once, thereby reducing the total number of HTTP requests and reducing the chance
+of being throttled by AWS.
+
+You can alternatively pass the relative endpoint to `metadata` and `dynamic`
+
+```ruby
+puts AWS::Instance.metadata(path: 'instance-id')
+puts AWS::Instance.dynamic( path: ('instance-identity/document').account_id
+```
+
+This has the added benefit of reducing the number of HTTP calls even further if needed/desired.  For instance `AWS::Instance.metadata.instance_id`
+will make 2 calls, 1 for `/meta-data` and another for `meta-data/instance-id`, where `AWS::Instance.metadata(path: 'instance-id')`
+will only make a single call to `/meta-data/instance-id`.  
+
+All calls are cached.
+
+Calls are retried upto 10 times in 1 second intervals if a 200 response is not received.
+
+
+
 To return stubbed responses, you can add this to an initializer:
 
 ```ruby
@@ -135,7 +156,11 @@ The code for `AWS::Instance` is mostly a copy directly from the aws_instmd repo.
 1. The class name.  We removed the MD(metadata) from the name since this gem also has the StackOutput namespace and it's all really metadata.
 2. `AWS::InstMD.meta_data` to `AWS::Instance.metadata`.  We changed meta_data to metadata to be consistent with the naming in our SDK and APIs.
 3. The `AWS::Instance.dynamic.instance_identity.document` returns a Hashish object you can call methods on, rather than a JSON document that has to be parsed manually into a hash. So `AWS::Instance.dynamic.instance_identity.document.account_id` just works.
-4. We added the ability to have stubbed responses returned.  See the usage section below.
+4. We added the ability to have stubbed responses returned.  See the usage section above.
+
+## Dependencies
+ Ruby >= 2.0
+ aws-sdk gem
 
 ## Contributing
 

data/aws_metadata.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0.0'
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency 'yard'

data/lib/aws_metadata/instance_metadata.rb

@@ -4,11 +4,45 @@
 require 'net/http'
 
 module AWS
-  class Instance
-    # @private
-    def self.method_missing name, *args, &block
-      @@root ||= Instance.new
-      @@root.method(name).call(*args, &block)
+  module Instance
+    def self.metadata(path: nil, version: 'latest', host: '169.254.169.254', port: '80')
+      load_stubs
+      url_prefix = "/#{version}/meta-data/"
+      if path.present?
+        @metadata_path       ||= Hashish.new
+        @metadata_path[path] ||= value_by_path(path, @metadata) do
+          query(http(host, port), "#{url_prefix}#{path}")
+        end
+      else
+        @metadata ||= Treeish.new http(host, port), url_prefix
+        raise 'no metadata' if @metadata.blank? # There should always be metadata
+        @metadata
+      end
+    end
+
+    def self.user_data(version: 'latest', host: '169.254.169.254', port: '80')
+      load_stubs
+      @user_data ||= query(http(host, port), "/#{version}/user-data")
+    end
+
+    def self.dynamic(path: nil, version: 'latest', host: '169.254.169.254', port: '80')
+      load_stubs
+      url_prefix = "/#{version}/dynamic/"
+      if path.present?
+        @dynamic_path       ||= Hashish.new
+        @dynamic_path[path] ||= value_by_path(path, @dynamic) do
+          query(http(host, port), "#{url_prefix}#{path}")
+        end
+      else
+        @dynamic ||= Treeish.new http(host, port), url_prefix
+      end
+    end
+
+    # All the metadata from 169.254.169.254
+    #
+    # The hashes are Hashish objects that allows regular method like calls where all method names are the keys underscored.
+    def self.to_hash
+      { :metadata => metadata.merge(Hash(@metadata_path)), :user_data => user_data, :dynamic => dynamic.merge(Hash(@dynamic_path)) }
     end
 
     # Can't be the first one to make that pun.
@@ -21,115 +55,76 @@ module AWS
         end
       end
 
-      def method_missing name
-        if name.to_s == 'document'
-          Hashish.new(JSON.parse(self['document']))
-        else
-          self[name.to_s.gsub('_', '-')]
-        end
+      def method_missing(name)
+        attr       = name.to_s.gsub('_', '-')
+        self[attr] = self[attr].call if self[attr].is_a?(Proc)
+        self[attr]
       end
     end
 
     # @private
     class Treeish < Hashish
       private
-      def initialize http, prefix
-        entries = Instance.query http, prefix
+      def initialize(http, prefix)
+        entries = Instance.query(http, prefix)
         entries.lines.each do |l|
           l.chomp!
           if l.end_with? '/'
-            self[l[0..-2]] = Treeish.new http, "#{prefix}#{l}"
+            self[l[0..-2]] = Proc.new { Treeish.new http, "#{prefix}#{l}" }
             # meta-data/public-keys/ entries have a '0=foo' format
           elsif l =~ /(\d+)=(.*)/
             number, name = $1, $2
-            self[name]   = Treeish.new http, "#{prefix}#{number}/"
+            self[name]   = Proc.new { Treeish.new http, "#{prefix}#{number}/" }
           else
-            self[l] = Instance.query http, "#{prefix}#{l}"
+            self[l] = Proc.new { Instance.query(http, "#{prefix}#{l}") }
           end
         end
       end
     end
 
-    attr_accessor :user_data, :metadata, :dynamic
+    private_class_method
 
-    # Amazon, Y U NO trailing slash entries
-    # in /, /$version and /$version/dynamic/??
-    # There is waaay too much code here.
     # @private
-    def initialize version='latest', host='169.254.169.254', port='80'
-      if AWS::Metadata.stub_responses
-        load_stubs
-        return
-      end
-      http      = Net::HTTP.new host, port
-      load_metadata(http, version)
-      load_user_data(http, version)
-      load_dynamic(http, version)
+    def self.http(host, port)
+      @http ||= Net::HTTP.new host, port
     end
 
     # @private
-    def self.query http, path
-      rep = http.request Net::HTTP::Get.new path
-      unless Net::HTTPOK === rep
-        return nil
-      end
-      rep.body
-    end
-
-    # All the metadata from 169.254.169.254
-    #
-    # The hashes are Hashish objects that allows regular method like calls where all method names are the keys underscored.
-    def to_hash
-      { :metadata => @metadata, :user_data => @user_data, :dynamic => @dynamic }
-    end
-
-    private
-
-    # Load data from the meta-data URL
-    # @private
-    def load_metadata(http, version)
+    def self.query(http, path)
       tries ||= 1
-      @metadata = Treeish.new http, "/#{version}/meta-data/"
-      raise 'no metadata' if @metadata.nil?
+      rep   = http.request Net::HTTP::Get.new path
+      raise "bad request: #{path}" unless Net::HTTPOK === rep
+      value = JSON.parse(rep.body)
+      value.is_a?(Hash) ? Hashish.new(value) : value
+    rescue JSON::ParserError
+      rep.body
     rescue
-      raise if tries >= 10
+      return '' if tries >= 10
       sleep 1
       tries += 1
       retry
     end
 
-    # Load data from the user-data URL
+    # Helper method to provide "stubs" for non aws environments, ie. development and test
     # @private
-    def load_user_data(http, version)
-      @user_data = Instance.query http, "/#{version}/user-data"
-    rescue
-      @user_data = nil
+    def self.load_stubs
+      return unless AWS::Metadata.stub_responses && @metadata.blank?
+      @yaml                                     ||= Pathname.new(File.join(AWS::Metadata.aws_identity_stubs_path, 'aws_identity_stubs.yml'))
+      @responses                                ||= YAML.load(ERB.new(@yaml.read).result)
+      @metadata                                 ||= Hashish.new @responses[:metadata]
+      @user_data                                ||= @responses[:user_data]
+      @dynamic                                  ||= Hashish.new @responses[:dynamic]
+      @dynamic['instance-identity']['document'] = @dynamic['instance-identity']['document'].to_json
     end
 
-    # Load data from the dynamic URL
-    # @private
-    def load_dynamic(http, version)
-      @dynamic = Hashish.new
-      begin
-        dynamic_stuff = Instance.query(http, "/#{version}/dynamic/").lines
-      rescue
-        dynamic_stuff = []
-      end
-      dynamic_stuff.each do |e|
-        e           = e.chomp.chomp '/'
-        @dynamic[e] = Treeish.new http, "/#{version}/dynamic/#{e}/"
+    def self.value_by_path(path, obj)
+      if AWS::Metadata.stub_responses
+        path.split('/').inject(obj) do |o, method|
+          o.send method.to_s.underscore
+        end
+      else
+        yield
       end
     end
-
-    # Helper method to provide "stubs" for non aws deployments
-    # @private
-    def load_stubs
-      yaml                                      = Pathname.new(File.join(AWS::Metadata.aws_identity_stubs_path, 'aws_identity_stubs.yml'))
-      responses                                 = YAML.load(ERB.new(yaml.read).result)
-      @metadata                                 = Hashish.new responses[:metadata]
-      @user_data                                = responses[:user_data]
-      @dynamic                                  = Hashish.new responses[:dynamic]
-      @dynamic['instance-identity']['document'] = @dynamic['instance-identity']['document'].to_json
-    end
   end
 end

data/lib/aws_metadata/version.rb

@@ -1,5 +1,5 @@
 module AWS
   module Metadata
-    VERSION = "0.1.5"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws_metadata
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Evident.io
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-14 00:00:00.000000000 Z
+date: 2016-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,7 +120,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="