tebako 0.10.0 → 0.12.0

data/lib/tebako/cli.rb

@@ -43,7 +43,7 @@ require_relative "version"
 module Tebako
   DEFAULT_TEBAFILE = ".tebako.yml"
   # Tebako packager front-end
-  class Cli < Thor
+  class Cli < Thor # rubocop:disable Metrics/ClassLength
     package_name "Tebako"
     class_option :prefix, type: :string, aliases: "-p", required: false,
                           desc: "A path to tebako packaging environment, '~/.tebako' ('$HOME/.tebako') by default"
@@ -82,28 +82,35 @@ module Tebako
       #{" " * 65}# If this parameter is not set, the application will start in the current directory of the host file system.
     DESC
 
+    REF_DESCRIPTION = <<~DESC
+      "Referenced tebako run-time package; 'tebako-runtime' by default".
+      #{" " * 65}# This option specifies the tebako runtime to be used by the application on Windows and if mode is 'application' only .
+    DESC
+
     RGP_DESCRIPTION = <<~DESC
-      Activates removal a reference to GLIBC_PRIVATE version of libpthread from tebako package. This allows Linux Gnu packages to run against versions of
-      #{" " * 65}# libpthread that differ from the version used for packaging. For example, package created at Ubuntu 20 system can be used on Ubuntu 22. This option works on Gnu Linux with
-      #{" " * 65}# Gnu toolchain only (not for LLVM/clang). The feature is exeprimental, we may consider other approach in the future.
+      Current working directory for packaged application. This directory shall be specified relative to root.
+      #{" " * 65}# If this parameter is not set, the application will start in the current directory of the host file system.
     DESC
 
     desc "press", "Press tebako image"
-    method_option :cwd, type: :string, aliases: "-c", required: false,
-                        desc: CWD_DESCRIPTION
-    method_option :"entry-point", type: :string, aliases: ["-e", "--entry"], required: true,
-                                  desc: "Ruby application entry point"
+    method_option :cwd, type: :string, aliases: "-c", required: false, desc: CWD_DESCRIPTION
     method_option :"log-level", type: :string, aliases: "-l", required: false, enum: %w[error warn debug trace],
                                 desc: "Tebako memfs logging level, 'error' by default"
     method_option :output, type: :string, aliases: "-o", required: false,
                            desc: "Tebako package file name, entry point base file name in the current folder by default"
-    method_option :root, type: :string, aliases: "-r", required: true, desc: "Root folder of the Ruby application"
+    method_option :"entry-point", type: :string, aliases: ["-e", "--entry"], required: false,
+                                  desc: "Ruby application entry point"
+    method_option :root, type: :string, aliases: "-r", required: false, desc: "Root folder of the Ruby application"
     method_option :Ruby, type: :string, aliases: "-R", required: false,
                          enum: Tebako::RubyVersion::RUBY_VERSIONS.keys,
                          desc: "Tebako package Ruby version, #{Tebako::RubyVersion::DEFAULT_RUBY_VERSION} by default"
-    method_option :patchelf, aliases: "-P", type: :boolean,
-                             desc: RGP_DESCRIPTION
+    method_option :patchelf, aliases: "-P", type: :boolean, desc: RGP_DESCRIPTION
+    method_option :mode, type: :string, aliases: "-m", required: false, enum: %w[bundle both runtime application],
+                         desc: "Tebako press mode, 'bundle' by default"
+    method_option :ref, type: :string, aliases: "-u", required: false, desc: REF_DESCRIPTION
+
     def press
+      validate_press_options
       (om, cm) = bootstrap
 
       do_press(om)
@@ -159,6 +166,22 @@ module Tebako
       end
     end
 
+    no_commands do
+      def source
+        c_path = Pathname.new(__FILE__).realpath
+        @source ||= File.expand_path("../../..", c_path)
+      end
+
+      def validate_press_options
+        return unless options["mode"] != "runtime"
+
+        opts = ""
+        opts += " '--root'" if options["root"].nil?
+        opts += " '--entry-point'" if options["entry-point"].nil?
+        raise Thor::Error, "No value provided for required options #{opts}" unless opts.empty?
+      end
+    end
+
     no_commands do
       include Tebako::CliHelpers
     end

data/lib/tebako/cli_helpers.rb

@@ -34,6 +34,7 @@ require_relative "codegen"
 require_relative "error"
 require_relative "options_manager"
 require_relative "scenario_manager"
+require_relative "packager_lite"
 
 # Tebako - an executable packager
 # Command-line interface methods
