simonmenke-capricorn 0.2.00

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/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,78 @@
+
+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)
+      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

data/lib/capricorn/extentions/thor_extentions.rb

@@ -0,0 +1,32 @@
+Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
+
+class Thor
+  class << self
+    attr_accessor :real_namespace # :nodoc:
+  end
+  def self.namespace=(value)
+    Thor.real_namespace = value
+  end
+  def self.namespace
+    Thor.real_namespace
+  end
+  self.namespace = nil
+end
+
+module Thor::Util # :nodoc:
+  class << self
+    alias_method :old_constant_to_thor_path, :constant_to_thor_path
+    alias_method :old_constant_from_thor_path, :constant_from_thor_path
+  end
+  
+  def self.constant_to_thor_path(*args) # :nodoc:
+    path = old_constant_to_thor_path(*args)
+    path.sub! /^#{Thor.namespace}:/, '' if Thor.namespace
+    path
+  end
+  
+  def self.constant_from_thor_path(path) # :nodoc:
+    path = "#{Thor.namespace}:"+path if Thor.namespace
+    old_constant_from_thor_path(path)
+  end
+end

data/lib/capricorn/job_queue.rb

@@ -0,0 +1,199 @@
+require 'thread'
+
+module Capricorn
+  class JobQueue
+    include DRbUndumped
+    
+    # create a new job queue
+    def initialize
+      @immediated_jobs = Array.new
+      @canceled_jobs = Array.new
+      @job_queue = Array.new
+      @jobs      = Hash.new
+      @mutex     = Mutex.new
+      @next_id   = 1
+      
+      @worker    = Thread.new(self) do |job_queue|
+        while job_queue.running? or job_queue.peek
+          
+          if job = job_queue.peek
+            job.run(job_queue)
+            job_queue.delete(job.id)
+          else
+            sleep(1)
+          end
+          
+        end
+      end
+    end
+    
+    # enqueue a new job with the given +name+, +options+ and +proc+
+    def enqueue(name, options={}, &proc)
+      @mutex.synchronize do
+        job = Job.new(@next_id, name, options, &proc)
+        @next_id += 1
+        @jobs[job.id] = job
+        @job_queue.push job.id
+        return job.id
+      end
+    end
+    
+    # dequeue the next job of the queue.
+    def dequeue
+      @mutex.synchronize do
+        id = @job_queue.shift
+        return @jobs.delete(id) if id
+      end
+    end
+    
+    # delete the job associated with the given +id+.
+    def delete(id)
+      @mutex.synchronize do
+        id = @job_queue.delete(id)
+        return @jobs.delete(id) if id
+      end
+    end
+    
+    # peek at the next job in the queue
+    def peek
+      job = nil
+      @mutex.synchronize do
+        id = @job_queue.first
+        job = @jobs[id] if id
+      end
+      job
+    end
+    
+    # get the size of the job queue
+    def size
+      @mutex.synchronize do
+        @job_queue.size
+      end
+    end
+    
+    # cancel the job associated with the given +id+.
+    def cancel(id)
+      @mutex.synchronize do
+        id = @job_queue.delete(id)
+        if id
+          @jobs.delete(id)
+          @canceled_jobs.push(id)
+        end
+      end
+    end
+    
+    # is the job associated with the given +id+ canceled.
+    def canceled?(id)
+      @mutex.synchronize do
+        return !@canceled_jobs.delete(id).nil?
+      end
+    end
+    
+    # run the job associated with the given +id+ immediately.
+    def immediate(id)
+      @mutex.synchronize do
+        @immediated_jobs.push(id) if @jobs[id]
+      end
+    end
+    
+    # should the job associated with the given +id+ be run immediately.
+    def immediated?(id)
+      @mutex.synchronize do
+        return !@immediated_jobs.delete(id).nil?
+      end
+    end
+    
+    # join the worker thread
+    def join!
+      @worker.join
+    end
+    
+    # wait until the queue is empty then stop the worker
+    def stop!
+      @mutex.synchronize do
+        @stopped = true
+      end
+      join!
+    end
+    
+    # is the queue stopping or stopped?
+    def stopped?
+      @mutex.synchronize do
+        return !!@stopped
+      end
+    end
+    
+    # is the queue running
+    def running?
+      !stopped?
+    end
+    
+    # iterate through all the jobs on the queue
+    def each
+      @mutex.synchronize do
+        @job_queue.each do |id|
+          job        = @jobs[id]
+          canceled   = @canceled_jobs.include?(id)
+          immediated = @immediated_jobs.include?(id)
+          
+          yield(job, canceled, immediated)
+        end
+      end
+    end
+    
+    class Job
+      include DRbUndumped
+      
+      attr_accessor :id, :name, :options, :proc
+      
+      def initialize(id, name, options={}, &proc)
+        @id = id.to_i
+        @mutex = Mutex.new
+        @name, @options, @proc = name, options, proc
+        @run_at = Time.now + (options.delete(:delay) || 30)
+      end
+      
+      def delay
+        @mutex.synchronize do
+          delay = @run_at - Time.now
+          delay = 0 if delay < 0
+          return delay
+        end
+      end
+      
+      def running?
+        @mutex.synchronize do
+          return @running
+        end
+      end
+      
+      def waiting?
+        @mutex.synchronize do
+          return @waiting
+        end
+      end
+      
+      def run(job_queue)
+        Capricorn.report do
+          @waiting = true
+          immediated = canceled = false
+          Capricorn.log "waiting #{@run_at - Time.now}s."
+          until immediated or canceled or @run_at <= Time.now
+            sleep(1)
+            canceled   = job_queue.canceled?(self.id)
+            immediated = job_queue.immediated?(self.id)
+          end
+          
+          unless canceled
+            @waiting = false
+            @running = true
+            Capricorn.log("[queue]> #{@name}")
+            @proc.call(@options)
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/capricorn/satellite/actions.rb

