cartage-remote 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ec28919c46cca17afd22212d913af4b3292c7eb
+  data.tar.gz: 50e8f6d1252e272526e4e8953f0a872107e0078d
+SHA512:
+  metadata.gz: a8cb9fd3b201d4951452c98b107fe68b01a3d61d4a544bbe864404467e28fea84791cf13654085d1a6201c0ed6407355e7da1b627dd9fb1b7b865dc4d8c23bc8
+  data.tar.gz: ec485dac5760aca2e8fa061050e72bdf3dd9c8a29a8ef71af6b5522b81f30345981ada21c9ee6ac47e71525aa79b6da746b8e593d37a3881db612ca4890fc6f3

data/.autotest

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+Autotest.add_hook :initialize do |at|
+  # .minitest.rb ensures that the gem version of minitest is used.
+  at.testlib = ".minitest.rb"
+  # at.testlib = "minitest/unit"
+  #
+  # at.extra_files << "../some/external/dependency.rb"
+  #
+  # at.libs << ":../some/external"
+  #
+  # at.add_exception "vendor"
+  #
+  # at.add_mapping(/dependency.rb/) do |f, _|
+  #   at.files_matching(/test_.*rb$/)
+  # end
+  #
+  # %w(TestA TestB).each do |klass|
+  #   at.extra_class_map[klass] = "test/test_misc.rb"
+  # end
+end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/.gemtest

@@ -0,0 +1 @@
+

data/.minitest.rb

@@ -0,0 +1,2 @@
+gem "minitest"
+require "minitest/autorun"

data/Contributing.rdoc

