capricorn 0.2.00

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.rb

@@ -0,0 +1,50 @@
+
+module Capricorn
+  class Satellite
+    include DRbUndumped
+    
+    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

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