simonmenke-shuttle 0.1.07

data/app_generators/engine/engine_generator.rb

@@ -0,0 +1,39 @@
+class EngineGenerator < RubiGen::Base
+  attr_reader :engine_name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @destination_root = args.shift
+    @engine_name = File.basename(File.expand_path(@destination_root)).underscore
+  end
+  
+  def manifest
+    record do |m|
+      
+      m.directory "app/controllers"
+      m.directory "app/models"
+      m.directory "app/views"
+      m.directory "app/helpers"
+      m.directory "config"
+      m.directory "db/migrate"
+      m.directory "lib"
+      m.directory "public/images"
+      m.directory "public/javascripts"
+      m.directory "public/stylesheets"
+      m.directory "rails"
+      m.directory "tasks"
+      
+      m.template('config/routes.rb',        "config/routes.rb")
+      m.template('Gmfile',                  "Gmfile")
+      m.template('rails/init.rb',           "rails/init.rb")
+      m.template('init.rb',                 "init.rb")
+      m.template('tasks/engine_tasks.rake', "tasks/#{engine_name}_tasks.rake")
+      m.template('README.rdoc',             "README.rdoc")
+      m.template('MIT-LICENSE.txt',         "MIT-LICENSE.txt")
+      m.template('lib/engine.rb',           "lib/#{engine_name}.rb")
+      m.template('gitignore',               ".gitignore")
+      
+    end
+  end
+  
+end

data/app_generators/engine/templates/config/routes.rb

@@ -0,0 +1,2 @@
+ActionController::Routing::Routes.draw do |map|
+end

data/app_generators/engine/templates/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__)+'/rails/init'

data/app_generators/engine/templates/lib/engine.rb

@@ -0,0 +1 @@
+# <%= engine_name.camelize %>

data/app_generators/engine/templates/rails/init.rb

@@ -0,0 +1 @@
+# Include hook code here

data/bin/shuttle

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+begin
+  require File.dirname(__FILE__)+'/../lib/shuttle'
+rescue LoadError
+  require 'rubygems'
+  require 'shuttle'
+end
+
+module Shuttle
+  BIN_PATH = File.expand_path($PROGRAM_NAME)
+  ORIGINAL_ARGV = ARGV.dup
+end
+
+Shuttle::AppRunner.use :Server
+Shuttle::AppRunner.use :Satellite
+Shuttle::AppRunner.use :Engines
+Shuttle::AppRunner.use :Jobs
+Shuttle::AppRunner.use :Dev
+Shuttle::AppRunner.namespace = 'shuttle:apps'
+Shuttle::AppRunner.start

data/lib/rubygems_plugin.rb

@@ -0,0 +1 @@
+require 'shuttle/extentions/rubygems_plugin'

data/lib/shuttle/actor/actions.rb