@@ -41,10 +42,27 @@ module Tebako
   # Cli helpers
   module CliHelpers
     def do_press(options_manager)
-      puts options_manager.press_announce
+      scenario_manager = Tebako::ScenarioManager.new(options_manager.root, options_manager.fs_entrance)
+      puts options_manager.press_announce(scenario_manager.msys?)
+
+      if options_manager.mode == "both" || options_manager.mode == "runtime" || options_manager.mode == "bundle"
+        do_press_runtime(options_manager, scenario_manager)
+      end
+
+      if options_manager.mode == "both" || options_manager.mode == "application"
+        do_press_application(options_manager, scenario_manager)
+      end
+
+      true
+    end
 
-      generate_files(options_manager)
+    def do_press_application(options_manager, scenario_manager)
+      packager = Tebako::PackagerLite.new(options_manager, scenario_manager)
+      packager.create_package
+    end
 
+    def do_press_runtime(options_manager, scenario_manager)
+      generate_files(options_manager, scenario_manager)
       cfg_cmd = "cmake -DSETUP_MODE:BOOLEAN=OFF #{options_manager.cfg_options} #{options_manager.press_options}"
       build_cmd = "cmake --build #{options_manager.output_folder} --target tebako --parallel #{Etc.nprocessors}"
       merged_env = ENV.to_h.merge(options_manager.b_env)
@@ -64,20 +82,18 @@ module Tebako
       true
     end
 
-    def generate_files(options_manager)
+    def generate_files(options_manager, scenario_manager)
       puts "-- Generating files"
-      scenario_manager = Tebako::ScenarioManager.new(options_manager.root, options_manager.fs_entrance)
       scenario_manager.configure_scenario
 
-      puts "   ... tebako-version.h"
       v_parts = Tebako::VERSION.split(".")
       Tebako::Codegen.generate_tebako_version_h(options_manager, v_parts)
-
-      puts "   ... tebako-fs.cpp"
       Tebako::Codegen.generate_tebako_fs_cpp(options_manager, scenario_manager)
-
-      puts "   ... deploy.rb"
       Tebako::Codegen.generate_deploy_rb(options_manager, scenario_manager)
+
+      return unless options_manager.mode == "both" || options_manager.mode == "runtime"
+
+      Tebako::Codegen.generate_stub_rb(options_manager)
     end
 
     def options_from_tebafile(tebafile)

data/lib/tebako/codegen.rb

@@ -28,6 +28,8 @@
 require "pathname"
 require "fileutils"
 
+require_relative "package_descriptor"
+
 # Tebako - an executable packager
 module Tebako
   # Code geberation
@@ -47,20 +49,42 @@ module Tebako
 
     SUBST
 
-    class << self
+    class << self # rubocop:disable Metrics/ClassLength
       def deploy_crt_implib(opt, scm)
         crt = ""
         if scm.msys?
           crt = <<~SUBST
             Tebako::Packager.create_implib("#{opt.ruby_src_dir}", "#{opt.data_src_dir}",
-                                           "#{File.basename(opt.package)}", rv)
+                                           "#{opt.package}", rv)
           SUBST
         end
         crt
       end
 
-      def deploy_cwd(opt)
-        opt.cwd.nil? ? "nil" : "\"#{opt.cwd}\""
+      def deploy_mk(opt, scm)
+        case opt.mode
+        when "bundle"
+          deploy_mk_bundle(opt, scm)
+        when /runtime|both/
+          deploy_mk_stub(opt)
+        end
+      end
+
+      def deploy_mk_bundle(opt, scm)
+        <<~SUBST
+          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
+                                  rv , "#{opt.root}", "#{scm.fs_entrance}", "#{opt.cwd}")
+          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_bundle_file}",
+                                    "#{opt.data_src_dir}")
+        SUBST
+      end
+
+      def deploy_mk_stub(opt)
+        <<~SUBST
+          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
+                                  rv, "#{File.join(opt.deps, "src", "tebako", "local")}", "stub.rb", nil)
+          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_stub_file}", "#{opt.data_src_dir}")
+        SUBST
       end
 
       def deploy_rb(opt, scm)
@@ -71,22 +95,41 @@ module Tebako
           Tebako::Packager::init("#{opt.stash_dir}", "#{opt.data_src_dir}",
                                "#{opt.data_pre_dir}", "#{opt.data_bin_dir}")
           #{deploy_crt_implib(opt, scm)}
