simonmenke-shuttle 0.1.07

data/lib/shuttle/actors/plesk_actor.rb

@@ -0,0 +1,210 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class PleskActor < Shuttle::Actor
+      
+      before_install_satellite   :create_client
+      before_install_satellite   :create_domain
+      after_install_satellite    :link_htdocs
+      after_install_satellite    :reload_subdomains
+      after_install_satellite    :restart_apache
+      on_install_satellite       :create_database
+      on_uninstall_satellite     :drop_databases
+      
+      def create_client
+        # only do this if this is needed
+        if false
+          unless system.client?(system.plesk_client)
+            system.create_client(system.plesk_client, system.plesk_client, 'mypwd')
+          end
+        end
+      end
+      
+      def create_domain
+        unless system.domain?(satellite.basedomain)
+          system.create_domain(system.plesk_client, satellite.basedomain,
+            system.web_user[0,20], (rand(1_000_000_000) + 10_000).to_s)
+        else
+          httpdocs_path = "/var/www/vhosts/#{satellite.basedomain}/httpdocs"
+          system.set_satellite_option(:web_user,
+            system.get_user_name(File.stat(httpdocs_path).uid))
+        end
+          
+        if satellite.subdomain? and !system.subdomain?(satellite.basedomain, satellite.subdomain)
+          system.create_subdomain(satellite.basedomain, satellite.subdomain)
+        end
+        
+        FileUtils.mkdir_p(system.satellite_root)
+        FileUtils.mkdir_p(system.shared_root)
+        FileUtils.chown_R(system.web_user, system.web_group, system.satellite_root)
+        FileUtils.chown_R(system.web_user, system.web_group, system.shared_root)
+      end
+      
+      def link_htdocs
+        httpdocs_path = File.join(File.dirname(system.satellite_root), 'httpdocs')
+        FileUtils.rm_rf(httpdocs_path)
+        FileUtils.ln_s(system.satellite_root, httpdocs_path)
+        FileUtils.chown_R(system.web_user, system.web_group, httpdocs_path)
+        
+        File.open(File.join(system.satellite_root, '../conf/vhost.conf'), 'w+') do |f|
+          f.puts "DocumentRoot #{httpdocs_path}/public"
+        end
+      end
+      
+      def reload_subdomains
+        system.run("#{system.plesk_websrvmng_bin} --reconfigure-vhost --vhost-name=#{satellite.basedomain}")
+      end
+      
+      def restart_apache
+        system.run("#{system.plesk_httpd_bin} restart")
+      end
+      
+      def create_database
+        db_name = satellite.domain.downcase.gsub(/[^a-z]+/, '_')[0,63]
+        db_user = db_name[0,13]
+        db_pswd = (rand(1_000_000_000) + 10_000).to_s
+        
+        system.create_database(satellite.basedomain, "#{db_name}_d", "#{db_user}_ud", db_pswd)
+        system.create_database(satellite.basedomain, "#{db_name}_t", "#{db_user}_ut", db_pswd)
+        system.create_database(satellite.basedomain, "#{db_name}_p", "#{db_user}_up", db_pswd)
+        
+        
+        system.as_user(system.web_user, system.web_group) do
+          config = %{
+development:
+  adapter: mysql
+  database: #{db_name}_d
+  username: #{db_user}_ud
+  password: #{db_pswd}
+  host: localhost
+  encoding: utf8
+  socket: /var/lib/mysql/mysql.sock
+
+test:
+  adapter: mysql
+  database: #{db_name}_t
+  username: #{db_user}_ut
+  password: #{db_pswd}
+  host: localhost
+  encoding: utf8
+  socket: /var/lib/mysql/mysql.sock
+
+production:
+  adapter: mysql
+  database: #{db_name}_p
+  username: #{db_user}_up
+  password: #{db_pswd}
+  host: localhost
+  encoding: utf8
+  socket: /var/lib/mysql/mysql.sock
+}
+          
+          db_file = File.join(system.satellite_root, 'config', 'database.yml')
+          File.open(db_file, 'w+') { |f| f.write config }
+        end
+      end
+      
+      def drop_databases
+        db_name = satellite.domain.downcase.gsub(/[^a-z]+/, '_')[0,63]
+        
+        system.drop_database("#{db_name}_d")
+        system.drop_database("#{db_name}_t")
+        system.drop_database("#{db_name}_p")
+      end
+      
+      module Helper
+        
+        def create_client(name, login, pwd)
+          
+        end
+        
+        # check is the client exists
+        def client?(login)
+          !(run("#{plesk_client_bin} -i #{login}") =~ /Object not found: Client/)
+        end
+        
+        # create a domain through plesk
+        def create_domain(client, domain, user, passwd)
+          run("#{plesk_domain_bin} -c #{domain} -clogin #{client} -status enabled -hosting true -hst_type phys -dns true -www true -login #{user} -passwd #{passwd} -shell /bin/bash")
+        end
+        
+        #  check if a domain exists with plesk
+        def domain?(domain)
+          !(run("#{plesk_domain_bin} -i #{domain}") =~ /Object not found: Domain/)
+        end
+        
+        # create a subdomain through plesk
+        def create_subdomain(basedomain, subdomain)
+          run("#{plesk_subdomain_bin} -c #{subdomain} -d #{basedomain}")
+        end
+        
+        #  check if a subdomain exists with plesk
+        def subdomain?(basedomain, subdomain)
+          run("#{plesk_subdomain_bin} -i -s #{subdomain} -d #{basedomain}") =~ /SUCCESS: Gathering/
+        end
+        
+        # create a database through plesk
+        def create_database(basedomain, db_name, db_user, pwd)
+          o = run("#{plesk_database_bin} -c #{db_name} -domain #{basedomain} -server #{plesk_database_server} -add_user #{db_user} -passwd #{pwd}")
+          if o =~ /Database with requested name already exists/
+            o = run("#{plesk_database_bin} -u #{db_name} -add_user #{db_user} -passwd #{pwd}")
+            if o =~ /Unable to create database user: User/
+              o = run("#{plesk_database_bin} -u #{db_name} -update_user #{db_user} -passwd #{pwd}")
+            end
+          end
+        end
+        
+        # drop a database through plesk
+        def drop_database(db_name)
+          run("#{plesk_database_bin} -r #{db_name}")
+        end
+        
+      end
+      
+      module Config
+        
+        # set the plesk client to be used for this satellite.
+        def plesk_client(&block)
+          satellite_option(:plesk_client, block)
+        end
+        
+        # path to the client tool.
+        def plesk_client_bin(&block)
+          option(:plesk_client_bin, block) { |v| v or '/usr/local/psa/bin/client' }
+        end
+        
+        # path to the domain tool.
+        def plesk_domain_bin(&block)
+          option(:plesk_domain_bin, block) { |v| v or '/usr/local/psa/bin/domain' }
+        end
+        
+        # path to the subdomain tool.
+        def plesk_subdomain_bin(&block)
+          option(:plesk_subdomain_bin, block) { |v| v or '/usr/local/psa/bin/subdomain' }
+        end
+        
+        # path to the database tool.
+        def plesk_database_bin(&block)
+          option(:plesk_database_bin, block) { |v| v or '/usr/local/psa/bin/database' }
+        end
+        
+        # path to the websrvmng tool.
+        def plesk_websrvmng_bin(&block)
+          option(:plesk_websrvmng_bin, block) { |v| v or '/usr/local/psa/admin/sbin/websrvmng' }
+        end
+        
+        # path to the httpd tool.
+        def plesk_httpd_bin(&block)
+          option(:plesk_httpd_bin, block) { |v| v or '/etc/init.d/httpd' }
+        end
+        
+        # host and port of database server.
+        def plesk_database_server(&block)
+          option(:plesk_database_server, block)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/shuttle/actors/sqlite3_actor.rb

