engineyard-serverside 1.5.26 → 1.5.27.pre

data/lib/engineyard-serverside.rb

@@ -11,11 +11,9 @@ $LOAD_PATH.unshift File.expand_path('vendor/thor/lib', File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path('vendor/open4/lib', File.dirname(__FILE__))
 $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/dataflow', File.dirname(__FILE__))
 
 require 'escape'
 require 'json'
-require 'dataflow'
 
 require 'engineyard-serverside/version'
 require 'engineyard-serverside/strategies/git'
@@ -27,6 +25,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

@@ -4,13 +4,6 @@ require 'pathname'
 module EY
   module Serverside
     class CLI < Thor
-      include Dataflow
-
-      def self.start(*)
-        super
-      rescue RemoteFailure
-        exit(1)
-      end
 
       method_option :migrate,         :type     => :string,
                                       :desc     => "Run migrations with this deploy",
@@ -63,7 +56,7 @@ module EY
         EY::Serverside::LoggedOutput.verbose = options[:verbose]
         EY::Serverside::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-deploy.log")
 
-        invoke :propagate
+        propagate
 
         EY::Serverside::Deploy.new(config).send(default_task)
       end
@@ -144,7 +137,7 @@ module EY
 
         EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))
 
-        invoke :propagate
+        propagate
 
         EY::Serverside::Server.all.each do |server|
           server.sync_directory app_dir
@@ -190,7 +183,7 @@ module EY
         config = EY::Serverside::Deploy::Configuration.new(options)
         EY::Serverside::Server.load_all_from_array(assemble_instance_hashes(config))
 
-        invoke :propagate
+        propagate
 
         EY::Serverside::Deploy.new(config).restart_with_maintenance_page
       end
@@ -212,34 +205,25 @@ 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
-        config          = EY::Serverside::Deploy::Configuration.new
-        gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
+        name            = "engineyard-serverside"
+        version         = EY::Serverside::VERSION
+        gem_filename    = "#{name}-#{version}.gem"
         local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
         remote_gem_file = File.join(Dir.tmpdir, gem_filename)
-        gem_binary      = File.join(Gem.default_bindir, 'gem')
-
-        barrier(*(EY::Serverside::Server.all.find_all do |server|
-          !server.local?            # of course this machine has it
-        end.map do |server|
-          need_later do
-            egrep_escaped_version = EY::Serverside::VERSION.gsub(/\./, '\.')
-            # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
-            # 0.5.11, and mistakenly thinking 0.5.1 is there
-            has_gem_cmd = "#{gem_binary} list engineyard-serverside | grep \"engineyard-serverside\" | egrep -q '#{egrep_escaped_version}[,)]'"
-
-            if !server.run(has_gem_cmd)  # doesn't have this exact version
-              puts "~> Installing engineyard-serverside on #{server.hostname}"
-
-              system(Escape.shell_command([
-                'scp', '-i', "#{ENV['HOME']}/.ssh/internal",
-                "-o", "StrictHostKeyChecking=no",
-                local_gem_file,
-               "#{config.user}@#{server.hostname}:#{remote_gem_file}",
-              ]))
-              server.run("sudo #{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'")
-            end
+
+        servers = EY::Serverside::Server.all.find_all { |server| !server.local? }
+
+        futures = EY::Serverside::Future.call(servers) do |server|
+          installed = server.gem?(name, version)
+          unless installed
+            info "~> Installing #{name} on #{server.hostname}"
+            server.copy(local_gem_file, remote_gem_file)
+            installed = server.install_gem(remote_gem_file)
           end
-        end))
+          installed
+        end
+
+        EY::Serverside::Future.success?(futures)
       end
 
       private

data/lib/engineyard-serverside/deploy.rb

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

data/lib/engineyard-serverside/future.rb

@@ -0,0 +1,29 @@
+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
+    end
+
+    if defined?(Fiber)
+      require 'engineyard-serverside/futures/celluloid'
+    else
+      require 'engineyard-serverside/futures/dataflow'
+    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,31 @@
+module EY
+  module Serverside
+    $LOAD_PATH.unshift File.expand_path('../../vendor/dataflow', File.dirname(__FILE__))
+    require 'dataflow'
+
+    class Future
+      extend Dataflow
+
+      def self.call(servers, *args, &block)
+        futures = []
+        # Dataflow needs to call `barrier` and `need_later` in the same object
+        barrier(*servers.map do |server|
+          future = new(server, *args, &block)
+          futures << future
+
+          need_later { future.call }
+        end)
+
+        futures
+      end
+
+      def future
+        @block.call(@server, *@args)
+      end
+
+      def call
+        @value ||= future
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/server.rb

@@ -83,12 +83,37 @@ module EY
         if local?
           logged_system(command)
         else
-          logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
+          logged_system(ssh_command + Escape.shell_command(["#{user}@#{hostname}", command]))
         end
       end
 
+      def copy(local_file, remote_file)
+        logged_system(scp_command + Escape.shell_command([local_file, "#{user}@#{hostname}:#{remote_file}"]))
+      end
+
       def ssh_command
-        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
+        "ssh #{ssh_options} "
+      end
+
+      def scp_command
+        "scp #{ssh_options} "
+      end
+
+      def ssh_options
+        "-i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
+      end
+
+      def gem?(name, version)
+        run("#{gem_command} list -i #{name} -v '#{version}'")
+      end
+
+      def install_gem(path)
+        # resin + ruby 1.8.6 need sudo privileges to install gems
+        run("sudo #{gem_command} install -q --no-ri --no-rdoc #{path}")
+      end
+
+      def gem_command
+        File.join(Gem.default_bindir, 'gem')
       end
 
     end

data/lib/engineyard-serverside/task.rb

@@ -1,7 +1,6 @@
 module EY
   module Serverside
     class Task
-      include Dataflow
 
       attr_reader :config
       alias :c :config
@@ -51,18 +50,18 @@ module EY
 
       private
 
-      def run_on_roles(cmd, wrapper=%w[sh -l -c])
-        results = EY::Serverside::Server.from_roles(@roles).map do |server|
-          to_run = block_given? ? yield(server, cmd.dup) : cmd
-          need_later { 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
-        barrier *results
-        # 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!?
-        results.all?{|x| x == true } || raise(EY::Serverside::RemoteFailure.new(cmd))
-      end
 
+        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.26'
+    VERSION = '1.5.27.pre'
   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'