nucleus 0.1.0

data/lib/nucleus/core/adapter_extensions/http_tail_client.rb

@@ -0,0 +1,26 @@
+module Nucleus
+  module Adapters
+    module HttpTailClient
+      # Executes a request to the given URL and expects a streaming response.<br>
+      # Each new chunk (usually lines) will be forwarded to the client via the api_stream.
+      #
+      # @param [String] url url to call
+      # @param [Nucleus::API::StreamCallback] api_stream stream to which new chunks will be forwarded
+      # @param [Symbol] http_method HTTP method to use
+      def tail_http_response(url, api_stream, http_method = :get)
+        http_connection = EventMachine::HttpRequest.new(url, inactivity_timeout: 0)
+        http_client = http_connection.send(http_method, keepalive: true)
+
+        # close stream on error
+        http_client.on_error do
+          log.debug('HttpTailClient detected an error, close stream...')
+          api_stream.close
+        end
+        # tail and immediately push the results to the stream
+        http_client.stream { |chunk| api_stream.send_message(chunk) }
+        # return object that responds to :stop and cancels the tailing request
+        TailStopper.new(http_connection, :close)
+      end
+    end
+  end
+end

data/lib/nucleus/core/adapter_extensions/tail_stopper.rb

@@ -0,0 +1,25 @@
+module Nucleus
+  module Adapters
+    # The TailStopper can be used to cancel a timer or an ongoing HTTP request,
+    # e.g. when the underlying connection was terminated.
+    class TailStopper
+      include Nucleus::Logging
+
+      def initialize(polling, method_to_stop)
+        @polling = polling
+        @method_to_stop = method_to_stop
+      end
+
+      # Stop the tailing
+      # @return [void]
+      def stop
+        log.debug('Stop tail updates, connection was closed')
+        begin
+          @polling.method(@method_to_stop).call
+        rescue
+          log.debug('Ignore error while closing connection')
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/core/common/errors/ambiguous_adapter_error.rb

@@ -0,0 +1,7 @@
+module Nucleus
+  class AmbiguousAdapterError < StartupError
+    def initialize(message)
+      super(message, ExitCodes::STARTUP_ERROR)
+    end
+  end
+end

data/lib/nucleus/core/common/errors/file_existence_error.rb

@@ -0,0 +1,7 @@
+module Nucleus
+  class FileExistenceError < StandardError
+    def initialize(message)
+      super(message)
+    end
+  end
+end

data/lib/nucleus/core/common/errors/startup_error.rb

@@ -0,0 +1,12 @@
+module Nucleus
+  class StartupError < StandardError
+    # exit code to use when exiting the application due to this error
+    attr_accessor :exit_code
+
+    # initialize with default exit code of ExitCodes::STARTUP_ERROR
+    def initialize(message, exit_code = ExitCodes::STARTUP_ERROR)
+      super(message)
+      @exit_code = exit_code
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Nucleus
+  # ExitCodes describe why the application failed and was stopped.
+  #
+  # Codes beginning with ___ stand for ___:
+  #
+  # 1xx => Startup failed
+  #
+  module ExitCodes
+    ##########################
+    ### Startup Exceptions ###
+    ##########################
+
+    # Unidentified startup error
+    STARTUP_ERROR = 100
+
+    # Custom SSH key was specified in the options but could not be loaded
+    INVALID_SSH_KEY_FILE = 101
+
+    # Invalid key, invalid or not of format ssh-rsa OpenSSH
+    INVALID_SSH_KEY = 102
+
+    # Invalid private key, we can only accept private keys without a passphrase
+    INVALID_SSH_KEY_FILE_PROTECTED = 103
+  end
+end

data/lib/nucleus/core/common/files/application_repo_sanitizer.rb

@@ -0,0 +1,52 @@
+module Nucleus
+  class ApplicationRepoSanitizer
+    include Nucleus::Logging
+
+    # Create a new instance of the object.
+    # @param [Boolean] exclude_git if true the '.git' directory won't be moved up, but will be ignored.
+    def initialize(exclude_git = true)
+      @exclude_git = exclude_git
+    end
+
+    # Sanitizing the repository_dir will check if the repository has more than one file / directory besides the git DB.
+    # If there is only one directory, all files in this directory are going to be moved one level up.
+    # If there was:
+    #
+    #     .git
+    #     wordfinder
+    #
+    # All contents of `wordfinder` will be moved one level up, resulting in:
+    #
+    #     config
+    #     lib
+    #     public
+    #     specs
+    #     views
+    #     README.md
+    #     server.js
+    #     ...
+    #
+    # @param [String] repository_dir path to the git repository that is going to be sanitized
+    def sanitize(repository_dir)
+      # no sanitizing for files
+      return unless File.directory?(repository_dir)
+      repo_entries = sanitized_dir_entries(repository_dir)
+      return unless repo_entries.length == 1
+
+      log.debug 'Uploaded application is wrapped in folder, fixing now by moving all contents one level up...'
+      dir = File.join(repository_dir, repo_entries[0])
+      dir_entries = sanitized_dir_entries(dir).map { |name| File.join(dir, name) }
+      FileUtils.mv(dir_entries, repository_dir)
+      # Now delete the usually empty directory
+      FileUtils.rm_r dir
+    end
+
+    private
+
+    def sanitized_dir_entries(dir)
+      Dir.entries(dir).reject do |entry|
+        entry == '.DS_Store' || (@exclude_git && entry == '.git') || entry == '.' || entry == '..'
+      end
+    end
+  end
+end

