torquebox-remote-deployer 0.1.2.pre2-java

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.idea
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec :name => 'torquebox-remote-deployer'

data/LICENSE.txt

@@ -0,0 +1,23 @@
+#--
+# The MIT License
+#
+# Copyright (c) 2007-2008 Sun Microsystems, Inc.
+#
+# 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 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/README.md

@@ -0,0 +1,80 @@
+# torquebox-remote-deployer
+
+The torquebox-remote-deployer is a Ruby Gem for deploying TorqueBox `.knob` files to a remote TorqueBox server.  It
+allows you to deploy your entire application as a single file, but still be able to run Rake and other jobs on the
+server.
+
+## How to Use It
+
+First, you'll need to set up your TorqueBox application for Rake.
+Then run `gem install torquebox-remote-deployer` or add the gem to your `Gemfile`:
+
+    gem "torquebox-remote-deployer"
+
+Once the Gem is installed, you'll have a few new Rake tasks:
+
+    rake torquebox:remote:deploy              # Deploy the local archive file t...
+    rake torquebox:remote:exec[cmd]           # Execute Ruby commands against t...
+    rake torquebox:remote:stage               # Upload this application to the ...
+    rake torquebox:remote:stage:check         # Verify that the archive file ma...
+    rake torquebox:remote:stage:deploy        # Deploy the staged archive file ...
+    rake torquebox:remote:undeploy            # Undeploy the archive file to th...
+
+Before using these, you'll need to configure your remote server by creating a `config/torquebox_remote.rb` file in your project.
+This file will be similar to `config/torquebox.rb` in its format, but the directives are different.
+You'll need to configure it like this:
+
+    TorqueBox::RemoteDeploy.configure do
+      torquebox_home "/opt/torquebox"
+      hostname "localhost"
+      port "2222"
+      user "vagrant"
+      key "~/.vagrant.d/insecure_private_key"
+      sudo true
+    end
+
+Of course, fill in the values with your own server information.
+Then you can stage your application on the remote server with this command:
+
+    $ rake torquebox:remote:stage
+
+This will create a Knob file, copy it to the remote server, and explode it to a location where commands can be run from
+its root directory; like this:
+
+    $ rake torquebox:remote:exec["bundle install --path vendor/bundle"]
+
+Or if you ran `bundle --deployment` before creating your Knob you can just jump right in and run something more useful like your migrations:
+
+    $ rake torquebox:remote:exec["bundle exec rake db:migrate"]
+
+After the `exec` tasks are complete, you can deploy the Knob to the TorqueBox server.
+
+    $ rake torquebox:remote:deploy
+
+This task works just like the `torquebox:deploy:archive` task, but remotely.
+
+## Deploying to Multiple Environments
+
+The `torquebox-remote-deployer` gem defaults to production mode, so all the examples shown above will execute with your `production` Bundler group and db config.  But it's most likely that you will want to deploy to a staging or test environment before deploying to production.  In that case, you'll need a config file for each one.  In each config file, you can specify the RACK_ENV or RAILS_ENV like this:
+
+    TorqueBox::RemoteDeploy.configure do
+      torquebox_home "/opt/torquebox"
+      hostname "localhost"
+      port "2222"
+      user "vagrant"
+      key "~/.vagrant.d/insecure_private_key"
+
+      # set the RAILS_ENV on the remote server
+      rails_env "test"
+    end
+
+Then you can deploy with the `TB_REMOTE_FILE` environment variable set like this:
+
+    $ TB_REMOTE_FILE=config/torquebox_remote.test.rb rake torquebox:remote:stage
+
+You can name the config file whatever you'd like, and you can have one per environment -- but use the same Rake tasks.
+
+## TODO
+
+*  Make it friendly to remote Windows targets (already works on Windows source machines).
+*  Support deploying over FTP or SFTP in addition to SCP/SSH.

data/lib/torquebox/rake/tasks/remote.rb

