nucleus 0.1.0

data/lib/nucleus/core/errors/adapter_error.rb

@@ -0,0 +1,13 @@
+module Nucleus
+  module Errors
+    class AdapterError < StandardError
+      # error constant to use when exiting the application due to this error
+      attr_accessor :ui_error
+
+      def initialize(message, ui_error)
+        super(message)
+        @ui_error = ui_error
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/adapter_missing_implementation_error.rb

@@ -0,0 +1,12 @@
+module Nucleus
+  module Errors
+    # The {AdapterMissingImplementationError} shall be thrown when the API requests an adapter to execute an action,
+    # e.g. update an application, but the adapter does not (yet) support this functionality.
+    class AdapterMissingImplementationError < AdapterError
+      # initialize with default error to be 501
+      def initialize(message, ui_error = ErrorMessages::MISSING_IMPLEMENTATION)
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/adapter_request_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class AdapterRequestError < AdapterError
+      # initialize with default error to be 400
+      def initialize(message, ui_error = ErrorMessages::ENDPOINT_BAD_REQUEST)
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/adapter_resource_not_found_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class AdapterResourceNotFoundError < AdapterError
+      # initialize with default error to be 404, endpoint resource not found
+      def initialize(message, ui_error = ErrorMessages::ENDPOINT_NOT_FOUND)
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/endpoint_authentication_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class EndpointAuthenticationError < AdapterError
+      # initialize with default error to be 401, authentication failed
+      def initialize(message, ui_error = ErrorMessages::AUTH_UNAUTHORIZED)
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/platform_specific_semantic_error.rb

@@ -0,0 +1,12 @@
+module Nucleus
+  module Errors
+    class PlatformSpecificSemanticError < AdapterError
+      # initialize with default error to be 422
+      def initialize(message, error_code = nil, ui_error = ErrorMessages::PLATFORM_SPECIFIC_ERROR_ENTITY)
+        # allow to customize the error code
+        ui_error[:error_code] = error_code unless error_code.nil?
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/platform_timeout_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class PlatformTimeoutError < AdapterError
+      # initialize with default error to be 504
+      def initialize(message)
+        super(message, ErrorMessages::PLATFORM_GATEWAY_TIMEOUT)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/platform_unavailable_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class PlatformUnavailableError < AdapterError
+      # initialize with default error to be 503
+      def initialize(message)
+        super(message, ErrorMessages::UNAVAILABLE)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/semantic_adapter_request_error.rb

@@ -0,0 +1,19 @@
+module Nucleus
+  module Errors
+    # The {SemanticAdapterRequestError} shall be thrown if the user request could not be executed due to logical errors.
+    # <br>
+    # Examples for semantic errors are:
+    #   - name already used
+    #   - quota violations
+    # <br>
+    # These errors are clearly to be distinguished from malformed requests.
+    class SemanticAdapterRequestError < AdapterError
+      # initialize with default error to be 422
+      def initialize(message, error_code = nil, ui_error = ErrorMessages::BAD_REQUEST_ENTITY)
+        # allow to customize the error code
+        ui_error[:error_code] = error_code unless error_code.nil?
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/errors/unknown_adapter_call_error.rb

@@ -0,0 +1,10 @@
+module Nucleus
+  module Errors
+    class UnknownAdapterCallError < AdapterError
+      # initialize with default error to be 500
+      def initialize(message, ui_error = ErrorMessages::RESCUED_ADAPTER_CALL)
+        super(message, ui_error)
+      end
+    end
+  end
+end

data/lib/nucleus/core/file_handling/archive_converter.rb

@@ -0,0 +1,29 @@
+module Nucleus
+  module Adapters
+    # The {ArchiveConverter} shall be used within the adapters to prepare application containers for deployment
+    # on the endpoint, by converting archives, e.g. from +tar.gz+ to +zip+, to match the endpoint APIs requirements.
+    module ArchiveConverter
+      extend Nucleus::Logging
+
+      # Convert an archived application, the +file+, from the +current_format+ to the +destination_format+.
+      # @param [IO] file archive file that shall be converted
+      # @param [String] current_format represented by well-known file extensions, e.g. zip or tar.gz
+      # @param [String] destination_format represented by well-known file extensions, e.g. zip or tar.gz
+      # @param [Boolean] sanitize if true, the application will be sanitized, meaning if all data is in one folder
+      #   it will be moved one level up so that the application data is not nested in another directory
+      # @return [StringIO] the data of the input file in a new archive matching the destination format
+      def self.convert(file, current_format, destination_format, sanitize = false)
+        extraction_dir = "#{Dir.tmpdir}/nucleus.app.convert.cf.deploy.#{SecureRandom.uuid}"
+        ArchiveExtractor.new.extract(file, extraction_dir, current_format)
+
+        # sanitize if desired
+        ApplicationRepoSanitizer.new.sanitize(extraction_dir) if sanitize
+
+        return Archiver.new.compress(extraction_dir, destination_format)
+      ensure
+        # now delete the tmp directory again
+        FileUtils.rm_rf(extraction_dir) if extraction_dir
+      end
+    end
+  end
+end

