puppet-armature 0.3.0 → 0.4.0

data/lib/armature/run.rb

@@ -4,7 +4,7 @@ require 'shellwords'
 module Armature::Run
   extend self
 
-  class CommandFailureError < StandardError
+  class CommandFailureError < Armature::Error
     attr_reader :status
     attr_reader :command
     attr_reader :output
@@ -17,30 +17,57 @@ module Armature::Run
     end
 
     def to_s
-      command_str = Armature::Run.command_to_string(*@command)
+      command_str = Armature::Run.command_to_string(@command)
       "Command failed: #{command_str}\nReturn: #{@status}\nOutput:\n#{@output}\n"
     end
   end
 
-  def command_to_string(*command)
-    command.shelljoin
+  def command_to_string(cmd)
+    escaped_words = cmd.map do |word|
+      escaped = Shellwords.escape(word)
+      if escaped == word || word.include?("'") || word.include?("\\")
+        escaped
+      else
+        # The word needs to be quoted, but doesn't contain ' or \. It can just
+        # singled-quoted.
+        "'#{word}'"
+      end
+    end
+
+    escaped_words.join(" ")
+  end
+
+  def command(environment={}, *cmd)
+    pipe_command("", environment, *cmd)
   end
 
-  def command(environment={}, *command)
-    logger = Logging.logger[self]
+  def pipe_command(input, environment={}, *cmd)
+    if input == ""
+      logger.debug("Run: " + command_to_string(cmd))
+    else
+      logger.debug("Run with input: " + command_to_string(cmd))
+    end
 
-    logger.debug(command_to_string(*command))
-    out, status = Open3.capture2e(environment, *command)
-    logger.debug(command_to_string(command.first) + ": #{status}")
+    start_time = Time.now
+    output, status = nil, nil
+    Open3.popen2e(environment, *cmd) do |pipe_in, pipe_out, promise|
+      pipe_in.write(input)
+      pipe_in.close()
+      output = pipe_out.read()
+      pipe_out.close()
+      status = promise.value
+    end
+    seconds = Time.now - start_time
+    logger.debug("Finished " + command_to_string([cmd.first]) + " in #{seconds}: #{status}")
 
     if ! status.success?
-      raise CommandFailureError.new(status, command, out)
+      raise CommandFailureError.new(status, cmd, output)
     end
 
-    out
+    output
   end
 
-  def clean_git(*command)
+  def clean_git(*cmd)
     # Disable general configuration files
     environment = {
       "HOME" => "",
@@ -48,6 +75,10 @@ module Armature::Run
       "GIT_CONFIG_NOSYSTEM" => "1",
     }
 
-    command(environment, "git", *command)
+    command(environment, "git", *cmd)
+  end
+
+  def logger
+    Logging.logger[self]
   end
 end

data/lib/armature/util.rb

@@ -1,4 +1,6 @@
-require 'json'
+require "json"
+require "net/http"
+require "uri"
 
 module Armature::Util
   extend self
@@ -46,7 +48,6 @@ module Armature::Util
     # operations to block.
     File.open(path, File::RDWR|File::CREAT, 0600) do |lock|
       if not lock.flock(mode | File::LOCK_NB)
-        logger = Logging.logger[self]
         logger.info("Waiting for lock on #{path}")
 
         start_time = Time.now
@@ -71,4 +72,52 @@ module Armature::Util
       yield lock
     end
   end
