engineyard-serverside 1.3.7 → 1.4.0

data/lib/engineyard-serverside/deploy_hook.rb

@@ -1,77 +1,79 @@
 module EY
-  class DeployHook < Task
-    def initialize(options)
-      super(EY::Deploy::Configuration.new(options))
-    end
+  module Serverside
+    class DeployHook < Task
+      def initialize(options)
+        super(EY::Serverside::Deploy::Configuration.new(options))
+      end
 
-    def callback_context
-      @context ||= CallbackContext.new(config)
-    end
+      def callback_context
+        @context ||= CallbackContext.new(config)
+      end
 
-    def run(hook)
-      hook_path = "#{c.release_path}/deploy/#{hook}.rb"
-      if File.exist?(hook_path)
-        Dir.chdir(c.release_path) do
-          puts "~> running deploy hook: deploy/#{hook}.rb"
-          if desc = syntax_error(hook_path)
-            hook_name = File.basename(hook_path)
-            abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
-          else
-            callback_context.instance_eval(IO.read(hook_path))
+      def run(hook)
+        hook_path = "#{c.release_path}/deploy/#{hook}.rb"
+        if File.exist?(hook_path)
+          Dir.chdir(c.release_path) do
+            puts "~> running deploy hook: deploy/#{hook}.rb"
+            if desc = syntax_error(hook_path)
+              hook_name = File.basename(hook_path)
+              abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
+            else
+              callback_context.instance_eval(IO.read(hook_path))
+            end
           end
         end
       end
-    end
 
-    def syntax_error(file)
-      valid = Kernel.system("ruby -c #{file} 2>/tmp/ey_invalid_deploy_hook | grep 'Syntax OK' --quiet")
-      File.new("/tmp/ey_invalid_deploy_hook").gets unless valid
-    end
-
-    class CallbackContext
-      def initialize(config)
-        @configuration = config
-        @node = node
+      def syntax_error(file)
+        valid = Kernel.system("ruby -c #{file} 2>/tmp/ey_invalid_deploy_hook | grep 'Syntax OK' --quiet")
+        File.new("/tmp/ey_invalid_deploy_hook").gets unless valid
       end
 
-      def method_missing(meth, *args, &blk)
-        if @configuration.respond_to?(meth)
-          @configuration.send(meth, *args, &blk)
-        else
-          super
+      class CallbackContext
+        def initialize(config)
+          @configuration = config
+          @node = node
         end
-      end
 
-      def respond_to?(meth, include_private=false)
-        @configuration.respond_to?(meth, include_private) || super
-      end
+        def method_missing(meth, *args, &blk)
+          if @configuration.respond_to?(meth)
+            @configuration.send(meth, *args, &blk)
+          else
+            super
+          end
+        end
 
-      def run(cmd)
-        system(Escape.shell_command(["sh", "-l", "-c", cmd]))
-      end
+        def respond_to?(meth, include_private=false)
+          @configuration.respond_to?(meth, include_private) || super
+        end
 
-      def sudo(cmd)
-        system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
-      end
+        def run(cmd)
+          system(Escape.shell_command(["sh", "-l", "-c", cmd]))
+        end
+
+        def sudo(cmd)
+          system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
+        end
 
-      # convenience functions for running on certain instance types
-      def on_app_master(&blk)                 on_roles(%w[solo app_master],          &blk) end
-      def on_app_servers(&blk)                on_roles(%w[solo app_master app],      &blk) end
-      def on_app_servers_and_utilities(&blk)  on_roles(%w[solo app_master app util], &blk) end
+        # convenience functions for running on certain instance types
+        def on_app_master(&blk)                 on_roles(%w[solo app_master],          &blk) end
+        def on_app_servers(&blk)                on_roles(%w[solo app_master app],      &blk) end
+        def on_app_servers_and_utilities(&blk)  on_roles(%w[solo app_master app util], &blk) end
 
-      def on_utilities(*names, &blk)
-        names.flatten!
-        on_roles(%w[util]) do
-          blk.call if names.empty? || names.include?(current_name)
+        def on_utilities(*names, &blk)
+          names.flatten!
+          on_roles(%w[util]) do
+            blk.call if names.empty? || names.include?(current_name)
+          end
+        end
+
+        private
+        def on_roles(desired_roles)
+          yield if desired_roles.any? { |role| current_roles.include?(role) }
         end
-      end
 
-      private
-      def on_roles(desired_roles)
-        yield if desired_roles.any? { |role| current_roles.include?(role) }
       end
 
     end
-
   end
 end

data/lib/engineyard-serverside/deprecation.rb