@@ -0,0 +1,47 @@
+require 'rake'
+require 'torquebox/deploy_utils'
+require 'torquebox/remote_deploy_utils'
+
+namespace :torquebox do
+  namespace :remote do
+
+    desc "Upload this application to the remote server as an archive file"
+    task :stage => ["torquebox:archive"] do
+      archive_name = TorqueBox::DeployUtils.archive_name
+      TorqueBox::RemoteDeployUtils.stage(archive_name)
+    end
+
+    desc "Execute Ruby commands against the staged archive file"
+    task :exec, [:cmd] do |t, args|
+      cmd = args[:cmd]
+      archive_name = TorqueBox::DeployUtils.archive_name
+      TorqueBox::RemoteDeployUtils.exec_ruby(archive_name, cmd)
+    end
+
+    desc "Deploy the local archive file to the remote TorqueBox server"
+    task :deploy do
+      archive_name = TorqueBox::DeployUtils.archive_name
+      TorqueBox::RemoteDeployUtils.deploy(archive_name)
+    end
+
+    namespace :stage do
+      desc "Deploy the staged archive file to the remote TorqueBox server"
+      task :deploy do
+        archive_name = TorqueBox::DeployUtils.archive_name
+        TorqueBox::RemoteDeployUtils.deploy_from_stage(archive_name)
+      end
+
+      desc "Verify that the archive file made it here intact"
+      task :check do
+        archive_name = TorqueBox::DeployUtils.archive_name
+        # TODO: checksum local and on server
+      end
+    end
+
+    desc "Undeploy the archive file to the remote TorqueBox server"
+    task :undeploy do
+      archive_name = TorqueBox::DeployUtils.archive_name
+      TorqueBox::RemoteDeployUtils.undeploy(archive_name)
+    end
+  end
+end

data/lib/torquebox/remote_deploy_utils.rb

