aws-codedeploy-agent 0.0.2 → 0.0.3

data/test/instance_agent/{codedeploy_plugin → plugins/codedeploy}/installer_test.rb

@@ -1,9 +1,8 @@
 require 'test_helper'
-require 'instance_agent/codedeploy_plugin/installer'
 
 class CodeDeployPluginInstallerTest < InstanceAgentTestCase
 
-  include InstanceAgent::CodeDeployPlugin
+  include InstanceAgent::Plugins::CodeDeployPlugin
 
   context "The CodeDeploy Plugin's file installer" do
 
@@ -49,8 +48,9 @@ class CodeDeployPluginInstallerTest < InstanceAgentTestCase
         InstallInstruction
           .stubs(:generate_instructions)
           .yields(@instruction_builder)
-          .returns([])
+          .returns(@instruction_builder)
 
+        @instruction_builder.stubs(:cleanup).returns(nil)
         File.stubs(:exists?).returns(false)
         File.stubs(:exists?).with("deploy-instructions-dir/ig1-cleanup").returns(false)
 
@@ -88,7 +88,7 @@ class CodeDeployPluginInstallerTest < InstanceAgentTestCase
 
           InstallInstruction
             .expects(:generate_instructions)
-            .returns([])
+            .returns(CommandBuilder.new)
             .in_sequence(call_sequence)
 
           @installer.install(@deployment_group_id, @app_spec)
@@ -366,13 +366,13 @@ class CodeDeployPluginInstallerTest < InstanceAgentTestCase
 
         context "with permissions" do
           setup do