+
+  def http_get_json(url, request_headers={})
+    accept = { "Accept" => "application/json" }
+    body = http_get(url, request_headers.merge(accept))
+    JSON.parse(body)
+  end
+
+  def http_get_request(url, request_headers={})
+    uri = URI.parse(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = (uri.scheme == "https")
+
+    request = Net::HTTP::Get.new(uri)
+    request["User-Agent"] = "armature #{Armature::VERSION} #{Armature::HOMEPAGE}"
+    request_headers.each do |key, value|
+      request[key] = value
+    end
+
+    http.request(request)
+  end
+
+  def http_get(url, request_headers={})
+    start_time = Time.now
+
+    current_url = url
+    body = nil
+
+    while body == nil do
+      response = http_get_request(current_url, request_headers)
+      if response.kind_of? Net::HTTPRedirection
+        logger.debug("HTTP redirection: #{current_url} to #{response["Location"].inspect}")
+        current_url = response["Location"]
+        next
+      end
+
+      response.value() # Raise error if we don't get 2xx response
+      body = response.body()
+    end
+
+    seconds = Time.now - start_time
+    logger.debug("Downloaded #{body.length()} bytes from #{current_url} in #{seconds}")
+
+    body
+  end
+
+  def logger
+    Logging.logger[self]
+  end
 end

data/lib/armature/version.rb

@@ -1,3 +1,4 @@
 module Armature
-  VERSION = '0.3.0'
+  VERSION = "0.4.0"
+  HOMEPAGE = "https://github.com/danielparks/armature"
 end

data/puppet-armature.gemspec

@@ -5,7 +5,7 @@ spec = Gem::Specification.new do |s|
   s.version = Armature::VERSION
   s.author = 'Daniel Parks'
   s.email = 'dp-os-armature@oxidized.org'
-  s.homepage = 'https://github.com/danielparks/armature'
+  s.homepage = Armature::HOMEPAGE
   s.license = 'BSD-2-Clause'
   s.platform = Gem::Platform::RUBY
   s.summary = 'Deploy Puppet environments and manage modules'

data/test/deploy_test.rb

@@ -6,7 +6,7 @@ class DeployTest < Minitest::Test
 
   def test_deploy_just_master_branch
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
       branches = Set.new(repo.get_branches())
 
       assert_equal(Set.new(['master']), branches,
@@ -14,11 +14,13 @@ class DeployTest < Minitest::Test
       assert_equal([], @environments.names(),
         "Environments before test incorrect")
 
-      @environments.checkout_ref(repo, "master")
+      @environments.check_out_ref(repo, "master")
 
       assert_equal(["master"], @environments.names(),
         "Environments after test incorrect")
-      assert_equal([".", "..", "master"], Dir.entries(@environments.path),
+      assert_equal(
+        [".", "..", "master"].sort(),
+        Dir.entries(@environments.path).sort(),
         "Environments directory after test incorrect")
     end
   end
@@ -26,13 +28,13 @@ class DeployTest < Minitest::Test
   ### FIXME: should this generate an error?
   def test_deploy_nonexistant_branch
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
       branches = Set.new(repo.get_branches())
 
       assert_equal(Set.new(['master']), branches,
         "Branches before test incorrect")
 
-      @environments.checkout_ref(repo, "foo")
+      @environments.check_out_ref(repo, "foo")
 
       assert_equal([], @environments.names(),
         "Environments after test incorrect")
@@ -41,11 +43,11 @@ class DeployTest < Minitest::Test
 
   def test_deploy_all_branches
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
       branches = Set.new(repo.get_branches())
 
-      Dir.mkdir(@context_path + "/foo")
-      File.symlink(@context_path + "/foo", @environments.path + "/foo")
+      Dir.mkdir("foo")
+      File.symlink("foo", @environments.path + "/foo")
 
       assert_equal(["foo"], @environments.names(),
         "Environments before test incorrect")
@@ -55,7 +57,7 @@ class DeployTest < Minitest::Test
       end
 
       branches.each do |branch|
-        @environments.checkout_ref(repo, branch)
+        @environments.check_out_ref(repo, branch)
       end
 
       assert_equal(["master"], @environments.names(),
@@ -65,20 +67,20 @@ class DeployTest < Minitest::Test
 
   def test_deploy_one_module
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
-      @environments.checkout_ref(repo, "master")
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
+      @environments.check_out_ref(repo, "master")
 
       assert_equal(
-        [".", "..", "module1"],
-        Dir.entries(@environments.path + "/master/modules"),
+        [".", "..", "module1"].sort(),
+        Dir.entries(@environments.path + "/master/modules").sort(),
         "Modules installed after test incorrect")
     end
   end
 
   def test_adding_module_and_redeploying
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
-      @environments.checkout_ref(repo, "master")
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
+      @environments.check_out_ref(repo, "master")
 
       repo_init("module-2")
       repo_commit("control", "Add module-2") do
@@ -91,10 +93,10 @@ class DeployTest < Minitest::Test
       end
 
       @cache.flush_memory!
-      @environments.checkout_ref(repo, "master")
+      @environments.check_out_ref(repo, "master")
       assert_equal(
-        [".", "..", "module1", "module2"],
-        Dir.entries(@environments.path + "/master/modules"),
+        [".", "..", "module1", "module2"].sort(),
+        Dir.entries(@environments.path + "/master/modules").sort(),
         "Modules installed after test incorrect")
       assert_environment_file_contains(
         "master/modules/module1/README.md",
@@ -107,8 +109,8 @@ class DeployTest < Minitest::Test
 
   def test_removing_module_and_redeploying
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
-      @environments.checkout_ref(repo, "master")
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
+      @environments.check_out_ref(repo, "master")
 
       repo_commit("control", "Remove module-1") do
         File.write("Puppetfile", <<-PUPPETFILE)
@@ -117,17 +119,16 @@ class DeployTest < Minitest::Test
       end
 
       @cache.flush_memory!
-      @environments.checkout_ref(repo, "master")
+      @environments.check_out_ref(repo, "master")
       assert_equal(
-        [".", ".."],
-        Dir.entries(@environments.path + "/master/modules"),
+        [".", ".."].sort(),
+        Dir.entries(@environments.path + "/master/modules").sort(),
         "Modules installed after test incorrect")
     end
   end
 
   def test_module_with_bad_ref
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
       repo_commit("control", "Set module-1 to bad ref") do
         File.write("Puppetfile", <<-PUPPETFILE)
           forge "https://forge.puppet.com"
@@ -136,23 +137,24 @@ class DeployTest < Minitest::Test
         PUPPETFILE
       end
 
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
       assert_raises(Armature::RefError) do
-        @environments.checkout_ref(repo, "master")
+        @environments.check_out_ref(repo, "master")
       end
 
       ### FIXME state of repo after an error is undefined, but this behavior
       ### seems reasonable.
       assert_equal(
-        [".", ".."],
-        Dir.entries(@environments.path),
+        [".", ".."].sort(),
+        Dir.entries(@environments.path).sort(),
         "Modules installed after test incorrect")
     end
   end
 
   def test_redeploying_module_with_bad_ref
     with_context do
-      repo = @cache.get_repo(repo_path("control"))
-      @environments.checkout_ref(repo, "master")
+      repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
+      @environments.check_out_ref(repo, "master")
 
       repo_commit("control", "Set module-1 to bad ref") do
         File.write("Puppetfile", <<-PUPPETFILE)
@@ -164,15 +166,15 @@ class DeployTest < Minitest::Test
 
       @cache.flush_memory!
       assert_raises(Armature::RefError) do
-        @environments.checkout_ref(repo, "master")
+        @environments.check_out_ref(repo, "master")
       end
 
       ### FIXME state of repo after an error is undefined
       ### What happens if other modules already exist?
       skip("state of repo after an error is undefined")
       assert_equal(
-        [".", "..", "module1"],
-        Dir.entries(@environments.path + "/master/modules"),
+        [".", "..", "module1"].sort(),
+        Dir.entries(@environments.path + "/master/modules").sort(),
         "Modules installed after test incorrect")
     end
   end
@@ -247,9 +249,8 @@ class DeployTest < Minitest::Test
         add_module_class("interesting", "two_b")
 
         @cache.flush_memory!
-        @environments.checkout_ref(@cache.get_repo(repo_path("control")), "master")
+        @environments.check_out_ref(Armature::Repo::Git::from_url(@cache, repo_path("control")), "master")
 
-        skip("checkout_ref doesn't update branches at the moment")
         assert_module_manifests("interesting",
           ["one.pp", "two.pp", "two_a.pp", "two_b.pp"],
           "Incorrect module version after redeploy")
@@ -265,7 +266,7 @@ class DeployTest < Minitest::Test
         add_module_class("interesting", "two_b")
 
         @cache.flush_memory!
-        @cache.update_branches()
+        @cache.update_mutable_refs()
 
         assert_module_manifests("interesting",
           ["one.pp", "two.pp", "two_a.pp", "two_b.pp"],
@@ -278,13 +279,12 @@ private
 
   # The "interesting" repo must be created first so it can be queried for shas
   def redeploy_module_with_ref_of_type(ref_type, ref)
-    repo = @cache.get_repo(repo_path("control"))
-
     repo_puppetfile_update("control", <<-MODULES)
       mod "interesting", :git=>"#{repo_path('interesting')}"
     MODULES
 
-    @environments.checkout_ref(repo, "master")
+    control_repo = Armature::Repo::Git::from_url(@cache, repo_path("control"))
+    @environments.check_out_ref(control_repo, "master")
 
     assert_module_manifests("interesting", ["one.pp", "two.pp", "three.pp"],
       "Incorrect module version after initial deploy")
@@ -299,7 +299,7 @@ private
     end
 
     @cache.flush_memory!
-    @environments.checkout_ref(repo, "master")
+    @environments.check_out_ref(control_repo, "master")
 
     yield
   end

data/test/helpers.rb

@@ -3,8 +3,17 @@ require 'fileutils'
 require 'tmpdir'
 
 module ArmatureTestHelpers
+  def with_temp_dir(name="test")
+    work_path = Dir.mktmpdir("armature.#{name}.")
+    Dir.chdir(work_path) do
+      yield
+    end
+  ensure
+    FileUtils.rm_rf(work_path)
+  end
+
   def repo_path(name)
-    @context_path + "/repos/" + name
+    "repos/" + name
   end
 
   def repo_init(name)
@@ -71,40 +80,32 @@ module ArmatureTestHelpers
     add_module_class(module_name, "three")
   end
 
-  def set_up_context
-    @context_path = Dir.mktmpdir("armature.test_context.")
-    @cache = Armature::Cache.new(@context_path + "/cache")
+  def with_context
+    with_temp_dir("context") do
+      @cache = Armature::Cache.new("cache")
 
-    Dir.mkdir(@context_path + "/environments")
-    @environments = Armature::Environments.new(@context_path + "/environments", @cache)
+      Dir.mkdir("environments")
+      @environments = Armature::Environments.new("environments", @cache)
 
-    repo_init("module-1")
+      repo_init("module-1")
 
-    repo_init("control") do
-      File.write("Puppetfile", <<-PUPPETFILE)
-        forge "https://forge.puppet.com"
+      repo_init("control") do
+        File.write("Puppetfile", <<-PUPPETFILE)
+          forge "https://forge.puppet.com"
 
-        mod "module1", :git=>"#{repo_path('module-1')}"
-      PUPPETFILE
-    end
-  end
-
-  def tear_down_context
-    FileUtils.rm_rf(@context_path)
+          mod "module1", :git=>"#{repo_path('module-1')}"
+        PUPPETFILE
+      end
 
+      yield
+    end
+  ensure
     # Ensure that code trying to use these after this point fails in a
     # predictable way.
-    @context_path = nil
     @cache = nil
     @environments = nil
   end
 
-  def with_context
-    set_up_context
-    yield
-    tear_down_context
-  end
-
   def environment_file_contains?(path, search)
     File.foreach(@environments.path + "/" + path).any? do
       |line| line.include? search
@@ -122,9 +123,10 @@ module ArmatureTestHelpers
   def assert_module_manifests(module_name, manifest_names=["init.pp"],
       message="Incorrect manifests in module '#{module_name}'",
       environment="master")
+    module_path = "#{@environments.path}/#{environment}/modules/#{module_name}"
     assert_equal(
       ([".", "..", ".keep"] + manifest_names).sort(),
-      Dir.entries(@environments.path + "/#{environment}/modules/#{module_name}/manifests"),
+      Dir.entries("#{module_path}/manifests").sort(),
       message)
   end
 end