@@ -0,0 +1,244 @@
+require "net/ssh"
+require "net/scp"
+
+require 'tempfile'
+
+module TorqueBox
+  module RemoteDeployUtils
+    class << self
+
+      def stage(archive_file)
+        with_config(archive_file) do |config, app_name|
+          # no need to stage if we are local. we'll just run from the app dir
+          unless config.local
+            cleanup_stage(config, archive_file, app_name)
+            prepare_stage(config, app_name)
+            stage_archive(config, archive_file)
+            unjar_staged_archive(config, archive_file, app_name)
+          end
+        end
+      end
+
+      def deploy(archive_file)
+        with_config(archive_file) do |config, app_name|
+          scp_upload(config, archive_file, "#{config.jboss_home}/standalone/deployments/")
+          do_deploy(config, app_name)
+        end
+      end
+
+      def deploy_from_stage(archive_file)
+        with_config(archive_file) do |config, app_name|
+          unless config.local
+            ssh_exec(config, "cp #{config.torquebox_home}/stage/#{app_name}.knob #{config.jboss_home}/standalone/deployments")
+          else
+            scp_upload(config, archive_file, "#{config.jboss_home}/standalone/deployments/")
+          end
+          do_deploy(config, app_name)
+        end
+      end
+
+      def undeploy(archive_file)
+        with_config(archive_file) do |config, app_name|
+          unless config.local
+            ssh_exec(config, "rm -f #{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml*")
+            ssh_exec(config, "rm -f #{config.jboss_home}/standalone/deployments/#{app_name}.knob")
+          else
+            FileUtils.rm("#{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml*")
+            FileUtils.rm("#{config.jboss_home}/standalone/deployments/#{app_name}.knob")
+          end
+        end
+      end
+
+      def exec_ruby(archive_file, cmd)
+        with_config(archive_file) do |config, app_name|
+          unless config.local
+            ssh_exec(config, "cd #{config.torquebox_home}/stage/#{app_name}",
+                     "export PATH=$PATH:#{config.torquebox_home}/jruby/bin",
+                     "export RAILS_ENV=#{config.rack_env}",
+                     "export RACK_ENV=#{config.rack_env}",
+                     "#{config.torquebox_home}/jruby/bin/jruby -S #{cmd}")
+          else
+            # not sure what to do here yet
+          end
+        end
+      end
+
+      private
+
+      def prefix(config)
+        config.sudo ? "sudo" : p
+      end
+
+      def do_deploy(config, app_name)
+        knob_yml = <<-YAML
+        application:
+          root: #{config.jboss_home}/standalone/deployments/#{app_name}.knob
+        environment:
+          RACK_ENV: #{config.rack_env}
+          RAILS_ENV: #{config.rack_env}
+        YAML
+
+        unless config.local
+          knob_yml_file = Tempfile.new("#{app_name}-knob.yml")
+          knob_yml_file.write(knob_yml)
+          knob_yml_file.rewind
+          scp_upload(config, knob_yml_file.path, "#{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml")
+          ssh_exec(config, "touch #{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml.dodeploy")
+        else
+          # todo copy temp file to somewhere
+          File.open("#{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml", "w") {}
+          File.open("#{config.jboss_home}/standalone/deployments/#{app_name}-knob.yml.dodeploy", "w") {}
+        end
+      end
+
+      def app_name(archive_file)
+        File.basename(archive_file, ".knob")
+      end
+
+      def unjar_staged_archive(config, archive_file, app_name)
+        ssh_exec(config, "cd #{config.torquebox_home}/stage/#{app_name} && #{prefix(config)}jar -xf ../#{archive_file}")
+      end
+
+      def stage_archive(config, archive_file)
+        scp_upload(config, archive_file, "#{config.torquebox_home}/stage/#{File.basename(archive_file)}")
+      end
+
+      def cleanup_stage(config, archive_file, app_name)
+        ssh_exec(config, "rm -f #{config.torquebox_home}/stage/#{archive_file}")
+        ssh_exec(config, "rm -rf #{config.torquebox_home}/stage/#{app_name}")
+      end
+
+      def prepare_stage(config, app_name)
+        unless config.local
+          ssh_exec(config, "mkdir -p #{config.torquebox_home}/stage/#{app_name}")
+        else
+          FileUtils.mkdir_p("#{config.torquebox_home}/stage/#{app_name}")
+        end
+      end
+
+      def with_config(archive_file)
+        read_config.each do |config|
+          yield config, app_name(archive_file)
+        end
+      end
+
+      def ssh_exec(config, *cmd)
+        begin
+          Net::SSH.start(config.hostname, config.user, :port => config.port, :keys => [config.key]) do |ssh|
+            ssh.exec(cmd.map { |c| "#{prefix(config)} #{c}" }.join("\n"))
+          end
+        rescue Net::SSH::AuthenticationFailed => e
+          raise "Can't authenticate as #{config.user}@#{config.hostname}:#{config.port}."
+        end
+      end
+
+      def scp_upload(config, local_file, remote_file)
+        unless config.local
+          Net::SCP.upload!(config.hostname, config.user, local_file, remote_file,
+                           :ssh => {:port => config.port, :keys => [config.key]}
+          ) do |ch, name, sent, total|
+            print "\rCopying #{name}: #{sent}/#{total}"
+          end
+          print "\n"
+        else
+          FileUtils.cp(local_file, remote_file)
+        end
+      end
+
+      def read_config
+        config_file = ENV["TB_REMOTE_FILE"] || ENV["tb_remote_file"] || "config/torquebox_remote.rb"
+        eval(File.read(config_file)).configurations
+      end
+    end
+  end
+
+  class RemoteDeploy
+    def self.configure(&blk)
+      new(blk)
+    end
+
+    def initialize(blk)
+      @config = RemoteConfig.new
+      @configs = []
+      instance_eval &blk
+    end
+
+    attr_reader :config
+
+    def configurations
+      # evenually, we should merge the base @config settings into the @configs
+      @configs.empty? ? [@config] : @configs
+    end
+
+    def hostname(h)
+      @config.hostname = h
+    end
+
+    def port(p)
+      @config.port = p
+    end
+
+    def user(u)
+      @config.user = u
+    end
+
+    def key(k)
+      @config.key = k
+    end
+
+    def torquebox_home(tbh)
+      @config.torquebox_home = tbh
+    end
+
+    def jboss_home(jbh)
+      @config.jboss_home = jbh
+    end
+
+    def sudo(sudo)
+      @config.sudo = sudo
+    end
+
+    def local(l)
+      @config.local = l
+    end
+
+    def host(&block)
+      @configs << RemoteDeploy.new(block).config
+    end
+
+    def rails_env(env)
+      @config.rack_env = env
+    end
+
+    def rack_env(env)
+      @config.rack_env = env
+    end
+  end
+
+  class RemoteConfig
+    attr_accessor :hostname, :port, :user, :key, :torquebox_home, :sudo, :local
+
+    def rack_env=(env)
+      @rack_env = env
+    end
+
+    def rack_env
+      @rack_env || "production"
+    end
+
+    def jboss_home=(jbh)
+      @jboss_home = jbh
+    end
+
+    def jboss_home
+      @jboss_home || "#{@torquebox_home}/jboss"
+    end
+
+    def initialize
+      @user = "torquebox"
+      @torquebox_home = "/opt/torquebox"
+      @sudo = false
+      @local = false
+    end
+  end
+end

