odysseus-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 917c4ba0f885774f77c2bb74ce396300be9f9ae077f5ddc8d54bd96e4766d6d8
+  data.tar.gz: ea50eb29cd561fa1ae3de2f6f81df06d33f4cb21bd4a36f3a0a60acc94cfd0f4
+SHA512:
+  metadata.gz: 1eef3bc36f17dce94de204c1b4ddec3bdbc9f2d3882ec2dc2b7fd56cfe90f56a53856c8bcfb90df3ee10dce4e9236f5a748efc7b7b88d5babea919a02f636772
+  data.tar.gz: 2a3b7d72b6ddbc2e6210839e803a8c9173d41d952775695dea80a1172a919d22308f40e17b0f79ae37668d0b7f109b1e4591b3445ea0fab2a47cde8b9e570caa

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-12-19
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright (c) Imfiny SAS / Wa Systems SAS
+  
+  Odysseus is an Open Source project licensed under the terms of
+  the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+  for license text.
+  
+  Odysseus Pro and Odysseus Enterprise have a commercial-friendly license.
+  

data/README.md

@@ -0,0 +1,43 @@
+# Odysseus::Core
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/odysseus/core`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/odysseus-core. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/odysseus-core/blob/trunk/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Odysseus::Core project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/odysseus-core/blob/trunk/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/odysseus/builder/client.rb

@@ -0,0 +1,292 @@
+# lib/odysseus/builder/client.rb
+
+module Odysseus
+  module Builder
+    class Client
+      # @param config [Hash] builder config from deploy.yml
+      # @param ssh_config [Hash] SSH config (user, keys)
+      # @param logger [Object] logger
+      # @param verbose [Boolean] show commands being executed
+      def initialize(config:, ssh_config: {}, logger: nil, verbose: false)
+        @config = normalize_config(config)
+        @ssh_config = ssh_config
+        @logger = logger || default_logger
+        @verbose = verbose
+      end
+
+      # Build Docker image
+      # @param context_path [String] path to build context (directory with Dockerfile)
+      # @param image [String] full image name with tag (e.g., "registry/app:v1.0.0")
+      # @return [Hash] build result with :success, :image, :strategy
+      def build(context_path:, image:)
+        @logger.info("Building image: #{image}")
+
+        case strategy
+        when :local
+          build_local(context_path: context_path, image: image)
+        when :remote
+          build_remote(context_path: context_path, image: image)
+        else
+          raise BuildError, "Unknown build strategy: #{strategy}"
+        end
+      end
+
+      # Build and push to registry
+      # @param context_path [String] path to build context
+      # @param image [String] full image name with tag
+      # @param registry [Hash] registry config (server, username, password)
+      # @return [Hash] build and push result
+      def build_and_push(context_path:, image:, registry: nil)
+        result = build(context_path: context_path, image: image)
+        return result unless result[:success]
+
+        if @config[:push] || registry
+          push_result = push(image: image, registry: registry)
+          result.merge(pushed: push_result[:success], push_output: push_result[:output])
+        else
+          result.merge(pushed: false)
+        end
+      end
+
+      # Push image to registry
+      # @param image [String] full image name with tag
+      # @param registry [Hash] registry config (server, username, password)
+      # @return [Hash] push result
+      def push(image:, registry: nil)
+        @logger.info("Pushing image to registry: #{image}")
+
+        executor = build_executor
+
+        # Login if credentials provided
+        if registry && registry[:username]
+          login_cmd = build_login_command(registry)
+          executor.call(login_cmd)
+        end
+
+        output = executor.call("docker push #{image}")
+        { success: true, output: output }
+      rescue SSHCommandError, BuildError => e
+        @logger.error("Push failed: #{e.message}")
+        { success: false, error: e.message }
+      end
+
+      # Push image directly to remote host via SSH (using docker pussh/unregistry)
+      # @param image [String] full image name with tag
+      # @param host [String] target host to push to
+      # @param user [String] SSH user (default: from ssh_config)
+      # @return [Hash] pussh result
+      def pussh(image:, host:, user: nil)
+        ssh_user = user || @ssh_config[:user] || 'root'
+        target = "#{ssh_user}@#{host}"
+
+        @logger.info("Pushing image via SSH to #{target}: #{image}")
+
+        # docker pussh uses: docker pussh IMAGE [USER@]HOST
+        cmd = "docker pussh #{image} #{target}"
+        @logger.debug(cmd) if @logger.respond_to?(:debug)
+
+        output = execute_local_command(cmd)
+        { success: true, output: output, host: host }
+      rescue BuildError => e
+        @logger.error("Pussh failed: #{e.message}")
+        { success: false, error: e.message, host: host }
+      end
+
+      # Push image to multiple hosts via SSH
+      # @param image [String] full image name with tag
+      # @param hosts [Array<String>] list of target hosts
+      # @param user [String] SSH user (default: from ssh_config)
+      # @return [Hash] results for each host
+      def pussh_to_hosts(image:, hosts:, user: nil)
+        results = {}
+
+        hosts.each do |host|
+          @logger.info("Pushing to #{host}...")
+          results[host] = pussh(image: image, host: host, user: user)
+        end
+
+        {
+          success: results.values.all? { |r| r[:success] },
+          results: results
+        }
+      end
+
+      # Check if image exists (locally or on build host)
+      # @param image [String] full image name with tag
+      # @return [Boolean]
+      def image_exists?(image)
+        executor = build_executor
+        output = executor.call("docker images -q #{image} 2>/dev/null || echo ''")
+        !output.strip.empty?
+      rescue
+        false
+      end
+
+      # Get configured build strategy
+      # @return [Symbol] :local or :remote
+      def strategy
+        @config[:strategy]
+      end
+
+      # Get configured build host (for remote strategy)
+      # @return [String, nil]
+      def build_host
+        @config[:host]
+      end
+
+      private
+
+      def normalize_config(config)
+        {
+          strategy: (config[:strategy] || config['strategy'] || 'local').to_sym,
+          host: config[:host] || config['host'],
+          dockerfile: config[:dockerfile] || config['dockerfile'] || 'Dockerfile',
+          context: config[:context] || config['context'] || '.',
+          arch: config[:arch] || config['arch'],
+          platforms: config[:platforms] || config['platforms'] || [],
+          build_args: config[:build_args] || config['build_args'] || {},
+          cache: config.key?(:cache) ? config[:cache] : (config.key?('cache') ? config['cache'] : true),
+          push: config[:push] || config['push'] || false,
+          multiarch: config[:multiarch] || config['multiarch'] || false
+        }
+      end
+
+      def build_local(context_path:, image:)
+        @logger.info("Building locally...")
+
+        cmd = build_docker_command(context_path: context_path, image: image)
+        @logger.debug(cmd) if @logger.respond_to?(:debug)
+
+        # For local builds, execute directly
+        output = execute_local(cmd, context_path)
+
+        { success: true, image: image, strategy: :local, output: output }
+      rescue => e
+        @logger.error("Local build failed: #{e.message}")
+        { success: false, strategy: :local, error: e.message }
+      end
+
+      def build_remote(context_path:, image:)
+        @logger.info("Building on remote host: #{@config[:host]}")
+
+        unless @config[:host]
+          raise BuildError, "Remote build strategy requires 'host' to be configured"
+        end
+
+        ssh = connect_to_build_host
+
+        begin
+          # Create remote build directory
+          remote_dir = "/tmp/odysseus-build-#{Time.now.to_i}"
+          ssh.execute("mkdir -p #{remote_dir}")
+
+          # Upload build context
+          @logger.info("Uploading build context...")
+          ssh.upload(context_path, remote_dir)
+
+          # Determine the actual context directory on remote
+          context_name = File.basename(context_path)
+          remote_context = "#{remote_dir}/#{context_name}"
+
+          # Build on remote
+          cmd = build_docker_command(context_path: remote_context, image: image)
+          @logger.debug(cmd) if @logger.respond_to?(:debug)
+
+          output = ssh.execute(cmd)
+
+          # Cleanup remote directory
+          ssh.execute("rm -rf #{remote_dir}")
+
+          { success: true, image: image, strategy: :remote, output: output }
+        rescue SSHCommandError => e
+          @logger.error("Remote build failed: #{e.message}")
+          { success: false, strategy: :remote, error: e.message }
+        ensure
+          ssh.close
+        end
+      end
+
+      def build_docker_command(context_path:, image:)
+        parts = []
+
+        if @config[:multiarch] && @config[:platforms].any?
+          # Use buildx for multi-platform builds
+          parts << 'docker buildx build'
+          parts << "--platform #{@config[:platforms].join(',')}"
+          parts << '--push' if @config[:push]
+        else
+          parts << 'docker build'
+          # Single architecture build
+          parts << "--platform linux/#{@config[:arch]}" if @config[:arch]
+        end
+
+        parts << "-t #{image}"
+        parts << "-f #{context_path}/#{@config[:dockerfile]}"
+        parts << '--no-cache' unless @config[:cache]
+
+        # Add build args
+        @config[:build_args].each do |key, value|
+          parts << "--build-arg #{key}=#{value}"
+        end
+
+        parts << context_path
+
+        parts.join(' ')
+      end
+
+      def build_login_command(registry)
+        server = registry[:server] || ''
+        "echo '#{registry[:password]}' | docker login #{server} -u #{registry[:username]} --password-stdin"
+      end
+
+      def execute_local(cmd, working_dir)
+        # Execute command locally using system
+        Dir.chdir(working_dir) do
+          output = `#{cmd} 2>&1`
+          unless $?.success?
+            raise BuildError, "Build command failed: #{output}"
+          end
+          output
+        end
+      end
+
+      def build_executor
+        case strategy
+        when :local
+          # Return a proc that executes locally
+          ->(cmd) { execute_local_command(cmd) }
+        when :remote
+          # Return a proc that executes via SSH
+          ssh = connect_to_build_host
+          ->(cmd) { ssh.execute(cmd) }
+        end
+      end
+
+      def execute_local_command(cmd)
+        output = `#{cmd} 2>&1`
+        unless $?.success?
+          raise BuildError, "Command failed: #{output}"
+        end
+        output
+      end
+
+      def connect_to_build_host
+        Odysseus::Deployer::SSH.new(
+          host: @config[:host],
+          user: @ssh_config[:user] || 'root',
+          keys: @ssh_config[:keys] || [],
+          verbose: @verbose
+        )
+      end
+
+      def default_logger
+        Object.new.tap do |l|
+          l.define_singleton_method(:info) { |msg| puts msg }
+          l.define_singleton_method(:warn) { |msg| puts "[WARN] #{msg}" }
+          l.define_singleton_method(:error) { |msg| puts "[ERROR] #{msg}" }
+          l.define_singleton_method(:debug) { |msg| puts "  > #{msg}" if @verbose }
+        end
+      end
+    end
+  end
+end