@@ -0,0 +1,63 @@
+== Contributing
+
+We value any contribution to cartage-remote you can provide: a bug report, a
+feature request, or code contributions.
+
+cartage-remote has a few contribution guidelines:
+
+* Changes *will* *not* be accepted without tests. The test suite is written
+  with {Minitest}[https://github.com/seattlerb/minitest].
+* Match our coding style.
+* Use a thoughtfully-named topic branch that contains your change. Rebase your
+  commits into logical chunks as necessary.
+* Use {quality commit messages}[http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html].
+* Do not change the version number; when your patch is accepted and a release
+  is made, the version will be updated at that point.
+* Submit a GitHub pull request with your changes.
+
+=== Test Dependencies
+
+cartage-remote uses Ryan Davis’s {Hoe}[https://github.com/seattlerb/hoe] to manage
+the release process, and it adds a number of rake tasks. You will mostly be
+interested in:
+
+    $ rake
+
+which runs the tests the same way that:
+
+    $ rake test
+    $ rake travis
+
+will do.
+
+To assist with the installation of the development dependencies for cartage-remote,
+I have provided the simplest possible Gemfile pointing to the (generated)
++cartage-remote.gemspec+ file. This will permit you to do:
+
+    $ bundle install
+
+to get the development dependencies. If you aleady have +hoe+ installed, you
+can accomplish the same thing with:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs, and
+generate the RDoc.
+
+=== Workflow
+
+Here's the most direct way to get your work merged into the project:
+
+* Fork the project.
+* Clone down your fork (<tt>git clone git://github.com/KineticCafe/cartage-remote.git</tt>).
+* Create a topic branch to contain your change (<tt>git checkout -b my\_awesome\_feature</tt>).
+* Hack away, add tests. Not necessarily in that order.
+* Make sure everything still passes by running +rake+.
+* If necessary, rebase your commits into logical chunks, without errors.
+* Push the branch up (<tt>git push origin my\_awesome\_feature</tt>).
+* Create a pull request against KineticCafe/cartage-remote and describe
+  what your change does and the why you think it should be merged.
+
+=== Contributors
+
+* Austin Ziegler created cartage-remote.

data/Gemfile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+# NOTE: This file is not the canonical source of dependencies. Edit the
+# Rakefile, instead.
+
+source "https://rubygems.org/"
+gemspec
+
+# vim: syntax=ruby

data/History.rdoc

@@ -0,0 +1,5 @@
+=== 1.0 / 2015-03-20
+
+*   1 major enhancement
+
+    *   Birthday!

data/Licence.rdoc

@@ -0,0 +1,27 @@
+== Licence
+
+This software is available under an MIT-style licence.
+
+* Copyright 2015 Kinetic Cafe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+* The names of its contributors may not be used to endorse or promote
+  products derived from this software without specific prior written
+  permission.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,12 @@
+.autotest
+.gemtest
+.minitest.rb
+Contributing.rdoc
+Gemfile
+History.rdoc
+Licence.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/cartage/remote.rb
+lib/cartage/remote/command.rb

data/README.rdoc

@@ -0,0 +1,45 @@
+= cartage-remote by Kinetic Cafe
+
+code :: https://github.com/KineticCafe/cartage-remote/
+issues :: https://github.com/KineticCafe/cartage-remote/issues
+continuous integration :: {<img src="https://travis-ci.org/KineticCafe/cartage-remote.png" />}[https://travis-ci.org/KineticCafe/cartage-remote]
+
+== Description
+
+cartage-remote is a plug-in for {cartage}[https://github.com/KineticCafe/cartage]
+to build a package on a remote machine with cartage.
+
+Cartage provides a repeatable means to create a package for a Rails application
+that can be used in deployment with a configuration tool like Ansible, Chef,
+Puppet, or Salt. The package is created with its dependencies bundled in
+`vendor/bundle`, so it can be deployed in environments with strict access
+control rules and without requiring development tool access.
+
+== Synopsis
+
+    # Build a package on a remote machine via SSH.
+    cartage remote
+
+== Install
+
+Add cartage-remote to your Gemfile:
+
+    gem 'cartage-remote', '~> 1.0'
+
+Or manually install:
+
+  % gem install cartage-remote
+
+== cartage-remote Semantic Versioning
+
+cartage-remote uses a {Semantic Versioning}[http://semver.org/] scheme with one
+change:
+
+* When PATCH is zero (+0+), it will be omitted from version references.
+
+cartage-remote will generally track cartage for major versions to ensure plugin API
+compatibility.
+
+:include: Contributing.rdoc
+
+:include: Licence.rdoc

data/Rakefile

@@ -0,0 +1,56 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'pathname'
+
+Hoe.plugin :doofus
+Hoe.plugin :email unless ENV['CI'] or ENV['TRAVIS']
+Hoe.plugin :gemspec2
+Hoe.plugin :git
+Hoe.plugin :minitest
+Hoe.plugin :rubygems
+
+spec = Hoe.spec 'cartage-remote' do
+  developer('Austin Ziegler', 'aziegler@kineticcafe.com')
+
+  self.history_file = 'History.rdoc'
+  self.readme_file = 'README.rdoc'
+  self.extra_rdoc_files = FileList['*.rdoc'].to_a
+
+  license 'MIT'
+
+  self.extra_deps << ['cartage', '~> 1.0']
+  self.extra_deps << ['fog', '~> 1.27']
+
+  self.extra_dev_deps << ['rake', '~> 10.0']
+  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  self.extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
+  self.extra_dev_deps << ['hoe-git', '~> 1.5']
+  self.extra_dev_deps << ['hoe-geminabox', '~> 0.3']
+=begin
+  self.extra_dev_deps << ['minitest', '~> 5.4']
+  self.extra_dev_deps << ['minitest-autotest', '~> 1.0']
+  self.extra_dev_deps << ['minitest-bisect', '~> 1.2']
+  self.extra_dev_deps << ['minitest-focus', '~> 1.1']
+  self.extra_dev_deps << ['minitest-moar', '~> 0.0']
+  self.extra_dev_deps << ['minitest-pretty_diff', '~> 0.1']
+  self.extra_dev_deps << ['simplecov', '~> 0.7']
+=end
+end
+
+=begin
+namespace :test do
+  task :coverage do
+    prelude = <<-EOS
+require 'simplecov'
+SimpleCov.start('test_frameworks') { command_name 'Minitest' }
+gem 'minitest'
+    EOS
+    spec.test_prelude = prelude.split($/).join('; ')
+    Rake::Task['test'].execute
+  end
+end
+=end
+
+# vim: syntax=ruby

data/lib/cartage/remote.rb

@@ -0,0 +1,381 @@
+begin
+  require 'psych'
+rescue LoadError
+end
+require 'tempfile'
+require 'yaml'
+require 'erb'
+require 'cartage/plugin'
+
+class Cartage
+  # Connect to a remote machine and build a package remotely. Cartage::Remote
+  # uses Fog::SSH with key-based, not password-based authentication to connect
+  # to a remote server.
+  #
+  # Cartage::Remote assumes a relatively stable build server, but does not
+  # require one (custom +prebuild+ and +postbuild+ scripts could be used to
+  # manage that).
+  #
+  # == Remote Build Isolation
+  #
+  # Cartage::Remote allows for safe builds across multiple projects and
+  # branches with path-based isolation. The pattern for the build path is shown
+  # below, where the last part of the path is where the code will be cloned to.
+  #
+  #   ~<remote_user>/cartage/<project-name>/<timestamp>/<project-name>
+  #          |          |           |            |           |
+  #          v          |           |            |           |
+  #     build root      v           |            |           |
+  #                  cartage        |            |           |
+  #                   path          v            |           |
+  #                              project         v           |
+  #                               path       isolation       |
+  #                                             path         v
+  #                                                        build
+  #                                                         path
+  #
+  # So that if I am deploying on a project called +calliope+ and my remote user
+  # is +build+, my isolated build path might be:
+  #
+  #   ~build/cartage/calliope/20150321091432/calliope
+  #
+  # == Remote Build Steps
+  #
+  # The steps for a remote build are:
+  #
+  # 1.  Configure Cartage and save the active Cartage configuration as a
+  #     temporary file that will be copied to the remote server.
+  # 2.  Configure the Fog::SSH adapters with the keys to connect to the remote
+  #     system.
+  # 3.  Create the +prebuild+ script and run it locally.
+  # 4.  Connect to the remote server, put the Cartage configuration file in the
+  #     isolation path, and clone the repository. Check the repo out to the
+  #     appropriate +release_hashref+.
+  # 5.  Create the +build+ script, copy it remotely, and run it from the build
+  #     isolation path (+build_path+). This is effectively:
+  #       cd "$build_path" && $build_script
+  # 6.  Clean up the remote server
+  #
+  # == Configuration
+  #
+  # Cartage::Remote is configured in the +plugins.remote+ section of the
+  # Cartage configuration file. The following keys are *required*:
+  #
+  # +server+:: A server string in the form <tt>[user@]host[:port]</tt> *or* a
+  #            dictionary with +user+, +host+, and +port+. In either form, this
+  #            will set @remote_user, @remote_host, and @remote_port. If
+  #            @remote_user is not provided, it will be set from
+  #            <tt>$USER</tt>.
+  #
+  # The following keys are optional:
+  #
+  # +keys+:: The SSH key(s) used to connect to the server. There are two basic
+  #          ways that keys can be provided:
+  #
+  #          * If provided as a string or an array of strings, the value(s)
+  #            will be applied as glob patterns to find key files on disk.
+  #          * If provided as a dictionary, the keys are irrelevant but the
+  #            values are the key data.
+  #
+  #          If keys are not provided, a default pattern of
+  #          <tt>~/.ssh/*id_[rd]sa</tt> will be used to find keys on the local
+  #          machine.
+  # +build+:: A multiline YAML string that is copied to the remote machine and
+  #           executed as a script there. If not provided, the following script
+  #           will be run:
+  #
+  #             #!/bin/bash
+  #             set -e
+  #             if [ -f Gemfile ]; then
+  #               bundle install --path %<remote_bundle>s
+  #               bundle exec cartage build \
+  #                 --config-file %<config_file>s \
+  #                 --target %<project_path>s
+  #             else
+  #               cartage build --config-file %<config_file>s \
+  #                 --target %<project_path>s
+  #             fi
+  # +prebuild+:: A multiline YAML string that is run as a script on the local
+  #              machine to prepare for running remotely. If not provided, the
+  #              following script will be run:
+  #
+  #                #!/bin/bash
+  #                ssh-keyscan -H %<remote_host>s >> ~/.ssh/known_hosts
+  # +postbuild+:: A multiline YAML string that is run as a script on the local
+  #               machine to finish the build process locally. If not provided,
+  #               nothing will run.
+  #
+  # == Script Substitution
+  #
+  # The +build+, +prebuild+, and +postbuild+ scripts require information from
+  # the Cartage and Cartage::Remote instances. When these scripts are rendered
+  # to disk, they will be run through Kernel#sprintf with the following
+  # substitution parameters specified as strings
+  # (<tt>%<<em>parameter-name</em>>s</tt>). All of these values are computed
+  # from the local Cartage configuration.
+  #
+  # +repo_url+:: The repository URL.
+  # +name+:: The package name.
+  # +release_hashref+:: The release hashref to build.
+  # +timestamp+:: The build timestamp.
+  # +remote_host+:: The remote build host.
+  # +remote_port+:: The remote build host SSH port (may be empty).
+  # +remote_user+:: The remote build user.
+  # +build_root+:: The remote build root, (usually
+  #                <tt>~<em>remote_user</em></tt>).
+  # +cartage_path+:: <tt><em>build_root</em>/cartage</tt>.
+  # +project_path+:: <tt><em>cartage_path</em>/<em>name</em></tt>.
+  # +isolation_path+:: <tt><em>project_path</em>/<em>timestamp</em></tt>.
+  # +build_path+:: The remote build path (contains the code to package).
+  #                <tt><em>isolation_path</em>/<em>name</em></tt>
+  # +remote_bundle+:: A place where dependencies for the build can be installed
+  #                   locally. <tt><em>isolation_path</em>/deps</tt>. Typically
+  #                   used in the +build+ script.
+  #                     bundle install --path %<remote_bundle>s
+  # +bundle_cache+:: The +bundle_cache+ for the remote server. Set the same as
+  #                  +project_path+.
+  # +config_file+:: The remote filename of the computed Cartage configuration.
+  #                 Must be provided to the remote run of +cartage+.
+  #                   bundle exec cartage build --config-file %<config_file>s
+  # +build_script+:: The full path to the remote build script.
+  #                  <tt><em>isolation_path</em>/cartage-build-remote</tt>.
+  #
+  # == Configuration Example
+  #
+  #   ---
+  #   plugins:
+  #     remote:
+  #       server:
+  #         host: build-server
+  #       script: |
+  #         #! /bin/bash
+  #         bundle install --path %<remote_bundle>s
+  #         bundle exec cartage s3 --config-file %<config_file>s
+  #
+  class Remote < Cartage::Plugin
+    VERSION = '1.0' #:nodoc:
+
+    def initialize(*) #:nodoc:
+      super
+      @tmpfiles = []
+    end
+
+    # Build on the remote server.
+    def build
+      @cartage.display 'Pre-build configuration...'
+      stage = :config
+
+      paths = OpenStruct.new(build_root: @build_root)
+      paths.cartage_path = paths.build_root.join('cartage')
+      paths.project_path = paths.cartage_path.join(@cartage.name)
+      paths.isolation_path = paths.project_path.join(@cartage.timestamp)
+      paths.build_path = paths.isolation_path.join(@cartage.name)
+      paths.remote_bundle = paths.isolation_path.join('deps')
+      paths.bundle_cache = paths.project_path
+      paths.config_file = paths.isolation_path.join('cartage.yml')
+      paths.build_script = paths.isolation_path.join('cartage-build-remote')
+
+      config_file = make_config(paths).path
+
+      subs = OpenStruct.new(
+        paths.to_h.merge(repo_url:        @cartage.repo_url,
+                         name:            @cartage.name,
+                         release_hashref: @cartage.release_hashref,
+                         timestamp:       @cartage.timestamp,
+                         remote_host:     @remote_host,
+                         remote_port:     @remote_port,
+                         remote_user:     @remote_user)
+      )
+
+      stage = :ssh_config
+      configure_ssh
+
+      @cartage.display 'Running prebuild script...'
+      stage = :prebuild
+      system(make_tmpscript('prebuild', @prebuild, subs).path)
+
+      stage = :remote_clone
+      @cartage.display <<-message
+Checking out #{@cartage.repo_url} at #{@cartage.release_hashref} remotely...
+      message
+
+      ssh %Q(mkdir -p #{paths.isolation_path})
+      @scp.upload(config_file, user_path(paths.config_file))
+      ssh %Q(git clone #{@cartage.repo_url} #{paths.build_path})
+      ssh <<-command
+cd #{paths.build_path} && git checkout #{@cartage.release_hashref}
+      command
+
+      @cartage.display 'Running build script...'
+      stage = :remote_build
+      script = make_tmpscript('build', @build, subs).path
+      @scp.upload(script, user_path(paths.build_script))
+      ssh %Q(cd #{paths.build_path} && #{paths.build_script})
+
+      stage = :cleanup
+      @cartage.display 'Cleaning up after the build...'
+      ssh %Q(rm -rf #{paths.isolation_path})
+    rescue StandardError => e
+      $stderr.puts "Remote error in stage #{stage}: #{e.message}"
+      $stderr.puts e.backtrace.join("\n") if @cartage.verbose
+    ensure
+      if @postbuild
+        @cartage.display 'Running postbuild script...'
+        system(make_tmpscript('postbuild', @postbuild, subs).path, stage.to_s)
+      end
+
+      @tmpfiles.each { |tmpfile|
+        tmpfile.close
+        tmpfile.unlink
+      }
+      @tmpfiles.clear
+    end
+
+    private
+
+    def resolve_config!(remote_config)
+      unless remote_config
+        raise ArgumentError, 'Cartage remote has no configuration.'
+      end
+
+      @remote_user = @remote_host = @remote_port = nil
+
+      case server = remote_config.server
+      when OpenStruct
+        @remote_user = server.user
+        @remote_host = server.host
+        @remote_port = server.port
+      when %r{\A(?:(?<user>[^@]+)@)?(?<host>[^@:]+)(?::(?<port>[^:]+))?\z}
+        @remote_user = $~[:user]
+        @remote_host = $~[:host]
+        @remote_port = $~[:port]
+      end
+
+      @remote_user ||= ENV['USER']
+
+      if @remote_host.nil? or @remote_host.empty?
+        raise ArgumentError, 'Cannot connect to remote; no server specified.'
+      end
+
+      @remote_server = @remote_host
+      @remote_server = "#{@remote_user}@#{@remote_server}" if @remote_user
+      @remote_server = "#{@remote_server}:#{@remote_port}" if @remote_port
+
+      @build_root = Pathname(remote_config.build_root || '~')
+
+      @build = remote_config.build
+      raise ArgumentError, <<-exception if @build.nil? or @build.empty?
+No build script to run on remote #{@remote_server}.
+      exception
+
+      @key_data = @keys = nil
+
+      case keys = remote_config.keys
+      when OpenStruct
+        @key_data = keys.to_h.values
+      when Array
+        @keys = keys
+      when String
+        @keys = [ keys ]
+      when nil
+        @keys = %w(~/.ssh/*id_[rd]sa)
+      end
+
+      @keys &&= @keys.map { |key|
+        Pathname.glob(Pathname(key).expand_path)
+      }.flatten
+
+      @prebuild = remote_config.prebuild || DEFAULT_PREBUILD_SCRIPT
+      @postbuild = remote_config.postbuild
+
+      # Force lazy values to be present during execution.
+      @cartage.repo_url
+      @cartage.root_path
+      @cartage.release_hashref
+      @cartage.timestamp
+      @cartage
+    end
+
+    def configure_ssh
+      require 'fog'
+      options = {
+        paranoid: true,
+        keys:     @keys,
+        key_data: @key_data
+      }
+
+      options[:port] = @remote_port if @remote_port
+
+      @ssh = Fog::SSH.new(@remote_host, @remote_user, options)
+      @scp = Fog::SCP.new(@remote_host, @remote_user, options)
+    end
+
+    def ssh(*commands)
+      results = @ssh.run(commands) do |stdout, stderr|
+        $stdout.print stdout unless stdout.nil?
+        $stderr.print stderr unless stderr.nil?
+      end
+
+      results.each do |result|
+        if result.status.nonzero?
+          fail "SSH Command failed with status (#{result.status}): " +
+            "#{result.status}"
+        end
+      end
+    end
+
+    def make_tmpfile(basename, content = nil)
+      Tempfile.new("#{basename}.").tap { |f|
+        f.write content || yield
+        f.close
+        @tmpfiles << f
+      }
+    end
+
+    def make_tmpscript(basename, content, subs)
+      make_tmpfile(basename, content % subs.to_h).tap { |f|
+        File.chmod(0700, f.path)
+      }
+    end
+
+    def make_config(paths)
+      make_tmpfile('config.yml') do
+        config = Cartage::Config.new(@cartage.config)
+        config.name            = @cartage.name
+        config.release_hashref = @cartage.release_hashref
+        config.timestamp       = @cartage.timestamp
+        config.root_path       = paths.build_path.to_s
+        config.bundle_cache    = paths.bundle_cache.to_s
+        config.to_yaml
+      end
+    end
+
+    def user_path(path)
+      path.to_s.sub(%r{\A~/}, '')
+    end
+
+    def self.commands #:nodoc:
+      require_relative 'remote/command'
+      [ Cartage::Remote::Command ]
+    end
+
+    DEFAULT_PREBUILD_SCRIPT = <<-script #:nodoc:
+#!/bin/bash
+
+ssh-keyscan -H %<remote_host>s >> ~/.ssh/known_hosts
+    script
+
+    DEFAULT_BUILD_SCRIPT = <<-script #:nodoc:
+#!/bin/bash
+
+set -e
+
+if [ -f Gemfile ]; then
+  bundle install --path %<remote_bundle>s
+  bundle exec cartage build --config-file %<config_file>s --target %<project_path>s
+else
+  cartage build --config-file %<config_file>s --target %<project_path>s
+fi
+    script
+  end
+end

data/lib/cartage/remote/command.rb

@@ -0,0 +1,22 @@
+require 'cartage/command'
+
+class Cartage::Remote::Command < Cartage::Command #:nodoc:
+  def initialize(cartage)
+    super(cartage, 'remote')
+    takes_commands(false)
+    short_desc('Build a release package and upload to cloud storage.')
+
+    @cartage = cartage
+    @remote = cartage.remote
+
+    Cartage.common_build_options(options, cartage)
+  end
+
+  def perform(*)
+    @remote.build
+  end
+
+  def with_plugins
+    %w(remote)
+  end
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: cartage-remote
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Austin Ziegler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cartage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: hoe-doofus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hoe-gemspec2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: hoe-git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: hoe-geminabox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: |-
+  cartage-remote is a plug-in for {cartage}[https://github.com/KineticCafe/cartage]
+  to build a package on a remote machine with cartage.
+
+  Cartage provides a repeatable means to create a package for a Rails application
+  that can be used in deployment with a configuration tool like Ansible, Chef,
+  Puppet, or Salt. The package is created with its dependencies bundled in
+  `vendor/bundle`, so it can be deployed in environments with strict access
+  control rules and without requiring development tool access.
+email:
+- aziegler@kineticcafe.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- Contributing.rdoc
+- History.rdoc
+- Licence.rdoc
+- Manifest.txt
+- README.rdoc
+files:
+- ".autotest"
+- ".gemtest"
+- ".minitest.rb"
+- Contributing.rdoc
+- Gemfile
+- History.rdoc
+- Licence.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/cartage/remote.rb
+- lib/cartage/remote/command.rb
+homepage: https://github.com/KineticCafe/cartage-remote/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+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.2.2
+signing_key: 
+specification_version: 4
+summary: cartage-remote is a plug-in for {cartage}[https://github.com/KineticCafe/cartage]
+  to build a package on a remote machine with cartage
+test_files: []