circus-deployment 0.0.1

data/lib/circus/profiles/base.rb

@@ -0,0 +1,115 @@
+require 'net/http'
+require 'yaml'
+require 'circus/external_util'
+
+module Circus
+  module Profiles
+    PROFILES=[]
+    
+    # Base functionality for an Profile
+    class Base
+      def initialize(name, dir, props)
+        @name = name
+        @dir = dir
+        @props = props
+      end
+      
+      def package_base_dir?
+        true
+      end
+      
+      def extra_dirs
+        []
+      end
+
+      def package_for_dev(logger, run_dir)
+        return false unless prepare_for_dev(logger, run_dir)
+        write_run_script(run_dir) do |f|
+          f.write(dev_run_script_content.strip)
+        end
+      end
+
+      def package_for_deploy(logger, run_dir)
+        return false unless prepare_for_deploy(logger, run_dir)
+        write_run_script(run_dir) do |f|
+          f.write(deploy_run_script_content.strip)
+        end
+        File.open(File.join(run_dir, 'requirements.yaml'), 'w') do |f|
+          f.write(requirements.to_yaml)
+        end
+      end
+      
+      def cleanup_after_deploy(logger, overlay_dir)
+      end
+
+      # Overriden by subclasses to specify the resources that they require. Defaults to a resource
+      # hash provided in the act definition
+      def requirements
+        (@props['requirements'] || {}).dup
+      end
+      
+      protected
+        # Overriden by subclasses to handle development preparation. Defaults to the same as the deployment preparation.
+        def prepare_for_dev(logger, run_dir)
+          prepare_for_deploy(logger, run_dir)
+        end
+
+        # Overriden by classes to handle generating the run script content for development. 
+        def dev_run_script_content
+        end
+
+        # Overriden by subclasses to handle deployment preparation
+        def prepare_for_deploy(logger, run_dir)
+          true
+        end
+
+        # Overriden by classes to handle generating the run script content for deployment.
+        def deploy_run_script_content
+        end
+
+        def write_run_script(run_dir)
+          File.open(File.join(run_dir, 'run'), 'w') do |f|
+            yield f
+          end
+          File.chmod 0777, File.join(run_dir, 'run')
+        end
+
+        def shell_run_script
+          <<-EOT
+          #!/bin/sh
+
+          #{yield}
+          EOT
+        end
+        
+        def write_dev_run_script(run_dir)
+          write_run_script(run_dir) do |f|
+            base_template = <<-EOT
+              #!/bin/sh
+
+              cd #{@dir}
+            EOT
+            
+            f.write(base_template.lstrip)
+            yield f
+          end
+        end        
+
+        def write_deploy_run_script(run_dir)
+          write_run_script(run_dir) do |f|
+            base_template = <<-EOT
+              #!/bin/sh
+
+            EOT
+            
+            f.write(base_template.lstrip)
+            yield f
+          end
+        end
+        
+        def run_external(logger, desc, cmd)
+          ExternalUtil.run_external(logger, desc, cmd)
+        end
+    end
+  end
+end

data/lib/circus/profiles/django.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../python_base', __FILE__)
+
+module Circus
+  module Profiles
+    class Django < PythonBase
+      DJANGO_APP_PROPERTY='django-app'
+      
+      # Checks if this is a Django application. Will accept the application if it 
+      # has a file named manage.py, or has a 'django-app' property describing the entry point.
+      def self.accepts?(name, dir, props)
+        return true if props.include? DJANGO_APP_PROPERTY
+        return File.exists?(File.join(dir, "manage.py"))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+        
+        @manage_script = props[DJANGO_APP_PROPERTY] || "manage.py"
+      end
+      
+      # The name of this profile
+      def name
+        "django"
+      end
+      
+      def prepare_for_deploy(logger, overlay_dir)
+        return false unless super
+        
+        File.open(File.join(overlay_dir, 'local_settings.py'), 'w') do |f|
+            f.write <<-EOT
+import os
+            
+DATABASE_ENGINE = 'postgresql_psycopg2'
+DATABASE_NAME = os.getenv('DATABASE_NAME')
+DATABASE_USER = os.getenv('DATABASE_USER')
+DATABASE_PASSWORD = os.getenv('DATABASE_PASSWORD')
+DATABASE_HOST = os.getenv('DATABASE_HOST')
+            EOT
+        end
+        true
+      end
+
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec vendor/bin/python #{@manage_script} runserver
+          EOT
+        end
+      end
+
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec vendor/bin/python #{@manage_script} runserver --noreload 0.0.0.0:$LISTEN_PORT
+          EOT
+        end
+      end
+
+      # Describes the requirements of the deployed application. Django applications automatically
+      # require a database with accessible credentials.
+      def requirements
+        res = super
+
+        db_name = @props['database_name'] || @name
+        res['resources'] ||= []
+        res['resources'] << {
+            'type' => 'Postgres',
+            'name' => db_name,
+            'user' => @props['database_user'] || db_name,
+            'password' => @props['database_password'] || db_name
+          }
+          
+        # TODO: The clown should be able to automatically allocate listening ports
+        res['system-properties'] ||= {}
+        res['system-properties']['LISTEN_PORT'] = 3000
+        
+        # TODO: The clown should be able to automatically respond with DB details
+        res['system-properties']['DATABASE_NAME'] = db_name
+        res['system-properties']['DATABASE_USER'] = db_name
+        res['system-properties']['DATABASE_PASSWORD'] = @props['database_password'] || db_name
+        res['system-properties']['DATABASE_HOST'] = 'localhost'
+        
+        res
+      end
+    end
+    
+    PROFILES << Django
+  end
+end