data/lib/nucleus/core/common/files/archive_extractor.rb

@@ -0,0 +1,112 @@
+module Nucleus
+  class ArchiveExtractor
+    def initialize(exclude_git = true)
+      @exclude_git = exclude_git
+    end
+
+    # Extract the file to the destination path.
+    # The compression format indicates which method must be used to extract the archive.
+    # @param [IO] file in-memory archive file to extract
+    # @param [String] destination_path where the archive is going to be extracted to
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @raise [StandardError] if the compression_format is not supported and can't be extracted
+    # @return [Integer] number of extracted files
+    def extract(file, destination_path, compression_format)
+      compression_method = compression_format_method_name(compression_format)
+      fail StandardError, 'Unsupported compression format' unless respond_to?(compression_method, true)
+
+      # be sure that directory exists
+      FileUtils.mkdir_p(destination_path, verbose: false)
+
+      begin
+        send(compression_method, file, destination_path)
+      rescue Zip::Error, Zlib::GzipFile::Error
+        raise API::Errors::ApplicationArchiveError, "Failed to extract #{compression_format} archive"
+      end
+    end
+
+    # Checks if the compression format is supported and an archive of this type could be extracted.
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @return [Boolean] true if format is supported, false if not
+    def supports?(compression_format)
+      compression_method = compression_format_method_name(compression_format)
+      respond_to?(compression_method, true)
+    end
+
+    private
+
+    def compression_format_method_name(compression_format)
+      "un_#{compression_format.downcase.gsub(/\./, '_').underscore}".to_sym
+    end
+
+    def un_zip(file, destination_path)
+      extracted = 0
+      Zip::File.open(file) do |zip_file|
+        # Handle entries one by one
+        zip_file.each do |entry|
+          next if @exclude_git && entry.name.start_with?('.git')
+          dest = File.join(destination_path, entry.name)
+          if entry.name_is_directory?
+            FileUtils.mkdir_p(dest) unless File.exist?(dest)
+          else
+            # make sure parent directory exists
+            FileUtils.mkdir_p(File.expand_path('..', dest))
+
+            entry.extract(dest) unless File.exist?(dest)
+            # increase count
+            extracted += 1
+          end
+        end
+      end
+      extracted
+    end
+
+    def un_tar_gz(file, destination_path)
+      extracted = 0
+      # unzip the archive into the repo, closes resource automatically
+      # Thanks to Draco Ater: http://stackoverflow.com/a/19139114/1009436
+      Gem::Package::TarReader.new(Zlib::GzipReader.open(file)) do |tar|
+        dest = nil
+        tar.each do |entry|
+          # Process Longlinks and skip to next entry
+          if entry.full_name == '././@LongLink'
+            dest = File.join(destination_path, entry.read.strip)
+            next
+          end
+
+          # Process default entry types (dir, file, symlink)
+          full_name = entry.full_name.sub(%r{(\.\/)?}, '')
+          dest ||= File.join(destination_path, full_name)
+          next if tar_git_entry? full_name
+          if entry.directory?
+            write_tar_dir_entry(entry, dest)
+          elsif entry.file?
+            write_tar_file_entry(entry, dest)
+            # increase count
+            extracted += 1
+          elsif entry.header.typeflag == '2'
+            # handle symlinks
+            File.symlink(entry.header.linkname, dest)
+          end
+          dest = nil
+        end
+      end
+    end
+    alias_method :un_tgz, :un_tar_gz
+
+    def tar_git_entry?(full_name)
+      @exclude_git && (full_name.start_with?('._.git') || full_name.start_with?('.git'))
+    end
+
+    def write_tar_file_entry(entry, dest)
+      FileUtils.rm_rf(dest) if File.directory?(dest)
+      File.open(dest, 'wb') { |f| f.print entry.read }
+      FileUtils.chmod(entry.header.mode, dest, verbose: false)
+    end
+
+    def write_tar_dir_entry(entry, dest)
+      File.delete(dest) if File.file?(dest)
+      FileUtils.mkdir_p(dest, mode: entry.header.mode, verbose: false)
+    end
+  end
+end

data/lib/nucleus/core/common/files/archiver.rb

