aggkit 0.2.5

data/lib/aggkit/childprocess/windows/structs.rb

@@ -0,0 +1,151 @@
+module Aggkit
+module ChildProcess
+  module Windows
+    # typedef struct _STARTUPINFO {
+    #   DWORD  cb;
+    #   LPTSTR lpReserved;
+    #   LPTSTR lpDesktop;
+    #   LPTSTR lpTitle;
+    #   DWORD  dwX;
+    #   DWORD  dwY;
+    #   DWORD  dwXSize;
+    #   DWORD  dwYSize;
+    #   DWORD  dwXCountChars;
+    #   DWORD  dwYCountChars;
+    #   DWORD  dwFillAttribute;
+    #   DWORD  dwFlags;
+    #   WORD   wShowWindow;
+    #   WORD   cbReserved2;
+    #   LPBYTE lpReserved2;
+    #   HANDLE hStdInput;
+    #   HANDLE hStdOutput;
+    #   HANDLE hStdError;
+    # } STARTUPINFO, *LPSTARTUPINFO;
+
+    class StartupInfo < FFI::Struct
+      layout :cb,               :ulong,
+             :lpReserved,       :pointer,
+             :lpDesktop,        :pointer,
+             :lpTitle,          :pointer,
+             :dwX,              :ulong,
+             :dwY,              :ulong,
+             :dwXSize,          :ulong,
+             :dwYSize,          :ulong,
+             :dwXCountChars,    :ulong,
+             :dwYCountChars,    :ulong,
+             :dwFillAttribute,  :ulong,
+             :dwFlags,          :ulong,
+             :wShowWindow,      :ushort,
+             :cbReserved2,      :ushort,
+             :lpReserved2,      :pointer,
+             :hStdInput,        :pointer, # void ptr
+             :hStdOutput,       :pointer, # void ptr
+             :hStdError,        :pointer # void ptr
+    end
+
+    #
+    # typedef struct _PROCESS_INFORMATION {
+    #   HANDLE hProcess;
+    #   HANDLE hThread;
+    #   DWORD  dwProcessId;
+    #   DWORD  dwThreadId;
+    # } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
+    #
+
+    class ProcessInfo < FFI::Struct
+      layout :hProcess,    :pointer, # void ptr
+             :hThread,     :pointer, # void ptr
+             :dwProcessId, :ulong,
+             :dwThreadId,  :ulong
+    end
+
+    #
+    # typedef struct _SECURITY_ATTRIBUTES {
+    #   DWORD  nLength;
+    #   LPVOID lpSecurityDescriptor;
+    #   BOOL   bInheritHandle;
+    # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
+    #
+
+    class SecurityAttributes < FFI::Struct
+      layout :nLength,              :ulong,
+             :lpSecurityDescriptor, :pointer, # void ptr
+             :bInheritHandle,       :int
+
+      def initialize(opts = {})
+        super()
+
+        self[:nLength]              = self.class.size
+        self[:lpSecurityDescriptor] = nil
+        self[:bInheritHandle]       = opts[:inherit] ? 1 : 0
+      end
+    end
+
+    #
+    # typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION {
+    #   LARGE_INTEGER PerProcessUserTimeLimit;
+    #   LARGE_INTEGER PerJobUserTimeLimit;
+    #   DWORD         LimitFlags;
+    #   SIZE_T        MinimumWorkingSetSize;
+    #   SIZE_T        MaximumWorkingSetSize;
+    #   DWORD         ActiveProcessLimit;
+    #   ULONG_PTR     Affinity;
+    #   DWORD         PriorityClass;
+    #   DWORD         SchedulingClass;
+    # } JOBOBJECT_BASIC_LIMIT_INFORMATION, *PJOBOBJECT_BASIC_LIMIT_INFORMATION;
+    #
+    class JobObjectBasicLimitInformation < FFI::Struct
+      layout :PerProcessUserTimeLimit, :int64,
+             :PerJobUserTimeLimit,     :int64,
+             :LimitFlags,              :ulong,
+             :MinimumWorkingSetSize,   :size_t,
+             :MaximumWorkingSetSize,   :size_t,
+             :ActiveProcessLimit,      :ulong,
+             :Affinity,                :pointer,
+             :PriorityClass,           :ulong,
+             :SchedulingClass,         :ulong
+    end
+
+    #
+    # typedef struct _IO_COUNTERS {
+    #   ULONGLONG ReadOperationCount;
+    #   ULONGLONG WriteOperationCount;
+    #   ULONGLONG OtherOperationCount;
+    #   ULONGLONG ReadTransferCount;
+    #   ULONGLONG WriteTransferCount;
+    #   ULONGLONG OtherTransferCount;
+    # } IO_COUNTERS, *PIO_COUNTERS;
+    #
+
+    class IoCounters < FFI::Struct
+      layout :ReadOperationCount,  :ulong_long,
+             :WriteOperationCount, :ulong_long,
+             :OtherOperationCount, :ulong_long,
+             :ReadTransferCount,   :ulong_long,
+             :WriteTransferCount,  :ulong_long,
+             :OtherTransferCount,  :ulong_long
+    end
+    #
+    # typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+    #   JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+    #   IO_COUNTERS                       IoInfo;
+    #   SIZE_T                            ProcessMemoryLimit;
+    #   SIZE_T                            JobMemoryLimit;
+    #   SIZE_T                            PeakProcessMemoryUsed;
+    #   SIZE_T                            PeakJobMemoryUsed;
+    # } JOBOBJECT_EXTENDED_LIMIT_INFORMATION, *PJOBOBJECT_EXTENDED_LIMIT_INFORMATION;
+    #
+
+    class JobObjectExtendedLimitInformation < FFI::Struct
+      layout :BasicLimitInformation, JobObjectBasicLimitInformation,
+             :IoInfo,                IoCounters,
+             :ProcessMemoryLimit,    :size_t,
+             :JobMemoryLimit,        :size_t,
+             :PeakProcessMemoryUsed, :size_t,
+             :PeakJobMemoryUsed,     :size_t
+    end
+
+
+  end # Windows
+end # ChildProcess
+end