data/lib/circus/profiles/jekyll.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../base', __FILE__)
+
+module Circus
+  module Profiles
+    class Jekyll < Base
+      # Checks if this is a Jekyll site based on whether there is a file named
+      # _config.yml on the root directory
+      def self.accepts?(name, dir, props)
+        return File.exists?(File.join(dir, "_config.yml"))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+      end
+      
+      # The name of this profile
+      def name
+        "jekyll"
+      end
+
+      def package_base_dir?
+        false
+      end
+      
+      def extra_dirs
+        ["#{@dir}/_site"]
+      end
+
+      def prepare_for_deploy(logger, overlay_dir)
+        run_external(logger, 'Generate site with Jekyll', "cd #{@dir}; jekyll")
+
+        # Create lighttpd.conf
+        File.open(File.join(overlay_dir, 'lighttpd.conf'), 'w') do |f|
+            f.write <<-EOT
+server.document-root = "_site/" 
+
+server.port = env.HTTPD_PORT
+
+mimetype.assign = (
+  ".html" => "text/html", 
+  ".txt" => "text/plain",
+  ".css" => "text/css",
+  ".jpg" => "image/jpeg",
+  ".png" => "image/png"
+)
+
+static-file.exclude-extensions = ( ".yaml" )
+index-file.names = ( "index.html" )
+            EOT
+        end
+        true
+      end
+
+      def cleanup_after_deploy(logger, overlay_dir)
+        FileUtils.rm_rf(File.join(@dir, '_site'))
+      end
+
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec jekyll --auto --server
+          EOT
+        end
+      end
+
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec lighttpd -D -f lighttpd.conf
+          EOT
+        end
+      end
+
+      # Describes the resources required by the deployed application. Jekyll sites automatically
+      # require a port to serve content on.
+      def requirements
+        res = super
+          
+        # TODO: The clown should be able to automatically allocate listening ports
+        res['system-properties'] ||= {}
+        res['system-properties']['HTTPD_PORT'] = 3000
+        
+        res
+      end
+    end
+    
+    PROFILES << Jekyll
+  end
+end

data/lib/circus/profiles/make_base.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../base', __FILE__)
+
+module Circus
+  module Profiles
+    class MakeBase < Base
+      # Development preparation is the same as deployment
+      def prepare_for_dev(logger, run_dir)
+        prepare_for_deploy(logger, run_dir)
+      end
+
+      def prepare_for_deploy(logger, overlay_dir)
+        # Build the application
+        run_external(logger, 'Compile application', "cd #{@dir}; make")
+      end
+    end
+  end
+end

data/lib/circus/profiles/pure_py.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../python_base', __FILE__)
+
+module Circus
+  module Profiles
+    class PurePy < PythonBase
+      PUREPY_APP_PROPERTY='purepy-app'
+      
+      # Checks if this is a pure python application. Will accept the application if it 
+      # has a file named <name>.py, or has a 'purepy-app' property describing the entry point.
+      def self.accepts?(name, dir, props)
+        return true if props.include? PUREPY_APP_PROPERTY
+        return File.exists?(File.join(dir, "#{name}.py"))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+        
+        @py_script = props[PUREPY_APP_PROPERTY] || "#{name}.py"
+      end
+      
+      # The name of this profile
+      def name
+        "pure-py"
+      end
+
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec vendor/bin/python #{@py_script}
+          EOT
+        end
+      end
+
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec vendor/bin/python #{@py_script}
+          EOT
+        end
+      end
+    end
+    
+    PROFILES << PurePy
+  end
+end

