nucleus 0.1.0

data/lib/nucleus/core/common/logging/multi_logger.rb

@@ -0,0 +1,59 @@
+# The MultiLogger allows to log messages not only to a file OR the stdout,
+# but to both or even more loggers at the same time.
+# The severity defaults to WARN but can be specified when instantiating the MultiLogger.
+#
+#    log_1 = Logger.new(STDOUT)
+#    log_2 = Logger.new(File.open('/tmp/foo'))
+#    multi_logger = MultiLogger.new(:level => Logger::WARN, :loggers => log_1)
+#    multi_logger.add_logger(log_2)
+#    multi_logger.warn('Something interesting happened.')
+#
+# By Chris Lowder, see https://gist.github.com/clowder/3639600
+class MultiLogger
+  attr_reader :level
+
+  # Initialize the MultiLogger, specify the severity level for all loggers
+  # and add one or more loggers.
+  #
+  # @param [Hash] args the options to create a message with.
+  # @option args [Integer] :level (2) The severity level
+  # @option args [Array<Logger>] :loggers ([]) The loggers that are initially to be added
+  # @return the object
+  def initialize(args = {})
+    @level = args[:level] || Logger::Severity::WARN
+    @loggers = []
+
+    Array(args[:loggers]).each { |logger| add_logger(logger) }
+  end
+
+  # Add a logger to the MultiLogger and adjust its level to the MultiLogger's current level.
+  #
+  # @param [Logger] logger the logger to add to the MultiLogger instance
+  def add_logger(logger)
+    logger.level = level
+    @loggers << logger
+  end
+
+  # Adjust the MultiLogger's current level.
+  #
+  # @param [Integer] level the severity level to apply to the MultiLogger instance
+  def level=(level)
+    @level = level
+    @loggers.each { |logger| logger.level = level }
+  end
+
+  # Close each Logger of the MultiLogger instance
+  def close
+    @loggers.map(&:close)
+  end
+
+  Logger::Severity.constants.each do |level|
+    define_method(level.downcase) do |*args|
+      @loggers.each { |logger| logger.send(level.downcase, args) }
+    end
+
+    define_method("#{level.downcase}?".to_sym) do
+      @level <= Logger::Severity.const_get(level)
+    end
+  end
+end

data/lib/nucleus/core/common/logging/request_log_formatter.rb

