conjure 0.1.6 → 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58a9a73a25cd4300e2bd4bdf5184a43c824ac548
+  data.tar.gz: 24a8eed9346681d7010d459d3e5de5a9bb106feb
+SHA512:
+  metadata.gz: e0e0dadb4bab906cb2ef594d8827ba57f4c553daa09068646945952882dac1a03cdec41feb411a90d62ccef5504f6d7a358ebcd64176b283c646796ec015a670
+  data.tar.gz: 70e583f8ef4c570da0054ef44038c4028c372226bb962713d09cb14fafb0072344a9db066022bd7d2f061ffc6c038b8fe168e6d389456e1064809fc787c0e522

data/History.md

@@ -1,3 +1,8 @@
+### Version 0.1.7
+2014-1-14
+
+* Improvements to error handling and verbose output
+
 ### Version 0.1.6
 2013-11-27
 

data/lib/conjure.rb

@@ -1,7 +1,12 @@
 module Conjure
+  require File.join(File.dirname(__FILE__), "conjure/provider")
   Dir[File.join(File.dirname(__FILE__), "conjure/**/*.rb")].each { |f| require f }
 
   def self.config
     @config ||= Config.load Dir.pwd
   end
+
+  def self.identity
+    @identity ||= Identity.new(config)
+  end
 end

data/lib/conjure/application.rb

@@ -0,0 +1,32 @@
+module Conjure
+  class Application
+    attr_reader :origin_url, :name
+
+    def initialize(options = {})
+      @origin_url = options[:origin_url] || find_origin_url(options[:path])
+      @name = find_name(@origin_url) if @origin_url
+    end
+
+    def instances
+      Instance.find(:application => self)
+    end
+
+    def data_sets
+      DataSet.find(:application => self)
+    end
+
+    private
+
+    def find_name(origin_url)
+      match = origin_url.match(/\/([^.]+)\.git$/)
+      match[1] if match
+    end
+
+    def find_origin_url(path)
+      return unless path
+      remote_info = `cd #{path}; git remote -v |grep origin`
+      match = remote_info.match(/(git@github.com[^ ]+)/)
+      match[1] if match
+    end
+  end
+end

data/lib/conjure/command.rb

@@ -2,8 +2,6 @@ require "thor"
 
 module Conjure
   class Command < Thor
-    attr_accessor :application_options
-
     class_option :verbose, :aliases => "-v", :type => :boolean, :desc => "Show details of low-level operations for debugging"
     def initialize(*args)
       super
@@ -15,39 +13,41 @@ module Conjure
     method_option :test, :type => :boolean, :desc => "Describe the deploy settings but don't deploy"
     method_option :origin, :type => :string, :desc => "Specify git URL to deploy from"
     def deploy
-      self.application_options = {
-        :branch => options[:branch],
-        :test => options[:test],
-        :origin => options[:origin],
-      }
-      application.deploy
+      deployment.deploy
     end
 
     desc "import FILE", "Import the production database from a postgres SQL dump"
     def import(file)
-      application.database.import file
+      deployment.database.import file
     end
 
     desc "export FILE", "Export the production database to a postgres SQL dump"
     def export(file)
-      application.database.export file
+      deployment.database.export file
     end
 
     desc "log", "Display the Rails log from the deployed application"
     method_option :num, :aliases => "-n", :type => :numeric, :default => 10, :desc => "Show N lines of output"
     method_option :tail, :aliases => "-t", :type => :boolean, :desc => "Continue streaming new log entries"
     def log
-      application.rails.log :lines => options[:num], :tail => options[:tail]
+      Service::RailsLogView.new(:shell => deployment.shell, :lines => options[:num], :tail => options[:tail]) do |stdout|
+        print stdout
+      end
     end
 
     desc "rake [ARGUMENTS...]", "Run the specified rake task on the deployed application"
     def rake(*arguments)