@@ -0,0 +1,35 @@
+
+module Capricorn
+  class Satellite
+    module Actions
+      
+      def add_engine(name, options={})
+        unless @engines.key? name
+          @engines[name] = options
+          true
+        else
+          false
+        end
+      end
+      
+      def update_engine(name, options={})
+        if @engines.key? name
+          @engines[name] = options
+          true
+        else
+          false
+        end
+      end
+      
+      def remove_engine(name)
+        if @engines.key? name
+          @engines.delete(name)
+          true
+        else
+          false
+        end
+      end
+      
+    end
+  end
+end

data/lib/capricorn/satellite/dependency_loader.rb

@@ -0,0 +1,78 @@
+
+
+module Capricorn
+  class Satellite
+    class DependencyLoader
+      
+      attr_reader :names, :specs, :engines
+      
+      def self.load_for(engines)
+        dependency_loader = self.new(engines)
+        dependency_loader.add_dependecies!
+        dependency_loader.order_by_dependecies!
+        
+        return dependency_loader
+      end
+      
+      def initialize(engines)
+        specs = engines.collect do |k,r|
+          s = Gem.source_index.find_name(k, Gem::Requirement.new(r[:version] || ">= 0.0.0"))
+          s.last
+        end.compact
+        
+        @names = specs.collect { |spec| spec.name }
+        @specs = specs.inject({}) { |h, spec| h[spec.name] = spec ; h }
+        @engines = engines
+      end
+      
+      def add_dependecies!
+        @specs.values.each do |spec|
+          add_dependecies_for spec
+        end
+      end
+      
+      def order_by_dependecies!
+        @names = tsort
+      end
+      
+      def each
+        @names.each do |name|
+          yield(@specs[name])
+        end
+      end
+      
+      def reverse_each
+        @names.reverse.each do |name|
+          yield(@specs[name])
+        end
+      end
+      
+    private
+      
+      include TSort
+      
+      def add_dependecies_for(spec)
+        engine_dependencies = spec.engine_dependencies || {}
+        engine_dependencies.each do |name, options|
+          gems = Gem.source_index.find_name(name, [options[:version]].compact)
+          next unless gem = gems.last
+          next if @names.include?(name) and gem.version <= @specs[gem.name].version
+          @specs[gem.name] = gem
+          @names.push(gem.name)
+          add_dependecies_for(gem)
+        end
+        @engines = @engines.merge(engine_dependencies)
+      end
+      
+      def tsort_each_node(&block)
+        @names.each(&block)
+      end
+      
+      def tsort_each_child(node, &block)
+        engine_dependencies = @specs[node].engine_dependencies || {}
+        engine_dependencies.keys.each(&block)
+      end
+      
+    end
+  end
+end

data/lib/capricorn/satellite/persistence.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+module Capricorn
+  class Satellite
+    module Persistence
+      
+      def self.included(base)
+        base.extend Capricorn::Satellite::Persistence::ClassMethods
+      end
+      
+      module ClassMethods
+        
+        def load(data)
+          Capricorn::Satellite.new(YAML.load(data))
+        end
+        
+        def load_file(path)
+          return nil unless File.exist?(path)
+          Capricorn::Satellite.new(YAML.load_file(path))
+        end
+        
+      end
+      
+      def dump(io=nil)
+        data = {}
+        
+        private_vars = %w( basedomain subdomain )
+        instance_variables.each do |ivar_name|
+          ivar_name = ivar_name.to_s
+          ivar_name =~ /^@(.+)$/
+          name = $1
+          unless private_vars.include? name
+            data[name] = instance_variable_get(ivar_name.to_sym)
+          end
+        end
+        
+        if io
+          io.write YAML.dump(data)
+        else
+          YAML.dump(data)
+        end
+      end
+      
+      def dump_file(path)
+        File.open(path, 'w+') { |f| dump(f) }
+      end
+      
+    end
+  end
+end

data/lib/capricorn/satellite.rb

@@ -0,0 +1,49 @@
+
+module Capricorn
+  class Satellite
+    
+    autoload :Actions,          File.dirname(__FILE__)+'/satellite/actions'
+    autoload :Persistence,      File.dirname(__FILE__)+'/satellite/persistence'
+    autoload :DependencyLoader, File.dirname(__FILE__)+'/satellite/dependency_loader'
+    
+    include Capricorn::Satellite::Actions
+    include Capricorn::Satellite::Persistence
+    
+    attr_reader :domain, :engines
+    
+    def initialize(domain)
+      if Hash === domain
+        domain.each do |name, value|
+          instance_variable_set("@#{name}".to_sym, value)
+        end
+      else
+        @domain = domain
+        @engines = {}
+      end
+      @domain.gsub! /^www\./, ''
+    end
+    
+    def basedomain
+      unless @basedomain
+        parts = self.domain.split('.')
+        parts = parts[-2..-1]
+        @basedomain = parts.join('.')
+      end
+      @basedomain
+    end
+    
+    def subdomain
+      unless @subdomain
+        parts = self.domain.split('.')
+        parts = parts[0..-3]
+        @subdomain = parts.join('.')
+      end
+      @subdomain unless @subdomain == ''
+    end
+    
+    def subdomain?
+      !self.subdomain.nil?
+    end
+    
+  end
+end