skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/util/gzip.rb

@@ -1,21 +0,0 @@
-require 'zlib'
-
-module Skylight
-  module Util
-    # Provides Gzip compressing support
-    module Gzip
-
-      # Compress a string with Gzip
-      #
-      # @param str [String] uncompressed string
-      # @return [String] compressed string
-      def self.compress(str)
-        output = StringIO.new
-        gz = Zlib::GzipWriter.new(output)
-        gz.write(str)
-        gz.close
-        output.string
-      end
-    end
-  end
-end

data/lib/skylight/util/inflector.rb

@@ -1,112 +0,0 @@
-module Skylight
-  module Util
-
-    # String Inflector methods
-    #
-    # From https://github.com/rails/rails/blob/f8e5022c73679f41db9bb6743179bab4571fb28e/activesupport/lib/active_support/inflector/methods.rb
-    module Inflector
-      extend self
-
-      # Tries to find a constant with the name specified in the argument string.
-      #
-      #   'Module'.constantize     # => Module
-      #   'Test::Unit'.constantize # => Test::Unit
-      #
-      # The name is assumed to be the one of a top-level constant, no matter
-      # whether it starts with "::" or not. No lexical context is taken into
-      # account:
-      #
-      #   C = 'outside'
-      #   module M
-      #     C = 'inside'
-      #     C               # => 'inside'
-      #     'C'.constantize # => 'outside', same as ::C
-      #   end
-      #
-      # NameError is raised when the name is not in CamelCase or the constant is
-      # unknown.
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-
-        # Trigger a builtin NameError exception including the ill-formed constant in the message.
-        Object.const_get(camel_cased_word) if names.empty?
-
-        # Remove the first blank element in case of '::ClassName' notation.
-        names.shift if names.size > 1 && names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
-
-            # Go down the ancestors to check it it's owned
-            # directly before we reach Object or the end of ancestors.
-            constant = constant.ancestors.inject do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
-              const
-            end
-
-            # owner is in Object, so raise
-            constant.const_get(name, false)
-          end
-        end
-      end
-
-      # Tries to find a constant with the name specified in the argument string.
-      #
-      #   'Module'.safe_constantize     # => Module
-      #   'Test::Unit'.safe_constantize # => Test::Unit
-      #
-      # The name is assumed to be the one of a top-level constant, no matter
-      # whether it starts with "::" or not. No lexical context is taken into
-      # account:
-      #
-      #   C = 'outside'
-      #   module M
-      #     C = 'inside'
-      #     C                    # => 'inside'
-      #     'C'.safe_constantize # => 'outside', same as ::C
-      #   end
-      #
-      # +nil+ is returned when the name is not in CamelCase or the constant (or
-      # part of it) is unknown.
-      #
-      #   'blargle'.safe_constantize  # => nil
-      #   'UnknownModule'.safe_constantize  # => nil
-      #   'UnknownModule::Foo::Bar'.safe_constantize  # => nil
-      def safe_constantize(camel_cased_word)
-        constantize(camel_cased_word)
-      rescue NameError => e
-        raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
-          e.name.to_s == camel_cased_word.to_s
-      rescue ArgumentError => e
-        raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
-      end
-
-      private
-
-      # Mount a regular expression that will match part by part of the constant.
-      #
-      #   const_regexp("Foo::Bar::Baz") # => /(Foo(::Bar(::Baz)?)?|Bar|Baz)/
-      #   const_regexp("::")            # => /::/
-      #
-      # NOTE: We also add each part in singly, because sometimes a search for a missing
-      # constant like Skylight::Foo::Bar will return an error just saying Foo was missing
-      def const_regexp(camel_cased_word) #:nodoc:
-        parts = camel_cased_word.split("::")
-
-        return Regexp.escape(camel_cased_word) if parts.empty?
-
-        regexp = parts.reverse.inject do |acc, part|
-          part.empty? ? acc : "#{part}(::#{acc})?"
-        end
-
-        "(" + ([regexp] + parts[1..-1]).join('|') + ")"
-      end
-    end
-  end
-end

data/lib/skylight/util/logging.rb