-      application.rails.rake arguments.join(" ")
+      task = arguments.join(" ")
+      Service::RakeTask.new(:task => task, :shell => deployment.shell) do |stdout|
+        print stdout
+      end
     end
 
     desc "console", "Start a console on the deployed application"
     def console
-      application.rails.console
+      Service::RailsConsole.new(:shell => deployment.shell) do |stdout|
+        print stdout
+      end
     end
 
     default_task :help
@@ -55,18 +55,20 @@ module Conjure
     private
 
     def application
-      self.application_options ||= {}
-      self.application_options[:origin] ||= github_url
-      Service::RailsApplication.new self.application_options
+      @application ||= Application.new(:path => Dir.pwd, :origin_url => options[:origin])
     end
 
-    def github_url
-      git_origin_url Dir.pwd
+    def deployment
+      @deployment ||= Service::RailsDeployment.new({
+        :branch => options[:branch],
+        :origin => application.origin_url,
+        :target => target,
+        :test => options[:test],
+      })
     end
 
-    def git_origin_url(source_path)
-      remote_info = `cd #{source_path}; git remote -v |grep origin`
-      remote_info.match(/(git@github.com[^ ]+)/)[1]
+    def target
+      Target.new(:machine_name => "#{application.name}-production")
     end
   end
 end

data/lib/conjure/config.rb

@@ -14,8 +14,7 @@ module Conjure
     end
 
     def method_missing(name)
-      return @options[name.to_s] if @options.has_key? name.to_s
-      super
+      @options[name.to_s]
     end
 
     def file_contents(name)

data/lib/conjure/data_set.rb

@@ -0,0 +1,7 @@
+module Conjure
+  class DataSet
+    def self.find(options = {})
+      []
+    end
+  end
+end

data/lib/conjure/identity.rb

@@ -0,0 +1,25 @@
+module Conjure
+  class Identity
+    require "digest/md5"
+
+    def initialize(config)
+      @config = config
+    end
+
+    def private_key_path
+      Pathname.new(@config.config_path).join @config.private_key_file
+    end
+
+    def public_key_path
+      Pathname.new(@config.config_path).join @config.public_key_file
+    end
+
+    def public_key_data
+      File.open(public_key_path, "rb") { |file| file.read }
+    end
+
+    def unique_identifier
+      "conjure_#{Digest::MD5.hexdigest(public_key_data)[0..7]}"
+    end
+  end
+end

data/lib/conjure/instance.rb

@@ -0,0 +1,7 @@
+module Conjure
+  class Instance
+    def self.find(options = {})
+      []
+    end
+  end
+end

data/lib/conjure/notes.txt