data/lib/torquebox-remote-deployer.rb

@@ -0,0 +1 @@
+require 'torquebox/rake/tasks/remote'

data/spec/fixtures/local_torquebox_remote.rb

@@ -0,0 +1,5 @@
+TorqueBox::RemoteDeploy.configure do
+  torquebox_home "#{File.expand_path("tmp/torquebox", File.dirname(__FILE__))}"
+  hostname "localhost"
+  local true
+end

data/spec/fixtures/multihost_torquebox_remote.rb

@@ -0,0 +1,18 @@
+TorqueBox::RemoteDeploy.configure do
+  host do
+    torquebox_home "/my/tb/dir"
+    jboss_home "/my/jboss/dir"
+    hostname "1.2.3.4"
+    port "2222"
+    user "torquebox"
+    key "~/.ssh/id_rsa.pub"
+    sudo true
+  end
+
+  host do
+    hostname "4.4.4.4"
+    port "22"
+    user "deploy"
+    key "~/.ssh/torquebox.pub"
+  end
+end

data/spec/fixtures/myapp.knob

@@ -0,0 +1 @@
+this is not really a knob file

data/spec/fixtures/simple_torquebox_remote.rb

@@ -0,0 +1,9 @@
+TorqueBox::RemoteDeploy.configure do
+  torquebox_home "/opt/torquebox"
+  hostname "localhost"
+  port "2222"
+  user "torquebox"
+  key "~/.ssh/id_rsa.pub"
+  rails_env "production"
+  rack_env "production"
+end