@@ -0,0 +1,91 @@
+module Nucleus
+  class Archiver
+    def initialize(exclude_git = true)
+      @exclude_git = exclude_git
+    end
+
+    # Compress the files of the path into an archive, using the compression format,
+    # which indicates which method must be used to compress the archive.
+    # @param [String] path which directory's contents are going to be compressed into the archive
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @raise [StandardError] if the compression_format is not supported and the directory can't be compressed
+    # @return [StringIO] compressed data of the given input path
+    def compress(path, compression_format)
+      compression_method = compression_format.downcase.gsub(/\./, '_').underscore.to_sym
+      fail StandardError,
+           "Unsupported compression format #{compression_format}" unless self.respond_to?(compression_method, true)
+      send(compression_method, path)
+    end
+
+    private
+
+    def tar(path)
+      string_io = StringIO.new('')
+      Gem::Package::TarWriter.new(string_io) do |tar|
+        Find.find(path) do |file|
+          # do not include the git files
+          next if @exclude_git && file.start_with?("#{path}/.git")
+
+          mode = File.stat(file).mode
+          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
+
+          if File.directory?(file)
+            tar.mkdir relative_file, mode
+          else
+            tar.add_file relative_file, mode do |tf|
+              File.open(file, 'rb') { |f| tf.write f.read }
+            end
+          end
+        end
+      end
+      string_io.rewind
+      string_io
+    end
+
+    def tar_gz(path)
+      tar_file = tar(path)
+      begin
+        gz = StringIO.new('')
+        z = Zlib::GzipWriter.new(gz)
+        z.write tar_file.string
+      ensure
+        z.close unless z.nil?
+      end
+
+      # z was closed to write the gzip footer, so
+      # now we need a new StringIO
+      StringIO.new gz.string
+    end
+
+    def zip(path)
+      string_io = Zip::OutputStream.write_buffer do |zio|
+        Find.find(path) do |file|
+          # do not process directories && do not include the Git DB files
+          next if File.directory?(file) || (@exclude_git && file.start_with?("#{path}/.git"))
+
+          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
+          zio.put_next_entry(relative_file)
+          File.open(file, 'rb') do |f|
+            zio.write f.read
+          end
+        end
+      end
+      string_io.rewind
+      string_io
+    end
+
+    def write_zip_entries(path, sub_path, io)
+      search_path = File.join(path, sub_path)
+      Find.find(path) do |file|
+        zip_file_path = file.sub(%r{^#{Regexp.escape search_path}\/?}, '')
+        next if @exclude_git && zip_file_path.start_with?('.git')
+        if File.directory?(file)
+          io.mkdir(zip_file_path)
+          write_zip_entries(path, zip_file_path, io)
+        else
+          io.get_output_stream(zip_file_path) { |f| f.print(File.open(file, 'rb').read) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Nucleus
+  class LinkGenerator
+    def initialize(env, api_version)
+      @env = env
+      @version = api_version
+    end
+
+    # Generate the link that references the resource.
+    # @param [Array<String>] namespaces nested namespaces that must be joined to access the resource
+    # @param [String] id id of the resource
+    # @return [String] URL to the resource
+    def resource(namespaces, id)
+      # resource can only exist for an API version
+      link = api_root
+      # combine namespace and entity ID
+      link << namespace(namespaces)
+      link << "/#{id}" unless id.nil? || id.empty?
+      # return the created link
+      link
+    end
+
+    # Create a link to the API root node.
+    #
+    # @return [String] link to the API root
+    def api_root
+      root_url << '/api'
+    end
+
+    # Get the root URL of the Nucleus API (scheme + host)
+    def root_url
+      "#{@env['rack.url_scheme']}://#{@env['HTTP_HOST']}"
+    end
+
+    private
+
+    def namespace(namespaces)
+      if namespaces.is_a?(String) && !namespaces.empty?
+        "/#{namespaces}"
+      elsif !namespaces.nil? && !namespaces.empty?
+        "/#{namespaces.join('/')}"
+      else
+        ''
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Nucleus
+  # Logging module for Nucleus.
+  # Include via
+  #     include Nucleus::Logging
+  # and then log your messages:
+  #    log.info('This is a test log message')
+  #
+  # @author Willem Buys
+  # Idea by Willem 'Jacob' Buys, as seen on http://stackoverflow.com/questions/917566/ruby-share-logger-instance-among-module-classes
+  module Logging
+    def log
+      @log ||= Logging.logger_for(self.class.name)
+    end
+
+    # Use a hash class-ivar to cache a unique Logger per class:
+    @loggers = {}
+
+    class << self
+      def logger_for(classname)
+        @loggers[classname] ||= configure_logger_for(classname)
+      end
+
+      def configure_logger_for(classname)
+        # prepare logging dir
+        log_dir = nucleus_config.logging.path
+        log_file = File.join(log_dir, 'nucleus.log')
+        # prepare path and create missing directories
+        FileUtils.mkdir_p(log_dir) unless File.directory?(log_dir)
+        # create the loggers
+        std_log = Logger.new(STDOUT)
+        # use rotation for x days
+        file_log = Logger.new(log_file, 'daily', 7)
+
+        # include custom log format that includes the request id
+        formatter = Nucleus::Logging::Formatter.new
+
+        [file_log, std_log].each do |logger|
+          # apply format
+          logger.formatter = formatter
+          # apply the classname
+          logger.progname = classname
+        end
+
+        # apply the log level from the app. configuration
+        multi_logger = MultiLogger.new(
+          level: nucleus_config.logging.key?(:level) ? nucleus_config.logging.level : Logger::Severity::WARN,
+          loggers: [std_log, file_log])
+        multi_logger
+      end
+    end
+  end
+end