data/lib/nucleus/core/file_handling/file_manager.rb

@@ -0,0 +1,64 @@
+module Nucleus
+  module Adapters
+    module FileManager
+      extend Nucleus::Logging
+
+      # Load the contents of the file.
+      # @param [String] file absolute path of the file to read
+      # @raise [Nucleus::FileExistenceError] if the file does not exist
+      # @return [StringIO] binary contents of the file, rewinded
+      def self.load_file(file)
+        io = StringIO.new('')
+        File.open(file, 'r') do |opened_file|
+          opened_file.binmode
+          io.write opened_file.read
+        end
+        io.rewind
+        io
+      end
+
+      # Save the data from within the {::Data} object to the file.
+      # By default, this replaces already existing files.
+      # If force is set to false, the method call will fail if there already is a file at the destination.
+      # If force is false, but expected_file_md5_hex is specified, the file will be replaced as long as
+      # the hexdigest of the current file is equal to the expected_file_md5_hex param.
+      #
+      # @param [String] file absolute path of the file to write to
+      # @param [Data] io data to write to the file
+      # @param [Boolean] force if true file is replaced, else write fails
+      # @param [String] expected_file_md5_hex MD5 hexdigest of the expected file to be replaced.
+      # If nil, file is not replaced as long as force == false
+      # @raise [Nucleus::FileExistenceError] if the file already existed
+      # @raise [ArgumentError] if expected_file_md5_hex did not match the MD5 hexdigest of the current file
+      # in the repository
+      # @return [void]
+      def self.save_file_from_data(file, io, force = true, expected_file_md5_hex = nil)
+        if File.exist? file
+          unless force
+            # fail if file exists, but shall not be replaced
+            fail Nucleus::FileExistenceError, 'File already exists' if expected_file_md5_hex.nil?
+
+            # do only replace if file is as expected
+            actual_hex = Digest::MD5.file(file).hexdigest
+            unless actual_hex == expected_file_md5_hex
+              fail ArgumentError, "File to replace does exist, but hash sum is different than expected: #{actual_hex}"
+            end
+          end
+        end
+
+        # rewind IO
+        io.rewind if io.respond_to? :rewind
+
+        # create parent directory
+        dirname = File.dirname(file)
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+
+        # write file and replace existing
+        File.open(file, 'w') do |opened_file|
+          opened_file.binmode
+          opened_file.write io.read
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/core/file_handling/git_deployer.rb