-            @permissions = [InstanceAgent::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("dst1/src1",
+            @permissions = [InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("dst1/src1",
                               {:type => ["file"]}),
-                            InstanceAgent::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/",
+                            InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/",
                               {:type => ["directory"],
                                :pattern => "dst*",
                                :except => []}),
-                            InstanceAgent::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("dst3/",
+                            InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("dst3/",
                               {:type => ["file","directory"],
                                :pattern => "file*",
                                :except => [*2]})]
@@ -472,8 +472,11 @@ class CodeDeployPluginInstallerTest < InstanceAgentTestCase
         setup do
           @command_list = [stub("a command", :execute => nil),
                            stub("a second command", :execute => nil)]
-          InstallInstruction.stubs(:generate_instructions).returns(@command_list)
-          @command_list.stubs(:to_json).returns("INSTALL!")
+          commands = mock("command builder")
+          commands.stubs(:command_array).returns(@command_list)
+          commands.stubs(:cleanup)
+          InstallInstruction.stubs(:generate_instructions).returns(commands)
+          commands.stubs(:to_json).returns("INSTALL!")
         end
 
         should "write them to disk" do

data/test/instance_agent/plugins/codedeploy/onpremise_config_test.rb

@@ -0,0 +1,72 @@
+class OnPremiseConfigTest < InstanceAgentTestCase
+
+  include InstanceAgent::Plugins::CodeDeployPlugin
+
+  linux_path = '/etc/codedeploy-agent/conf/codedeploy.onpremises.yml'
+
+  context "Config file doesn't exist" do
+    setup do
+      File.stubs(:exists?).with(linux_path).returns(false)
+    end
+
+    should "do nothing" do
+      OnPremisesConfig.configure
+    end
+  end
+
+  context "Linux config file exists" do
+    setup do
+      File.stubs(:exists?).with(linux_path).returns(true)
+    end
+
+    context "Linux file is not readable" do
+      setup do
+        File.stubs(:readable?).with(linux_path).returns(false)
+      end
+
+      should "do nothing" do
+        OnPremisesConfig.configure
+      end
+    end
+
+    context "Linux file is valid" do
+      
+      linux_file = <<-END
+      region: us-east-test
+      aws_access_key_id: linuxkey
+      aws_secret_access_key: linuxsecretkey
+      iam_user_arn: test:arn
+      END
+
+      setup do
+        File.stubs(:readable?).with(linux_path).returns(true)
+        File.stubs(:read).with(linux_path).returns(linux_file)
+      end
+
+      should "set the ENV variables correctly" do
+        OnPremisesConfig.configure
+        assert_equal 'us-east-test', ENV['AWS_REGION']
+        assert_equal 'linuxkey', ENV['AWS_ACCESS_KEY']
+        assert_equal 'linuxsecretkey', ENV['AWS_SECRET_KEY']
+        assert_equal 'test:arn', ENV['AWS_HOST_IDENTIFIER']
+      end
+    end
+    
+    context "config file with invalid yaml" do
+      linux_file = <<-END
+        invalid yaml content
+      END
+
+      setup do 
+        File.stubs(:readable?).with(linux_path).returns(true)
+        File.stubs(:read).with(linux_path).returns(linux_file)
+      end
+      
+      should "raise an exception" do
+        assert_raise do
+          OnPremisesConfig.configure
+        end
+      end
+    end
+  end
+end

data/test/instance_agent/runner/child_test.rb

@@ -5,7 +5,7 @@ class RunnerChildTest < InstanceAgentTestCase
     setup do
       @dir = '/tmp'
       @agent = mock()
-      InstanceAgent::CodeDeployPlugin::CommandPoller.stubs(:new).returns(@agent)
+      InstanceAgent::Plugins::CodeDeployPlugin::CommandPoller.stubs(:new).returns(@agent)
       @agent.stubs(:description).returns("CommandPoller")
       InstanceAgent::Runner::Child.any_instance.stubs(:trap_signals)
       @child = InstanceAgent::Runner::Child.new(0, 777)

data/vendor/gems/.codedeploy-commands-1.0.0.created.rid

@@ -1 +1 @@
-Tue, 04 Nov 2014 07:48:38 +0000
+Tue, 30 Jun 2015 13:02:54 -0700

data/vendor/gems/codedeploy-commands/lib/aws/plugins/deploy_control_endpoint.rb

@@ -11,6 +11,10 @@ module Aws
               url = "https://codedeploy-commands.us-east-1.amazonaws.com"
             when "us-west-2"
               url = "https://codedeploy-commands.us-west-2.amazonaws.com"
+            when "eu-west-1"
+              url = "https://codedeploy-commands.eu-west-1.amazonaws.com"
+            when "ap-southeast-2"
+              url = "https://codedeploy-commands.ap-southeast-2.amazonaws.com"
             else
               raise "Not able to find an endpoint. Unknown region."
           end

data/vendor/gems/jmespath-1.0.1/lib/jmespath.rb

@@ -0,0 +1,41 @@
+require 'multi_json'
+require 'pathname'
+
+module JMESPath
+
+  autoload :CachingParser, 'jmespath/caching_parser'
+  autoload :Errors, 'jmespath/errors'
+  autoload :ExprNode, 'jmespath/expr_node'
+  autoload :Lexer, 'jmespath/lexer'
+  autoload :Parser, 'jmespath/parser'
+  autoload :Runtime, 'jmespath/runtime'
+  autoload :Token, 'jmespath/token'
+  autoload :TokenStream, 'jmespath/token_stream'
+  autoload :TreeInterpreter, 'jmespath/tree_interpreter'
+  autoload :VERSION, 'jmespath/version'
+
+  class << self
+
+
+    # @param [String] expression A valid
+    #   [JMESPath](https://github.com/boto/jmespath) expression.
+    # @param [Hash] data
+    # @return [Mixed,nil] Returns the matched values. Returns `nil` if the
+    #   expression does not resolve inside `data`.
+    def search(expression, data)
+      data = case data
+        when Hash, Struct then data # check for most common case first
+        when Pathname then load_json(data)
+        when IO, StringIO then MultiJson.load(data.read)
+        else data
+        end
+      Runtime.new.search(expression, data)
+    end
+
+    # @api private
+    def load_json(path)
+      MultiJson.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
+    end
+
+  end
+end

data/vendor/gems/jmespath-1.0.1/lib/jmespath/caching_parser.rb

@@ -0,0 +1,30 @@
+require 'thread'
+
+module JMESPath
+  class CachingParser
+
+    def initialize(options = {})
+      @parser = options[:parser] || Parser.new(options)
+      @mutex = Mutex.new
+      @cache = {}
+    end
+
+    def parse(expression)
+      if cached = @cache[expression]
+        cached
+      else
+        cache_expression(expression)
+      end
+    end
+
+    private
+
+    def cache_expression(expression)
+      @mutex.synchronize do
+        @cache.clear if @cache.size > 1000
+        @cache[expression] = @parser.parse(expression)
+      end
+    end
+
+  end
+end

data/vendor/gems/jmespath-1.0.1/lib/jmespath/errors.rb

@@ -0,0 +1,17 @@
+module JMESPath
+  module Errors
+
+    class Error < StandardError; end
+
+    class RuntimeError < Error; end
+
+    class SyntaxError < Error; end
+
+    class InvalidTypeError < Error; end
+
+    class InvalidArityError < Error; end
+
+    class UnknownFunctionError < Error; end
+
+  end
+end

data/vendor/gems/jmespath-1.0.1/lib/jmespath/expr_node.rb

@@ -0,0 +1,15 @@
+module JMESPath
+  # @api private
+  class ExprNode
+
+    def initialize(interpreter, node)
+      @interpreter = interpreter
+      @node = node
+    end
+
+    attr_reader :interpreter
+
+    attr_reader :node
+
+  end
+end

data/vendor/gems/jmespath-1.0.1/lib/jmespath/lexer.rb

@@ -0,0 +1,116 @@
+module JMESPath
+  # @api private
+  class Lexer
+
+    # @api private
+    TOKEN_PATTERNS = {}
+
+    # @api private
+    TOKEN_TYPES = {}
+
+    {
+      '[a-zA-Z_][a-zA-Z_0-9]*'     => :identifier,
+      '\.'                         => :dot,
+      '\*'                         => :star,
+      '\[\]'                       => :flatten,
+      '-?\d+'                      => :number,
+      '\|\|'                       => :or,
+      '\|'                         => :pipe,
+      '\[\?'                       => :filter,
+      '\['                         => :lbracket,
+      '\]'                         => :rbracket,
+      '"(?:\\\\\\\\|\\\\"|[^"])*"' => :quoted_identifier,
+      '`(?:\\\\\\\\|\\\\`|[^`])*`' => :literal,
+      ','                          => :comma,
+      ':'                          => :colon,
+      '@'                          => :current,
+      '&'                          => :expref,
+      '\('                         => :lparen,
+      '\)'                         => :rparen,
+      '\{'                         => :lbrace,
+      '\}'                         => :rbrace,
+      '!='                         => :comparator,
+      '=='                         => :comparator,
+      '<='                         => :comparator,
+      '>='                         => :comparator,
+      '<'                          => :comparator,
+      '>'                          => :comparator,
+      '[ \t]'                      => :skip,
+    }.each.with_index do |(pattern, type), n|
+      TOKEN_PATTERNS[n] = pattern
+      TOKEN_TYPES[n] = type
+    end
+
+    # @api private
+    TOKEN_REGEX = /(#{TOKEN_PATTERNS.values.join(')|(')})/
+
+    # @api private
+    JSON_VALUE = /^[\["{]/
+
+    # @api private
+    JSON_NUMBER = /^\-?[0-9]*(\.[0-9]+)?([e|E][+|\-][0-9]+)?$/
+
+    # @param [String<JMESPath>] expression
+    # @return [Array<Hash>]
+    def tokenize(expression)
+      offset = 0
+      tokens = []
+      expression.scan(TOKEN_REGEX).each do |match|
+        match_index = match.find_index { |token| !token.nil? }
+        match_value = match[match_index]
+        type = TOKEN_TYPES[match_index]
+        token = Token.new(type, match_value, offset)
+        if token.type != :skip
+          case token.type
+          when :number then token_number(token, expression, offset)
+          when :literal then token_literal(token, expression, offset)
+          when :quoted_identifier
+            token_quoted_identifier(token, expression, offset)
+          end
+          tokens << token
+        end
+        offset += match_value.size
+      end
+      tokens << Token.new(:eof, nil, offset)
+      unless expression.size == offset
+        syntax_error('invalid expression', expression, offset) 
+      end
+      tokens
+    end
+
+    private
+
+    def token_number(token, expression, offset)
+      token[:value] = token[:value].to_i
+    end
+
+    def token_literal(token, expression, offset)
+      token[:value] = token[:value][1..-2].lstrip.gsub('\`', '`')
+      token[:value] =
+        case token[:value]
+        when 'true', 'false' then token[:value] == 'true'
+        when 'null' then nil
+        when '' then syntax_error("empty json literal", expression, offset)
+        when JSON_VALUE then decode_json(token[:value], expression, offset)
+        when JSON_NUMBER then decode_json(token[:value], expression, offset)
+        else decode_json('"' + token[:value] + '"', expression, offset)
+        end
+    end
+
+    def token_quoted_identifier(token, expression, offset)
+      token[:value] = decode_json(token[:value], expression, offset)
+    end
+
+    def decode_json(json, expression, offset)
+      MultiJson.load(json)
+    rescue MultiJson::ParseError => e
+      syntax_error(e.message, expression, offset)
+    end
+
+    def syntax_error(message, expression, offset)
+      msg = message + "in #{expression.inspect} at #{offset}"
+      raise Errors::SyntaxError.new(msg)
+    end
+
+  end
+end

data/vendor/gems/jmespath-1.0.1/lib/jmespath/parser.rb

@@ -0,0 +1,347 @@
+require 'set'
+
+module JMESPath
+  # @api private
+  class Parser
+
+    # @api private
+    AFTER_DOT = Set.new([
+        :identifier,        # foo.bar
+        :quoted_identifier, # foo."bar"
+        :star,              # foo.*
+        :lbrace,            # foo[1]
+        :lbracket,          # foo{a: 0}
+        :function,          # foo.*.to_string(@)
+        :filter,            # foo.[?bar==10]
+    ])
+
+    CURRENT_NODE = { type: :current }
+
+    # @option options [Lexer] :lexer
+    def initialize(options = {})
+      @lexer = options[:lexer] || Lexer.new()
+    end
+
+    # @param [String<JMESPath>] expression
+    def parse(expression)
+      stream = TokenStream.new(expression, @lexer.tokenize(expression))
+      result = expr(stream)
+      if stream.token.type != :eof
+        raise Errors::SyntaxError, "expected :eof got #{stream.token.type}"
+      else
+        result
+      end
+    end
+
+    # @api private
+    def method_missing(method_name, *args)
+      if matches = method_name.match(/^(nud_|led_)(.*)/)
+        raise Errors::SyntaxError, "unexpected token #{matches[2]}"
+      else
+        super
+      end
+    end
+
+    private
+
+    # @param [TokenStream] stream
+    # @param [Integer] rbp Right binding power
+    def expr(stream, rbp = 0)
+      left = send("nud_#{stream.token.type}", stream)
+      while rbp < stream.token.binding_power
+        left = send("led_#{stream.token.type}", stream, left)
+      end
+      left
+    end
+
+    def nud_current(stream)
+      stream.next
+      CURRENT_NODE
+    end
+
+    def nud_expref(stream)
+      stream.next
+      {
+        type: :expression,
+        children: [expr(stream, 2)]
+      }
+    end
+
+    def nud_filter(stream)
+      led_filter(stream, CURRENT_NODE)
+    end
+
+    def nud_flatten(stream)
+      led_flatten(stream, CURRENT_NODE)
+    end
+
+    def nud_identifier(stream)
+      token = stream.token
+      stream.next
+      { type: :field, key: token.value }
+    end
+
+    def nud_lbrace(stream)
+      valid_keys = Set.new([:quoted_identifier, :identifier])
+      stream.next(match:valid_keys)
+      pairs = []
+      begin
+        pairs << parse_key_value_pair(stream)
+        if stream.token.type == :comma
+          stream.next(match:valid_keys)
+        end
+      end while stream.token.type != :rbrace
+      stream.next
+      {
+        type: :multi_select_hash,
+        children: pairs
+      }
+    end
+
+    def nud_lbracket(stream)
+      stream.next
+      type = stream.token.type
+      if type == :number || type == :colon
+        parse_array_index_expression(stream)
+      elsif type == :star && stream.lookahead(1).type == :rbracket
+        parse_wildcard_array(stream)
+      else
+        parse_multi_select_list(stream)
+      end
+    end
+
+    def nud_literal(stream)
+      value = stream.token.value
+      stream.next
+      {
+        type: :literal,
+        value: value
+      }
+    end
+
+    def nud_quoted_identifier(stream)
+      token = stream.token
+      next_token = stream.next
+      if next_token.type == :lparen
+        msg = 'quoted identifiers are not allowed for function names'
+        raise Errors::SyntaxError, msg
+      else
+        { type: :field, key: token[:value] }
+      end
+    end
+
+    def nud_star(stream)
+      parse_wildcard_object(stream, CURRENT_NODE)
+    end
+
+    def led_comparator(stream, left)
+      token = stream.token
+      stream.next
+      {
+        type: :comparator,
+        relation: token.value,
+        children: [
+          left,
+          expr(stream),
+        ]
+      }
+    end
+
+    def led_dot(stream, left)
+      stream.next(match:AFTER_DOT)
+      if stream.token.type == :star
+        parse_wildcard_object(stream, left)
+      else
+        {
+          type: :subexpression,
+          children: [
+            left,
+            parse_dot(stream, Token::BINDING_POWER[:dot])
+          ]
+        }
+      end
+    end
+
+    def led_filter(stream, left)
+      stream.next
+      expression = expr(stream)
+      if stream.token.type != :rbracket
+        raise Errors::SyntaxError, 'expected a closing rbracket for the filter'
+      end
+      stream.next
+      rhs = parse_projection(stream, Token::BINDING_POWER[:filter])
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          left ? left : CURRENT_NODE,
+          {
+            type: :condition,
+            children: [expression, rhs],
+          }
+        ]
+      }
+    end
+
+    def led_flatten(stream, left)
+      stream.next
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          { type: :flatten, children: [left] },
+          parse_projection(stream, Token::BINDING_POWER[:flatten])
+        ]
+      }
+    end
+
+    def led_lbracket(stream, left)
+      stream.next(match: Set.new([:number, :colon, :star]))
+      type = stream.token.type
+      if type == :number || type == :colon
+        {
+          type: :subexpression,
+          children: [
+            left,
+            parse_array_index_expression(stream)
+          ]
+        }
+      else
+        parse_wildcard_array(stream, left)
+      end
+    end
+
+    def led_lparen(stream, left)
+      args = []
+      name = left[:key]
+      stream.next
+      while stream.token.type != :rparen
+        args << expr(stream, 0)
+        if stream.token.type == :comma
+          stream.next
+        end
+      end
+      stream.next
+      {
+        type: :function,
+        fn: name,
+        children: args,
+      }
+    end
+
+    def led_or(stream, left)
+      stream.next
+      {
+        type: :or,
+        children: [left, expr(stream, Token::BINDING_POWER[:or])]
+      }
+    end
+
+    def led_pipe(stream, left)
+      stream.next
+      {
+        type: :pipe,
+        children: [left, expr(stream, Token::BINDING_POWER[:pipe])],
+      }
+    end
+
+    def parse_array_index_expression(stream)
+      pos = 0
+      parts = [nil, nil, nil]
+      begin
+        if stream.token.type == :colon
+          pos += 1
+        else
+          parts[pos] = stream.token.value
+        end
+        stream.next(match:Set.new([:number, :colon, :rbracket]))
+      end while stream.token.type != :rbracket
+      stream.next
+      if pos == 0
+        { type: :index, index: parts[0] }
+      elsif pos > 2
+        raise Errors::SyntaxError, 'invalid array slice syntax: too many colons'
+      else
+        { type: :slice, args: parts }
+      end
+    end
+
+    def parse_dot(stream, binding_power)
+      if stream.token.type == :lbracket
+        stream.next
+        parse_multi_select_list(stream)
+      else
+        expr(stream, binding_power)
+      end
+    end
+
+    def parse_key_value_pair(stream)
+      key = stream.token.value
+      stream.next(match:Set.new([:colon]))
+      stream.next
+      {
+        type: :key_value_pair,
+        key: key,
+        children: [expr(stream)]
+      }
+    end
+
+    def parse_multi_select_list(stream)
+      nodes = []
+      begin
+        nodes << expr(stream)
+        if stream.token.type == :comma
+          stream.next
+          if stream.token.type == :rbracket
+            raise Errors::SyntaxError, 'expression epxected, found rbracket'
+          end
+        end
+      end while stream.token.type != :rbracket
+      stream.next
+      {
+        type: :multi_select_list,
+        children: nodes
+      }
+    end
+
+    def parse_projection(stream, binding_power)
+      type = stream.token.type
+      if stream.token.binding_power < 10
+        CURRENT_NODE
+      elsif type == :dot
+        stream.next(match:AFTER_DOT)
+        parse_dot(stream, binding_power)
+      elsif type == :lbracket || type == :filter
+        expr(stream, binding_power)
+      else
+        raise Errors::SyntaxError, 'syntax error after projection'
+      end
+    end
+
+    def parse_wildcard_array(stream, left = nil)
+      stream.next(match:Set.new([:rbracket]))
+      stream.next
+      {
+        type: :projection,
+        from: :array,
+        children: [
+          left ? left : CURRENT_NODE,
+          parse_projection(stream, Token::BINDING_POWER[:star])
+        ]
+      }
+    end
+
+    def parse_wildcard_object(stream, left = nil)
+      stream.next
+      {
+        type: :projection,
+        from: :object,
+        children: [
+          left ? left : CURRENT_NODE,
+          parse_projection(stream, Token::BINDING_POWER[:star])
+        ]
+      }
+    end
+
+  end
+end