aws-cache 0.0.01

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 401dd27434bfe5f1cb76b9b4e4ba32778186b3b4
+  data.tar.gz: 0acfb5461a33efaa30af90077a6fd9e510bf9ae9
+SHA512:
+  metadata.gz: e62ab25345e9c47119490cf7261ac2ff86d9d32d5d226b89b9748c36d39f8e7ea10bc99382a7f5b944175721301c6de2bc37cc19f1d1fa09f113887d79c24454
+  data.tar.gz: 5d9a6fc941d936d9ac34f2773401c2b3444841a23498fab249417a09c9da1de5c02ac24081064cc55661ee95e45e8587c17f3d451d85e661a51fdf44fcbfbd67

data/lib/aws-cache.rb

@@ -0,0 +1,193 @@
+require 'redis'
+require 'json'
+require 'aws-sdk'
+require 'yaml'
+
+class AwsCache
+  # Please follow semantic versioning (semver.org).
+  VERSION = '0.0.1'
+
+  def initialize(opts)
+    @redis = optional_element(opts, ['redis'])
+    if @redis.nil?
+      @redis = Redis.new(url: 'redis://aws-cache:6379/0')
+    end
+    @keyspace = optional_element(opts, ['keyspace'], AwsCache::VERSION)
+    @region = optional_element(opts, ['region'], 'us-east-1')
+  end
+
+  def ec2_instances
+    instances = cache_get('aws_ec2_instances', 300) do
+      instances = {}
+    
+      ec2 = Aws::EC2::Client.new(region: @region)
+      page = ec2.describe_instances
+      page.each do |page|
+	page = 
+        page.data[:reservations].each do |res|
+          res[:instances].each do |instance|
+	    list_to_hash!(instance, [:tags], :key)
+	    list_to_hash!(instance, [:block_device_mappings], :device_name)
+	    instances[instance[:instance_id]] = instance
+	  end
+	end
+      end
+    
+      instances
+    end
+
+    return instances
+  end
+
+  def stack_instances(stack_name)
+    instances = self.ec2_instances
+    stack_instances = {}
+    instances.each do |id, instance|
+      if stack_name == optional_element(instance, [':tags','StackName',':value'], '')
+        stack_instances[id] = instance
+      end
+    end
+    return stack_instances
+  end
+
+  def auto_scaling_groups
+    groups = cache_get('aws_auto_scaling_groups', 300) do
+      groups = {}
+    
+      autoscaling = Aws::AutoScaling::Client.new(region: @region)
+      page = autoscaling.describe_auto_scaling_groups
+      page.each do |page|
+        page.data[:auto_scaling_groups].each do |group|
+	  instances = {}
+	  list_to_hash!(group, [:instances], :instance_id)
+	  list_to_hash!(group, [:tags], :key)
+	  groups[group[:auto_scaling_group_name]] = group
+	end
+      end
+    
+      groups
+    end
+
+    return groups
+  end
+
+  def stack_auto_scaling_groups(stack_name)
+    groups = self.auto_scaling_groups
+    stack_groups = {}
+    groups.each do |name, group|
+      if stack_name == optional_element(group, [':tags','StackName',':value'], '')
+        stack_groups[name] = group
+      end
+    end
+    return stack_groups
+  end
+
+  def describe_stacks
+    cloudformation_stacks = cache_get('aws_cloudformation_describe_stacks', 900) do
+      cloudformation_stacks = {}
+    
+      cfn = Aws::CloudFormation::Client.new(region: @region)
+      page = cfn.describe_stacks
+      page.each do |page|
+        page.data[:stacks].each do |stack|
+	  list_to_hash!(stack, [:parameters], :parameter_key)
+	  list_to_hash!(stack, [:outputs], :output_key)
+	  list_to_hash!(stack, [:tags], :key)
+	  cloudformation_stacks[stack[:stack_name]] = stack
+	end
+      end
+    
+      cloudformation_stacks
+    end
+
+    return cloudformation_stacks
+  end
+
+  def describe_stack(stack_name)
+    stacks = self.describe_stacks
+    return stacks[stack_name]
+  end
+
+  def list_stack_resources(stack_name)
+    stack_resources = cache_get("aws_cloudformation_list_stack_resources:#{stack_name}", 900) do
+      stack_resources = {}
+      cfn = Aws::CloudFormation::Client.new(region: @region)
+
+      page = cfn.list_stack_resources(stack_name: stack_name)
+      page.each do |page|
+        resources = page.data[:stack_resource_summaries]
+	resources.each do |resource|
+	  stack_resources[resource[:logical_resource_id]] = resource
+	end
+      end
+    
+      stack_resources
+    end
+
+    return stack_resources
+  end
+
+  # One way this is different than describe_stacks is that it includes
+  # deleted stacks.
+  def list_stacks
+    stacks = cache_get('aws_cloudformation_list_stacks', 900) do
+      # Can't return a hash, because some stacks will appear more
+      # than once, such as if the stack was deleted and recreated.
+      stacks = []
+    
+      cfn = Aws::CloudFormation::Client.new(region: @region)
+      page = cfn.list_stacks
+      page.each do |page|
+        page.data[:stack_summaries].each do |stack|
+	  stacks.push(stack)
+	end
+      end
+    
+      stacks
+    end
+
+    return stacks
+  end
+
+  private
+  def optional_element(hash, keys, default=nil)
+    keys.each do |key|
+      if !hash.is_a?(Hash) || !hash.has_key?(key)
+	return default
+      end
+      hash = hash[key]
+    end
+    return hash 
+  end
+
+  def cache_get(key, ttl)
+    vkey = "#{key}_#{@keyspace}"
+    hash = @redis.get(vkey)
+puts hash
+    unless hash.nil?
+      hash = YAML.load(hash)
+    end
+
+    if hash.nil?
+      hash = yield
+
+      hash = hash.to_yaml
+      @redis.setex(vkey, ttl, hash)
+      hash = YAML.load(hash)
+    end
+
+    return hash
+  end
+
+  def list_to_hash!(src, keys, by_key)
+    hash = {}
+    last_key = keys.pop
+    keys.each do |key|
+      src = src[key]
+    end
+    src[last_key].each do |entry|
+      hash[entry[by_key]] = entry
+    end
+    src[last_key] = hash
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: aws-cache
+version: !ruby/object:Gem::Version
+  version: 0.0.01
+platform: ruby
+authors:
+- Stephen J. Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: You know, to avoid api throttling errors.
+email: stsmith@manta.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aws-cache.rb
+homepage: https://github.com/mantacode/aws-cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: AWS api access layer that caches via Redis.
+test_files: []