capricorn 0.2.00

data/lib/capricorn/apps/jobs.rb

@@ -0,0 +1,35 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+module Capricorn
+  module Apps
+    class Jobs < Thor
+      
+      desc "list", 'list the jobs in the queue'
+      method_options :token => :optional
+      def list
+        queued_jobs = Capricorn.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)
+        Capricorn.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)
+        Capricorn.client(options[:token]).immediate_job(id.to_i)
+      end
+      
+    end
+  end
+end

data/lib/capricorn/apps/satellite.rb

@@ -0,0 +1,32 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+module Capricorn
+  module Apps # :nodoc:
+    
+    class Satellite < Thor
+      desc 'list', 'show all managed satellites'
+      method_options :token => :optional
+      def list
+        Capricorn.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)
+        Capricorn.client(options[:token]).install_satellite(domain)
+      end
+      
+      desc 'uninstall DOMAIN', 'uninstall a satellite'
+      method_options :token => :optional
+      def uninstall(domain)
+        Capricorn.client(options[:token]).uninstall_satellite(domain)
+      end
+    end
+    
+  end
+end

data/lib/capricorn/apps/server.rb

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

data/lib/capricorn/client.rb

@@ -0,0 +1,48 @@
+require 'drb'
+require 'drb/ssl'
+require 'uri'
+
+module Capricorn
+  class Client
+    
+    autoload :AuthToken, File.dirname(__FILE__)+'/client/auth_token'
+    
+    # return a DRb uri for the given Capricorn uri.
+    def self.parse_uri(uri)
+      uri     = URI.parse(uri)
+      use_ssl = (uri.scheme == 'ssl+capricorn')
+      uri.scheme = 'druby'
+      return use_ssl, uri.to_s
+    end
+    
+    # return an potentialy initialize the client to the given token.
+    def self.current(token=nil)
+      @client = connect(token) unless @client
+      @client
+    end
+    
+    # connect to the server referenced by the given token.
+    def self.connect(token=nil)
+      token ||= 'core.token'
+      
+      [Capricorn::DEFAULT_ROOT_SYSTEM_DIR,
+       Capricorn::DEFAULT_USER_SYSTEM_DIR,
+       File.join(Capricorn::DEFAULT_USER_SYSTEM_DIR, 'tokens'),
+       '.'].each do |path|
+        path = File.expand_path(File.join(path, token))
+        if File.file? path
+          token = path
+          break
+        end
+      end
+      
+      unless File.file? token
+        raise "Unable to read the token at: #{token}"
+      end
+      
+      token = Capricorn::Client::AuthToken.load_file(token) if String === token
+      token.connect if token
+    end
+    
+  end
+end

data/lib/capricorn/client/auth_token.rb

@@ -0,0 +1,98 @@
+require 'yaml'
+
+module Capricorn
+  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 capricorn server can be accessed.
+      attr_reader :target_uri
+      # the SSL verification mode used by the capricorn server
+      attr_reader :verify_mode
+      # the optional CA certificate used by the capricorn 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 = Capricorn::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

data/lib/capricorn/daemon.rb