data/spec/remote_deploy_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe TorqueBox::RemoteDeploy do
+  describe ".configure" do
+    context "defaults" do
+      subject do
+        TorqueBox::RemoteDeploy.configure do
+          hostname "1.2.3.4"
+          port "2222"
+          user "torquebox"
+          key "~/.ssh/id_rsa.pub"
+        end
+      end
+
+      it "has one configurations" do
+        subject.configurations.size.should == 1
+        subject.config.should == subject.configurations[0]
+      end
+
+      it "has hostname 1.2.3.4" do
+        subject.config.hostname.should == "1.2.3.4"
+      end
+
+      it "has port 2222" do
+        subject.config.port.should == "2222"
+      end
+
+      it "has user torquebox" do
+        subject.config.user.should == "torquebox"
+      end
+
+      it "has key '~/.ssh/id_rsa.pub'" do
+        subject.config.key.should == "~/.ssh/id_rsa.pub"
+      end
+
+      it "has torquebox_home '/opt/torquebox'" do
+        subject.config.torquebox_home.should == "/opt/torquebox"
+      end
+
+      it "has jboss_home '/opt/torquebox/jboss'" do
+        subject.config.jboss_home.should == "/opt/torquebox/jboss"
+      end
+
+      it "has sudo false" do
+        subject.config.sudo.should == false
+      end
+    end
+
+    context "overrides" do
+      subject do
+        TorqueBox::RemoteDeploy.configure do
+          torquebox_home "/my/tb/dir"
+          jboss_home "/my/jboss/dir"
+          hostname "1.2.3.4"
+          port "2222"
+          user "torquebox"
+          key "~/.ssh/id_rsa.pub"
+          sudo true
+        end
+      end
+
+      it "has one configurations" do
+        subject.configurations.size.should == 1
+        subject.config.should == subject.configurations[0]
+      end
+
+      it "has hostname 1.2.3.4" do
+        subject.config.hostname.should == "1.2.3.4"
+      end
+
+      it "has port 2222" do
+        subject.config.port.should == "2222"
+      end
+
+      it "has user torquebox" do
+        subject.config.user.should == "torquebox"
+      end
+
+      it "has key '~/.ssh/id_rsa.pub'" do
+        subject.config.key.should == "~/.ssh/id_rsa.pub"
+      end
+
+      it "has torquebox_home '/my/tb/dir'" do
+        subject.config.torquebox_home.should == "/my/tb/dir"
+      end
+
+      it "has jboss_home '/my/jboss/dir'" do
+        subject.config.jboss_home.should == "/my/jboss/dir"
+      end
+
+      it "has sudo true" do
+        subject.config.sudo.should == true
+      end
+    end
+
+    context "multiple hosts" do
+      subject do
+        TorqueBox::RemoteDeploy.configure do
+          host do
+            torquebox_home "/my/tb/dir"
+            jboss_home "/my/jboss/dir"
+            hostname "1.2.3.4"
+            port "2222"
+            user "torquebox"
+            key "~/.ssh/id_rsa.pub"
+            sudo true
+          end
+
+          host do
+            hostname "4.4.4.4"
+            port "22"
+            user "deploy"
+            key "~/.ssh/torquebox.pub"
+          end
+        end
+      end
+
+      it "has one configurations" do
+        subject.configurations.size.should == 2
+      end
+
+      it "has correct config" do
+        test_config(subject.configurations[0])
+        test_config(subject.configurations[1])
+      end
+
+      def test_config(configuration)
+        if configuration.hostname == "4.4.4.4"
+          configuration.torquebox_home.should == "/opt/torquebox"
+        elsif configuration.hostname == "1.2.3.4"
+          configuration.torquebox_home.should == "/my/tb/dir"
+        else
+          fail
+        end
+      end
+    end
+  end
+end