data/lib/aggkit/childprocess/windows.rb

@@ -0,0 +1,35 @@
+require "ffi"
+require "rbconfig"
+
+module Aggkit
+module ChildProcess
+  module Windows
+    module Lib
+      extend FFI::Library
+
+      def self.msvcrt_name
+        host_part = RbConfig::CONFIG['host_os'].split("_")[1]
+        manifest  = File.join(RbConfig::CONFIG['bindir'], 'ruby.exe.manifest')
+
+        if host_part && host_part.to_i > 80 && File.exists?(manifest)
+          "msvcr#{host_part}"
+        else
+          "msvcrt"
+        end
+      end
+
+      ffi_lib "kernel32", msvcrt_name
+      ffi_convention :stdcall
+
+
+    end # Library
+  end # Windows
+end # ChildProcess
+end Aggkit
+
+require "aggkit/childprocess/windows/lib"
+require "aggkit/childprocess/windows/structs"
+require "aggkit/childprocess/windows/handle"
+require "aggkit/childprocess/windows/io"
+require "aggkit/childprocess/windows/process_builder"
+require "aggkit/childprocess/windows/process"

data/lib/aggkit/childprocess.rb

@@ -0,0 +1,213 @@
+require 'aggkit/childprocess/version'
+require 'aggkit/childprocess/errors'
+require 'aggkit/childprocess/abstract_process'
+require 'aggkit/childprocess/abstract_io'
+require 'fcntl'
+require 'logger'
+
+module Aggkit
+
+  module ChildProcess
+
+
+    @posix_spawn = false
+
+    class << self
+
+
+    attr_writer :logger
+
+    def new(*args)
+      case os
+      when :macosx, :linux, :solaris, :bsd, :cygwin, :aix
+        if posix_spawn?
+          Unix::PosixSpawnProcess.new(args)
+        elsif jruby?
+          JRuby::Process.new(args)
+        else
+          Unix::ForkExecProcess.new(args)
+        end
+      when :windows
+        Windows::Process.new(args)
+      else
+        raise Error.new("unsupported platform #{platform_name.inspect}")
+      end
+    end
+    alias build new
+
+    def logger
+      return @logger if defined?(@logger) && @logger
+
+      @logger = Logger.new($stderr)
+      @logger.level = $DEBUG ? Logger::DEBUG : Logger::INFO
+
+      @logger
+    end
+
+    def platform
+      if RUBY_PLATFORM == 'java'
+        :jruby
+      elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
+        :ironruby
+      else
+        os
+      end
+    end
+
+    def platform_name
+      @platform_name ||= "#{arch}-#{os}"
+    end
+
+    def unix?
+      !windows?
+    end
+
+    def linux?
+      os == :linux
+    end
+
+    def jruby?
+      platform == :jruby
+    end
+
+    def windows?
+      os == :windows
+    end
+
+    def posix_spawn?
+      enabled = @posix_spawn || %w[1 true].include?(ENV['CHILDPROCESS_POSIX_SPAWN'])
+      return false unless enabled
+
+      require 'ffi'
+      begin
+        require "childprocess/unix/platform/#{ChildProcess.platform_name}"
+      rescue LoadError
+        raise ChildProcess::MissingPlatformError
+      end
+
+      require 'childprocess/unix/lib'
+      require 'childprocess/unix/posix_spawn_process'
+
+      true
+    rescue ChildProcess::MissingPlatformError => ex
+      warn_once ex.message
+      false
+    end
+
+    #
+    # Set this to true to enable experimental use of posix_spawn.
+    #
+
+    attr_writer :posix_spawn
+
+    def os
+      @os ||= begin
+        require 'rbconfig'
+        host_os = RbConfig::CONFIG['host_os'].downcase
+
+        case host_os
+        when /linux/
+          :linux
+        when /darwin|mac os/
+          :macosx
+        when /mswin|msys|mingw32/
+          :windows
+        when /cygwin/
+          :cygwin
+        when /solaris|sunos/
+          :solaris
+        when /bsd|dragonfly/
+          :bsd
+        when /aix/
+          :aix
+        else
+          raise Error.new("unknown os: #{host_os.inspect}")
+        end
+      end
+    end
+
+    def arch
+      @arch ||= begin
+        host_cpu = RbConfig::CONFIG['host_cpu'].downcase
+        case host_cpu
+        when /i[3456]86/
+          if workaround_older_macosx_misreported_cpu?
+            # Workaround case: older 64-bit Darwin Rubies misreported as i686
+            'x86_64'
+          else
+            'i386'
+          end
+        when /amd64|x86_64/
+          'x86_64'
+        when /ppc|powerpc/
+          'powerpc'
+        else
+          host_cpu
+        end
+      end
+    end
+
+    #
+    # By default, a child process will inherit open file descriptors from the
+    # parent process. This helper provides a cross-platform way of making sure
+    # that doesn't happen for the given file/io.
+    #
+
+    def close_on_exec(file)
+      if file.respond_to?(:close_on_exec=)
+        file.close_on_exec = true
+      elsif file.respond_to?(:fcntl) && defined?(Fcntl::FD_CLOEXEC)
+        file.fcntl Fcntl::F_SETFD, Fcntl::FD_CLOEXEC
+
+        if jruby? && posix_spawn?
+          # on JRuby, the fcntl call above apparently isn't enough when
+          # we're launching the process through posix_spawn.
+          fileno = JRuby.posix_fileno_for(file)
+          Unix::Lib.fcntl fileno, Fcntl::F_SETFD, Fcntl::FD_CLOEXEC
+        end
+      elsif windows?
+        Windows::Lib.dont_inherit file
+      else
+        raise Error.new("not sure how to set close-on-exec for #{file.inspect} on #{platform_name.inspect}")
+      end
+    end
+
+      private
+
+      def warn_once(msg)
+        @warnings ||= {}
+
+        unless @warnings[msg]
+          @warnings[msg] = true
+          logger.warn msg
+        end
+      end
+
+      # Workaround: detect the situation that an older Darwin Ruby is actually
+      # 64-bit, but is misreporting cpu as i686, which would imply 32-bit.
+      #
+      # @return [Boolean] `true` if:
+      #   (a) on Mac OS X
+      #   (b) actually running in 64-bit mode
+      def workaround_older_macosx_misreported_cpu?
+        os == :macosx && is_64_bit?
+      end
+
+      # @return [Boolean] `true` if this Ruby represents `1` in 64 bits (8 bytes).
+      def is_64_bit?
+        1.size == 8
+      end
+
+
+    end # class << self
+
+
+end # ChildProcess
+
+end # Aggkit
+
+require 'jruby' if Aggkit::ChildProcess.jruby?
+
+require 'aggkit/childprocess/unix'    if Aggkit::ChildProcess.unix?
+require 'aggkit/childprocess/windows' if Aggkit::ChildProcess.windows?
+require 'aggkit/childprocess/jruby'   if Aggkit::ChildProcess.jruby?

