conjure 0.0.2 → 0.1.0

data/History.md

@@ -1,3 +1,11 @@
+### Version 0.1.0
+2013-10-24
+
+* Support revision deploys
+* Add `--branch` option for deploys
+* Add `console`, `log`, and `rake` commands
+* SSH performance improvements
+
 ### Version 0.0.2
 2013-10-14
 

data/README.md

@@ -1,4 +1,7 @@
 ## Conjure
+[![Gem Version](https://badge.fury.io/rb/conjure.png)](http://badge.fury.io/rb/conjure)
+[![Build Status](https://travis-ci.org/brianauton/conjure.png?branch=master)](https://travis-ci.org/brianauton/conjure)
+[![Code Climate](https://codeclimate.com/github/brianauton/conjure.png)](https://codeclimate.com/github/brianauton/conjure)
 
 Magically powerful deployment for Rails applications.
 
@@ -70,19 +73,46 @@ Finally, tell Conjure to deploy your app:
 
 The last line of the output will tell you the IP address of the
 deployed server. Repeating the command will reuse the existing server
-rather than deploying a new one.
+rather than deploying a new one. Specify a branch to deploy with
+`--branch` or `-b` (default is `master`):
+
+    conjure deploy --branch=mybranch
 
 ### Additional Commands
 
-These commands are available after you've deployed with `conjure
+Additional commands are available after you've deployed with `conjure
 deploy`.
 
+#### Export
+
+Produce a Postgres SQL dump of the currently-deployed server's
+production database, and save it to the local file `FILE`.
+
     conjure export FILE
 
-This will produce a Postgres SQL dump of the currently-deployed
-server's production database, and save it to the local file `FILE`.
+#### Import
+
+Overwrite the production database on the currently-deployed server
+with a Postgres SQL dump from the local file `FILE`.
 
     conjure import FILE
 
-This will overwrite the production database on the currently-deployed
-server with a Postgres SQL dump from the local file `FILE`.
+#### Log
+
+Show logs from the deployed application. Optionally specify the number
+of lines with `-n`, and use --tail to continue streaming new lines as
+they are added to the log.
+
+    conjure log [-n=NUM] [--tail|-t]
+
+#### Console
+
+Open a console on the deployed application.
+
+    conjure console
+
+#### Rake
+
+Run a rake task on the deployed application and show the output.
+
+    conjure rake [ARGUMENTS...]

data/bin/conjure

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
 require "conjure"
-require "thor"
 
 Conjure::Command.start

data/lib/conjure.rb

@@ -1,7 +1,11 @@
 module Conjure
 
-  VERSION = "0.0.2" unless defined?(VERSION)
+  VERSION = "0.1.0" unless defined?(VERSION)
   autoload :Command, "conjure/command"
+  autoload :Config, "conjure/config"
   autoload :Service, "conjure/service"
 
+  def self.config
+    @config ||= Config.load Dir.pwd
+  end
 end

data/lib/conjure/command.rb

@@ -1,44 +1,57 @@
+require "thor"
+
 module Conjure
   class Command < Thor
-    desc "deploy", "Deploys the app"
+    attr_accessor :application_options
+
+    desc "deploy", "Deploy the app"
+    method_option :branch, :aliases => "-b", :type => :string, :desc => "Specify branch to deploy"
+    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
-      Service::RailsApplication.create github_url, app_name, rails_environment, config(Dir.pwd)
+      self.application_options = {
+        :branch => options[:branch],
+        :test => options[:test],
+        :origin => options[:origin],
+      }
+      application.deploy
     end
 
-    desc "import FILE", "Imports the production database from a postgres SQL dump"
+    desc "import FILE", "Import the production database from a postgres SQL dump"
     def import(file)
-      Service::PostgresClient.create(docker_host, "#{app_name}_#{rails_environment}").import file
-      puts "[export] #{File.size file} bytes imported from #{file}"
+      application.database.import file
     end
 
-    desc "export FILE", "Exports the production database to a postgres SQL dump"
+    desc "export FILE", "Export the production database to a postgres SQL dump"
     def export(file)
-      Service::PostgresClient.create(docker_host, "#{app_name}_#{rails_environment}").export file
-      puts "[export] #{File.size file} bytes exported to #{file}"
+      application.database.export file
     end
 
-    default_task :help
-
-    private
-
-    def rails_environment
-      "production"
+    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]
     end
 
-    def docker_host
-      Service::DockerHost.create "#{app_name}-#{rails_environment}", config(Dir.pwd)
+    desc "rake [ARGUMENTS...]", "Run the specified rake task on the deployed application"
+    def rake(*arguments)
+      application.rails.rake arguments.join(" ")
     end
 
-    def config(source_path)
-      require "ostruct"
-      config_path = File.join source_path, "config", "conjure.yml"
-      data = YAML.load_file config_path
-      data["config_path"] = File.dirname config_path
-      OpenStruct.new data
+    desc "console", "Start a console on the deployed application"
+    def console
+      application.rails.console
     end
 
-    def app_name
-      name_from_github_url github_url
+    default_task :help
+
+    private
+
+    def application
+      self.application_options ||= {}
+      self.application_options[:origin] ||= github_url
+      Service::RailsApplication.create self.application_options
     end
 
     def github_url
@@ -49,9 +62,5 @@ module Conjure
       remote_info = `cd #{source_path}; git remote -v |grep origin`
       remote_info.match(/(git@github.com[^ ]+)/)[1]
     end
-
-    def name_from_github_url(github_url)
-      github_url.match(/\/([^.]+)\.git$/)[1]
-    end
   end
 end

data/lib/conjure/config.rb

@@ -0,0 +1,11 @@
+module Conjure
+  class Config
+    def self.load(root_path)
+      require "ostruct"
+      config_path = File.join root_path, "config", "conjure.yml"
+      data = YAML.load_file config_path
+      data["config_path"] = File.dirname config_path
+      OpenStruct.new data
+    end
+  end
+end

data/lib/conjure/service.rb

@@ -1,17 +1,23 @@
 module Conjure
   module Service
     autoload :RailsApplication, "conjure/service/rails_application"
+    autoload :RailsCodebase, "conjure/service/rails_codebase"
     autoload :RailsServer, "conjure/service/rails_server"
     autoload :MachineInstance, "conjure/service/machine_instance"
     autoload :DockerHost, "conjure/service/docker_host"
     autoload :CloudServer, "conjure/service/cloud_server"
-    autoload :PostgresServer, "conjure/service/postgres_server"
-    autoload :PostgresClient, "conjure/service/postgres_client"
+    autoload :PostgresDatabase, "conjure/service/postgres_database"
+    autoload :RemoteShell, "conjure/service/remote_shell"
   end
 
   class Basic
     def self.create(*args)
       new(*args)
     end
+
+    def file_contents(file_path)
+      file_path = File.join Conjure.config.config_path, file_path
+      `cat #{file_path}`
+    end
   end
 end

data/lib/conjure/service/cloud_server.rb

@@ -3,15 +3,14 @@ module Conjure
     class CloudServer < Basic
       require "fog"
 
-      def initialize(name, config = {})
+      def initialize(name)
         @name = name
-        @config = config
       end
 
-      def run(command, options = {})
+      def run(command, options = {}, &block)
         set_fog_credentials
         upload_files options[:files].to_a
-        result = server.ssh(command).first
+        result = remote_shell.run(command, :stream_stdin => options[:stream_stdin], &block)
         remove_files options[:files].to_a
         result
       end
@@ -23,7 +22,7 @@ module Conjure
       end
 
       def remove_files(files)
-        files.each{|local_path, remote_path| server.ssh "rm -f #{remote_path}"}
+        files.each{|local_path, remote_path| run "rm -f #{remote_path}"}
       end
 
       def server
@@ -64,8 +63,8 @@ module Conjure
       def compute_options
         {
           provider: :digitalocean,
-          digitalocean_api_key: config.digitalocean_api_key,
-          digitalocean_client_id: config.digitalocean_client_id,
+          digitalocean_api_key: Conjure.config.digitalocean_api_key,
+          digitalocean_client_id: Conjure.config.digitalocean_client_id,
         }
       end
 
@@ -74,27 +73,23 @@ module Conjure
       end
 
       def region_id
-        @region_id ||= connection.regions.find{|r| r.name == config.digitalocean_region}.id
+        @region_id ||= connection.regions.find{|r| r.name == Conjure.config.digitalocean_region}.id
       end
 
       def image_id
         @image_id ||= connection.images.find{|r| r.name == "Ubuntu 13.04 x64"}.id
       end
 
-      def config
-        @config
-      end
-
       def set_fog_credentials
         Fog.credentials.merge! fog_credentials
       end
 
       def private_key_file
-        Pathname.new(config.config_path).join config.private_key_file
+        Pathname.new(Conjure.config.config_path).join Conjure.config.private_key_file
       end
 
       def public_key_file
-        Pathname.new(config.config_path).join config.public_key_file
+        Pathname.new(Conjure.config.config_path).join Conjure.config.public_key_file
       end
 
       def fog_credentials
@@ -103,6 +98,14 @@ module Conjure
           public_key_path: public_key_file,
         }
       end
+
+      def remote_shell
+        @remote_shell ||= RemoteShell.new(
+          :ip_address => server.public_ip_address,
+          :username => "root",
+          :private_key_path => private_key_file,
+        )
+      end
     end
   end
 end

data/lib/conjure/service/docker_host.rb

@@ -3,17 +3,12 @@ module Conjure
     class DockerHost < Basic
       VERBOSE = false
 
-      def initialize(server_name, config = {})
+      def initialize(server_name)
         @server_name = server_name
-        @config = config
       end
 
       def server
-        @server ||= Service::CloudServer.create @server_name, config
-      end
-
-      def config
-        @config
+        @server ||= Service::CloudServer.create @server_name
       end
 
       def ip_address
@@ -22,6 +17,8 @@ module Conjure
 
       def new_docker_path
         puts "[docker] Installing docker"
+        server.run "dd if=/dev/zero of=/root/swapfile bs=1024 count=524288"
+        server.run "mkswap /root/swapfile; swapon /root/swapfile"
         server.run "curl https://get.docker.io/gpg | apt-key add -"
         server.run "echo 'deb https://get.docker.io/ubuntu docker main' >/etc/apt/sources.list.d/docker.list"
         server.run "apt-get update"
@@ -41,47 +38,52 @@ module Conjure
         @docker_path ||= new_docker_path
       end
 
-      def command(command, options = {})
+      def command(command, options = {}, &block)
         full_command = "#{docker_path} #{command}"
         full_command = "nohup #{full_command}" if options[:nohup]
         full_command = "echo '#{shell_escape options[:stdin]}' | #{full_command}" if options[:stdin]
         puts "   [scp] #{options[:files].inspect}" if VERBOSE and options[:files]
         puts "   [ssh] #{full_command}" if VERBOSE
-        result = server.run full_command, files: options[:files]
+        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
       end
 
-      def clean_stopped_processes
-        command "rm `#{docker_path} ps -a -q`"
+      def ensure_host_directory(dir)
+        server.run "mkdir -p #{dir}"
       end
 
       def shell_escape(text)
         text.gsub "'", "'\"'\"'"
       end
 
+      def images
+        ImageSet.new self
+      end
+
       def containers
-        ContainerSet.new self
+        ContainerSet.new :host => self
       end
     end
 
-    class ContainerSet
+    class ImageSet
       def initialize(host)
         @host = host
       end
 
       def create(options)
-        Container.new @host, options
+        Image.new @host, options
       end
     end
 
-    class Container
+    class Image
       def initialize(host, options)
         @host = host
         @label = options[:label]
         @base_image = options[:base_image]
         @ports = options[:ports].to_a
         @volumes = options[:volumes].to_a
+        @host_volumes = options[:host_volumes]
         @setup_commands = options[:setup_commands].to_a
         @daemon_command = options[:daemon_command]
         @environment = options[:environment]
@@ -89,25 +91,35 @@ module Conjure
       end
 
       def image_fingerprint
-        {base_image: @base_image, setup_commands: @setup_commands}
+        Digest::SHA1.hexdigest(dockerfile)[0..11]
+      end
+
+      def expected_image_name
+        "#{@label}:#{image_fingerprint}"
+      end
+
+      def installed_image_name
+        build unless image_installed?
+        expected_image_name
       end
 
-      def image_name
-        hash = Digest::SHA1.hexdigest(image_fingerprint.to_yaml).first(12)
-        "#{@label}_#{hash}"
+      def image_installed?
+        @host.command("history #{expected_image_name}") rescue false
       end
 
-      def run
-        unless id
-          build
-          puts "[docker] Starting #{@label} image"
-          container_id = @host.command("run -d #{@label}").strip
-          if(!id)
+      def run(command = "")
+        unless running_container
+          puts "[docker] Starting #{@label}"
+          run_options = @host_volumes ? host_volume_options(@host_volumes) : ""
+          command = shell_command command if command != ""
+          container_id = @host.command("run #{run_options} -d #{installed_image_name} #{command}").strip
+          if(!running_container)
             output = @host.command "logs #{container_id}"
             raise "Docker: #{@label} daemon exited with: #{output}"
           end
         end
-        puts "[docker] #{@label} is running at #{ip_address}"
+        puts "[docker] #{@label} is running at #{running_container.ip_address}"
+        running_container
       end
 
       def raise_build_errors(build_output)
@@ -121,11 +133,8 @@ module Conjure
         end
       end
 
-      def raise_run_errors(run_output)
-      end
-
       def dockerfile
-        lines = ["FROM #{@base_image}"]
+        lines = ["FROM #{base_image_name}"]
         lines += @environment.map{|k, v| "ENV #{k} #{v}"} if @environment
         lines += @setup_commands.map{|c| "RUN #{c}"}
         lines << "EXPOSE #{@ports.map{|p| "#{p}:#{p}"}.join ' '}" if @ports.to_a.any?
@@ -134,17 +143,30 @@ module Conjure
         lines.join "\n"
       end
 
+      def base_image_name
+        @base_image.respond_to?(:installed_image_name) ? @base_image.installed_image_name : @base_image
+      end
+
       def build
+        destroy_instances
         puts "[docker] Building #{@label} image"
-        raise_build_errors(@host.command "build -t #{@label} -", stdin: dockerfile)
-        @host.clean_stopped_processes
+        raise_build_errors(@host.command "build -t #{expected_image_name} -", stdin: dockerfile)
+        @host.containers.destroy_all_stopped
       end
 
-      def command(command, options = {})
-        build
-        puts "[docker] Executing #{@label} image"
+      def command(command, options = {}, &block)
+        destroy_instances
         file_options = options[:files] ? "-v /files:/files" : ""
-        @host.command "run #{file_options} #{@label} #{command}", files: files_hash(options[:files])
+        file_options += " "+host_volume_options(@host_volumes) if @host_volumes
+        file_options += " -i" if options[:stream_stdin]
+        @host.command "run #{file_options} #{installed_image_name} #{shell_command command}", :stream_stdin => options[:stream_stdin], :files => files_hash(options[:files]), &block
+      end
+
+      def host_volume_options(host_volumes)
+        host_volumes.map do |host_path, container_path|
+          @host.ensure_host_directory host_path
+          "-v=#{host_path}:#{container_path}:rw"
+        end.join " "
       end
 
       def files_hash(files_array)
@@ -157,10 +179,52 @@ module Conjure
         "bash -c '#{@host.shell_escape command}'"
       end
 
-      def id
-        @id ||= @host.command("ps | grep #{@label}: ; true").strip.split("\n").first.to_s[0..11]
-        @id = nil if @id == ""
-        @id
+      def running_container
+        @runnning_container ||= @host.containers.find(:image_name => expected_image_name)
+      end
+
+      def destroy_instances
+        @host.containers.destroy_all :image_name => @label
+      end
+
+      def stop
+        destroy_instances
+      end
+    end
+
+    class ContainerSet
+      attr_accessor :host
+
+      def initialize(options)
+        self.host = options[:host]
+      end
+
+      def find(options)
+        image_name = options[:image_name]
+        id = host.command("ps | grep #{image_name} ; true").strip.split("\n").first.to_s[0..11]
+        id = nil if id == ""
+        Container.new(:host => host, :id => id) if id
+      end
+
+      def destroy_all_stopped
+        host.command "rm `#{host.docker_path} ps -a -q`"
+      end
+
+      def destroy_all(options)
+        while container = find(:image_name => options[:image_name]) do
+          puts "[docker] Stopping #{options[:image_name]}"
+          host.command "stop #{container.id}"
+          host.command "rm #{container.id}"
+        end
+      end
+    end
+
+    class Container
+      attr_accessor :id, :host
+
+      def initialize(options)
+        self.id = options[:id]
+        self.host = options[:host]
       end
 
       def ip_address
@@ -169,7 +233,7 @@ module Conjure
 
       def status
         require "json"
-        JSON.parse(@host.command "inspect #{id}").first
+        JSON.parse(host.command "inspect #{id}").first
       end
     end
   end

data/lib/conjure/service/postgres_database.rb

@@ -0,0 +1,69 @@
+module Conjure
+  module Service
+    class PostgresDatabase < Basic
+      def initialize(host, db_name)
+        @host = host
+        @db_name = db_name
+      end
+
+      def base_image
+        @base_image ||= @host.images.create(
+          label: "postgres",
+          base_image: "ubuntu",
+          setup_commands: [
+            "apt-get install -y python-software-properties software-properties-common",
+            "add-apt-repository -y ppa:pitti/postgresql",
+            "apt-get update",
+            "apt-get install -y postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2",
+          ],
+        )
+      end
+
+      def server_image
+        @server_image ||= @host.images.create(
+          label: "pgserver",
+          base_image: base_image,
+          setup_commands: [
+            "service postgresql start; su postgres -c 'createuser -d -r -s root; createdb -O root root'; service postgresql stop",
+            "echo 'host all all 0.0.0.0/0 trust' >>/etc/postgresql/9.2/main/pg_hba.conf",
+            "echo \"listen_addresses='*'\" >>/etc/postgresql/9.2/main/postgresql.conf",
+          ],
+          daemon_command: "su postgres -c '#{bin_path}/postgres -c config_file=/etc/postgresql/9.2/main/postgresql.conf'",
+          volumes: ["/var/lib/postgresql/9.2/main"],
+        )
+      end
+
+      def run
+        container
+      end
+
+      def container
+        @container ||= server_image.run
+      end
+
+      def ip_address
+        container.ip_address
+      end
+
+      def export(file)
+        File.open file, "w" do |f|
+          f.write base_image.command("#{bin_path}/pg_dump #{client_options} #{@db_name}")
+        end
+        puts "[export] #{File.size file} bytes exported to #{file}"
+      end
+
+      def import(file)
+        base_image.command "#{bin_path}/psql #{client_options} -d #{@db_name} -f /files/#{File.basename file}", files: [file]
+        puts "[import] #{File.size file} bytes imported from #{file}"
+      end
+
+      def client_options
+        "-U root -h #{ip_address}"
+      end
+
+      def bin_path
+        "/usr/lib/postgresql/9.2/bin"
+      end
+    end
+  end
+end

data/lib/conjure/service/rails_application.rb

@@ -1,15 +1,42 @@
 module Conjure
   module Service
     class RailsApplication < Basic
-      def initialize(github_url, name = "myapp", environment = "production", config = {})
-        @name = name
-        @environment = environment
-        docker = Service::DockerHost.create "#{name}-#{environment}", config
-        postgres = Service::PostgresServer.create docker
-        postgres.run
-        rails = Service::RailsServer.create docker, github_url, name, postgres.ip_address, environment
-        rails.run
-        puts "[deploy] Application deployed to #{docker.ip_address}"
+      def initialize(options)
+        @origin = options[:origin]
+        @name = name_from_origin @origin
+        @branch = options[:branch] || "master"
+        @environment = "production"
+        @test = options[:test]
+      end
+
+      def deploy
+        puts "[deploy] Deploying #{@name}:#{@branch} to #{@environment}"
+        unless @test
+          database.run
+          codebase.install
+          rails.run
+          puts "[deploy] Application deployed to #{docker.ip_address}"
+        end
+      end
+
+      def docker
+        @docker ||= Service::DockerHost.create "#{@name}-#{@environment}"
+      end
+
+      def database
+        @database ||= Service::PostgresDatabase.create docker, "#{@name}_#{@environment}"
+      end
+
+      def codebase
+        @codebase ||= Service::RailsCodebase.create docker, @origin, @branch, @name, database.ip_address, @environment
+      end
+
+      def rails
+        @rails ||= Service::RailsServer.create docker, @name, @environment
+      end
+
+      def name_from_origin(origin)
+        origin.match(/\/([^.]+)\.git$/)[1]
       end
     end
   end

data/lib/conjure/service/rails_codebase.rb

@@ -0,0 +1,71 @@
+module Conjure
+  module Service
+    class RailsCodebase < Basic
+      def initialize(host, github_url, branch, app_name, database_ip_address, rails_environment)
+        @github_url = github_url
+        @branch = branch
+        @app_name = app_name
+        @database_ip_address = database_ip_address
+        @rails_environment = rails_environment
+        github_private_key = file_contents(Conjure.config.private_key_file).gsub("\n", "\\n")
+        github_public_key = file_contents(Conjure.config.public_key_file).gsub("\n", "\\n")
+        @image = host.images.create(
+          label: "codebase",
+          base_image: "ubuntu",
+          setup_commands: [
+            "apt-get install -y git",
+            "mkdir -p /root/.ssh; echo '#{github_private_key}' > /root/.ssh/id_rsa",
+            "mkdir -p /root/.ssh; echo '#{github_public_key}' > /root/.ssh/id_rsa.pub",
+            "chmod -R go-rwx /root/.ssh",
+            "echo 'Host github.com\\n\\tStrictHostKeyChecking no\\n' >> /root/.ssh/config",
+          ],
+          host_volumes: {"/rails_app" => "/#{app_name}"},
+        )
+      end
+
+      def database_yml
+        {
+          @rails_environment => {
+            "adapter" => "postgresql",
+            "database" => "#{@app_name}_#{@rails_environment}",
+            "encoding" => "utf8",
+            "host" => @database_ip_address,
+            "username" => "root",
+            "template" => "template0",
+          }
+        }.to_yaml
+      end
+
+      def install
+        code_checked_out ? fetch_code_updates : checkout_code
+        configure_database
+        configure_logs
+      end
+
+      def code_checked_out
+        @image.command("[ -d #{@app_name}/.git ] && echo yes; true").strip == "yes"
+      end
+
+      def checkout_code
+        puts "[  repo] Checking out code from git"
+        @image.command "git clone -b #{@branch} #{@github_url}"
+      end
+
+      def fetch_code_updates
+        puts "[  repo] Fetching code updates from git"
+        @image.command "cd #{@app_name}; git reset --hard; git checkout #{@branch}; git pull"
+      end
+
+      def configure_database
+        puts "[  repo] Generating database.yml"
+        @image.command "echo '#{database_yml}' >/#{@app_name}/config/database.yml"
+      end
+
+      def configure_logs
+        puts "[  repo] Configuring application logger"
+        setup = 'Rails.logger = Logger.new "#{Rails.root}/log/#{Rails.env}.log"'
+        @image.command "echo '#{setup}' >/#{@app_name}/config/initializers/z_conjure_logger.rb"
+      end
+    end
+  end
+end

data/lib/conjure/service/rails_server.rb

@@ -1,68 +1,111 @@
 module Conjure
   module Service
     class RailsServer < Basic
-      def file_contents(config, file_path)
-        file_path = File.join config.config_path, file_path
-        `cat #{file_path}`
+      def initialize(host, app_name, rails_environment)
+        @host = host
+        @app_name = app_name
+        @rails_environment = rails_environment
       end
 
-      def initialize(host, github_url, app_name, database_ip_address, rails_environment = "production")
-        config = host.config
-        ruby_version = file_contents(config, "../.ruby-version").strip
-        github_private_key = file_contents(config, config.private_key_file).gsub("\n", "\\n")
-        github_public_key = file_contents(config, config.public_key_file).gsub("\n", "\\n")
-        @container = host.containers.create(
-          label: "rails",
+      def base_image
+        @base_image ||= @host.images.create(
+          label: "rails_base",
           base_image: "ubuntu",
           setup_commands: [
-           "apt-get install -y curl git",
+            "apt-get install -y curl git",
             "curl -L https://get.rvm.io | bash -s stable",
             "rvm install #{ruby_version}",
             "bash -c 'source /usr/local/rvm/scripts/rvm; rvm use #{ruby_version}@global --default'",
-            "mkdir -p /root/.ssh; echo '#{github_private_key}' > /root/.ssh/id_rsa",
-            "mkdir -p /root/.ssh; echo '#{github_public_key}' > /root/.ssh/id_rsa.pub",
-            "chmod -R go-rwx /root/.ssh",
-            "echo 'Host github.com\\n\\tStrictHostKeyChecking no\\n' >> /root/.ssh/config",
-            "git clone #{github_url}",
             "apt-get install -y #{apt_packages_required_for_gems.join ' '}",
-            "cd #{app_name}; bundle --deployment",
-
             "echo 'deb http://us.archive.ubuntu.com/ubuntu/ precise universe' >>/etc/apt/sources.list",
             "apt-get install -y python-software-properties software-properties-common",
             "add-apt-repository -y ppa:chris-lea/node.js-legacy",
             "apt-get update",
             "apt-get install -y nodejs",
 
-            "echo '#{database_yml database_ip_address, app_name, rails_environment}' >/#{app_name}/config/database.yml",
-            "cd #{app_name}; bundle exec rake db:setup",
           ],
           environment: {
             PATH:"/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-            RAILS_ENV: rails_environment,
+            RAILS_ENV: @rails_environment,
             GITHUB_TOKEN: ENV["GITHUB_TOKEN"],
             FRECKLE_SUBDOMAIN: "neomind",
           },
-          daemon_command: "cd #{app_name}; bundle exec rails server -p 80",
+          host_volumes: {"/rails_app" => "/#{@app_name}"},
+        )
+      end
+
+      def server_image
+        @server_image ||= @host.images.create(
+          label: "rails_server",
+          base_image: base_image,
           ports: [80],
-          volumes: ["/#{app_name}/log"],
+          environment: {
+            PATH:"/usr/local/rvm/gems/ruby-1.9.3-p448@global/bin:/usr/local/rvm/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+          },
+          host_volumes: {"/rails_app" => "/#{@app_name}"},
         )
       end
 
       def run
-        @container.run
+        install_gems
+        update_database
+        restart_server
+      end
+
+      def install_gems
+        puts "[ rails] Installing gems"
+        base_image.command "cd #{@app_name}; bundle --deployment"
+      end
+
+      def update_database
+        database_exists ? migrate_database : initialize_database
+      end
+
+      def database_exists
+        puts "[ rails] Checking the database status"
+        base_image.command("cd #{@app_name}; bundle exec rake db:version; true").include? "Current version:"
+      end
+
+      def migrate_database
+        puts "[ rails] Migrating the database"
+        base_image.command "cd #{@app_name}; bundle exec rake db:migrate"
+      end
+
+      def initialize_database
+        puts "[ rails] Setting up the database"
+        base_image.command "cd #{@app_name}; 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
       end
 
-      def database_yml(database_ip_address, app_name, rails_environment)
-        {
-          rails_environment => {
-            "adapter" => "postgresql",
-            "database" => "#{app_name}_#{rails_environment}",
-            "encoding" => "utf8",
-            "host" => database_ip_address,
-            "username" => "root",
-            "template" => "template0",
-          }
-        }.to_yaml.gsub("\n", "\\n")
+      def ruby_version
+        file_contents("../.ruby-version").strip
       end
 
       def apt_packages_required_for_gems

data/lib/conjure/service/remote_shell.rb

@@ -0,0 +1,61 @@
+module Conjure
+  module Service
+    class RemoteShell
+      require "net/ssh"
+
+      def initialize(options)
+        @options = options
+      end
+    
+      def run(command, options = {})
+        stdout, stderr, exit_status = ["", "", nil]
+        session.open_channel do |channel|
+          channel.request_pty
+          channel.exec command do |c, success|
+            raise "Failed to execute command via SSH" unless success
+            channel.on_data do |c, data|
+              yield data if block_given?
+              stdout << data
+            end
+            channel.on_extended_data { |c, type, data| stderr << data }
+            channel.on_request("exit-status") { |c, data| exit_status = data.read_long }
+          end
+          if options[:stream_stdin]
+            channel.on_process do
+              poll_stream(STDIN) { |data| channel.send_data data }
+            end
+          end
+        end
+        if options[:stream_stdin]
+          with_raw_tty { session.loop 0.01 }
+        else
+          session.loop
+        end
+        Result.new stdout, stderr, exit_status
+      end
+      
+      def session
+        session_options = {
+          :auth_methods => ["publickey"],
+          :key_data => File.read(@options[:private_key_path]),
+          :keys_only => true,
+          :paranoid => false,
+        }
+        @session ||= Net::SSH.start @options[:ip_address], @options[:username], session_options
+      end
+
+      def poll_stream(stream, &block)
+        yield stream.sysread(1) if IO.select([stream], nil, nil, 0.01)
+      end
+
+      def with_raw_tty
+        system "stty raw -echo"
+        yield
+      ensure
+        system "stty -raw echo"
+      end
+    end
+
+    Result = Struct.new(:stdout, :stderr, :status)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conjure
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2013-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -59,6 +59,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !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: 
 email:
 - brianauton@gmail.com
@@ -70,11 +102,13 @@ files:
 - lib/conjure.rb
 - lib/conjure/service/cloud_server.rb
 - lib/conjure/service/rails_server.rb
-- lib/conjure/service/postgres_server.rb
+- lib/conjure/service/rails_codebase.rb
 - lib/conjure/service/rails_application.rb
 - lib/conjure/service/machine_instance.rb
-- lib/conjure/service/postgres_client.rb
+- lib/conjure/service/remote_shell.rb
 - lib/conjure/service/docker_host.rb
+- lib/conjure/service/postgres_database.rb
+- lib/conjure/config.rb
 - lib/conjure/service.rb
 - lib/conjure/command.rb
 - README.md

data/lib/conjure/service/postgres_client.rb

@@ -1,32 +0,0 @@
-module Conjure
-  module Service
-    class PostgresClient < Basic
-      def initialize(host, db_name)
-        server = PostgresServer.create host
-        server.run
-        @server_ip = server.ip_address
-        @db_name = db_name
-        @container = host.containers.create(
-          label: "pgclient",
-          base_image: "ubuntu",
-          setup_commands: [
-            "apt-get install -y python-software-properties software-properties-common",
-            "add-apt-repository -y ppa:pitti/postgresql",
-            "apt-get update",
-            "apt-get install -y postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2",
-          ],
-        )
-      end
-
-      def export(file)
-        File.open file, "w" do |f|
-          f.write @container.command("/usr/lib/postgresql/9.2/bin/pg_dump -U root -h #{@server_ip} #{@db_name}")
-        end
-      end
-
-      def import(file)
-        @container.command "/usr/lib/postgresql/9.2/bin/psql -U root -h #{@server_ip} -d #{@db_name} -f /files/#{File.basename file}", files: [file]
-      end
-    end
-  end
-end

data/lib/conjure/service/postgres_server.rb

@@ -1,31 +0,0 @@
-module Conjure
-  module Service
-    class PostgresServer < Basic
-      def initialize(host)
-        @container = host.containers.create(
-          label: "postgres",
-          base_image: "ubuntu",
-          setup_commands: [
-            "apt-get install -y python-software-properties software-properties-common",
-            "add-apt-repository -y ppa:pitti/postgresql",
-            "apt-get update",
-            "apt-get install -y postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2",
-            "service postgresql start; su postgres -c 'createuser -d -r -s root; createdb -O root root'; service postgresql stop",
-            "echo 'host all all 0.0.0.0/0 trust' >>/etc/postgresql/9.2/main/pg_hba.conf",
-            "echo \"listen_addresses='*'\" >>/etc/postgresql/9.2/main/postgresql.conf",
-          ],
-          daemon_command: "su postgres -c '/usr/lib/postgresql/9.2/bin/postgres -c config_file=/etc/postgresql/9.2/main/postgresql.conf'",
-          volumes: ["/var/lib/postgresql/9.2/main"],
-        )
-      end
-
-      def run
-        @container.run
-      end
-
-      def ip_address
-        @container.ip_address
-      end
-    end
-  end
-end