@@ -0,0 +1,27 @@
+module EY
+  module Serverside
+    def self.deprecation_warning(msg)
+      STDERR.puts "DEPRECATION WARNING: #{msg}"      
+    end
+  end
+  
+  def self.const_missing(const)
+    if EY::Serverside.const_defined?(const)
+      EY::Serverside.deprecation_warning("EY::#{const} has been deprecated. use EY::Serverside::#{const} instead")
+      EY::Serverside.class_eval(const.to_s)
+    else
+      super
+    end
+  end
+  
+  def self.node
+    EY::Serverside.deprecation_warning("EY.node has been deprecated. use EY::Serverside.node instead")
+    EY::Serverside.node
+  end
+
+  def self.dna_json
+    EY::Serverside.deprecation_warning("EY.dna_json has been deprecated. use EY::Serverside.dna_json instead")
+    EY::Serverside.dna_json
+  end
+
+end

data/lib/engineyard-serverside/lockfile_parser.rb

@@ -1,101 +1,103 @@
 require 'yaml'
 module EY
-  class LockfileParser
+  module Serverside
+    class LockfileParser
 
-    attr_reader :bundler_version, :lockfile_version
+      attr_reader :bundler_version, :lockfile_version
 
-    def initialize(lockfile_contents)
-      @lockfile_version, @bundler_version = Parse106.new(lockfile_contents).parse
-    end
+      def initialize(lockfile_contents)
+        @lockfile_version, @bundler_version = Parse106.new(lockfile_contents).parse
+      end
 
-    private
+      private
 
-    class BaseParser
-      def initialize(contents)
-        @contents = contents
-      end
-      def parse
-        raise "Unknown lockfile format #{@contents[0,50]}..."
+      class BaseParser
+        def initialize(contents)
+          @contents = contents
+        end
+        def parse
+          raise "Unknown lockfile format #{@contents[0,50]}..."
+        end
       end
-    end
 
-    class Parse09 < BaseParser
-      def parse
-        from_yaml = safe_yaml_load(@contents)
-        unless from_yaml.is_a?(Hash)
-          return super
-        end
-        bundler_version = from_yaml['specs'].map do |spec|
-          # spec is a one-element hash: the key is the gem name, and
-          # the value is {"version" => the-version}.
-          if spec.keys.first == "bundler"
-            spec.values.first["version"]
+      class Parse09 < BaseParser
+        def parse
+          from_yaml = safe_yaml_load(@contents)
+          unless from_yaml.is_a?(Hash)
+            return super
           end
-        end.compact.first
-        [:bundler09, bundler_version]
-      end
-      def safe_yaml_load(loadable)
-        YAML.load(loadable) #won't always raise... soemtimes parses the contents as 1 big string
-      rescue ArgumentError => e  # not yaml
-        nil
+          bundler_version = from_yaml['specs'].map do |spec|
+            # spec is a one-element hash: the key is the gem name, and
+            # the value is {"version" => the-version}.
+            if spec.keys.first == "bundler"
+              spec.values.first["version"]
+            end
+          end.compact.first
+          [:bundler09, bundler_version]
+        end
+        def safe_yaml_load(loadable)
+          YAML.load(loadable) #won't always raise... soemtimes parses the contents as 1 big string
+        rescue ArgumentError => e  # not yaml
+          nil
+        end
       end
-    end
 
-    class Parse10 < Parse09
-      def parse
-        unless @contents.index(/^DEPENDENCIES/)
-          return super
-        end
-        dep_section = ""
-        in_dependencies_section = false
-        @contents.each_line do |line|
-          if line =~ /^DEPENDENCIES/
-            in_dependencies_section = true
-          elsif line =~ /^\S/
-            in_dependencies_section = false
-          elsif in_dependencies_section
-            dep_section << line
+      class Parse10 < Parse09
+        def parse
+          unless @contents.index(/^DEPENDENCIES/)
+            return super
+          end
+          dep_section = ""
+          in_dependencies_section = false
+          @contents.each_line do |line|
+            if line =~ /^DEPENDENCIES/
+              in_dependencies_section = true
+            elsif line =~ /^\S/
+              in_dependencies_section = false
+            elsif in_dependencies_section
+              dep_section << line
+            end
           end
-        end
 
-        unless dep_section.length > 0
-          raise "Couldn't parse #{@contents}; exiting"
-          exit(1)
-        end
+          unless dep_section.length > 0
+            raise "Couldn't parse #{@contents}; exiting"
+            exit(1)
+          end
 
-        result = dep_section.scan(/^\s*bundler\s*\(=\s*([^\)]+)\)/).first
-        bundler_version = result ? result.first : nil
-        [:bundler10, bundler_version]
+          result = dep_section.scan(/^\s*bundler\s*\(=\s*([^\)]+)\)/).first
+          bundler_version = result ? result.first : nil
+          [:bundler10, bundler_version]
+        end
       end
