simonmenke-shuttle 0.1.07

data/lib/shuttle/client.rb

@@ -0,0 +1,48 @@
+require 'drb'
+require 'drb/ssl'
+require 'uri'
+
+module Shuttle
+  class Client
+    
+    autoload :AuthToken, File.dirname(__FILE__)+'/client/auth_token'
+    
+    # return a DRb uri for the given Shuttle uri.
+    def self.parse_uri(uri)
+      uri     = URI.parse(uri)
+      use_ssl = (uri.scheme == 'ssl+shuttle')
+      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'
+      
+      [Shuttle::DEFAULT_ROOT_SYSTEM_DIR,
+       Shuttle::DEFAULT_USER_SYSTEM_DIR,
+       File.join(Shuttle::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 = Shuttle::Client::AuthToken.load_file(token) if String === token
+      token.connect if token
+    end
+    
+  end
+end

data/lib/shuttle/exception_handler.rb

@@ -0,0 +1,53 @@
+autoload :Logger, 'logger'
+
+module Shuttle
+  module ExceptionHandler
+    
+    def self.setup(out=STDOUT, err=STDERR)
+      if String === out
+        @out = Logger.new(out, 'daily')
+      else
+        @out = Logger.new(out)
+      end
+      if String === err
+        @err = Logger.new(err, 'daily')
+      else
+        @err = Logger.new(err)
+      end
+      @out.level = Logger::DEBUG
+      @err.level = Logger::DEBUG
+    end
+    
+    def self.err
+      @err
+    end
+    
+    def self.out
+      @out
+    end
+    
+    def logger
+      Shuttle::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)
+  Shuttle::ExceptionHandler.out.info(msg)
+end

data/lib/shuttle/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/shuttle/extentions/thor_extentions.rb

@@ -0,0 +1,32 @@
+require 'thor'
+
+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/shuttle/job_queue.rb

@@ -0,0 +1,199 @@
+require 'thread'
+
+module Shuttle
+  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)
+        Shuttle.report do
+          @waiting = true
+          immediated = canceled = false
+          Shuttle.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
+            Shuttle.log("[queue]> #{@name}")
+            @proc.call(@options)
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/shuttle/satellite/actions.rb

@@ -0,0 +1,35 @@
+
+module Shuttle
+  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/shuttle/satellite/dependency_loader.rb

@@ -0,0 +1,79 @@
+
+autoload :TSort, 'tsort'
+
+module Shuttle
+  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/shuttle/satellite/persistence.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+module Shuttle
+  class Satellite
+    module Persistence
+      
+      def self.included(base)
+        base.extend Shuttle::Satellite::Persistence::ClassMethods
+      end
+      
+      module ClassMethods
+        
+        def load(data)
+          Shuttle::Satellite.new(YAML.load(data))
+        end
+        
+        def load_file(path)
+          return nil unless File.exist?(path)
+          Shuttle::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/shuttle/satellite.rb

@@ -0,0 +1,49 @@
+
+module Shuttle
+  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 Shuttle::Satellite::Actions
+    include Shuttle::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/shuttle/server/daemon.rb

@@ -0,0 +1,85 @@
+require 'uri'
+
+module Shuttle
+  class Server
+    
+    module Daemon # :nodoc:
+      
+      def self.included(base)
+        base.extend Shuttle::Server::Daemon::ClassMethods
+      end
+      
+      # all a daemon needs to run
+      module ClassMethods
+        
+        # construct a Shuttle uri from a DRb uri
+        def construct_uri(uri)
+          uri        = URI.parse(uri)
+          uri.scheme = ( Shuttle.system.use_ssl? ? 'ssl+shuttle' : 'shuttle')
+          uri.to_s
+        end
+        
+        # stop teh server
+        def stop
+          Shuttle.client.stop_server
+        end
+        
+        # start the server
+        def start
+          start_with_failsafe
+        end
+        
+        # start the failsafe runner.
+        def start_with_failsafe
+          stop_server = false
+          wait_before_start = 0
+          retries = 0
+          until stop_server
+            if wait_before_start > 0
+              sleep(wait_before_start)
+              wait_before_start = 0
+            end
+            
+            pid = Process.fork { self.run_server }
+            Process.waitpid(pid, 0)
+            case $?.exitstatus
+            when Shuttle::STOP_STATUS
+              stop_server = true
+            when Shuttle::RESTART_STATUS
+              wait_before_start = 2
+            when Shuttle::RELOAD_STATUS
+              stop_server = true
+              Shuttle.system.run(%{sleep 2 ; #{Shuttle::BIN_PATH} #{ORIGINAL_ARGV.join(' ')}})
+            else
+              retries += 1
+              stop_server = true if retries >= 3
+            end
+          end
+          
+          path = Shuttle.system.path('Server.pid')
+          File.unlink(path) if File.file?(path)
+        end
+        
+        # start the actual DRb server
+        def run_server
+          Dir.chdir(Shuttle.system.root)
+          
+          Shuttle.log "Server started"
+          DRb.start_service "druby://localhost:5000", self.proxy, self.options_for_server
+          Shuttle.log "listening at #{self.construct_uri("druby://#{`hostname`.strip}:5000")}"
+          make_client_cert_public!
+          
+          at_exit do
+            unless $task_child
+              Shuttle.system.queue.stop!
+              Shuttle.log "Server stopped"
+            end
+          end
+          
+          DRb.thread.join
+        end
+        
+      end
+    end
+  end
+end

data/lib/shuttle/server/proxy.rb

@@ -0,0 +1,25 @@
+
+module Shuttle
+  class Server
+    # the proxy object hides all the server internals from the clients.
+    class Proxy
+      
+      def initialize(server)
+        @server = server
+      end
+      
+      def self.allow(*methods)
+        methods.each do |method|
+          module_eval %{ def #{method}(*args,&block) ; @server.#{method}(*args,&block) ; end }
+        end
+      end
+      
+      allow :stop_server, :restart_server, :reload_server, :server_version, :update_server, :install_satellite, :uninstall_satellite, :install_engine, :update_engine, :uninstall_engine, :satellites, :queued_jobs, :cancel_job, :immediate_job
+      
+      class << self
+        undef_method :allow
+      end
+      
+    end
+  end
+end