data/lib/aggkit/env.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+require 'English'
+require 'dotenv'
+
+module Dotenv
+  module_function
+
+  def load_without_export(*filenames)
+    with(*filenames) do |f|
+      ignoring_nonexistent_files do
+        Environment.new(f, true)
+      end
+    end
+  end
+end
+
+module Aggkit
+
+  class Env
+    attr_accessor :project, :name, :env_root, :environment
+
+    def self.list path = Dir.pwd
+      root = Project.new(path).project_root
+      Pathfinder.new(root).each_env
+    end
+
+    def self.with_env env, &block
+      current_env = ENV.to_h
+      env.each_pair do |k, v|
+        ENV[k.to_s] = v.to_s
+      end
+      yield
+    ensure
+      (env.keys.map(&:to_s) - current_env.keys).each do |key|
+        ENV.delete(key.to_s)
+      end
+
+      current_env.each_pair do |k, v|
+        ENV[k.to_s] = v.to_s
+      end
+    end
+
+    def initialize path
+      @project = if File.directory?(File.expand_path(path))
+        @name = File.basename(File.realpath(File.expand_path(path)))
+        Project.new(path)
+      else
+        @name = path.strip
+        Project.new(Dir.pwd)
+      end
+
+      if !self.class.list.include?(@name)
+        raise "There no env #{@name.inspect} in project: #{project.project_root.inspect}"
+      end
+
+      @env_root = File.join(project_root, 'envs', @name)
+
+      @environment = prepare_environment
+    end
+
+    def with_env &block
+      Env.with_env(environment) &block
+    end
+
+    def project_root
+      project.project_root
+    end
+
+    def core_root
+      project.core_root
+    end
+
+    def dot_file
+      File.join(env_root, '.env')
+    end
+
+    def project_dot_file
+      File.join(project_root, '.env')
+    end
+
+    def core_dot_file
+      File.join(core_root, '.env') rescue nil
+    end
+
+    def env_files
+      [core_dot_file, project_dot_file, dot_file].compact.select{|f| File.exists?(f)}.uniq
+    end
+
+    def show
+      {
+        name: name,
+        project_root: project_root,
+        core_root: core_root,
+        envfiles: env_files,
+        envs: environment,
+      }
+    end
+
+private
+
+
+    def prepare_environment
+      base_env = {
+        'ENV_ROOT'      => env_root,
+        'PROJECT_ROOT'  => project_root,
+        'CORE_ROOT'     => core_root,
+        'PATH'          => check_path_variable(env_root),
+      }
+
+      dot_env = prepare_dot(base_env)
+
+      compose_env = prepare_compose(dot_env.merge(base_env))
+
+      dot_env.merge(base_env).merge(compose_env)
+    end
+
+    def prepare_dot env
+      Env.with_env(env) do
+        Dotenv.load_without_export(*env_files)
+      end
+    end
+
+    def prepare_compose env
+      compose_files = if env['COMPOSE_FILE']
+        env['COMPOSE_FILE']
+      elsif File.exists?(File.join(env_root, "docker-compose.yml"))
+        File.join(env_root, "docker-compose.yml")
+      elsif File.exists?(File.join(env_root, "docker-compose.yaml"))
+        File.join(env_root, "docker-compose.yaml")
+      end
+
+      if compose_files
+        result_file = File.join(env_root, "compose-result.yml")
+        Env.with_env(env.merge('COMPOSE_FILE' => compose_files)) do
+          result_content = `merger.rb`
+          File.write(result_file, result_content)
+        end
+        {
+          'COMPOSE_FILE' => result_file
+        }
+      else
+        {}
+      end
+    end
+
+    def check_path_variable path
+      if ENV['PATH'][path]
+        ENV['PATH']
+      else
+        "#{ENV['PATH']}:#{path}"
+      end
+    end
+
+    class Pathfinder
+      attr_accessor :path
+
+      def initialize path
+        @path = File.realpath(File.expand_path(path))
+      end
+
+      def each_parent
+        current = path.split(File::SEPARATOR)
+        Enumerator.new do |y|
+          while !current.empty? do
+            y << current.join(File::SEPARATOR)
+            current.pop
+          end
+        end
+      end
+
+      def each_env
+        Dir.chdir(File.join(path, 'envs')) do 
+          Dir.glob('**/*').select do |f|
+            File.directory? f
+          end.select do |f|
+            File.exists?(File.join(f, '.env')) || File.exists?(File.join(f, 'docker-compose.yml')) || File.exists?(File.join(f, 'docker-compose.yaml')) 
+          end.sort
+        end
+      end
+    end
+
+    class Project
+      attr_accessor :env_root
+
+      def initialize path
+        raise "env path #{path} is not directory!" if !File.directory?(File.expand_path(path))
+        @env_root = File.realpath(File.expand_path(path))
+      end
+
+      def project_root
+        @project_root = Pathfinder.new(env_root).each_parent.find do |path|
+          root?(path)
+        end || (raise "Can't find project root")
+      end
+
+      def core_root
+        @core_root = Pathfinder.new(project_root).each_parent.find do |path|
+          core?(path)
+        end
+      end
+
+      def root? path
+        return File.realpath(File.expand_path(path)) if File.directory?("#{path}/.git") ||
+          File.exists?("#{path}/base-service.yml") ||
+          File.exists?("#{path}/common-services.yml") ||
+          File.directory?("#{path}/envs")
+      end
+
+      def core? path
+        return File.realpath(File.expand_path(path)) if File.exists?("#{path}/.core")
+      end
+
+    end
+
+
+  end
+
+end