@@ -0,0 +1,44 @@
+
+module Shuttle
+  module Actors # :nodoc:
+    class Sqlite3Actor < Shuttle::Actor
+      
+      after_install_satellite :write_config_file
+      
+      # write the +database.yml+ config file.
+      def write_config_file
+        system.as_user(system.web_user, system.web_group) do
+          
+          config = %{# SQLite version 3.x
+#   gem install sqlite3-ruby (not necessary on OS X Leopard)
+development:
+  adapter: sqlite3
+  database: db/system/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/system/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/system/production.sqlite3
+  pool: 5
+  timeout: 5000
+}
+          
+          db_file = File.join(system.satellite_root, 'config', 'database.yml')
+          File.open(db_file, 'w+') { |f| f.write config }
+          
+        end
+      end
+      
+    end
+  end
+end

data/lib/shuttle/app_runner.rb

@@ -0,0 +1,118 @@
+require 'thor'
+require File.dirname(__FILE__)+'/extentions/thor_extentions'
+
+module Shuttle
+  
+  # AppRunner allows us to have multiple apps in different namespaces
+  class AppRunner < Thor
+    
+    # register a subapplication with the app runner.
+    def self.use(app)
+      Shuttle::Apps.const_get(app)
+    end
+    
+    # Override Thor#help so we can give info about not-yet-loaded tasks
+    def help(task = nil)
+      super
+      
+      unless task
+        search = ".*#{search}" if options["substring"]
+        search = /^#{search}.*/i
+        group  = options[:group] || "standard"
+        
+        classes = Thor.subclasses.select do |k|
+          (options[:all] || k.group_name == group) && 
+          Thor::Util.constant_to_thor_path(k.name) =~ search
+        end
+        display_klasses(false, classes)
+      end
+    end
+    
+    # forward actions to the sub apps
+    def method_missing(meth, *args)
+      meth = meth.to_s
+      super(meth.to_sym, *args) unless meth.include?(?:)
+      
+      begin
+        task = Thor[meth]
+        task.parse(task.klass.new, ARGV[1..-1])
+      rescue => e
+        puts e.message
+      end
+    end
+    
+    private
+    
+    def display_klasses(with_modules = false, klasses = Thor.subclasses)
+      klasses -= [Thor, Shuttle::AppRunner] unless with_modules
+      raise Error, "No Thor tasks available" if klasses.empty?
+      
+      if with_modules && !thor_yaml.empty?
+        max_name = thor_yaml.max { |(xk, xv), (yk, yv)| xk.to_s.size <=> yk.to_s.size }.first.size
+        modules_label    = "Modules"
+        namespaces_label = "Namespaces"
+        column_width     = [max_name + 4, modules_label.size + 1].max
+        
+        print "%-#{column_width}s" % modules_label
+        puts namespaces_label
+        print "%-#{column_width}s" % ("-" * modules_label.size)
+        puts "-" * namespaces_label.size
+        
+        thor_yaml.each do |name, info|
+          print "%-#{column_width}s" % name
+          puts info[:constants].map { |c| Thor::Util.constant_to_thor_path(c) }.join(", ")
+        end
+      
+        puts
+      end
+      
+      # Calculate the largest base class name
+      max_base = klasses.max do |x,y| 
+        Thor::Util.constant_to_thor_path(x.name).size <=> Thor::Util.constant_to_thor_path(y.name).size
+      end.name.size
+      
+      # Calculate the size of the largest option description
+      max_left_item = klasses.max do |x,y| 
+        (x.maxima.usage + x.maxima.opt).to_i <=> (y.maxima.usage + y.maxima.opt).to_i
+      end
+      
+      max_left = max_left_item.maxima.usage + max_left_item.maxima.opt
+      
+      unless klasses.empty?
+        puts # add some spacing
+        klasses.each { |k| display_tasks(k, max_base, max_left); }
+      else
+        puts "\033[1;34mNo Thor tasks available\033[0m"
+      end
+    end  
+    
+    def display_tasks(klass, max_base, max_left)
+      if klass.tasks.values.length > 1
+        
+        base = Thor::Util.constant_to_thor_path(klass.name)
+        
+        if base.to_a.empty?
+          base = 'default' 
+          puts "\033[1;35m#{base}\033[0m"
+        else
+          puts "\033[1;34m#{base}\033[0m"
+        end
+    
+        puts "-" * base.length
+        
+        klass.tasks.each true do |name, task|
+          format_string = "%-#{max_left + max_base + 5}s"
+          print format_string % task.formatted_usage(true)
+          puts task.description
+        end
+        
+        unless klass.opts.empty?
+          puts "\nglobal options: #{Options.new(klass.opts)}"
+        end
+        
+        puts # add some spacing
+      end
+    end
+    
+  end
+end

