truex-skylight 0.6.0

data/lib/skylight/util/inflector.rb

@@ -0,0 +1,110 @@
+module Skylight
+  module Util
+    module Inflector
+      extend self
+
+      # From https://github.com/rails/rails/blob/f8e5022c73679f41db9bb6743179bab4571fb28e/activesupport/lib/active_support/inflector/methods.rb
+
+      # 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

@@ -0,0 +1,87 @@
+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
+        @logger.<<(*args)
+      end
+
+      def close
+      end
+    end
+
+    module Logging
+      def self.trace?
+        ENV[TRACE_ENV_KEY]
+      end
+
+      if trace?
+        def trace(msg, *args)
+          log :debug, msg, *args
+        end
+
+        def t
+          log :debug, yield
+        end
+      else
+        def trace(*)
+        end
+
+        def t
+        end
+      end
+
+      def debug(msg, *args)
+        log :debug, msg, *args
+      end
+
+      def info(msg, *args)
+        log :info, msg, *args
+      end
+
+      def warn(msg, *args)
+        log :warn, msg, *args
+      end
+
+      def error(msg, *args)
+        log :error, msg, *args
+      end
+
+      alias log_trace trace
+      alias log_debug debug
+      alias log_info  info
+      alias log_warn  warn
+      alias log_error error
+
+      alias fmt       sprintf
+
+      def log(level, msg, *args)
+        return unless respond_to?(:config)
+        return unless c = config
+
+        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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,205 @@
+require 'uri'
+require 'logger'
+require 'net/http'
+require 'fileutils'
+require 'digest/sha2'
+require 'skylight/util/ssl'
+
+# Used from extconf.rb
+module Skylight
+  module Util
+    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
+
+      def self.fetch(opts = {})
+        fetcher = new(
+          BASE_URL,
+          opts[:target],
+          opts[:version],
+          opts[:checksum],
+          opts[:arch],
+          opts[:required],
+          opts[:platform],
+          opts[:logger] || Logger.new(STDOUT))
+
+        fetcher.fetch
+      end
+
+      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
+
+      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
+              else
+                log "fetching native ext; uri=#{uri}; redirected=#{res}"
+                uri = res
+
+                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
+
+      def http_get(host, port, use_ssl, path, out)
+        if http_proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+          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
+
+      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
+
+      def source_uri
+        "#{@source}/#{@version}/#{basename}"
+      end
+
+      def deconstruct_uri(uri)
+        uri = URI(uri)
+        [ uri.host, uri.port, uri.scheme == 'https', uri.request_uri ]
+      end
+
+      def maybe_raise(err)
+        error err
+
+        if @required
+          raise err
+        end
+      end
+
+      def log(msg)
+        msg = "[SKYLIGHT] #{msg}"
+        @log.info msg
+      end
+
+      def error(msg, e=nil)
+        msg = "[SKYLIGHT] #{msg}"
+        msg << "\n#{e.backtrace.join("\n")}" if e
+        @log.error msg
+      end
+    end
+  end
+end

data/lib/skylight/util/platform.rb

@@ -0,0 +1,67 @@
+require 'rbconfig'
+
+# Used from extconf and to load libskylight
+module Skylight
+  module Util
+    module Platform
+      # Normalize the platform OS
+      OS = case os = RbConfig::CONFIG['host_os'].downcase
+      when /linux/
+        "linux"
+      when /darwin/
+        "darwin"
+      when /freebsd/
+        "freebsd"
+      when /netbsd/
+        "netbsd"
+      when /openbsd/
+        "openbsd"
+      when /sunos|solaris/
+        "solaris"
+      when /mingw|mswin/
+        "windows"
+      else
+        os
+      end
+
+      # Normalize the platform CPU
+      ARCH = case cpu = RbConfig::CONFIG['host_cpu'].downcase
+      when /amd64|x86_64/
+        "x86_64"
+      when /i?86|x86|i86pc/
+        "x86"
+      when /ppc|powerpc/
+        "powerpc"
+      when /^arm/
+        "arm"
+      else
+        cpu
+      end
+
+      LIBEXT = case OS
+      when /darwin/
+        'dylib'
+      when /linux|bsd|solaris/
+        'so'
+      when /windows|cygwin/
+        'dll'
+      else
+        'so'
+      end
+
+      TUPLE = "#{ARCH}-#{OS}"
+
+      def self.tuple
+        TUPLE
+      end
+
+      def self.libext
+        LIBEXT
+      end
+
+      def self.dlext
+        RbConfig::CONFIG['DLEXT']
+      end
+    end
+  end
+end