data/lib/aggkit/runner.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'English'
+
+module Aggkit
+
+  module Runner
+
+    def init_service(service)
+      STDOUT.sync = true
+      STDERR.sync = true
+
+      puts "Starting #{service}..."
+
+      trap('EXIT') do
+        puts "Stopping #{service}..."
+      end
+    end
+
+    def error(message)
+      STDERR.puts "Error: #{message}"
+    end
+
+    def die(message)
+      error(message)
+      exit 1
+    end
+
+    def load_envs(string, env = ENV)
+      envs = Dotenv::Parser.new(string).call
+      envs.each_pair do |k, v|
+        env[k] = v
+      end
+      envs
+    end
+
+    def load_envs_from_consul(consul, service)
+      envs = execute!("consul.rb --consul=http://#{consul}:8500 --env services/env/#{service} --pristine -d", "Can't load envs")
+      load_envs(envs)
+    end
+
+    def execute(cmd)
+      puts "Executing: #{cmd}"
+      output = `#{cmd}`
+      @last_result = $?
+      output
+    end
+
+    def execute!(cmd, error = nil)
+      output = execute(cmd)
+      ($? || @last_result).success? || die(error || "Can't execute: #{cmd}")
+      output
+    end
+
+    def ensure_env_defined!(key, env = ENV)
+      env.key?(key) || die("Environment variable #{key} must present!")
+      env[key]
+    end
+
+    def envsubst(*paths)
+      paths = paths.flatten.map{|c| c.to_s.strip }.reject(&:empty?)
+      paths.each do |path|
+        Dir.glob("#{path}/**/*.in") do |templ|
+          output = templ.sub(/\.in$/, '')
+          cmd = "cat '#{templ}' | envsubst > '#{output}'"
+          system(cmd) || die("envsubst failed: #{cmd}")
+        end
+      end
+    end
+
+    def envsubst_file(templ, output = nil)
+      output ||= templ.sub(/\.in$/, '')
+      die('filename must ends with .in or output must be provided') if output.strip == templ.strip
+      cmd = "cat '#{templ}' | envsubst > '#{output}'"
+      system(cmd) || die("envsubst failed: #{cmd}")
+    end
+
+  end
+
+end

data/lib/aggkit/version.rb

@@ -0,0 +1,5 @@
+module Aggkit
+
+  VERSION = '0.2.5'.freeze
+
+end