@@ -0,0 +1,133 @@
+module Nucleus
+  module Adapters
+    class GitDeployer
+      include Nucleus::Logging
+
+      # Initialize a new instance of the GitDeployer
+      # @param [String] user_email email address of the user, used as author of commits
+      # @param [String] repo_url address where the repository can be retrieved
+      # @param [String] repo_name name of the directory for the repository that shall be created in the tmp dir
+      # @param [String] repo_branch branch to push to
+      def initialize(repo_name, repo_url, user_email, repo_branch = 'master')
+        @repo_name = repo_name
+        @repo_url = repo_url
+        @repo_branch = repo_branch
+        @user_email = user_email
+      end
+
+      # Force a build using the latest git commit.
+      # To enforce the new build, a file 'nucleus-rebuild-trigger'
+      # gets created or updated in the repository and the changes will be pushed.
+      # @return [void]
+      def trigger_build
+        push_repository_changes do |repo_dir|
+          # add a custom file that always changes the data and triggers a new build
+          build_trigger_file = File.join(repo_dir, 'nucleus-rebuild-trigger')
+          current_md5 = File.exist?(build_trigger_file) ? Digest::MD5.file(build_trigger_file).hexdigest : nil
+          data = StringIO.new("Nucleus rebuild, triggered at #{Time.now}")
+          FileManager.save_file_from_data(build_trigger_file, data, false, current_md5)
+        end
+        nil
+      end
+
+      # Deploys the contents of the archive file to the repository that resides at the repo_url.
+      #
+      # @param [File] file archive file whose contents shall be deployed to the repository
+      # @param [String] file_compression_format compression format of the application archive, e.g. 'zip' or 'tar.gz'
+      # @return [void]
+      def deploy(file, file_compression_format)
+        extractor = Nucleus::ArchiveExtractor.new
+        fail Errors::AdapterRequestError,
+             'Unsupported format of the application archive' unless extractor.supports? file_compression_format
+
+        push_repository_changes do |repo_dir|
+          # now remove all current files, except the git db
+          Find.find(repo_dir) do |f|
+            next if f.start_with?("#{repo_dir}/.git") || f == repo_dir
+            FileUtils.rm_rf(f) if File.directory?(f)
+            FileUtils.rm_f(f) if File.file?(f)
+          end
+
+          # uncompress and extract to
+          extracted = extractor.extract(file, repo_dir, file_compression_format)
+          fail Errors::AdapterRequestError, 'Invalid application: Archive did not contain any files' if extracted == 0
+
+          # if the application was wrapped within a directory, move all 1st level files and dirs to the root
+          sanitizer = Nucleus::ApplicationRepoSanitizer.new
+          sanitizer.sanitize(repo_dir)
+        end
+        nil
+      end
+
+      # Download the contents of a git repository in the requested format.
+      # @param [String] format compression to be used for the download e.g. 'zip' or 'tar.gz'
+      # @return [StringIO] data requested to be downloaded
+      def download(format, exclude_git = true)
+        with_repository do |repo_dir|
+          # TODO: maybe we can do this directly via SSH and prevent the disk writes?
+          # download files temporarily from the repo
+          Nucleus::Archiver.new(exclude_git).compress(repo_dir, format)
+        end
+      end
+
+      private
+
+      def with_repository
+        tmp_dir = Dir.tmpdir
+        repo_dir = "#{tmp_dir}/#{@repo_name}"
+        begin
+          repository = Git.clone(@repo_url, @repo_name, path: tmp_dir)
+          # checkout custom branch
+          unless @repo_branch == 'master'
+            begin
+              repository.checkout(repository.branch(@repo_branch))
+            rescue StandardError
+              # catch errors, might occur if no commit has been made and we try to switch the branch
+              repository.checkout(@repo_branch, new_branch: true)
+            end
+          end
+
+          # now execute the actual actions on the repository
+          yield repo_dir, repository
+        ensure
+          # now delete the tmp directory again
+          FileUtils.rm_rf(repo_dir)
+        end
+      end
+
+      def push_repository_changes
+        with_repository do |repo_dir, repository|
+          repository.config('user.name', 'Nucleus')
+          repository.config('user.email', @user_email)
+          # update files
+          yield repo_dir
+          # push changes
+          push(repository)
+        end
+      end
+
+      # Push all contents of the repository to the default remote 'origin'.
+      # The repository will also be pushed if none of the files did change and no new commit was made.
+      # @param [Git::Lib] repository repository whose contents are to be pushed
+      # @return [void]
+      def push(repository)
+        # add all files to the repository
+        repository.add(all: true)
+
+        # commit, but be aware: current version could be identical to previous version resulting in an error
+        begin
+          repository.commit('Application deployment via Nucleus')
+        rescue Git::GitExecuteError => e
+          # usually indicates that no files could be committed, repository is up to date
+          log.debug("Git commit failed: #{e}")
+        end
+
+        # repack to enhance compression
+        repository.repack
+
+        # force push, so that the push is executed even when all files remain unchanged
+        repository.push('origin', @repo_branch, force: true)
+      end
+    end
+  end
+end

data/lib/nucleus/core/file_handling/git_repo_analyzer.rb

@@ -0,0 +1,23 @@
+module Nucleus
+  module Adapters
+    module GitRepoAnalyzer
+      # Is the repository having any branch?
+      # @param [String] repo_host repository host where the repository can be retrieved
+      # @param [String] repo_name name of the directory for the repository that shall be created in the tmp dir
+      # @param [String] username user to authenticate with
+      # @return [TrueClass, FalseClass] true if the repository has any non-empty branch, e.g. 'master'
+      def self.any_branch?(repo_host, repo_name, username)
+        detected_branch = false
+        options = { forward_agent: true, auth_methods: ['publickey'],
+                    keys: [nucleus_config.ssh.handler.key_file], keys_only: true }
+        Net::SSH.start(repo_host, username, options) do |ssh|
+          ssh.exec! "git-upload-pack '/#{repo_name}.git'" do |ch, stream, data|
+            detected_branch = (detected_branch || data != '0000') unless stream == :stderr
+            ch.close
+          end
+        end
+        detected_branch
+      end
+    end
+  end
+end