data/spec/remote_deploy_utils_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe TorqueBox::RemoteDeployUtils do
+
+  before(:each) do
+    @util = TorqueBox::RemoteDeployUtils
+  end
+
+  describe ".stage" do
+    it "stages one host" do
+      ENV["tb_remote_file"] = File.join(File.dirname(__FILE__), "fixtures/simple_torquebox_remote.rb")
+      @util.stub(:ssh_exec)
+      @util.should_receive(:scp_upload).with(anything(), "myapp.knob", "/opt/torquebox/stage/myapp.knob")
+      @util.stage("myapp.knob")
+    end
+
+    it "stages two hosts" do
+      ENV["tb_remote_file"] = File.join(File.dirname(__FILE__), "fixtures/multihost_torquebox_remote.rb")
+      @util.stub(:ssh_exec)
+      @util.should_receive(:scp_upload).with(anything(), "myapp.knob", "/my/tb/dir/stage/myapp.knob")
+      @util.should_receive(:scp_upload).with(anything(), "myapp.knob", "/opt/torquebox/stage/myapp.knob")
+      @util.stage("myapp.knob")
+    end
+
+    context "local" do
+      it "stages" do
+        ENV["tb_remote_file"] = File.join(File.dirname(__FILE__), "fixtures/local_torquebox_remote.rb")
+        @util.stage("myapp.knob")  # does nothing
+      end
+    end
+  end
+
+  describe ".deploy" do
+    context "local" do
+      before do
+        FileUtils.mkdir_p(deploy_dir)
+      end
+
+      after do
+        FileUtils.remove_dir("#{File.dirname(__FILE__)}/../tmp/torquebox", true)
+      end
+
+      it "deploys" do
+        ENV["tb_remote_file"] = File.join(File.dirname(__FILE__), "fixtures/local_torquebox_remote.rb")
+        @util.deploy(File.join(File.dirname(__FILE__), "fixtures/myapp.knob"))
+        File.exists?("#{deploy_dir}/myapp.knob").should == true
+
+        # this isn't really testing the real deal yet
+        File.exists?("#{deploy_dir}/myapp-knob.yml").should == true
+        File.exists?("#{deploy_dir}/myapp-knob.yml.dodeploy").should == true
+      end
+
+      def deploy_dir
+        "#{File.dirname(__FILE__)}/../tmp/torquebox/jboss/standalone/deployments/"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'java'
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'torquebox-remote-deployer'

data/torquebox-remote-deployer.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "torquebox-remote-deployer"
+  s.version     = "0.1.2.pre2"
+  s.platform    = "java"
+  s.authors     = ["Joe Kutner"]
+  s.email       = ["jpkutner@gmail.com"]
+  s.homepage    = "https://github.com/jkutner/torquebox-remote-deployer"
+  s.summary     = %q{Deploy Knob files to a remote server with ease.}
+  s.description = %q{This utility allows you to deploy a Torquebox Knob file to a remote server}
+
+  s.rubyforge_project = "torquebox-remote-deployer"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "jruby-openssl"
+  s.add_dependency "net-ssh"
+  s.add_dependency "net-scp"
+  s.add_dependency "rake"
+  s.add_dependency "torquebox-rake-support"
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: torquebox-remote-deployer
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 0.1.2.pre2
+platform: java
+authors: 
+  - Joe Kutner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-29 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: jruby-openssl
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: net-ssh
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: net-scp
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: rake
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id004
+  - !ruby/object:Gem::Dependency 
+    name: torquebox-rake-support
+    prerelease: false
+    requirement: &id005 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id005
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id006 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id006
+description: This utility allows you to deploy a Torquebox Knob file to a remote server
+email: 
+  - jpkutner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - Gemfile
+  - LICENSE.txt
+  - README.md
+  - lib/torquebox-remote-deployer.rb
+  - lib/torquebox/rake/tasks/remote.rb
+  - lib/torquebox/remote_deploy_utils.rb
+  - spec/fixtures/local_torquebox_remote.rb
+  - spec/fixtures/multihost_torquebox_remote.rb
+  - spec/fixtures/myapp.knob
+  - spec/fixtures/simple_torquebox_remote.rb
+  - spec/remote_deploy_spec.rb
+  - spec/remote_deploy_utils_spec.rb
+  - spec/spec_helper.rb
+  - torquebox-remote-deployer.gemspec
+homepage: https://github.com/jkutner/torquebox-remote-deployer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+requirements: []
+
+rubyforge_project: torquebox-remote-deployer
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Deploy Knob files to a remote server with ease.
+test_files: 
+  - spec/fixtures/local_torquebox_remote.rb
+  - spec/fixtures/multihost_torquebox_remote.rb
+  - spec/fixtures/myapp.knob
+  - spec/fixtures/simple_torquebox_remote.rb
+  - spec/remote_deploy_spec.rb
+  - spec/remote_deploy_utils_spec.rb
+  - spec/spec_helper.rb