@@ -1,127 +0,0 @@
-require 'logger'
-
-module Skylight
-  module Util
-    # Log both to the specified logger and STDOUT
-    class AlertLogger
-      def initialize(logger)
-        @logger = logger
-      end
-
-      def write(*args)
-        STDERR.write *args
-
-        # Try to avoid writing to STDOUT/STDERR twice
-        logger_logdev = @logger.instance_variable_get(:@logdev)
-        logger_out = logger_logdev && logger_logdev.respond_to?(:dev) ? logger_logdev.dev : nil
-        if logger_out != STDOUT && logger_out != STDERR
-          @logger.<<(*args)
-        end
-      end
-
-      def close
-      end
-    end
-
-    module Logging
-
-      def self.trace?
-        ENV[TRACE_ENV_KEY]
-      end
-
-      if trace?
-        # The second set is picked up by YARD
-        def trace(msg, *args)
-          log :debug, msg, *args
-        end
-
-        def t
-          log :debug, yield
-        end
-      else
-        # Logs if `ENV[TRACE_ENV_KEY]` is set.
-        #
-        # @param (see #debug)
-        #
-        # See {TRACE_ENV_KEY}.
-        def trace(msg, *args)
-        end
-
-        # Evaluates and logs the result of the block if `ENV[TRACE_ENV_KEY]` is set
-        #
-        # @yield block to be evaluted
-        # @yieldreturn arguments for {#debug}
-        #
-        # See {TRACE_ENV_KEY}.
-        def t
-        end
-      end
-
-      # @param msg (see #log)
-      # @param args (see #log)
-      def debug(msg, *args)
-        log :debug, msg, *args
-      end
-
-      # @param msg (see #log)
-      # @param args (see #log)
-      def info(msg, *args)
-        log :info, msg, *args
-      end
-
-      # @param msg (see #log)
-      # @param args (see #log)
-      def warn(msg, *args)
-        log :warn, msg, *args
-      end
-
-      # @param msg (see #log)
-      # @param args (see #log)
-      def error(msg, *args)
-        log :error, msg, *args
-        raise sprintf(msg, *args) if ENV['SKYLIGHT_RAISE_ON_ERROR']
-      end
-
-      alias log_trace trace
-      alias log_debug debug
-      alias log_info  info
-      alias log_warn  warn
-      alias log_error error
-
-      # Alias for `Kernel#sprintf`
-      # @return [String]
-      def fmt(*args)
-        sprintf(*args)
-      end
-
-      # @param level [String,Symbol] the method on `logger` to use for logging
-      # @param msg [String] the message to log
-      # @param args [Array] values for `Kernel#sprintf` on `msg`
-      def log(level, msg, *args)
-        c = if respond_to?(:config)
-          config
-        elsif self.is_a?(Config)
-          self
-        end
-
-        return unless c
-
-        if logger = c.logger
-          return unless logger.respond_to?(level)
-
-          if args.length > 0
-            logger.send level, sprintf("[SKYLIGHT] [#{Skylight::VERSION}] #{msg}", *args)
-          else
-            logger.send level, "[SKYLIGHT] [#{Skylight::VERSION}] #{msg}"
-          end
-        end
-      rescue Exception => e
-        if ENV[TRACE_ENV_KEY]
-          puts "[ERROR] #{e.message}"
-          puts e.backtrace
-        end
-      end
-
-    end
-  end
-end

data/lib/skylight/util/multi_io.rb

@@ -1,21 +0,0 @@
-# Util allowing proxying writes to multiple location
-# Used from extconf
-module Skylight
-  module Util
-    class MultiIO
-
-      def initialize(*targets)
-         @targets = targets
-      end
-
-      def write(*args)
-        @targets.each {|t| t.write(*args)}
-      end
-
-      def close
-        @targets.each(&:close)
-      end
-
-    end
-  end
-end

data/lib/skylight/util/native_ext_fetcher.rb