@@ -0,0 +1,76 @@
+
+module Shuttle
+  class Actor
+    module Actions
+      
+      def self.included(base)
+        base.extend Shuttle::Actor::Actions::ClassMethods
+      end
+      
+      # run the callbacks registerd to <tt>action</tt>. the will run the <tt>before</tt>, <tt>on</tt> and <tt>after</tt> fases.
+      def run_callbacks!(action)
+        action = action.to_sym
+        run_callbacks_in_fase! action, :before
+        run_callbacks_in_fase! action, :on
+        run_callbacks_in_fase! action, :after
+      end
+      
+      # run the callbacks registerd to <tt>action</tt> in the +fase+
+      def run_callbacks_in_fase!(action, fase)
+        action = action.to_sym
+        fase   = fase.to_sym
+        self.class.methods_for(action, fase).each { |meth| self.send(meth) }
+      end
+      
+      module ClassMethods
+        
+        # register a callback to be run <tt>before</tt> the <tt>action</tt>.
+        def before(action, meth)
+          methods_for(action, :before).push(meth.to_sym)
+        end
+        
+        # register a callback to be run <tt>on</tt> the <tt>action</tt>.
+        def on(action, meth)
+          methods_for(action, :on).push(meth.to_sym)
+        end
+        
+        # register a callback to be run <tt>after</tt> the <tt>action</tt>.
+        def after(action, meth)
+          methods_for(action, :after).push(meth.to_sym)
+        end
+        
+        # get the registered callbacks for the +action+ and +face+.
+        def methods_for(action, fase)
+          action = action.to_sym
+          fase   = fase.to_sym
+          
+          @actions ||= {}
+          @actions[action] ||= {}
+          @actions[action][fase] ||= []
+          @actions[action][fase]
+        end
+        
+        # define one or more actions.
+        def action(*names)
+          names.each do |name|
+            module_eval %{
+              def self.before_#{name}(meth)
+                before(:#{name}, meth)
+              end
+              def self.on_#{name}(meth)
+                on(:#{name}, meth)
+              end
+              def self.after_#{name}(meth)
+                after(:#{name}, meth)
+              end
+              def run_#{name}_callbacks!
+                run_callbacks!(:#{name})
+              end
+            }
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/shuttle/actor.rb

@@ -0,0 +1,23 @@
+
+module Shuttle
+  
+  # The actor class provides the mechanisme for scheduling the execution of seperate tasks.
+  class Actor
+    
+    autoload :Actions, File.dirname(__FILE__)+'/actor/actions'
+    
+    include Shuttle::Actor::Actions
+    
+    attr_reader :system, :satellite
+    
+    action :install_satellite, :uninstall_satellite, :link_satellite
+    action :install_engine,    :uninstall_engine,    :update_engine
+    
+    # create a new actor for the provided system and satellite
+    def initialize(system, satellite)
+      @system    = system
+      @satellite = satellite
+    end
+    
+  end
+end

data/lib/shuttle/actors/apache_actor.rb

@@ -0,0 +1,56 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class ApacheActor < Shuttle::Actor
+      
+      on_install_satellite :write_config_file
+      after_install_satellite :restart
+      
+      on_uninstall_satellite :remove_config_file
+      after_uninstall_satellite :restart
+      
+      # restart the apache server
+      def restart
+        system.run "#{system.apachectl_path} -k restart"
+      end
+      
+      # write the vhost config file (needs apache restart)
+      def write_config_file
+        config = %{<VirtualHost *>
+  ServerName #{satellite.domain}
+  
+  ErrorLog   logs/#{satellite.domain}.error.log
+  CustomLog  logs/#{satellite.domain}.access.log common
+  DocumentRoot #{system.satellite_root}/public
+  <Directory "#{system.satellite_root}/public">
+    Options All
+    AllowOverride All
+    Order allow,deny
+    Allow from all
+  </Directory>
+</VirtualHost>}
+        File.open(system.apache_conf_path, 'w+') { |f| f.write config }
+      end
+      
+      # remove the vhost config file (needs apache restart)
+      def remove_config_file
+        File.unlink(system.apache_conf_path) if File.exist? system.apache_conf_path
+      end
+      
+      module Config
+        
+        # path to the apachectl tool
+        def apachectl_path(&block)
+          option(:apachectl_path, block) { |v| v or find_bin('apache2ctl', 'apachectl') }
+        end
+        
+        # path to the vhost specific config files
+        def apache_conf_path(&block)
+          satellite_option(:apache_conf_path, block) { |s,v| v or "/opt/local/apache2/conf/apps/#{s.domain}.conf" }
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/shuttle/actors/base_actor.rb

@@ -0,0 +1,276 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class BaseActor < Shuttle::Actor
+      
+      on_install_satellite   :create_rails_app
+      on_link_satellite      :link_engines
+      on_uninstall_satellite :destroy_rails_app
+      
+      # create a new rails app for the current satellite
+      def create_rails_app
+        system.as_user(system.web_user, system.web_group) do
+          FileUtils.mkdir_p(File.dirname(system.satellite_root), :verbose => true)
+          FileUtils.mkdir_p(system.shared_root, :verbose => true)
+        end
+        
+        Dir.chdir(File.dirname(system.satellite_root)) do
+          system.user_run system.web_user, "rails --force #{system.satellite_root}"
+        end
+        
+        system.as_user(system.web_user, system.web_group) do
+          Dir.chdir(File.dirname(system.satellite_root)) do
+            link(File.join(system.shared_root,    'public'),
+                 File.join(system.satellite_root, 'public', 'system'))
+            link(File.join(system.shared_root,    'private'),
+                 File.join(system.satellite_root, 'db', 'system'))
+            link(File.join(system.shared_root,    'log'),
+                 File.join(system.satellite_root, 'log'))
+            link(File.join(system.shared_root,    'settings'),
+                 File.join(system.satellite_root, 'config', 'settings'))
+          end
+          
+        end
+      end
+      
+      # destroy the rails app for the current satellite
+      def destroy_rails_app
+        FileUtils.rm_rf system.satellite_root, :verbose => true
+      end
+      
+      # link the required engines for the current satellite
+      def link_engines
+        Dir.chdir(system.satellite_root) do
+          system.as_user(system.web_user, system.web_group) do
+            
+            write_environment
+            clean_links
+            @dependecies.reverse_each do |spec|
+              link_engine(spec)
+            end
+            
+          end
+          run_migrations
+        end
+      end
+      
+    private
+      
+      def link(src, dst)
+        FileUtils.mkdir_p(File.dirname(dst), :verbose => true)
+        FileUtils.mkdir_p(src, :verbose => true)
+        FileUtils.rm_rf dst, :verbose => true
+        FileUtils.symlink(src, dst, :verbose => true)
+      end
+      
+      def write_environment
+        @dependecies = Shuttle::Satellite::DependencyLoader.load_for(satellite.engines)
+        @dependecies.engines
+        
+        rails_header = "Rails::Initializer.run do |config|\n"
+        gems_header  = "  # Gems added by engine_manager:\n  \n"
+        
+        gsub_file('config/environment.rb') do |content|
+          content.gsub! /^\s*config.gem.+\n/, ''
+          content.gsub! %r{#{Regexp.escape(rails_header)}(#{Regexp.escape(gems_header)})?},
+            "#{rails_header}#{gems_header}"
+          
+          @dependecies.reverse_each do |spec|
+            gem_options = @dependecies.engines[spec.name] || {}
+            content.gsub! "engine_manager:\n",
+              "engine_manager:\n  config.gem #{spec.name.inspect}, #{gem_options.inspect}\n"
+          end
+        end
+      end
+      
+      def link_engine(spec)
+        Shuttle.log "linking: #{spec.name}..."
+        path = File.join(spec.full_gem_path, 'public')
+        if File.directory?(path)
+          FileUtils.mkdir_p('public/vendor', :verbose => true)
+          FileUtils.ln_s(path, "public/vendor/#{spec.name}", :verbose => true)
+        end
+        
+        path = File.join(spec.full_gem_path, 'tasks')
+        if File.directory?(path)
+          FileUtils.mkdir_p("lib/tasks/vendor/#{spec.name}", :verbose => true)
+          Dir.glob("#{path}/*.rake").each do |rake_file|
+            FileUtils.ln_s(rake_file,
+              "lib/tasks/vendor/#{spec.name}/#{File.basename(rake_file)}", :verbose => true)
+          end
+        end
+        
+        path = File.join(spec.full_gem_path, 'db', 'migrate')
+        if File.directory?(path)
+          FileUtils.mkdir_p("db/migrate", :verbose => true)
+          unlinked_migrations.concat(Dir.glob("#{path}/*.rb"))
+          linked_migrations.each do |migration, target|
+            if target.starts_with? spec.full_gem_path
+              unlinked_migrations.delete(target)
+              unused_migrations.delete(migration)
+            end
+          end
+        end
+      end
+      
+      def clean_links
+        FileUtils.rm_rf("lib/tasks/vendor", :verbose => true)
+        FileUtils.rm_rf("public/vendor", :verbose => true)
+      end
+      
+      def run_migrations
+        Shuttle.log "running your migrations..." unless unlinked_migrations.empty? and unused_migrations.empty?
+        
+        unlinked_migration_targets = unlinked_migrations.collect{ |migration|
+          File.basename(migration) }
+        
+        unused_migrations.each do |migration, target|
+          unless unlinked_migration_targets.include? File.basename(migration)
+            migration =~ /(\d+)_[^.]+\.rb/
+            system.user_run(system.web_user, "cd #{system.satellite_root} ; rake db:migrate:down RAILS_ENV=#{system.rails_environment} VERSION=#{$1}")
+          end
+          FileUtils.rm_rf(migration, :verbose => true)
+        end
+        system.as_user(system.web_user, system.web_group) do
+          unlinked_migrations.each do |migration|
+            FileUtils.ln_s(migration, "db/migrate/#{File.basename(migration)}", :verbose => true)
+          end
+        end
+        
+        unless unlinked_migrations.empty?
+          system.user_run(system.web_user, "cd #{system.satellite_root} ; rake db:migrate RAILS_ENV=#{system.rails_environment}")
+        end
+      end
+      
+      def gsub_file(path, pattern=nil, replace=nil, &block)
+        if File.exist? path
+          content = File.read(path)
+          if block
+            block.call(content)
+          else
+            return false unless content.gsub!(pattern, replace)
+          end
+          File.open(path, 'w+') { |f| f.write content }
+        end
+      end
+      
+      def linked_migrations
+        @linked_migrations ||= Dir.glob('db/migrate/*.rb').select { |migration| File.symlink?(migration) }.inject({}) { |m, migration| m[migration] = File.readlink(migration) ; m }
+      end
+      
+      def unused_migrations
+        @unused_migrations ||= linked_migrations.dup
+      end
+      
+      def unlinked_migrations
+        @unlinked_migrations ||= []
+      end
+      
+      module Helper
+        
+        # install a gem.
+        def gem_install(name, options={})
+          gem_cmd('install', name, options)
+        end
+        
+        # check if a gem is installed
+        def gem_installed(name, options)
+          version = options[:version] || '0.0.0'
+          options = { :version => version, :installed => true }
+          (gem_cmd('list', name, options).strip == 'true')
+        end
+        
+        # update a gem
+        def gem_update(name, options={})
+          !(gem_cmd('update', name, options) =~ /Nothing to update/)
+        end
+        
+        # ensure the presence of a gem
+        def ensure_presence_of_gem(name, options={})
+          if !gem_installed(name, options)
+            gem_install(name, options)
+          end
+        end
+        
+      private
+        
+        def gem_cmd(cmd, args, options={})
+          user   = options.delete(:user)
+          user ||= (install_gems_with_web_user ?  web_user : system_user)
+          
+          args = [args].flatten.compact
+          args.collect! { |a| (a and a.inspect) || '' }
+          args += options.map do |k,v|
+            if TrueClass === v
+              "--#{k}"
+            else
+              "--#{k}=#{v.inspect}"
+            end
+          end
+          output = user_run(user, "#{gem_bin_path} #{cmd} #{args.join(' ')}")
+          Gem.refresh
+          output
+        end
+        
+      end
+      
+      module Config
+        
+        # set the path to the ruby executable.
+        def ruby_path(&block)
+          option(:ruby_path, block) { |s, v| v or find_bin('ruby', 'ruby1.8', 'ruby18') }
+        end
+        
+        # set the path to the gem executable.
+        def gem_bin_path(&block)
+          option(:gem_bin_path, block) { |s, v| v or find_bin('gem', 'gem1.8', 'gem18') }
+        end
+        
+        # set the path to the rails executable.
+        def rails_path(&block)
+          option(:rails_path, block) do |v|
+            user = (install_gems_with_web_user ?  web_user : system_user)
+            v or user_find_bin(user, 'rails')
+          end
+        end
+        
+        # set the owner group of the current satellite.
+        def web_group(&block)
+          satellite_option(:web_group, block)
+        end
+        
+        # set the owner of the current satellite.
+        def web_user(&block)
+          satellite_option(:web_user, block)
+        end
+        
+        # set the system user (the user which runs the shuttle server).
+        def system_user(&block)
+          option(:system_user, block) { |v| v or 'root' }
+        end
+        
+        # set whether gems should be installed with the web user.
+        def install_gems_with_web_user(&block)
+          option(:install_gems_with_web_user, block)
+        end
+        
+        # set the path to the satellite's root path
+        def satellite_root(&block)
+          satellite_option(:satellite_root, block)
+        end
+        
+        # set the path to the satellite's shared path
+        def shared_root(&block)
+          satellite_option(:shared_root, block)
+        end
+        
+        # set the rails environment.
+        def rails_environment(&block)
+          satellite_option(:rails_environment, block) { |s,v| v or 'development' }
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/shuttle/actors/mysql_actor.rb

@@ -0,0 +1,20 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class MysqlActor < Shuttle::Actor
+      
+      on_install_satellite       :create_database
+      before_uninstall_satellite :backup_database
+      on_uninstall_satellite     :drop_database
+      
+      def create_database
+        
+      end
+      
+      def drop_database
+        
+      end
+      
+    end
+  end
+end

data/lib/shuttle/actors/passenger_actor.rb

@@ -0,0 +1,19 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class PassengerActor < Shuttle::Actor
+      
+      after_install_satellite   :restart
+      after_link_satellite      :restart
+      
+      # restart the current satellite.
+      def restart
+        system.as_user(system.web_user, system.web_group) do
+          tmp_restart = File.join(system.satellite_root, 'tmp', 'restart.txt')
+          FileUtils.touch tmp_restart, :verbose => true
+        end
+      end
+      
+    end
+  end
+end