-          Tebako::Packager.deploy("#{opt.data_src_dir}", "#{opt.data_pre_dir}",
-                                  rv , "#{opt.root}",
-                                  "#{scm.fs_entrance}", #{deploy_cwd(opt)})
-          Tebako::Packager.mkdwarfs("#{opt.deps_bin_dir}", "#{opt.data_bin_file}",
-                                    "#{opt.data_src_dir}")
+          #{deploy_mk(opt, scm)}
         SUBST
       end
 
       def deploy_rq
         <<~SUBST
+          require "#{File.join(__dir__, "package_descriptor.rb")}"
           require "#{File.join(__dir__, "packager.rb")}"
           require "#{File.join(__dir__, "ruby_version.rb")}"
         SUBST
       end
 
+      def stub_rb(opt)
+        <<~SUBST
+          puts "Copyright (c) 2024 Ribose Inc (https://www.ribose.com)"
+          puts "Tebako runtime stub v#{Tebako::VERSION}"
+          puts "To run your application please call #{File.basename(opt.package)} --tebako-run <your tebako package>"
+        SUBST
+      end
+
+      def generate_stub_rb(options_manager)
+        puts "   ... stub.rb"
+
+        fname = File.join(options_manager.deps, "src", "tebako", "local", "stub.rb")
+        FileUtils.mkdir_p(File.dirname(fname))
+
+        File.open(fname, "w") do |file|
+          file.write(COMMON_RUBY_HEADER)
+          file.write(stub_rb(options_manager))
+        end
+      end
+
       def generate_deploy_rb(options_manager, scenario_manager)
+        puts "   ... deploy.rb"
+
         fname = File.join(options_manager.deps, "bin", "deploy.rb")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -96,7 +139,20 @@ module Tebako
         end
       end
 
+      def generate_package_descriptor(options_manager, scenario_manager)
+        puts "   ... package_descriptor"
+        fname = File.join(options_manager.deps, "src", "tebako", "package_descriptor")
+        FileUtils.mkdir_p(File.dirname(fname))
+        descriptor = Tebako::PackageDescriptor.new(options_manager.ruby_ver, Tebako::VERSION,
+                                                   scenario_manager.fs_mount_point, scenario_manager.fs_entry_point,
+                                                   options_manager.cwd)
+        File.binwrite(fname, descriptor.serialize)
+        fname
+      end
+
       def generate_tebako_fs_cpp(options_manager, scenario_manager)
+        puts "   ... tebako-fs.cpp"
+
         fname = File.join(options_manager.deps, "src", "tebako", "tebako-fs.cpp")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -107,6 +163,8 @@ module Tebako
       end
 
       def generate_tebako_version_h(options_manager, v_parts)
+        puts "   ... tebako-version.h"
+
         fname = File.join(options_manager.deps, "include", "tebako", "tebako-version.h")
         FileUtils.mkdir_p(File.dirname(fname))
 
@@ -125,7 +183,17 @@ module Tebako
       end
 
       def tebako_fs_cpp(options_manager, scenario_manager)
+        case options_manager.mode
+        when "bundle"
+          tebako_fs_cpp_bundle(options_manager, scenario_manager)
+        when /runtime|both/
+          tebako_fs_cpp_stub(options_manager, scenario_manager)
+        end
+      end
+
+      def tebako_fs_cpp_bundle(options_manager, scenario_manager)
         <<~SUBST
+          #include <limits.h>
           #include <incbin/incbin.h>
 
           namespace tebako {
@@ -135,7 +203,24 @@ module Tebako
             const  char * package_cwd 	 = #{package_cwd(options_manager, scenario_manager)};
             char   original_cwd[PATH_MAX];
 
-            INCBIN(fs, "#{options_manager.output_folder}/p/fs.bin");
+            INCBIN(fs, "#{options_manager.data_bundle_file}");
+          }
+        SUBST
+      end
+
+      def tebako_fs_cpp_stub(options_manager, scenario_manager)
+        <<~SUBST
+          #include <limits.h>
+          #include <incbin/incbin.h>
+
+          namespace tebako {
+            const  char * fs_log_level   = "#{options_manager.l_level}";
+            const  char * fs_mount_point = "#{scenario_manager.fs_mount_point}";
+            const  char * fs_entry_point = "/local/stub.rb";
+            const  char * package_cwd 	 = nullptr;
+            char   original_cwd[PATH_MAX];
+
+            INCBIN(fs, "#{options_manager.data_stub_file}");
           }
         SUBST
       end

data/lib/tebako/deploy_helper.rb

@@ -70,7 +70,7 @@ module Tebako
     def deploy
       BuildHelpers.with_env(deploy_env) do
         update_rubygems
-        system("#{gem_command} env")
+        system("#{gem_command} env") if @verbose
         install_gem("tebako-runtime")
         install_gem("bundler", BUNDLER_VERSION) if needs_bundler?
         deploy_solution

data/lib/tebako/options_manager.rb

@@ -73,16 +73,32 @@ module Tebako
       @cwd ||= f_cwd
     end
 
+    def cwd_announce
+      @cwd_announce ||= cwd.nil? ? "<Host current directory>" : cwd
+    end
+
     # DATA_BIN_DIR folder is used to create packaged filesystem
     # set(DATA_BIN_DIR  ${CMAKE_CURRENT_BINARY_DIR}/p)
     def data_bin_dir
       @data_bin_dir ||= File.join(output_folder, "p")
     end
 
-    # DATA_BIN_FILE is packaged filesystem itself
-    # set(DATA_BIN_FILE ${DATA_BIN_DIR}/fs.bin)
-    def data_bin_file
-      @data_bin_file ||= File.join(data_bin_dir, "fs.bin")
+    #  Mode       File(s)                       Content
+    #  bundle     fs.bin                      Application
+    #  both       fs.bin, fs2.bin     Stub, application respectively
+    #  runtime    fs.bin                         Stub
+    #  app        fs2.bin                     Application
+
+    def data_bundle_file
+      @data_bundle_file ||= File.join(data_bin_dir, "fs.bin")
+    end
+
+    def data_stub_file
+      @data_stub_file ||= File.join(data_bin_dir, "fs.bin")
+    end
+
+    def data_app_file
+      @data_app_file ||= File.join(data_bin_dir, "fs2.bin")
     end
 
     # DATA_PRE_DIR folder is used to build gems  that need to be packaged
@@ -131,11 +147,11 @@ module Tebako
     end
 
     def l_level
-      @l_level ||= if @options["log-level"].nil?
-                     "error"
-                   else
-                     @options["log-level"]
-                   end
+      @l_level ||= @options["log-level"].nil? ? "error" : @options["log-level"]
+    end
+
+    def mode
+      @mode ||= @options["mode"].nil? ? "bundle" : @options["mode"]
     end
 
     def m_files
@@ -179,10 +195,57 @@ module Tebako
                   end
     end
 
-    def press_announce
-      cwd_announce = cwd.nil? ? "<Host current directory>" : cwd
-      @press_announce ||= <<~ANN
+    def press_announce(is_msys)
+      case mode
+      when "application"
+        press_announce_application(is_msys)
+      when "both"
+        press_announce_both
+      when "bundle"
+        press_announce_bundle
+      when "runtime"
+        press_announce_runtime
+      end
+    end
+
+    def press_announce_ref(is_msys)
+      if is_msys
+        " referencing runtime at '#{ref}'"
+      else
+        ""
+      end
+    end
+
+    def press_announce_application(is_msys)
+      <<~ANN
         Running tebako press at #{prefix}
+           Mode:                      'application'
+           Ruby version:              '#{@ruby_ver}'
+           Project root:              '#{root}'
+           Application entry point:   '#{fs_entrance}'
+           Package file name:         '#{package}.tebako'#{press_announce_ref(is_msys)}
+           Package working directory: '#{cwd_announce}'
+      ANN
+    end
+
+    def press_announce_both
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'both'
+           Ruby version:              '#{@ruby_ver}'
+           Project root:              '#{root}'
+           Application entry point:   '#{fs_entrance}'
+           Runtime file name:         '#{package}'
+           Package file name:         '#{package}.tebako'
+           Loging level:              '#{l_level}'
+           Package working directory: '#{cwd_announce}'
+      ANN
+    end
+
+    def press_announce_bundle
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'bundle'
            Ruby version:              '#{@ruby_ver}'
            Project root:              '#{root}'
            Application entry point:   '#{fs_entrance}'
@@ -192,6 +255,16 @@ module Tebako
       ANN
     end
 
+    def press_announce_runtime
+      <<~ANN
+        Running tebako press at #{prefix}
+           Mode:                      'runtime'
+           Ruby version:              '#{@ruby_ver}'
+           Runtime file name:         '#{package}'
+           Loging level:              '#{l_level}'
+      ANN
+    end
+
     def press_options
       @press_options ||= "-DPCKG:STRING='#{package}' -DLOG_LEVEL:STRING='#{l_level}' " \
     end
@@ -200,6 +273,10 @@ module Tebako
       Pathname.new(path).relative?
     end
 
+    def ref
+      @ref ||= @options["ref"].nil? ? "tebako-runtime" : @options["ref"].gsub("\\", "/")
+    end
+
     def remove_glibc_private
       @remove_glibc_private ||= if RUBY_PLATFORM.end_with?("linux") || RUBY_PLATFORM.end_with?("linux-gnu")
                                   "-DREMOVE_GLIBC_PRIVATE=#{@options["patchelf"] ? "ON" : "OFF"}"

data/lib/tebako/package_descriptor.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2023-2024 [Ribose Inc](https://www.ribose.com).
+# All rights reserved.
+# This file is a part of tebako
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require "stringio"
+
+module Tebako
+  # Tebako application package descriptor
+  class PackageDescriptor
+    SIGNATURE = "TAMATEBAKO"
+
+    attr_reader :ruby_version_major, :ruby_version_minor, :ruby_version_patch, :tebako_version_major,
+                :tebako_version_minor, :tebako_version_patch, :mount_point, :entry_point, :cwd
+
+    def initialize(*args)
+      if args.size == 1 && args[0].is_a?(Array)
+        deserialize(args[0])
+      elsif args.size == 5
+        construct_from_params(*args)
+      else
+        raise ArgumentError, "Invalid arguments"
+      end
+    end
+
+    def serialize
+      buffer = StringIO.new
+
+      buffer.write(SIGNATURE)
+      serialize_versions(buffer)
+
+      write_string(buffer, @mount_point)
+      write_string(buffer, @entry_point)
+
+      serialize_cwd(buffer)
+      buffer.string
+    end
+
+    private
+
+    def deserialize(buffer)
+      stream = StringIO.new(buffer.pack("C*"))
+
+      signature = stream.read(SIGNATURE.size)
+      raise ArgumentError, "Invalid or missing signature" if signature != SIGNATURE
+
+      deserialize_versions(stream)
+      @mount_point = read_string(stream)
+      @entry_point = read_string(stream)
+
+      cwd_present = stream.read(1).unpack1("C")
+      @cwd = cwd_present == 1 ? read_string(stream) : nil
+    end
+
+    def construct_from_params(ruby_version, tebako_version, mount_point, entry_point, cwd)
+      parse_version(ruby_version, :@ruby_version_major, :@ruby_version_minor, :@ruby_version_patch)
+      parse_version(tebako_version, :@tebako_version_major, :@tebako_version_minor, :@tebako_version_patch)
+
+      @mount_point = mount_point
+      @entry_point = entry_point
+      @cwd = cwd
+    end
+
+    def deserialize_versions(stream)
+      @ruby_version_major = read_uint16(stream)
+      @ruby_version_minor = read_uint16(stream)
+      @ruby_version_patch = read_uint16(stream)
+      @tebako_version_major = read_uint16(stream)
+      @tebako_version_minor = read_uint16(stream)
+      @tebako_version_patch = read_uint16(stream)
+    end
+
+    def parse_version(version, major_sym, minor_sym, patch_sym)
+      major, minor, patch = version.split(".").map(&:to_i)
+      raise ArgumentError, "Invalid version format" unless major && minor && patch
+
+      instance_variable_set(major_sym, major)
+      instance_variable_set(minor_sym, minor)
+      instance_variable_set(patch_sym, patch)
+    end
+
+    def write_uint16(buffer, value)
+      buffer.write([value].pack("v"))
+    end
+
+    def read_uint16(stream)
+      data = stream.read(2)
+      raise ArgumentError, "Unexpected end of stream" if data.nil?
+
+      data.unpack1("v")
+    end
+
+    def serialize_cwd(buffer)
+      if @cwd
+        buffer.write([1].pack("C"))
+        write_string(buffer, @cwd)
+      else
+        buffer.write([0].pack("C"))
+      end
+    end
+
+    def serialize_versions(buffer)
+      write_uint16(buffer, @ruby_version_major)
+      write_uint16(buffer, @ruby_version_minor)
+      write_uint16(buffer, @ruby_version_patch)
+      write_uint16(buffer, @tebako_version_major)
+      write_uint16(buffer, @tebako_version_minor)
+      write_uint16(buffer, @tebako_version_patch)
+    end
+
+    def write_string(buffer, str)
+      write_uint16(buffer, str.size)
+      buffer.write(str)
+    end
+
+    def read_string(stream)
+      size = read_uint16(stream)
+      stream.read(size)
+    end
+  end
+end