@@ -1,253 +0,0 @@
-require 'uri'
-require 'logger'
-require 'net/http'
-require 'fileutils'
-require 'digest/sha2'
-require 'skylight/util/ssl'
-require 'skylight/util/proxy'
-
-# Used from extconf.rb
-module Skylight
-  module Util
-    # Utility class for fetching the native extension from a URL
-    class NativeExtFetcher
-      BASE_URL = "https://s3.amazonaws.com/skylight-agent-packages/skylight-native"
-      MAX_REDIRECTS = 5
-      MAX_RETRIES = 3
-
-      include FileUtils
-
-      class FetchError < StandardError; end
-
-      # Creates a new fetcher and fetches
-      # @param opts [Hash]
-      def self.fetch(opts = {})
-        fetcher = new(
-          opts[:source] || BASE_URL,
-          opts[:target],
-          opts[:version],
-          opts[:checksum],
-          opts[:arch],
-          opts[:required],
-          opts[:platform],
-          opts[:logger] || Logger.new(STDOUT))
-
-        fetcher.fetch
-      end
-
-      # @param source [String] the base url to download from
-      # @param target [String] file to download as
-      # @param version [String] version to download
-      # @param checksum [String] checksum of the archive
-      # @param arch [String] platform architecture, e.g. `linux-x86_64`
-      # @param required [Boolean] whether the download is required to be successful
-      # @param platform
-      # @param log [Logger]
-      def initialize(source, target, version, checksum, arch, required, platform, log)
-        raise "source required" unless source
-        raise "target required" unless target
-        raise "checksum required" unless checksum
-        raise "arch required" unless arch
-
-        @source = source
-        @target = target
-        @version = version
-        @checksum = checksum
-        @required = required
-        @platform = platform
-        @arch = arch
-        @log = log
-      end
-
-      # Fetch the native extension, verify, inflate, and save (if applicable)
-      #
-      # @return [String] the inflated archive
-      def fetch
-        log "fetching native ext; curr-platform=#{@platform}; " \
-          "requested-arch=#{@arch}; version=#{@version}"
-
-        tar_gz = "#{@target}/#{basename}"
-
-        unless sha2 = fetch_native_ext(source_uri, tar_gz, MAX_RETRIES, MAX_REDIRECTS)
-          maybe_raise "could not fetch native extension"
-          return
-        end
-
-        unless verify_checksum(sha2)
-          maybe_raise "could not verify checksum"
-          return
-        end
-
-        Dir.chdir File.dirname(tar_gz) do
-          system "tar xzvf #{tar_gz}"
-        end
-
-        true
-      ensure
-        rm_f tar_gz if tar_gz
-      end
-
-      def fetch_native_ext(uri, out, attempts, redirects)
-        redirects.times do |i|
-          # Ensure the location is available
-          mkdir_p File.dirname(out)
-          rm_f out
-
-          remaining_attempts = attempts
-
-          log "attempting to fetch from remote; uri=#{uri}"
-
-          begin
-            host, port, use_ssl, path = deconstruct_uri(uri)
-
-            File.open out, 'w' do |f|
-              res, extra = http_get(host, port, use_ssl, path, f)
-
-              case res
-              when :success
-                log "successfully downloaded native ext; out=#{out}"
-                return extra
-              when :redirect
-                log "fetching native ext; uri=#{uri}; redirected=#{res}"
-                uri = extra
-
-                next
-              end
-            end
-          rescue => e
-            remaining_attempts -= 1
-
-            error "failed to fetch native extension; uri=#{uri}; msg=#{e.message}; remaining-attempts=#{remaining_attempts}", e
-
-            if remaining_attempts > 0
-              sleep 2
-              retry
-            end
-
-            return
-          end
-        end
-
-        log "exceeded max redirects"
-        return
-      end
-
-      # Get with `Net::HTTP`
-      #
-      # @param host [String] host for `Net::HTTP` request
-      # @param port [String,Integer] port for `Net::HTTP` request
-      # @param use_ssl [Boolean] whether SSL should be used for this request
-      # @param path [String] the path to request
-      # @param out [IO]
-      #
-      # If `ENV['HTTP_PROXY']` is set, it will be used as a proxy for this request.
-      def http_get(host, port, use_ssl, path, out)
-        if http_proxy = Proxy.detect_url(ENV)
-          log "connecting with proxy: #{http_proxy}"
-          uri = URI.parse(http_proxy)
-          p_host, p_port = uri.host, uri.port
-          p_user, p_pass = uri.userinfo.split(/:/) if uri.userinfo
-        end
-
-        opts = {}
-        opts[:use_ssl] = use_ssl
-
-        if use_ssl
-          opts[:ca_file] = SSL.ca_cert_file_or_default
-        end
-
-        Net::HTTP.start(host, port, p_host, p_port, p_user, p_pass, use_ssl: use_ssl) do |http|
-          http.request_get path do |resp|
-            case resp
-            when Net::HTTPSuccess
-              digest = Digest::SHA2.new
-
-              resp.read_body do |chunk|
-                digest << chunk
-                out.write chunk
-              end
-
-              return [ :success, digest.hexdigest ]
-            when Net::HTTPRedirection
-              unless location = resp['location']
-                raise "received redirect but no location"
-              end
-
-              return [ :redirect, location ]
-            else
-              raise "received HTTP status code #{resp.code}"
-            end
-          end
-        end
-      end
-
-      # Verify the checksum of the archive
-      #
-      # @param actual [String]
-      # @return [Boolean] whether the checksum matches
-      def verify_checksum(actual)
-        unless @checksum == actual
-          log "checksum mismatch; expected=#{@checksum}; actual=#{actual}"
-          return false
-        end
-
-        true
-      rescue Exception => e
-        error "failed to read skylight agent archive; e=#{e.message}"
-        false
-      end
-
-      def basename
-        "skylight_#{@arch}.tar.gz"
-      end
-
-      # The url that will be fetched
-      #
-      # @return String
-      def source_uri
-        "#{@source}/#{@version}/#{basename}"
-      end
-
-      # Split the uri string into its component parts
-      #
-      # @param uri [String] the uri
-      # @return [Array<String>] the host, port, scheme, and request_uri
-      def deconstruct_uri(uri)
-        uri = URI(uri)
-        [ uri.host, uri.port, uri.scheme == 'https', uri.request_uri ]
-      end
-
-      # Log an error and raise if `required` is `true`
-      #
-      # @param err [String]
-      # @return [void]
-      def maybe_raise(err)
-        error err
-
-        if @required
-          raise err
-        end
-      end
-
-      # Log an `info` to the `logger`
-      #
-      # @param msg [String]
-      # @return [void]
-      def log(msg)
-        msg = "[SKYLIGHT] #{msg}"
-        @log.info msg
-      end
-
-      # Log an `error` to the `logger`
-      #
-      # @param msg [String]
-      # @param e [Exception] the exception associated with the error
-      # @return [void]
-      def error(msg, e=nil)
-        msg = "[SKYLIGHT] #{msg}"
-        msg << "\n#{e.backtrace.join("\n")}" if e
-        @log.error msg
-      end
-    end
-  end
-end