data/lib/circus/profiles/pure_rb.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../ruby_base', __FILE__)
+
+module Circus
+  module Profiles
+    class PureRb < RubyBase
+      PURERB_APP_PROPERTY='purerb-app'
+      
+      # Checks if this is a pure ruby application. Will accept the application if it 
+      # has a file named <name>.rb, or has a 'purerb-app' property describing the entry point.
+      def self.accepts?(name, dir, props)
+        return true if props.include? PURERB_APP_PROPERTY
+        return File.exists?(File.join(dir, "#{name}.rb"))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+        
+        @rb_script = props[PURERB_APP_PROPERTY] || "#{name}.rb"
+      end
+      
+      # The name of this profile
+      def name
+        "pure-rb"
+      end
+
+      # Just run the script in development
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec ruby #{@rb_script}
+          EOT
+        end
+      end
+
+      # Install our gems and then run in deployment
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec ruby #{@rb_script}
+          EOT
+        end
+      end
+    end
+    
+    PROFILES << PureRb
+  end
+end

data/lib/circus/profiles/python_base.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../base', __FILE__)
+
+module Circus
+  module Profiles
+    class PythonBase < Base
+      # Development preparation is the same as deployment
+      def prepare_for_dev(logger, run_dir)
+        prepare_for_deploy(logger, run_dir)
+      end
+
+      def prepare_for_deploy(logger, overlay_dir)
+        # Build the virtualenv
+        if has_depsfile?
+          unless File.exists? "#{@dir}/vendor"
+            return false unless run_external(logger, "Create virtualenv", "cd #{@dir}; virtualenv --no-site-packages vendor")
+          end
+
+          File.read(depsfile_fn).lines.each do |dep|
+            return false unless run_external(logger, "Install dep #{dep}", 
+                "cd #{@dir}; vendor/bin/easy_install -q \"#{dep.strip}\"")
+          end
+
+          return false unless run_external(logger, "Make virtualenv relocatable", "cd #{@dir}; virtualenv --relocatable vendor")
+        end
+        
+        true
+      end
+
+      protected
+        def depsfile_fn
+          "#{@dir}/Pydeps"
+        end
+
+        def has_depsfile?
+          File.exists? depsfile_fn
+        end
+    end
+  end
+end

data/lib/circus/profiles/rack.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../ruby_base', __FILE__)
+
+module Circus
+  module Profiles
+    class Rack < RubyBase
+      RACKFILE_NAME='ruby-rackfile'
+      
+      # Checks if this is a rack applcation. Will accept the application if it has a config.ru, or if the
+      # properties describe the location of an alternative rack entry point.
+      def self.accepts?(name, dir, props)
+        return true if props.include? RACKFILE_NAME
+        return File.exists?(File.join(dir, 'config.ru'))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+        
+        @rackup_name = props[RACKFILE_NAME] || 'config.ru'
+      end
+      
+      # The name of this profile
+      def name
+        "rack"
+      end
+      
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec bundle exec thin -R #{@rackup_name} -p #{listen_port} start
+          EOT
+        end
+      end
+
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec bundle exec vendor/bin/thin -R #{@rackup_name} -p #{listen_port} start
+          EOT
+        end
+      end
+      
+      def extra_dirs
+        if has_gemfile?
+          ["#{@dir}/.bundle"]
+        else
+          []
+        end
+      end
+      
+      private
+        def listen_port
+          @props['web-app-port'] || 3000
+        end
+    end
+    
+    PROFILES << Rack
+  end
+end

data/lib/circus/profiles/ruby_base.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../base', __FILE__)
+require 'fileutils'
+require 'bundler/circus_util'
+
+module Circus
+  module Profiles
+    class RubyBase < Base
+      BUNDLER_TOOL=File.expand_path('../../../bundler/circus_bundler.rb', __FILE__)
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+      end
+
+      # No dev preparation required. Don't override dev_run_script_content, since it is the
+      # same as the deployment variant.
+      def prepare_for_dev(logger, run_dir); true; end
+
+      def prepare_for_deploy(logger, overlay_dir)
+        # Run the gem bundler if necessary
+        if has_gemfile?
+          logger.info("Bundling gems")
+          run_external(logger, 'gem bundling', "cd #{@dir}; ruby #{BUNDLER_TOOL}")
+        end
+        
+        true
+      end
+      
+      def cleanup_after_deploy(logger, overlay_dir)
+        Bundler::CircusUtil.unfix_external_paths(@dir)
+      end
+
+      def extra_dirs
+        if has_gemfile?
+          ["#{@dir}/.bundle"]
+        else
+          []
+        end
+      end
+
+      protected
+        def has_gemfile?
+          File.exists? "#{@dir}/Gemfile"
+        end
+
+        # class LoggingShell
+        #   def say(msg)
+        #     puts msg
+        #   end
+        # end
+    end
+  end
+end

