capricorn 0.2.00

data/lib/capricorn/actors/mysql_actor.rb

@@ -0,0 +1,20 @@
+
+module Capricorn
+  module Actors # :nodoc:
+    class MysqlActor < Capricorn::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/capricorn/actors/passenger_actor.rb

@@ -0,0 +1,19 @@
+
+module Capricorn
+  module Actors # :nodoc:
+    class PassengerActor < Capricorn::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

data/lib/capricorn/actors/plesk_actor.rb

@@ -0,0 +1,210 @@
+
+module Capricorn
+  module Actors # :nodoc:
+    class PleskActor < Capricorn::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/capricorn/actors/sqlite3_actor.rb

@@ -0,0 +1,44 @@
+
+module Capricorn
+  module Actors # :nodoc:
+    class Sqlite3Actor < Capricorn::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/capricorn/app_runner.rb

@@ -0,0 +1,119 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+require File.dirname(__FILE__)+'/extentions/thor_extentions'
+
+module Capricorn
+  
+  # AppRunner allows us to have multiple apps in different namespaces
+  class AppRunner < Thor
+    
+    # register a subapplication with the app runner.
+    def self.use(app)
+      Capricorn::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, Capricorn::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/capricorn/apps/dev.rb

@@ -0,0 +1,15 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+module Capricorn
+  module Apps # :nodoc:
+    
+    class Dev < Thor
+      desc "activate DOMAIN", "turn an existing satelite into a development satelite"
+      def activate(domain)
+        Capricorn.runtime_gem('rubigen', Capricorn::RUBIGEN_VERSION)
+        Capricorn.client.make_development_satellite(domain)
+      end
+    end
+    
+  end
+end

data/lib/capricorn/apps/engines.rb

@@ -0,0 +1,33 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+module Capricorn
+  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]
+        Capricorn.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]
+        Capricorn.client(options[:token]).update_engine(domain, name, desc)
+      end
+      
+      desc 'uninstall DOMAIN NAME', 'uninstall an engine'
+      method_options :token => :optional
+      def uninstall(domain, name)
+        Capricorn.client(options[:token]).uninstall_engine(domain, name)
+      end
+    end
+    
+  end
+end