@@ -0,0 +1,58 @@
+Application.deploy should become Deployment.create
+
+Instead of passing DockerHost objects around, pass something that
+knows how to provision OS shells (possibly from multiple sources).
+DigitalOceanAccount etc should be an implementation of this interface.
+shell = shell_source.prepare_shell do
+  run "cmd"
+  run "cmd2"
+  environment :key => "value"
+  port 80
+end
+
+Application - the code to be deployed (in the abstract, i.e. in a
+repo not yet copied to the server(s)
+
+Instance - a specific running copy of an application
+  accessed through various interfaces: web address, rails console, etc
+
+Database - n/a, too ambiguous
+Dataset - A specific data set
+  accessed through an interface w/ a specific db protocol.
+
+Deployment should return a shell in the app environment as an
+interface
+
+Deployment should return a DataSet (that possible aggregates multiple
+data sets used by the app). If an app needs a MySQL database, a Redis
+database, and a local directory of user-uploaded files, all these must
+stay in sync with each other and so should be aggregated under a
+single DataSet interface.
+
+Instance should instantiate and provide subsequent access to all
+runtime dependencies of the codebase. This includes the web server,
+data sets, etc. An app's mutable local filesystem should be considered
+a data set too, and probably also the logs.
+
+An Application should be something more abstract than the current
+Codebase. It shouldn't know about the rails environment or the
+database, it should be little more than a reference to a git repo. The
+concept of a "codebase" that's checked out onto the deployment
+server(s) should be something else (maybe just a Volume that a branch
+of the application gets copied to).
+
+But where do the database, logger, cron jobs, and other required
+services get identified and instantiated?
+
+Conjure's basic job is: deploy [something] [somewhere] using
+[resources]. "Something" is a Service, of which Instance and DataSet
+are both types. "Somewhere" is the desired interface over which the
+new Service will be accessible. "Resource" is the cloud service, local
+VMs, and other combined resources that will be used to do the
+deployment.
+
+Need a concept for something that has both stdin and stdout (and
+stderr) streams ("Console"?). This is what's returned by a rake task
+or rails console instantiation, to connect it to the user's console,
+and it can also be returned from a CommandShell to give the user
+direct access to that as well.

data/lib/conjure/provider.rb

@@ -0,0 +1,26 @@
+module Conjure
+  module Provider
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def self.all(service_type)
+      providers(service_type).map{|block| block.call}.flatten.compact
+    end
+
+    def self.register_provider(service_type, &block)
+      providers(service_type) << block
+    end
+
+    def self.providers(service_type)
+      @providers ||= {}
+      @providers[service_type] ||= []
+    end
+
+    module ClassMethods
+      def provides(service_type, &block)
+        Conjure::Provider.register_provider(service_type, &block)
+      end
+    end
+  end
+end

data/lib/conjure/service/cloud_server.rb

@@ -2,7 +2,6 @@ module Conjure
   module Service
     class CloudServer
       require "fog"
-      require "digest/md5"
       require "pathname"
 
       def initialize(name)
@@ -11,22 +10,13 @@ module Conjure
 
       def run(command, options = {}, &block)
         set_fog_credentials
-        upload_files options[:files].to_a
+        file_set = RemoteFileSet.new(:shell => remote_shell, :files => options[:files])
+        file_set.upload
         result = remote_shell.run(command, :stream_stdin => options[:stream_stdin], &block)
-        remove_files options[:files].to_a
+        file_set.remove
         result
       end
 
-      def upload_files(files)
-        dir_names = files.map{|local_path, remote_path| File.dirname remote_path}.uniq
-        run "mkdir -p #{dir_names.join ' '}" if dir_names.any?
-        files.each{|local_path, remote_path| server.scp local_path, remote_path}
-      end
-
-      def remove_files(files)
-        files.each{|local_path, remote_path| run "rm -f #{remote_path}"}
-      end
-
       def server
         @server ||= existing_server
         @server ||= new_server
@@ -46,66 +36,49 @@ module Conjure
 
       def new_server
         Log.info " [cloud] Launching new server #{@name}"
-        connection.servers.bootstrap bootstrap_options.merge(fog_credentials)
+        bootstrap_options = account.bootstrap_options.merge(:name => @name)
+        options = prepare_bootstrap_options(bootstrap_options).merge(fog_credentials)
+        connection.servers.bootstrap options
       end
 
-      def connection
-        @connection ||= Fog::Compute.new compute_options
-      end
-
-      def bootstrap_options
-        {
-          name: @name,
-          flavor_id: flavor_id,
-          region_id: region_id,
-          image_id: image_id,
-        }
+      def account
+        @account ||= Provider.all(:cloud_account).first
       end
 
-      def compute_options
-        {
-          provider: :digitalocean,
-          digitalocean_api_key: Conjure.config.digitalocean_api_key,
-          digitalocean_client_id: Conjure.config.digitalocean_client_id,
-        }
+      def connection
+        @connection ||= Fog::Compute.new account.compute_options
       end
 
-      def flavor_id
-        @flavor_id ||= connection.flavors.find{|f| f.name == "512MB"}.id
+      def add_resource_id(options, type)
+        id = "#{type}_id".to_sym
+        name = "#{type}_name".to_sym
+        collection = "#{type}s".to_sym
+        options[id] = resource_id(collection, options[name]) if options[name]
       end
 
-      def region_id
-        @region_id ||= connection.regions.find{|r| r.name == Conjure.config.digitalocean_region}.id
+      def prepare_bootstrap_options(options)
+        add_resource_id(options, :flavor)
+        add_resource_id(options, :region)
+        add_resource_id(options, :image)
+        options
       end
 
-      def image_id
-        @image_id ||= connection.images.find{|r| r.name == "Ubuntu 13.04 x64"}.id
+      def resource_id(collection, name)
+        connection.send(collection).find{|i| i.name == name}.id
       end
 
       def set_fog_credentials
-        Fog.credential = fog_key_identifier
+        Fog.credential = Conjure.identity.unique_identifier
         Fog.credentials.merge! fog_credentials
       end
 
-      def private_key_file
-        Pathname.new(Conjure.config.config_path).join Conjure.config.private_key_file
-      end
-
-      def public_key_file
-        Pathname.new(Conjure.config.config_path).join Conjure.config.public_key_file
-      end
-
       def fog_credentials
         {
-          private_key_path: private_key_file,
-          public_key_path: public_key_file,
+          private_key_path: Conjure.identity.private_key_path,
+          public_key_path: Conjure.identity.public_key_path,
         }
       end
 
-      def fog_key_identifier
-        "conjure_#{Digest::MD5.hexdigest(File.read public_key_file)[0..7]}"
-      end
-
       def remote_shell
         @remote_shell ||= RemoteShell.new(
           :ip_address => server.public_ip_address,

data/lib/conjure/service/database.rb

@@ -5,8 +5,8 @@ module Conjure
         services_by_gem.each do |gem_name, service_class|
           if options[:codebase].gem_names.include? gem_name
             return service_class.new(
-              :docker_host => options[:docker_host],
-              :database_name => options[:codebase].database_name,
+              :target => options[:target],
+              :database_name => "rails_app_db",
               :adapter_name => adapters_by_gem[gem_name],
             )
           end

data/lib/conjure/service/database/mysql.rb

@@ -3,13 +3,13 @@ module Conjure
     class Database
       class Mysql
         def initialize(options)
-          @host = options[:docker_host]
+          @target = options[:target]
           @db_name = options[:database_name]
           @adapter_name = options[:adapter_name]
         end
 
         def base_image
-          @base_image ||= @host.shell.prepare(
+          @base_image ||= @target.shell.prepare(
             label: "mysql",
             setup_commands: [
               "apt-get install -y mysql-server mysql-client"

data/lib/conjure/service/database/postgres.rb

@@ -3,12 +3,12 @@ module Conjure
     class Database
       class Postgres
         def initialize(options)
-          @host = options[:docker_host]
+          @target = options[:target]
           @db_name = options[:database_name]
         end
 
         def base_image
-          @base_image ||= @host.shell.prepare(
+          @base_image ||= @target.shell.prepare(
             label: "postgres",
             setup_commands: [
               "apt-get install -y python-software-properties software-properties-common",

data/lib/conjure/service/digital_ocean_account.rb

@@ -0,0 +1,31 @@
+module Conjure
+  module Service
+    class DigitalOceanAccount
+      include Conjure::Provider
+
+      provides :cloud_account do
+        new if configured?
+      end
+
+      def self.configured?
+        Conjure.config.digitalocean_api_key and Conjure.config.digitalocean_client_id
+      end
+
+      def compute_options
+        {
+          :provider => :digitalocean,
+          :digitalocean_api_key => Conjure.config.digitalocean_api_key,
+          :digitalocean_client_id => Conjure.config.digitalocean_client_id,
+        }
+      end
+
+      def bootstrap_options
+        {
+          :flavor_name => "512MB",
+          :region_name => (Conjure.config.digitalocean_region || "New York 1"),
+          :image_name => "Ubuntu 13.04 x64",
+        }
+      end
+    end
+  end
+end

data/lib/conjure/service/docker_host.rb

@@ -43,7 +43,6 @@ module Conjure
         full_command = "nohup #{full_command}" if options[:nohup]
         full_command = "echo '#{shell_escape options[:stdin]}' | #{full_command}" if options[:stdin]
         Log.debug "   [scp] #{options[:files].inspect}" if options[:files]
-        Log.debug "   [ssh] #{full_command}"
         result = server.run full_command, :stream_stdin => options[:stream_stdin], :files => options[:files], &block
         raise "Docker error: #{result.stdout} #{result.stderr}" unless result.status == 0
         result.stdout

data/lib/conjure/service/docker_shell.rb

@@ -15,8 +15,8 @@ module Conjure
         )
       end
 
-      def command(*args)
-        (@image || default_image).command *args
+      def command(*args, &block)
+        (@image || default_image).command *args, &block
       end
 
       def run(*args)

data/lib/conjure/service/forwarded_shell.rb

@@ -16,7 +16,7 @@ module Conjure
       def command(c)
         container = @shell.run "/usr/sbin/sshd -D -e"
         escaped_command = @shell.docker_host.shell_escape c
-        ssh_command = "ssh -A -o StrictHostKeyChecking=no #{container.ip_address} '#{escaped_command}'"
+        ssh_command = "ssh -A -o StrictHostKeyChecking=no -o PasswordAuthentication=no #{container.ip_address} '#{escaped_command}'"
         result = @shell.docker_host.server.run ssh_command
         result.stdout
       end

data/lib/conjure/service/rails_codebase.rb

@@ -1,12 +1,11 @@
 module Conjure
   module Service
     class RailsCodebase
-      def initialize(host, github_url, branch, app_name, rails_environment)
+      def initialize(target, github_url, branch, rails_environment)
         @github_url = github_url
         @branch = branch
-        @app_name = app_name
         @rails_environment = rails_environment
-        @host = host
+        @target = target
       end
 
       def database_yml
@@ -33,12 +32,12 @@ module Conjure
           :volume => volume,
           :branch => @branch,
           :origin_url => @github_url,
-          :public_key => Conjure.config.file_contents(:public_key_file).gsub("\n", "\\n"),
+          :public_key => Conjure.identity.public_key_data.gsub("\n", "\\n"),
         )
       end
 
       def volume
-        @volume ||= Volume.new(:docker_host => @host, :host_path => "/rails_app", :container_path => "/#{@app_name}")
+        @volume ||= Volume.new(:target => @target, :host_path => "/rails_app", :container_path => "/application_root")
       end
 
       def configure_database
@@ -52,16 +51,12 @@ module Conjure
         volume.write "config/initializers/z_conjure_logger.rb", setup
       end
 
-      def database_name
-        "#{@app_name}_#{@rails_environment}"
-      end
-
       def gem_names
         volume.read("Gemfile").scan(/gem ['"]([^'"]+)['"]/).flatten
       end
 
       def database
-        @database ||= Database.new :docker_host => @host, :codebase => self
+        @database ||= Database.new :target => @target, :codebase => self
       end
     end
   end

data/lib/conjure/service/rails_console.rb

@@ -0,0 +1,10 @@
+module Conjure
+  module Service
+    class RailsConsole
+      def initialize(options, &block)
+        shell = options[:shell]
+        shell.command("cd application_root; bundle exec rails console", :stream_stdin => true, &block)
+      end
+    end
+  end
+end

data/lib/conjure/service/rails_deployment.rb

@@ -0,0 +1,39 @@
+module Conjure
+  module Service
+    class RailsDeployment
+      def initialize(options)
+        @origin = options[:origin]
+        @branch = options[:branch] || "master"
+        @environment = "production"
+        @test = options[:test]
+        @target = options[:target]
+      end
+
+      def deploy
+        Log.info "[deploy] Deploying #{@branch} to #{@environment}"
+        unless @test
+          codebase.install
+          rails.run
+          Log.info "[deploy] Application deployed to #{@target.ip_address}"
+        end
+      end
+
+      def database
+        codebase.database
+      end
+
+      def codebase
+        @codebase ||= Service::RailsCodebase.new @target, @origin, @branch, @environment
+      end
+
+      def rails
+        @rails ||= Service::RailsServer.new @target, @environment
+      end
+
+      def shell
+        rails.base_image
+      end
+    end
+  end
+end
+

data/lib/conjure/service/rails_log_view.rb

@@ -0,0 +1,14 @@
+module Conjure
+  module Service
+    class RailsLogView
+      def initialize(options, &block)
+        arguments = []
+        arguments << "-n #{options[:lines]}" if options[:lines]
+        arguments << "-f" if options[:tail]
+        arguments << "application_root/log/production.log"
+        options[:shell].command("tail #{arguments.join ' '}", &block)
+      rescue Interrupt
+      end
+    end
+  end
+end

data/lib/conjure/service/rails_server.rb

@@ -1,19 +1,19 @@
 module Conjure
   module Service
     class RailsServer
-      def initialize(host, app_name, rails_environment)
-        @host = host
-        @app_name = app_name
+      def initialize(target, rails_environment)
+        @target = target
         @rails_environment = rails_environment
       end
 
       def base_image
-        @base_image ||= @host.shell.prepare(
+        @base_image ||= @target.shell.prepare(
           label: "rails_base",
           setup_commands: [
             "apt-get install -y curl git",
             "curl -L https://get.rvm.io | bash -s stable",
-            "rvm install #{ruby_version}",
+            "/usr/local/rvm/bin/rvm install #{ruby_version}",
+            "ln -s /usr/local/rvm/rubies/* /usr/local/rvm/default-ruby",
             "bash -c 'source /usr/local/rvm/scripts/rvm; rvm use #{ruby_version}@global --default'",
             "ln -s /usr/local/rvm/rubies/*/lib/ruby/gems/* /usr/local/rvm/gems/default",
             "apt-get install -y #{apt_packages_required_for_gems.join ' '}",
@@ -25,12 +25,12 @@ module Conjure
 
           ],
           environment: {
-            PATH:"/usr/local/rvm/gems/default/bin:/usr/local/rvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+            PATH:"/usr/local/rvm/gems/default/bin:/usr/local/rvm/default-ruby/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
             RAILS_ENV: @rails_environment,
             GITHUB_TOKEN: ENV["GITHUB_TOKEN"],
             FRECKLE_SUBDOMAIN: "neomind",
           },
-          host_volumes: {"/rails_app" => "/#{@app_name}"},
+          host_volumes: {"/rails_app" => "/application_root"},
         )
       end
 
@@ -39,7 +39,7 @@ module Conjure
           label: "rails_server",
           ports: [80],
           environment: {
-            PATH:"/usr/local/rvm/gems/default/bin:/usr/local/rvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+            PATH:"/usr/local/rvm/gems/default/bin:/usr/local/rvm/default-ruby/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
           },
         )
       end
@@ -52,7 +52,7 @@ module Conjure
 
       def install_gems
         Log.info "[ rails] Installing gems"
-        base_image.command "cd #{@app_name}; bundle --deployment"
+        base_image.command "cd application_root; bundle --deployment"
       end
 
       def update_database
@@ -61,45 +61,22 @@ module Conjure
 
       def database_exists
         Log.info "[ rails] Checking the database status"
-        base_image.command("cd #{@app_name}; bundle exec rake db:version; true").include? "Current version:"
+        base_image.command("cd application_root; bundle exec rake db:version; true").include? "Current version:"
       end
 
       def migrate_database
         Log.info "[ rails] Migrating the database"
-        base_image.command "cd #{@app_name}; bundle exec rake db:migrate"
+        base_image.command "cd application_root; bundle exec rake db:migrate"
       end
 
       def initialize_database
         Log.info "[ rails] Setting up the database"
-        base_image.command "cd #{@app_name}; bundle exec rake db:setup"
+        base_image.command "cd application_root; bundle exec rake db:setup"
       end
 
       def restart_server
         server_image.stop
-        server_image.run "cd #{@app_name}; rm -f tmp/pids/server.pid; bundle exec rails server -p 80"
-      end
-
-      def log(options = {})
-        arguments = []
-        arguments << "-n #{options[:lines]}" if options[:lines]
-        arguments << "-f" if options[:tail]
-        log_file = "#{@app_name}/log/#{@rails_environment}.log"
-        base_image.command "tail #{arguments.join ' '} #{log_file}" do |stdout, stderr|
-          puts stdout
-        end
-      rescue Interrupt => e
-      end
-
-      def rake(command)
-        base_image.command "cd #{@app_name}; bundle exec rake #{command}" do |stdout, stderr|
-          print stdout
-        end
-      end
-
-      def console
-        base_image.command "cd #{@app_name}; bundle exec rails console", :stream_stdin => true do |stdout, stderr|
-          print stdout
-        end
+        server_image.run "cd application_root; rm -f tmp/pids/server.pid; bundle exec rails server -p 80"
       end
 
       def ruby_version

data/lib/conjure/service/rake_task.rb

@@ -0,0 +1,11 @@
+module Conjure
+  module Service
+    class RakeTask
+      def initialize(options, &block)
+        task = options[:task]
+        shell = options[:shell]
+        shell.command("cd application_root; bundle exec rake #{task}", &block)
+      end
+    end
+  end
+end

data/lib/conjure/service/remote_file_set.rb

@@ -0,0 +1,24 @@
+module Conjure
+  module Service
+    class RemoteFileSet
+      require "net/scp"
+
+      def initialize(options)
+        @shell = options[:shell]
+        @files = options[:files].to_a
+      end
+
+      def upload
+        dir_names = @files.map{|local_path, remote_path| File.dirname remote_path}.uniq
+        @shell.run "mkdir -p #{dir_names.join ' '}" if dir_names.any?
+        @files.each do |local_path, remote_path|
+          @shell.session.scp.upload! local_path, remote_path
+        end
+      end
+
+      def remove
+        @files.each{|local_path, remote_path| @shell.run "rm -f #{remote_path}"}
+      end
+    end
+  end
+end

data/lib/conjure/service/remote_shell.rb

@@ -13,6 +13,7 @@ module Conjure
       end
     
       def run(command, options = {}, &block)
+        Log.debug "   [ssh] #{command}"
         result = nil
         session.open_channel do |channel|
           channel.request_pty

data/lib/conjure/service/repository_link.rb

@@ -20,7 +20,8 @@ module Conjure
 
       def checkout_code
         Log.info "[  repo] Checking out code from git"
-        git_shell.command "git clone -b #{@branch} #{@origin_url} #{code_path}"
+        output = git_shell.command "git clone -b #{@branch} #{@origin_url} #{code_path}"
+        raise "Access denied to git repo" if output.include? "Permission denied"
       end
 
       def fetch_code_updates

data/lib/conjure/service/volume.rb

@@ -1,10 +1,10 @@
 module Conjure
   module Service
     class Volume
-      attr_reader :docker_host, :container_path
+      attr_reader :target, :container_path
 
       def initialize(options)
-        @docker_host = options[:docker_host]
+        @target = options[:target]
         @host_path = options[:host_path]
         @container_path = options[:container_path]
       end
@@ -18,7 +18,7 @@ module Conjure
       end
 
       def shell
-        @shell ||= @docker_host.shell.prepare(
+        @shell ||= @target.shell.prepare(
           :label => "volume",
           :host_volumes => {@host_path => @container_path},
         )

data/lib/conjure/target.rb

@@ -0,0 +1,19 @@
+module Conjure
+  class Target
+    def initialize(options)
+      @machine_name = options[:machine_name]
+    end
+
+    def shell
+      docker_host.shell
+    end
+
+    def ip_address
+      docker_host.ip_address
+    end
+
+    def docker_host
+      @docker_host ||= Service::DockerHost.new @machine_name
+    end
+  end
+end

data/lib/conjure/version.rb

@@ -1,3 +1,3 @@
 module Conjure
-  VERSION = "0.1.6" unless defined?(VERSION)
+  VERSION = "0.1.7" unless defined?(VERSION)
 end

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: conjure
 version: !ruby/object:Gem::Version
-  version: 0.1.6
-  prerelease: 
+  version: 0.1.7
 platform: ruby
 authors:
 - Brian Auton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-28 00:00:00.000000000 Z
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.0
+        version: 1.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.0
+        version: 1.19.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: unf
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0.beta1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0.beta1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -99,51 +88,62 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- History.md
+- License.txt
+- README.md
+- bin/conjure
 - lib/conjure.rb
+- lib/conjure/application.rb
+- lib/conjure/command.rb
+- lib/conjure/config.rb
+- lib/conjure/data_set.rb
+- lib/conjure/identity.rb
+- lib/conjure/instance.rb
+- lib/conjure/log.rb
+- lib/conjure/notes.txt
+- lib/conjure/provider.rb
 - lib/conjure/service/cloud_server.rb
-- lib/conjure/service/rails_server.rb
-- lib/conjure/service/rails_codebase.rb
-- lib/conjure/service/rails_application.rb
-- lib/conjure/service/forwarded_shell.rb
-- lib/conjure/service/repository_link.rb
-- lib/conjure/service/volume.rb
-- lib/conjure/service/database/postgres.rb
+- lib/conjure/service/database.rb
 - lib/conjure/service/database/mysql.rb
-- lib/conjure/service/remote_shell.rb
+- lib/conjure/service/database/postgres.rb
+- lib/conjure/service/digital_ocean_account.rb
 - lib/conjure/service/docker_host.rb
 - lib/conjure/service/docker_shell.rb
-- lib/conjure/service/database.rb
-- lib/conjure/log.rb
-- lib/conjure/config.rb
+- lib/conjure/service/forwarded_shell.rb
+- lib/conjure/service/rails_codebase.rb
+- lib/conjure/service/rails_console.rb
+- lib/conjure/service/rails_deployment.rb
+- lib/conjure/service/rails_log_view.rb
+- lib/conjure/service/rails_server.rb
+- lib/conjure/service/rake_task.rb
+- lib/conjure/service/remote_file_set.rb
+- lib/conjure/service/remote_shell.rb
+- lib/conjure/service/repository_link.rb
+- lib/conjure/service/volume.rb
+- lib/conjure/target.rb
 - lib/conjure/version.rb
-- lib/conjure/command.rb
-- README.md
-- History.md
-- License.txt
-- bin/conjure
 homepage: http://github.com/brianauton/conjure
 licenses:
 - MIT
+metadata: {}
 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.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Magically powerful deployment for Rails applications
 test_files: []

data/lib/conjure/service/rails_application.rb

@@ -1,43 +0,0 @@
-module Conjure
-  module Service
-    class RailsApplication
-      def initialize(options)
-        @origin = options[:origin]
-        @name = name_from_origin @origin
-        @branch = options[:branch] || "master"
-        @environment = "production"
-        @test = options[:test]
-      end
-
-      def deploy
-        Log.info "[deploy] Deploying #{@name}:#{@branch} to #{@environment}"
-        unless @test
-          codebase.install
-          rails.run
-          Log.info "[deploy] Application deployed to #{docker.ip_address}"
-        end
-      end
-
-      def docker
-        @docker ||= Service::DockerHost.new "#{@name}-#{@environment}"
-      end
-
-      def database
-        codebase.database
-      end
-
-      def codebase
-        @codebase ||= Service::RailsCodebase.new docker, @origin, @branch, @name, @environment
-      end
-
-      def rails
-        @rails ||= Service::RailsServer.new docker, @name, @environment
-      end
-
-      def name_from_origin(origin)
-        origin.match(/\/([^.]+)\.git$/)[1]
-      end
-    end
-  end
-end
-