@@ -0,0 +1,71 @@
+
+module Capricorn
+  module Daemon
+    class Base
+      
+      def self.daemonize(&block)
+        Capricorn::Daemon::Controller.start(self,&block)
+      end
+      
+    end
+  
+    module PidFile
+      def self.store(pid)
+        File.open(self.pid_file, 'w') {|f| f << pid}
+      end
+  
+      def self.recall
+        IO.read(self.pid_file).to_i rescue nil
+      end
+      
+      def self.destroy
+        FileUtils.rm(self.pid_file) if self.exist?
+      end
+      
+      def self.pid_file
+        Capricorn.system.path("Server.pid")
+      end
+      
+      def self.exist?
+        File.file?(self.pid_file)
+      end
+    end
+  
+    module Controller
+      
+      def self.start(daemon, &block)
+        fork do
+          Process.setsid
+          exit if fork
+          if PidFile.exist?
+            puts "Pid file #{PidFile.pid_file} already exists. Not starting."
+            exit 1
+          end
+          Capricorn::Daemon::PidFile.store(Process.pid)
+          Dir.chdir Capricorn.system.root
+          File.umask 0000
+          
+          Capricorn::ExceptionHandler.redirect_std
+          
+          trap("TERM") { daemon.stop; exit }
+          at_exit { Capricorn::Daemon::PidFile.destroy if $master }
+          at_exit(&block) if block
+          daemon.start
+        end
+        puts "Daemon started."
+      end
+      
+      def self.stop
+        if !Capricorn::Daemon::PidFile.exist?
+          puts "Pid file not found. Is the daemon started?"
+          exit
+        end
+        pid = Capricorn::Daemon::PidFile.recall
+        pid && Process.kill("TERM", pid)
+      rescue Errno::ESRCH
+        puts "Pid file found, but process was not running. The daemon may have died."
+      end
+      
+    end
+  end
+end

data/lib/capricorn/exception_handler.rb

@@ -0,0 +1,79 @@
+
+module Capricorn
+  module ExceptionHandler
+    
+    def self.setup(out=STDOUT, err=STDERR)
+      if String === out
+        @out    = Logger.new(out, 'daily')
+        @stdout = @out.instance_variable_get('@logdev').instance_variable_get('@dev')
+      else
+        @out    = Logger.new(out)
+        @stdout = out
+      end
+      
+      if String === err
+        @err = Logger.new(err, 'daily')
+        @stderr = @err.instance_variable_get('@logdev').instance_variable_get('@dev')
+      else
+        @err    = Logger.new(err)
+        @stderr = err
+      end
+      
+      @out.level = Logger::DEBUG
+      @err.level = Logger::DEBUG
+    end
+    
+    def self.err
+      @err
+    end
+    
+    def self.out
+      @out
+    end
+    
+    def self.stderr
+      @stderr
+    end
+    
+    def self.stdout
+      @stdout
+    end
+    
+    def self.redirect_std
+      if STDOUT != self.stdout
+        STDOUT.reopen self.stdout
+      end
+      
+      if STDERR != self.stderr
+        STDERR.reopen self.stderr
+      end
+      
+      STDIN.reopen "/dev/null"
+    end
+    
+    def logger
+      Capricorn::ExceptionHandler
+    end
+    
+    def log(*args, &block)
+      args = [args.inspect] if args.size == 1 and Array === args.first
+      logger.out.info(*args, &block)
+    end
+    
+    def report
+      yield
+    rescue Exception => e
+      if StandardError === e
+        logger.err.error(e)
+      else
+        logger.err.fatal(e)
+      end
+      raise e
+    end
+    
+  end
+end
+
+def FileUtils.fu_output_message(msg)
+  Capricorn::ExceptionHandler.out.info(msg)
+end

data/lib/capricorn/extentions/rubygems_plugin.rb

@@ -0,0 +1,27 @@
+require 'rubygems/specification'
+
+module Gem # :nodoc:
+  class Specification
+    attribute :engine_dependencies, {}
+    
+    def add_engine_dependency(name, options={})
+      name = name.to_s
+      add_runtime_dependency(name, *[options[:version]].compact)
+      @engine_dependencies ||= {}
+      @engine_dependencies[name] = options
+    end
+    
+    alias_method :ruby_code_without_engines, :ruby_code # :nodoc:
+    def ruby_code(obj) # :nodoc:
+      return obj.inspect if Hash === obj
+      return ruby_code_without_engines(obj)
+    end
+    
+    alias_method :to_ruby_without_engines, :to_ruby # :nodoc:
+    def to_ruby # :nodoc:
+      code = to_ruby_without_engines
+      code.gsub! /s\.engine_dependencies\s+[=]([^\n]+)/, 's.instance_variable_set(:@engine_dependencies,\1)'
+      code
+    end
+  end
+end