data/lib/shuttle/apps/dev.rb

@@ -0,0 +1,27 @@
+require 'thor'
+
+module Shuttle
+  module Apps # :nodoc:
+    
+    class Dev < Thor
+      desc "create NAME", "create a new engine"
+      def create(name)
+        require 'rubigen'
+        system("rails #{name}")
+        
+        FileUtils.rm_r("#{name}/doc", :verbose => true)
+        FileUtils.rm_r("#{name}/README", :verbose => true)
+        FileUtils.rm_r("#{name}/public/javascripts", :verbose => true)
+        
+        require 'rubigen/scripts/generate'
+        RubiGen::Base.use_application_sources!
+        RubiGen::Scripts::Generate.new.run(["-f", name], :generator => 'engine')
+      end
+      
+      desc "link", "link the current development app"
+      def link
+      end
+    end
+    
+  end
+end

data/lib/shuttle/apps/engines.rb

@@ -0,0 +1,33 @@
+require 'thor'
+
+module Shuttle
+  module Apps # :nodoc:
+    
+    class Engines < Thor
+      desc 'install DOMAIN NAME', 'install an engine'
+      method_options :version => :required, :lib => :optional, :source => :optional, :token => :optional
+      def install(domain, name)
+        desc = { :version => options[:version] }
+        desc[:lib]    = options[:lib]    if options[:lib]
+        desc[:source] = options[:source] if options[:source]
+        Shuttle.client(options[:token]).install_engine(domain, name, desc)
+      end
+      
+      desc 'update DOMAIN NAME', 'update an engine'
+      method_options :version => :required, :lib => :optional, :source => :optional, :token => :optional
+      def update(domain, name)
+        desc = { :version => options[:version] }
+        desc[:lib]    = options[:lib]    if options[:lib]
+        desc[:source] = options[:source] if options[:source]
+        Shuttle.client(options[:token]).update_engine(domain, name, desc)
+      end
+      
+      desc 'uninstall DOMAIN NAME', 'uninstall an engine'
+      method_options :token => :optional
+      def uninstall(domain, name)
+        Shuttle.client(options[:token]).uninstall_engine(domain, name)
+      end
+    end
+    
+  end
+end