-    end
 
-    class Parse106 < Parse10
-      def parse
-        unless @contents.index(/^METADATA/)
-          return super
-        end
-        meta_section = ""
-        in_meta_section = false
-        @contents.each_line do |line|
-          if line =~ /^METADATA/
-            in_meta_section = true
-          elsif line =~ /^\S/
-            in_meta_section = false
-          elsif in_meta_section
-            meta_section << line
+      class Parse106 < Parse10
+        def parse
+          unless @contents.index(/^METADATA/)
+            return super
+          end
+          meta_section = ""
+          in_meta_section = false
+          @contents.each_line do |line|
+            if line =~ /^METADATA/
+              in_meta_section = true
+            elsif line =~ /^\S/
+              in_meta_section = false
+            elsif in_meta_section
+              meta_section << line
+            end
           end
-        end
 
-        unless meta_section.length > 0
-          raise "Couldn't parse #{@contents}; exiting"
-          exit(1)
-        end
+          unless meta_section.length > 0
+            raise "Couldn't parse #{@contents}; exiting"
+            exit(1)
+          end
 
-        result = meta_section.scan(/^\s*version:\s*(.*)$/).first
-        bundler_version = result ? result.first : nil
-        [:bundler10, bundler_version]
+          result = meta_section.scan(/^\s*version:\s*(.*)$/).first
+          bundler_version = result ? result.first : nil
+          [:bundler10, bundler_version]
+        end
       end
-    end
 
+    end
   end
 end

data/lib/engineyard-serverside/logged_output.rb

@@ -1,78 +1,80 @@
 require 'open4'
 
 module EY
-  module LoggedOutput
+  module Serverside
+    module LoggedOutput
 
-    class Tee
-      def initialize(*streams)
-        @streams = streams.flatten
-      end
+      class Tee
+        def initialize(*streams)
+          @streams = streams.flatten
+        end
 
-      def <<(output)
-        @streams.each do |s|
-          s << output
-          s.flush
+        def <<(output)
+          @streams.each do |s|
+            s << output
+            s.flush
+          end
+          self
         end
-        self
-      end
-    end # Tee
+      end # Tee
 
-    @@logfile = File.join(ENV['HOME'], 'ey.log')
-    def self.logfile=(filename)
-      File.unlink filename if File.exist?(filename)  # start fresh
-      @@logfile = filename
-    end
+      @@logfile = File.join(ENV['HOME'], 'ey.log')
+      def self.logfile=(filename)
+        File.unlink filename if File.exist?(filename)  # start fresh
+        @@logfile = filename
+      end
 
-    def self.logfile
-      @@logfile
-    end
+      def self.logfile
+        @@logfile
+      end
 
-    @@verbose = false
-    def self.verbose=(v)
-      @@verbose = !!v
-    end
+      @@verbose = false
+      def self.verbose=(v)
+        @@verbose = !!v
+      end
 
-    def self.verbose?
-      @@verbose
-    end
+      def self.verbose?
+        @@verbose
+      end
 
-    def verbose?
-      EY::LoggedOutput.verbose?
-    end
+      def verbose?
+        EY::Serverside::LoggedOutput.verbose?
+      end
 
-    def info(msg)
-      with_logfile do |log|
-        Tee.new($stdout, log) << (msg + "\n")
+      def info(msg)
+        with_logfile do |log|
+          Tee.new($stdout, log) << (msg + "\n")
+        end
       end
-    end
 
-    def debug(msg)
-      with_logfile do |log|
-        log << "#{msg}\n"
+      def debug(msg)
+        with_logfile do |log|
+          log << "#{msg}\n"
+        end
       end
-    end
 
-    def logged_system(cmd)
-      with_logfile do |log|
-        out = verbose? ? Tee.new($stdout, log) : log
-        err = Tee.new($stderr, log)    # we always want to see errors
+      def logged_system(cmd)
+        with_logfile do |log|
+          out = verbose? ? Tee.new($stdout, log) : log
+          err = Tee.new($stderr, log)    # we always want to see errors
+
+          out <<  ":: running #{cmd}\n"
 
-        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
 
-        # :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
+      private
+      def with_logfile
+        File.open(logfile, 'a') {|f| yield f }
       end
-    end
 
-    private
-    def with_logfile
-      File.open(logfile, 'a') {|f| yield f }
-    end
+      def logfile
+        EY::Serverside::LoggedOutput.logfile
+      end
 
-    def logfile
-      EY::LoggedOutput.logfile
     end
-
   end
 end