engineyard-serverside 1.5.23.ruby19.8 → 1.5.23.ruby19.9

data/lib/engineyard-serverside.rb

@@ -2,12 +2,13 @@
 
 $LOAD_PATH.unshift File.expand_path('vendor/escape/lib', File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path('vendor/json_pure/lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path('vendor/open4/lib', File.dirname(__FILE__))
 
 require 'escape'
 require 'json'
 require 'tmpdir'
-require 'celluloid'
 require 'thor'
+require 'open4'
 
 require 'engineyard-serverside/version'
 require 'engineyard-serverside/strategies/git'
@@ -19,6 +20,7 @@ require 'engineyard-serverside/lockfile_parser'
 require 'engineyard-serverside/cli'
 require 'engineyard-serverside/configuration'
 require 'engineyard-serverside/deprecation'
+require 'engineyard-serverside/future'
 
 module EY
   module Serverside

data/lib/engineyard-serverside/cli.rb

@@ -199,24 +199,21 @@ module EY
        desc "propagate", "Propagate the engineyard-serverside gem to the other instances in the cluster. This will install exactly version #{EY::Serverside::VERSION}."
       def propagate
         ey_server_side = Dependency.new('engineyard-serverside', EY::Serverside::VERSION)
-        futures = EY::Serverside::Server.all.find_all do |server|
-          !server.local?            # of course this machine has it
-        end.map do |server|
-          Celluloid::Future.new do
-            log = {}
+        servers = EY::Serverside::Server.all.find_all { |server| !server.local? }
+
+        futures = EY::Serverside::Future.call(servers) do |server|
+          installed = server.gem?(ey_server_side.name, ey_server_side.version)
+          unless installed
             unless server.gem?(ey_server_side.name, ey_server_side.version)
-              (dependencies + [ey_server_side]).each do |dependency|
-                unless server.gem?(dependency.name, dependency.version)
-                  puts "~> Installing #{dependency.name} on #{server.hostname}"
-                  server.copy(dependency.local_path, dependency.remote_path)
-                  log[dependency.name] = server.install_gem(dependency.remote_path)
-                end
-              end
+              puts "~> Installing #{ey_server_side.name} on #{server.hostname}"
+              server.copy(ey_server_side.local_path, ey_server_side.remote_path)
+              installed = server.install_gem(ey_server_side.remote_path)
             end
-            log
           end
+          installed
         end
-        futures.map {|f| f.value} unless futures.empty?
+
+        EY::Serverside::Future.success?(futures)
       end
 
       private
@@ -231,11 +228,6 @@ module EY
         }
       end
 
-      def dependencies
-        [Dependency.new('celluloid', Celluloid::VERSION),
-         Dependency.new('thor', '0.13.3')]
-      end
-
       class Dependency
         attr_reader :name, :version
         def initialize(name, version)

data/lib/engineyard-serverside/deploy.rb

@@ -145,10 +145,10 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
       # task
       def push_code
         info "~> Pushing code to all servers"
-        futures = EY::Serverside::Server.all.map do |server|
-          Celluloid::Future.new { server.sync_directory(config.repository_cache) }
+        futures = EY::Serverside::Future.call(EY::Serverside::Server.all) do |server|
+          server.sync_directory(config.repository_cache)
         end
-        futures.all? {|f| f.value == true}
+        EY::Serverside::Future.success?(futures)
       end
 
       # task

data/lib/engineyard-serverside/future.rb

@@ -0,0 +1,33 @@
+module EY
+  module Serverside
+    class Future
+      def self.success?(futures)
+        futures.empty? || futures.all? {|f| f.success?}
+      end
+
+      def initialize(server, *args, &block)
+        @server = server
+        @args = args
+        @block = block
+      end
+
+      def success?
+        @value == true
+      end
+
+      def error?
+        !success?
+      end
+
+      def inspect
+        %Q{<Serverside::Future @server="#{@server.hostname}" @args="#{@args}" @value="#{@value}"}
+      end
+    end
+
+    if RUBY_VERSION =~ /1\.8/
+      require 'engineyard-serverside/futures/dataflow'
+    else
+      require 'engineyard-serverside/futures/celluloid'
+    end
+  end
+end

data/lib/engineyard-serverside/futures/celluloid.rb

@@ -0,0 +1,25 @@
+module EY
+  module Serverside
+    $LOAD_PATH.unshift File.expand_path('../../vendor/celluloid/lib', File.dirname(__FILE__))
+    require 'celluloid'
+    class Future
+      def self.call(servers, *args, &block)
+        futures = servers.map do |server|
+          new(server, *args, &block)
+        end
+
+        futures.each {|f| f.call}
+        futures
+      end
+
+      def future
+        Celluloid::Future.new(@server, *@args, &@block)
+      end
+
+      def call
+        # Celluloid needs to call the block explicitely
+        @value ||= future.call
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/futures/dataflow.rb

@@ -0,0 +1,25 @@
+module EY
+  module Serverside
+    $LOAD_PATH.unshift File.expand_path('../../vendor/dataflow/lib', File.dirname(__FILE__))
+    require 'dataflow'
+
+    class Future
+      def self.call(servers, *args, &block)
+        futures = barrier(*servers.map do |server|
+          new(server, *args, &block)
+        end)
+
+        futures.each {|f| f.call}
+        futures
+      end
+
+      def future
+        need_later { @block.call(@server, *@args) }
+      end
+
+      def call
+        @value ||= future
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/logged_output.rb

@@ -57,9 +57,14 @@ module EY
 
       def logged_system(cmd)
         with_logfile do |log|
-          pid = Process.spawn(cmd, :out => log, :err => log)
-          Process.waitpid(pid)
-          $?.success?
+          out = verbose? ? Tee.new($stdout, log) : log
+          err = Tee.new($stderr, log)    # we always want to see errors
+
+          out <<  ":: running #{cmd}\n"
+
+          # :quiet means don't raise an error on nonzero exit status
+          status = Open4.spawn cmd, 0 => '', 1 => out, 2 => err, :quiet => true
+          status.exitstatus == 0
         end
       end
 

data/lib/engineyard-serverside/task.rb

@@ -47,21 +47,18 @@ module EY
 
       private
 
-      def run_on_roles(cmd, wrapper=%w[sh -l -c])
-        futures = EY::Serverside::Server.from_roles(@roles).map do |server|
-          to_run = block_given? ? yield(server, cmd.dup) : cmd
-          Celluloid::Future.new { server.run(Escape.shell_command(wrapper + [to_run])) }
+      def run_on_roles(cmd, wrapper=%w[sh -l -c], &block)
+        servers = EY::Serverside::Server.from_roles(@roles)
+        futures = EY::Serverside::Future.call(servers, block_given?) do |server, exec_block|
+          to_run = exec_block ? block.call(server, cmd.dup) : cmd
+          server.run(Escape.shell_command(wrapper + [to_run]))
         end
-        # MRI's truthiness check is an internal C thing that does not call
-        # any methods... so Dataflow cannot proxy it & we must "x == true"
-        # Rubinius, wherefore art thou!?
-        unless futures.empty?
-          results = futures.map {|x| x.value}
-          results.all?{|x| x == true } || raise(EY::Serverside::RemoteFailure.new("""#{cmd}
-Results: #{results}"""))
+
+        unless EY::Serverside::Future.success?(futures)
+          failures = futures.select {|f| f.error? }.map {|f| f.inspect}.join("\n")
+          raise EY::Serverside::RemoteFailure.new(failures)
         end
       end
-
     end
   end
 end

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '1.5.23.ruby19.8'
+    VERSION = '1.5.23.ruby19.9'
   end
 end

data/lib/vendor/celluloid/lib/celluloid.rb

@@ -0,0 +1,261 @@
+require 'logger'
+require 'thread'
+
+module Celluloid
+  @logger = Logger.new STDERR
+
+  class << self
+    attr_accessor :logger # Thread-safe logger class
+
+    def included(klass)
+      klass.send :extend, ClassMethods
+    end
+
+    # Are we currently inside of an actor?
+    def actor?
+      !!Thread.current[:actor]
+    end
+
+    # Obtain the currently running actor (if one exists)
+    def current_actor
+      actor = Thread.current[:actor]
+      raise NotActorError, "not in actor scope" unless actor
+      actor.proxy
+    end
+    alias_method :current, :current_actor
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      actor = Thread.current[:actor]
+      if actor
+        actor.receive(timeout, &block)
+      else
+        Thread.mailbox.receive(timeout, &block)
+      end
+    end
+
+    # Sleep letting the actor continue processing messages
+    def sleep(interval)
+      actor = Thread.current[:actor]
+      if actor
+        actor.sleep(interval)
+      else
+        Kernel.sleep interval
+      end
+    end
+
+    # Obtain a hash of active tasks to their current activities
+    def tasks
+      actor = Thread.current[:actor]
+      raise NotActorError, "not in actor scope" unless actor
+      actor.tasks
+    end
+  end
+
+  # Class methods added to classes which include Celluloid
+  module ClassMethods
+    # Create a new actor
+    def new(*args, &block)
+      proxy = Actor.new(allocate).proxy
+      proxy.send(:initialize, *args, &block)
+      proxy
+    end
+    alias_method :spawn, :new
+
+    # Create a new actor and link to the current one
+    def new_link(*args, &block)
+      current_actor = Celluloid.current_actor
+      raise NotActorError, "can't link outside actor context" unless current_actor
+
+      proxy = Actor.new(allocate).proxy
+      current_actor.link proxy
+      proxy.send(:initialize, *args, &block)
+      proxy
+    end
+    alias_method :spawn_link, :new_link
+
+    # Create a supervisor which ensures an instance of an actor will restart
+    # an actor if it fails
+    def supervise(*args, &block)
+      Supervisor.supervise(self, *args, &block)
+    end
+
+    # Create a supervisor which ensures an instance of an actor will restart
+    # an actor if it fails, and keep the actor registered under a given name
+    def supervise_as(name, *args, &block)
+      Supervisor.supervise_as(name, self, *args, &block)
+    end
+
+    # Trap errors from actors we're linked to when they exit
+    def trap_exit(callback)
+      @exit_handler = callback.to_sym
+    end
+
+    # Obtain the exit handler for this actor
+    attr_reader :exit_handler
+
+    # Configure a custom mailbox factory
+    def use_mailbox(klass = nil, &block)
+      if block
+        define_method(:mailbox_factory, &block)
+      else
+        define_method(:mailbox_factory) { klass.new }
+      end
+    end
+  end
+
+  #
+  # Instance methods
+  #
+
+  # Is this actor alive?
+  def alive?
+    Thread.current[:actor].alive?
+  end
+
+  # Raise an exception in caller context, but stay running
+  def abort(cause)
+    raise AbortError.new(cause)
+  end
+
+  # Terminate this actor
+  def terminate
+    Thread.current[:actor].terminate
+  end
+
+  def inspect
+    str = "#<Celluloid::Actor(#{self.class}:0x#{object_id.to_s(16)})"
+    ivars = instance_variables.map do |ivar|
+      "#{ivar}=#{instance_variable_get(ivar).inspect}"
+    end
+
+    str << " " << ivars.join(' ') unless ivars.empty?
+    str << ">"
+  end
+
+  # Send a signal with the given name to all waiting methods
+  def signal(name, value = nil)
+    Thread.current[:actor].signal name, value
+  end
+
+  # Wait for the given signal
+  def wait(name)
+    Thread.current[:actor].wait name
+  end
+
+  # Obtain the current_actor
+  def current_actor
+    Celluloid.current_actor
+  end
+
+  # Obtain the running tasks for this actor
+  def tasks
+    Celluloid.tasks
+  end
+
+  # Obtain the Ruby object the actor is wrapping. This should ONLY be used
+  # for a limited set of use cases like runtime metaprogramming. Interacting
+  # directly with the wrapped object foregoes any kind of thread safety that
+  # Celluloid would ordinarily provide you, and the object is guaranteed to
+  # be shared with at least the actor thread. Tread carefully.
+  def wrapped_object; self; end
+
+  # Obtain the Celluloid::Links for this actor
+  def links
+    Thread.current[:actor].links
+  end
+
+  # Link this actor to another, allowing it to crash or react to errors
+  def link(actor)
+    actor.notify_link current_actor
+    notify_link actor
+  end
+
+  # Remove links to another actor
+  def unlink(actor)
+    actor.notify_unlink current_actor
+    notify_unlink actor
+  end
+
+  def notify_link(actor)
+    links << actor
+  end
+
+  def notify_unlink(actor)
+    links.delete actor
+  end
+
+  # Is this actor linked to another?
+  def linked_to?(actor)
+    Thread.current[:actor].links.include? actor
+  end
+
+  # Receive an asynchronous message via the actor protocol
+  def receive(timeout = nil, &block)
+    Celluloid.receive(timeout, &block)
+  end
+
+  # Sleep while letting the actor continue to receive messages
+  def sleep(interval)
+    Celluloid.sleep(interval)
+  end
+
+  # Call a block after a given interval
+  def after(interval, &block)
+    Thread.current[:actor].after(interval, &block)
+  end
+
+  # Perform a blocking or computationally intensive action inside an
+  # asynchronous thread pool, allowing the caller to continue processing other
+  # messages in its mailbox in the meantime
+  def async(&block)
+    # This implementation relies on the present implementation of
+    # Celluloid::Future, which uses an Actor to run the block
+    Future.new(&block).value
+  end
+
+  # Process async calls via method_missing
+  def method_missing(meth, *args, &block)
+    # bang methods are async calls
+    if meth.to_s.match(/!$/)
+      unbanged_meth = meth.to_s.sub(/!$/, '')
+      call = AsyncCall.new(@mailbox, unbanged_meth, args, block)
+
+      begin
+        Thread.current[:actor].mailbox << call
+      rescue MailboxError
+        # Silently swallow asynchronous calls to dead actors. There's no way
+        # to reliably generate DeadActorErrors for async calls, so users of
+        # async calls should find other ways to deal with actors dying
+        # during an async call (i.e. linking/supervisors)
+      end
+
+      return # casts are async and return immediately
+    end
+
+    super
+  end
+end
+
+require 'celluloid/version'
+require 'celluloid/actor_proxy'
+require 'celluloid/calls'
+require 'celluloid/core_ext'
+require 'celluloid/events'
+require 'celluloid/fiber'
+require 'celluloid/fsm'
+require 'celluloid/links'
+require 'celluloid/logger'
+require 'celluloid/mailbox'
+require 'celluloid/receivers'
+require 'celluloid/registry'
+require 'celluloid/responses'
+require 'celluloid/signals'
+require 'celluloid/task'
+require 'celluloid/timers'
+
+require 'celluloid/actor'
+require 'celluloid/actor_pool'
+require 'celluloid/supervisor'
+require 'celluloid/future'
+require 'celluloid/application'