data/lib/shuttle/apps/jobs.rb

@@ -0,0 +1,35 @@
+require 'thor'
+
+module Shuttle
+  module Apps
+    class Jobs < Thor
+      
+      desc "list", 'list the jobs in the queue'
+      method_options :token => :optional
+      def list
+        queued_jobs = Shuttle.client(options[:token]).queued_jobs
+        queued_jobs.each do |id, name, canceled, immediated, running, waiting, delay|
+          status = []
+          status.push canceled   ? 'c' : ' '
+          status.push immediated ? 'i' : ' '
+          status.push running    ? 'r' : ' '
+          status.push waiting    ? 'w' : ' '
+          puts("% 8d  % 8d  % 8s  %s" % [id, delay.to_i, status.join, name])
+        end
+      end
+      
+      desc "cancel ID", 'cancel the job with ID'
+      method_options :token => :optional
+      def cancel(id)
+        Shuttle.client(options[:token]).cancel_job(id.to_i)
+      end
+      
+      desc "immediate ID", 'immediately run the job with ID'
+      method_options :token => :optional
+      def immediate(id)
+        Shuttle.client(options[:token]).immediate_job(id.to_i)
+      end
+      
+    end
+  end
+end

data/lib/shuttle/apps/satellite.rb

@@ -0,0 +1,32 @@
+require 'thor'
+
+module Shuttle
+  module Apps # :nodoc:
+    
+    class Satellite < Thor
+      desc 'list', 'show all managed satellites'
+      method_options :token => :optional
+      def list
+        Shuttle.client(options[:token]).satellites.each do |sat|
+          puts sat.domain
+          sat.engines.each do |name, options|
+            puts "- #{name} #{options.inspect}"
+          end
+        end
+      end
+      
+      desc 'install DOMAIN', 'install a satellite'
+      method_options :token => :optional
+      def install(domain)
+        Shuttle.client(options[:token]).install_satellite(domain)
+      end
+      
+      desc 'uninstall DOMAIN', 'uninstall a satellite'
+      method_options :token => :optional
+      def uninstall(domain)
+        Shuttle.client(options[:token]).uninstall_satellite(domain)
+      end
+    end
+    
+  end
+end

data/lib/shuttle/apps/server.rb