data/lib/circus/profiles/shell.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../make_base', __FILE__)
+
+module Circus
+  module Profiles
+    class Shell < MakeBase
+      SHELL_APP_PROPERTY='shell-app'
+      
+      # Checks if this is a shell applcation. Will accept the application if it 
+      # has a file named <name>.sh, or has a 'shell-app' property describing the entry point.
+      def self.accepts?(name, dir, props)
+        return true if props.include? SHELL_APP_PROPERTY
+        return File.exists?(File.join(dir, "#{name}.sh"))
+      end
+      
+      def initialize(name, dir, props)
+        super(name, dir, props)
+        
+        @sh_script = props[SHELL_APP_PROPERTY] || "#{name}.sh"
+      end
+      
+      # The name of this profile
+      def name
+        "shell"
+      end
+      
+      def dev_run_script_content
+        shell_run_script do
+          <<-EOT
+          cd #{@dir}
+          exec sh #{@sh_script}
+          EOT
+        end
+      end
+
+      def deploy_run_script_content
+        shell_run_script do
+          <<-EOT
+          exec sh #{@sh_script}
+          EOT
+        end
+      end
+    end
+    
+    PROFILES << Shell
+  end
+end

data/lib/circus/profiles.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../profiles/base', __FILE__)
+require File.expand_path('../profiles/ruby_base', __FILE__)
+require File.expand_path('../profiles/rack', __FILE__)
+require File.expand_path('../profiles/pure_rb', __FILE__)
+require File.expand_path('../profiles/python_base', __FILE__)
+require File.expand_path('../profiles/pure_py', __FILE__)
+require File.expand_path('../profiles/make_base', __FILE__)
+require File.expand_path('../profiles/shell', __FILE__)
+require File.expand_path('../profiles/django', __FILE__)
+require File.expand_path('../profiles/jekyll', __FILE__)

data/lib/circus/repos/git.rb

@@ -0,0 +1,42 @@
+module Circus
+  module Repos
+    class Git
+      # Checks if the current directory (or a parent) are Git working trees. Uses
+      # a call to git remote to test (which will fail with a non-zero exit if the
+      # tree isn't a valid git tree)
+      def self.accepts_dir? dir_name
+        `git remote >/dev/null 2>/dev/null`
+        $? == 0
+      end
+      
+      def self.accepts_id?(key)
+        key == 'git'
+      end
+      
+      def self.type_id
+        'git'
+      end
+      
+      def initialize(dir)
+        @dir = dir
+      end
+      
+      def repo_url
+        first_remote = `(cd #{@dir}; git remote -v) | grep fetch`.lines.first
+        return nil unless first_remote
+        
+        first_remote.split(' ', 2)[1].gsub('(fetch)', '').strip
+      end
+      
+      def current_revision
+        `(cd #{@dir}; git rev-parse HEAD)`.strip
+      end
+      
+      def write_patch(patch_fn)
+        `(cd #{@dir}; git diff HEAD >#{patch_fn})`.strip
+      end
+    end
+    
+    REPOS << Git
+  end
+end

data/lib/circus/repos/mercurial.rb

@@ -0,0 +1,42 @@
+module Circus
+  module Repos
+    class Mercurial
+      # Checks if the current directory (or a parent) are Hg working trees. Uses
+      # a call to hg status to test (which will fail with a non-zero exit if the
+      # tree isn't a valid git tree)
+      def self.accepts_dir? dir_name
+        `hg st >/dev/null 2>/dev/null`
+        $? == 0
+      end
+      
+      def self.accepts_id?(key)
+        key == 'hg' || key == 'mercurial'
+      end
+      
+      def self.type_id
+        'hg'
+      end
+      
+      def initialize(dir)
+        @dir = dir
+      end
+      
+      def repo_url
+        first_path = `(cd #{@dir}; hg paths)`.lines.first
+        return nil unless first_path
+        
+        first_path.split('=', 2)[1].strip
+      end
+      
+      def current_revision
+        `(cd #{@dir}; hg id -i)`[0..11]
+      end
+      
+      def write_patch(patch_fn)
+        `(cd #{@dir}; hg diff >#{patch_fn})`.strip
+      end
+    end
+    
+    REPOS << Mercurial
+  end
+end