@@ -0,0 +1,48 @@
+require 'English'
+
+module Nucleus
+  module Logging
+    class Formatter
+      FORMAT = "%s, %38s [%s#%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        if Thread.current[:nucleus_request_id].nil?
+          # if there is no request id, then fill up the space
+          request_part = "[#{'*' * 36}]"
+        else
+          request_part = "[#{Thread.current[:nucleus_request_id]}]"
+        end
+
+        format(FORMAT, severity[0..0], request_part, format_datetime(time),
+               $PID, severity, progname, msg2str(msg))
+      end
+
+      private
+
+      def format_datetime(time)
+        if @datetime_format.nil?
+          format(time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ', time.usec)
+        else
+          time.strftime(@datetime_format)
+        end
+      end
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/core/common/ssh_handler.rb

@@ -0,0 +1,108 @@
+module Nucleus
+  class SSHHandler
+    include Nucleus::Logging
+
+    attr_reader :key_file
+
+    # Setup the SSHHandler.
+    # @param [String] custom_ssh_key_file path to the key file
+    # @return [Nucleus::SSHHandler] the created instance
+    def initialize(custom_ssh_key_file = nil)
+      @custom_ssh_key_file = custom_ssh_key_file
+      @key_file = @custom_ssh_key_file
+      @key_file_history = []
+      @agent_file_history = []
+
+      if custom_ssh_key_file
+        # file must not be accessible by others, otherwise usage will be forbidden by git.
+        FileUtils.chmod(0600, custom_ssh_key_file) if OS.unix?
+        cache_public_key
+      end
+
+      # create the initial agent / key combination
+      create_agent_key_combo
+    end
+
+    # Get the public key that shall be used for authentication.
+    # Furthermore, the method assures that the agent, which was registered in the GIT_SSH variable, is available.
+    # @return [String] ssh public key in full format (type, value, comment)
+    def public_key
+      return @public_key if File.exist?(@agent_file) && File.exist?(@key_file)
+      # create the agent and key if at least one file does not exist (anymore)
+      create_agent_key_combo
+      @public_key
+    end
+
+    # Cleanup all created tmp files. Usually to be invoked before shutdown.
+    def cleanup
+      @agent_file_history.each { |af| FileUtils.rm_f(af) }
+      @key_file_history.each { |kf| FileUtils.rm_f(kf) }
+    end
+
+    private
+
+    def create_agent_key_combo
+      log.debug('(Re-) creating the nucleus ssh agent')
+
+      # create a new private key
+      create_private_key
+
+      # save the agent file
+      create_agent
+
+      # add to history so that it will be cleaned up
+      add_history_entry
+
+      # finally apply the custom SSH script
+      Git.configure { |config| config.git_ssh = @agent_file }
+    end
+
+    def create_private_key
+      # only create a new tmp key if no custom key location was specified
+      return if @custom_ssh_key_file
+
+      log.debug('Create new private key file')
+      @key_file = File.expand_path(File.join(Dir.tmpdir, 'nucleus', 'ssh', 'key', "#{SecureRandom.uuid}.pem"))
+      # make sure key file path exists
+      FileUtils.mkdir_p(File.dirname(@key_file))
+
+      # generates default key of type RSA and with 2048 bits
+      File.write(@key_file, SSHKey.generate(type: 'RSA', bits: 2048, comment: 'tmp_key_4_nucleus').private_key)
+      cache_public_key
+
+      # file must not be accessible by others, otherwise usage will be forbidden by git.
+      FileUtils.chmod(0600, @key_file) if OS.unix?
+    end
+
+    def create_agent
+      # use uuid so that more than one instance can run at the same time
+      @agent_file = File.expand_path(File.join(Dir.tmpdir, 'nucleus', 'ssh', 'agent', SecureRandom.uuid))
+      # windows requires the extension, otherwise git complains that it can't spawn such a file
+      @agent_file = "#{@agent_file}.bat" if OS.windows?
+      # make sure agent file path exists
+      FileUtils.mkdir_p(File.dirname(@agent_file))
+
+      # adapt the agent file to OS specific requirements
+      if OS.unix?
+        File.write(@agent_file, "ssh -i #{@key_file} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $*")
+        FileUtils.chmod(0700, @agent_file)
+      else
+        File.write(@agent_file, "@echo off\r\nssh -i #{@key_file} -o UserKnownHostsFile=NUL "\
+          '-o StrictHostKeyChecking=no %*')
+      end
+    end
+
+    def add_history_entry
+      @key_file_history.push(@key_file) unless @custom_ssh_key_file
+      @agent_file_history.push(@agent_file)
+    end
+
+    def cache_public_key
+      @public_key = SSHKey.new(File.read(@key_file), comment: 'Nucleus').ssh_public_key
+    rescue
+      msg = "Invalid custom SSH key '#{@key_file}', must be of type ssh-rsa."
+      STDERR.puts msg
+      raise Nucleus::StartupError.new(msg, Nucleus::ExitCodes::INVALID_SSH_KEY)
+    end
+  end
+end

data/lib/nucleus/core/common/stream_callback.rb

@@ -0,0 +1,27 @@
+module Nucleus
+  class StreamCallback
+    include Nucleus::Logging
+
+    attr_accessor :closed
+
+    def initialize(stream)
+      @stream = stream
+      @closed = false
+    end
+
+    # Send a message via the stream to the client
+    # @param [String] message content to send to the client
+    def send_message(message)
+      log.debug "New streamed message part: #{message}"
+      @stream.chunk message
+    end
+
+    # Close the stream
+    # @return [void]
+    def close
+      log.debug 'Close API stream, invoked by adapter callback'
+      # close API stream of the Rack server unless it was already closed
+      @stream.close unless @closed
+    end
+  end
+end

data/lib/nucleus/core/common/thread_config_accessor.rb

@@ -0,0 +1,85 @@
+# Redefines the Class and provides the thread_lib_accessor.
+#
+# If invoked with a variable name, the class and its instances can be used
+# as a key-value config for that variable name.
+# E.g.:
+#    class ThreadedConfig
+#      thread_config_accessor :some_setting, :default => 5
+#    end
+#
+#    class TestThreadedConfig < Test::Unit::TestCase
+#      def test_that_the_accessors_work!
+#        # create instance
+#        config = ThreadedConfig.new
+#        # assign value to the class
+#        ThreadedConfig.setting_a = 1
+#
+#        # value is equal for both, class and instance
+#        assert_equal 1, ThreadedConfig.setting_a
+#        assert_equal 1, config.setting_a
+#
+#        # create new Thread, which should NOT have the values assigned
+#        Thread.new {
+#          config.setting_a = 2
+#          assert_equal 2, ThreadedConfig.setting_a
+#          assert_equal 2, config.setting_a
+#        }.join
+#
+#        # create new Thread and assert the default value was assigned
+#        Thread.new { assert_equal 5, ThreadedConfig.setting_a }.join
+#
+#        assert_equal 1, ThreadedConfig.setting_a
+#      end
+#    end
+#
+# By coderrr (Steve), see https://coderrr.wordpress.com/2008/04/10/lets-stop-polluting-the-threadcurrent-hash/
+class Class
+  # Binds accessors to the class and its instances and allows to use them as thread-bound config
+  def thread_config_accessor(name, options = {})
+    mod = Module.new
+    mod.module_eval do
+      class_variable_set :"@@#{name}", Hash.new { |h, k| h[k] = options[:default] }
+    end
+
+    # use finalizer to prevent memory leaks and clean-up when threads die
+    mod.module_eval %{
+      FINALIZER = lambda {|id| @@#{name}.delete id }
+
+      def #{name}
+        @@#{name}[Thread.current.object_id]
+      end
+
+      def #{name}=(val)
+        ObjectSpace.define_finalizer Thread.current, FINALIZER  unless @@#{name}.has_key? Thread.current.object_id
+        @@#{name}[Thread.current.object_id] = val
+      end
+    }
+
+    class_eval do
+      include mod
+      extend mod
+    end
+  end
+
+  # Binds accessors to the class and its instances and allows to use them as (read-only) thread-bound config
+  def thread_config_accessor_readonly(name, options = {})
+    mod = Module.new
+    mod.module_eval do
+      class_variable_set :"@@#{name}", Hash.new { |h, k| h[k] = options[:default] }
+    end
+
+    # use finalizer to prevent memory leaks and clean-up when threads die
+    mod.module_eval %{(
+      FINALIZER = lambda {|id| @@#{name}.delete id }
+
+      def #{name}
+        @@#{name}[Thread.current.object_id]
+      end
+    )}
+
+    class_eval do
+      include mod
+      extend mod
+    end
+  end
+end

data/lib/nucleus/core/common/url_converter.rb

@@ -0,0 +1,28 @@
+module Nucleus
+  module UrlConverter
+    # Convert the URL to the secure 'HTTPS' scheme. Passed URLs must be in one of the following forms:
+    #    {scheme}://{prefix.}host.domain
+    #    {prefix.}host.domain
+    #
+    # An url that would raise an {::ArgumentError} is
+    #    /path/to/somewhere
+    #
+    # @param [String] url_to_secure url that shall be converted to use HTTPS
+    # @raise ArgumentError if url is not absolute, starts with a '/'
+    # @return [String] url with HTTPS scheme
+    def secure_url(url_to_secure)
+      # return if URL already is secure
+      return url_to_secure if url_to_secure =~ /\A#{URI.regexp(['https'])}\z/
+      throw ArgumentError, "Invalid URL '#{url_to_secure}', can't secure relative URL" if url_to_secure.start_with?('/')
+      uri = URI.parse(url_to_secure)
+      if uri.scheme.nil?
+        uri = "https://#{url_to_secure}"
+        secured_url = uri.to_s
+      elsif uri.scheme != 'https'
+        uri.scheme = 'https'
+        secured_url = uri.to_s
+      end
+      secured_url
+    end
+  end
+end

data/lib/nucleus/core/enums/application_states.rb

@@ -0,0 +1,26 @@
+module Nucleus
+  module Enums
+    # All states that an application can obtain according to the lifecycle of Nucleus apps.
+    module ApplicationStates
+      # Application is created, no data has been deployed yet to any of the instances.
+      CREATED = :created
+      # Application crashed, none of the instances is running.
+      # here was an error while starting or running the application-
+      CRASHED = :crashed
+      # All instances of the application were idled by the platform.
+      IDLE = :idle
+      # At least one instance of the application is running.
+      RUNNING = :running
+      # All instances of the already deployed application are stopped.
+      STOPPED = :stopped
+      # The application data has been deployed, but the application was not started yet. No instance is running.
+      DEPLOYED = :deployed
+
+      # List all application states.
+      # @return [Array<Symbol>] Symbols representing an application state
+      def self.all
+        constants
+      end
+    end
+  end
+end

data/lib/nucleus/core/enums/logfile_types.rb

@@ -0,0 +1,28 @@
+module Nucleus
+  module Enums
+    # All types of logs that are distinguished by Nucleus.
+    module ApplicationLogfileType
+      # The API log aggregates all messages that changed the application state, e.g. updating an application.
+      API = :api
+      # The application log includes all messages of the application itself
+      APPLICATION = :application
+      # The build log shows the information of the recent build process(es).
+      BUILD = :build
+      # The error log shows all logged error messages
+      ERROR = :error
+      # All logs marked as +other+ can't be assigned to any of the other states
+      OTHER = :other
+      # The request log shows all requests that were made to the application
+      REQUEST = :request
+      # System logs aggregate all system relevant outputs,
+      # e.g. calling lifecycle operations on application instances
+      SYSTEM = :system
+
+      # List all types of log files.
+      # @return [Array<Symbol>] Symbols representing a log file type
+      def self.all
+        constants
+      end
+    end
+  end
+end

data/lib/nucleus/core/error_messages.rb

@@ -0,0 +1,127 @@
+module Nucleus
+  # The {ErrorMessages} module groups all error definitions that can be returned by the RESTful API.
+  # With its constants, it provides the skeleton to create error messages that comply with the error schema of Nucleus.
+  module ErrorMessages
+    #################
+    # CLIENT ERRORS #
+    #################
+
+    ENDPOINT_BAD_REQUEST = {
+      status: 400,
+      error_code: 400_001,
+      message: 'Bad Request'
+    }
+
+    AUTH_BAD_REQUEST = {
+      status: 400,
+      error_code: 400_002,
+      message: 'Bad Authentication Request'
+    }
+
+    BAD_REQUEST_VALIDATION = {
+      status: 400,
+      error_code: 400_003,
+      message: 'Bad Request: Parameter validation failed'
+    }
+
+    BAD_REQUEST_APP_ARCHIVE = {
+      status: 400,
+      error_code: 400_004,
+      message: 'Bad Request: Application archive is damaged or did not match the declared file format'
+    }
+
+    AUTH_UNAUTHORIZED = {
+      status: 401,
+      error_code: 401_000,
+      message: 'Unauthorized: Authentication failed'
+    }
+
+    ENDPOINT_AUTH_FAILED = {
+      status: 401,
+      error_code: 401_001,
+      message: 'Authentication failed, endpoint rejected authentication attempt'
+    }
+
+    NOT_FOUND = {
+      status: 404,
+      error_code: 404_000,
+      message: 'The resource could not be found'
+    }
+
+    ENDPOINT_NOT_FOUND = {
+      status: 404,
+      error_code: 404_001,
+      message: 'The resource could not be found'
+    }
+
+    INVALID_ACCEPT_HEADER = {
+      status: 406,
+      error_code: 406_000,
+      message: 'Invalid Accept header, vendor or version not found'
+    }
+
+    BAD_REQUEST_ENTITY = {
+      status: 422,
+      error_code: 422_000,
+      message: 'Unprocessable Entity: Request was valid, but has been rejected by the endpoint, '\
+      'saying the message was semantically false. Check the dev_message for detailed error analysis'
+    }
+
+    # All platform specific semantic errors should have a unique error code!
+    PLATFORM_SPECIFIC_ERROR_ENTITY = {
+      status: 422,
+      error_code: 422_001,
+      message: 'Unprocessable Entity: Request format was valid, but has been rejected by the endpoint, '\
+        'saying the message contains data that can not be processed by this specific platform.'
+    }
+
+    # Quota violations are a common issue and therefore deserve their own message ;)
+    PLATFORM_QUOTA_ERROR = {
+      status: 422,
+      error_code: 422_002,
+      message: 'Unprocessable Entity: Request format was valid, but has been rejected by the endpoint. '\
+        'Your account would exceed its quota limits. Please check your account and its billing status.'
+    }
+
+    #################
+    # SERVER ERRORS #
+    #################
+
+    RESCUED = {
+      status: 500,
+      error_code: 500_000,
+      message: 'Oops, something went terribly wrong here :/'
+    }
+
+    RESCUED_ADAPTER_CALL = {
+      status: 500,
+      error_code: 500_001,
+      message: 'Endpoint call failed with unforeseen cause'
+    }
+
+    RESCUED_ADAPTER_CALL_SERVER = {
+      status: 500,
+      error_code: 500_002,
+      message: 'Endpoint crashed with server error'
+    }
+
+    MISSING_IMPLEMENTATION = {
+      status: 501,
+      error_code: 501_000,
+      message: 'Not Implemented'
+    }
+
+    UNAVAILABLE = {
+      status: 503,
+      error_code: 503_000,
+      message: 'Service Unavailable'
+    }
+
+    PLATFORM_GATEWAY_TIMEOUT = {
+      status: 504,
+      error_code: 504_000,
+      message: 'Gateway Timeout. The platform raised an internal Timeout error. We don\'t know to what '\
+        'degree the request has been processed, or if it wasn\'t executed at all.'
+    }
+  end
+end