@@ -0,0 +1,70 @@
+require 'thor'
+require 'simple-daemon'
+
+module Shuttle
+  module Apps
+    
+    class Server < Thor
+      
+      desc "start", 'start the server'
+      method_options :foreground => :boolean,  :config => :optional
+      def start
+        Shuttle.server? true
+        Shuttle::System.load!(options[:root_path])
+        
+        begin
+          FileUtils.mkdir_p(Shuttle.system.root)
+        rescue Errno::EACCES
+          Shuttle.logger.out.fatal "must be executed as root"
+          exit(1)
+        end
+        
+        unless Shuttle.system.is_user('root')
+          Shuttle.logger.out.fatal "must be executed as root"
+          exit(1)
+        end
+        
+        SimpleDaemon.const_set 'WORKING_DIRECTORY', Shuttle.system.root
+        if options[:foreground]
+          Shuttle::Server.start
+        else
+          ARGV.clear and ARGV.concat(%w( start ))
+          Shuttle::Server.daemonize
+        end
+      end
+      
+      desc "stop", 'stop the server'
+      method_options :token => :optional
+      def stop
+        Shuttle.client(options[:token]).stop_server
+      end
+      
+      desc "restart", 'restart the server'
+      method_options :token => :optional
+      def restart
+        Shuttle.client(options[:token]).restart_server
+      end
+      
+      desc "reload", 'reload the server'
+      method_options :token => :optional
+      def reload
+        Shuttle.client(options[:token]).reload_server
+      end
+      
+      desc "update", 'update the shuttle'
+      method_options :token => :optional
+      def update
+        Shuttle.client(options[:token]).update_server
+      end
+      
+      desc "version", 'version of the server'
+      method_options :token => :optional
+      def version
+        puts "Client: #{Shuttle.version}"
+        puts "Server: #{Shuttle.client(options[:token]).server_version}"
+      end
+      
+    end
+    
+  end
+end

data/lib/shuttle/client/auth_token.rb

@@ -0,0 +1,98 @@
+require 'yaml'
+
+module Shuttle
+  class Client
+    class AuthToken
+      
+      # load a token from the passed IO.
+      def self.load(io)
+        self.new YAML.load(io)
+      end
+      
+      # load a token from a file referenced by the given +path+.
+      def self.load_file(path)
+        self.new YAML.load_file(path)
+      end
+      
+      # the uri at which the shuttle server can be accessed.
+      attr_reader :target_uri
+      # the SSL verification mode used by the shuttle server
+      attr_reader :verify_mode
+      # the optional CA certificate used by the shuttle server
+      attr_reader :ca_certificate_data
+      # the private key used by the client
+      attr_reader :private_key_data
+      # the certificate used by the client
+      attr_reader :certificate_data
+      
+      # create a new token from the given options
+      #
+      # +:target_uri+, +:verify_mode+, +:ca_certificate_data+, +:private_key_data+, +:certificate_data+
+      def initialize(options={})
+        @target_uri          = options[:target_uri]
+        @verify_mode         = options[:verify_mode]
+        @ca_certificate_data = options[:ca_certificate_data]
+        @private_key_data    = options[:private_key_data]
+        @certificate_data    = options[:certificate_data]
+      end
+      
+      # get the parsed and initialized OpenSSL::X509::Certificate
+      def ca_certificate
+        @ca_certificate ||= OpenSSL::X509::Certificate.new(@ca_certificate_data)
+      end
+      
+      # get the parsed and initialized OpenSSL::X509::Certificate
+      def certificate
+        @certificate ||= OpenSSL::X509::Certificate.new(@certificate_data)
+      end
+      
+      # get the parsed and initialized OpenSSL::PKey::RSA
+      def private_key
+        @private_key ||= OpenSSL::PKey::RSA.new(@private_key_data)
+      end
+      
+      # connect to the server and return the server handle.
+      def connect
+        use_ssl, uri = Shuttle::Client.parse_uri(self.target_uri)
+        if use_ssl
+          DRb.start_service nil, nil, self.options_for_drb
+        else
+          DRb.start_service
+        end
+        DRbObject.new nil, uri
+      end
+      
+      # return options for use with DRb
+      def options_for_drb
+        @options_for_drb ||= {
+          :SSLVerifyMode => self.verify_mode,
+          :SSLCACertificate => self.ca_certificate,
+          :SSLPrivateKey => self.private_key,
+          :SSLCertificate => self.certificate
+        }
+      end
+      
+      # dump this token to the given IO or return the content as a String
+      def dump(io=nil)
+        data = {
+          :target_uri => self.target_uri,
+          :verify_mode => self.verify_mode,
+          :ca_certificate_data => self.ca_certificate_data,
+          :private_key_data => self.private_key_data,
+          :certificate_data => self.certificate_data
+        }
+        if io
+          io.write YAML.dump(data)
+        else
+          YAML.dump(data)
+        end
+      end
+      
+      # dump this token to a file at the given +path+.
+      def dump_file(path)
+        File.open(path, 'w+') { |f| dump(f) }
+      end
+      
+    end
+  end
+end