data/lib/nucleus/core/import/adapter_configuration.rb

@@ -0,0 +1,53 @@
+module Nucleus
+  module Adapters
+    extend Nucleus::Logging
+
+    # Get all adapter configuration files that are included in the application.
+    # The config files must be located at the +config/adapters+ directory.
+    #
+    # @return [Array<File>] all adapter configuration files
+    def self.configuration_files
+      return @configuration_files if @configuration_files
+      adapter_dir = "#{Nucleus.root}/config/adapters"
+      files = Dir[File.join(adapter_dir, '*.yml')] | Dir[File.join(adapter_dir, '*.yaml')]
+      files = files.flatten.compact
+      files.collect! { |file| File.expand_path(file) }
+      log.debug "... found #{files.size} adapter config file(s)"
+      @configuration_files = files
+      @configuration_files
+    end
+
+    # Get the clazz to the adapter file that matches the adapter_config and api_version.
+    #
+    # @param [String] adapter_config adapter configuration that indicates the adapter's name
+    # @param [String] api_version API version to load the adapter for
+    # @return [String] clazz name of the adapter
+    def self.adapter_clazz(adapter_config, api_version)
+      adapter_file = adapter_file(adapter_config, api_version)
+      return if adapter_file.nil?
+      # transform path to clazz and load an instance
+      adapter_clazz = "Nucleus::Adapters::#{api_version.upcase}::#{File.basename(adapter_file, '.rb').capitalize}"
+      adapter_clazz.camelize.split('::').inject(Object) { |a, e| a.const_get e }
+    end
+
+    # Get the path to the adapter's class file by translation from the adapter configuration's name.
+    # If the adapter configuration is called 'abc-vendor.yml', then the adapter's source file must
+    # be found below +app/adapters/#{api_version}/+ with the name +abc-vendor_adapter.rb+.
+    #
+    # @param [String] adapter_config adapter configuration that indicates the adapter's name
+    # @param [String] api_version API version to load the adapter for
+    # @raise [Nucleus::AmbiguousAdapterError] if more than one adapter was found for an adapter configuration
+    # @return [String] path to the adapter's class file
+    def self.adapter_file(adapter_config, api_version)
+      log.debug "... trying to resolve adapter for config #{adapter_config} and API #{api_version}..."
+      adapter_name = File.basename(adapter_config).sub(/.[^.]+\z/, '.rb')
+      file_search_path = "#{Nucleus.root}/lib/nucleus/adapters/#{api_version}/*/#{adapter_name}"
+      adapter_file = Dir.glob(file_search_path)
+      fail AmbiguousAdapterError, "More than 1 adapter file found for #{adapter_name}" unless adapter_file.size <= 1
+
+      return if adapter_file.empty?
+      log.debug "... found '#{adapter_file.first}'"
+      adapter_file.first
+    end
+  end
+end

data/lib/nucleus/core/import/vendor_parser.rb

@@ -0,0 +1,28 @@
+module Nucleus
+  module VendorParser
+    extend Nucleus::Logging
+
+    # Get a parsed vendor instance from the adapter_config file
+    #
+    # @param [File, String, Path] adapter_config path to the adapter configuration file to be parsed
+    # @return [Nucleus::Vendor] the parsed Vendor instance
+    def self.parse(adapter_config)
+      schema_file = "#{Nucleus.root}/schemas/api.adapter.schema.yml"
+      schema = Kwalify::Yaml.load_file(schema_file, untabify: true, preceding_alias: true)
+      validator = Kwalify::Validator.new(schema)
+      config_parser = Kwalify::Yaml::Parser.new(validator, data_binding: true, preceding_alias: true)
+
+      vendor = config_parser.parse_file(adapter_config)
+      errors = config_parser.errors
+      # show errors
+      if errors && !errors.empty?
+        errors.each do |e|
+          log.error "[#{e.path}] #{e.message}"
+        end
+      end
+      # vendor is not valid and shall not be returned
+      return nil if errors && !errors.empty?
+      vendor
+    end
+  end
+end