bubing 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05a902c19d0555ec614c68bd6711d4a47fb4e8fe
+  data.tar.gz: 0c02b9af4fed83709f4f19612179c7bd7f142cb2
+SHA512:
+  metadata.gz: 0c36fe6f2a4e9e8c898a645b98e49bedfa53a6ea4a63cf4916c1423b629c3788ed79ea2e82c91f7799395c733b2906e1f4a4e447b5a03648eb3a7f5a2af18acb
+  data.tar.gz: aade555ff9aff1256e69fe8dbfee3ce082ab120c887275148e331b0c74185920427487c989e8128fb85bd8e55f0a15dcd71980819fff3aa5e545f6bb2308751c

data/bin/bubing

@@ -0,0 +1,73 @@
+#!/bin/env ruby
+
+require 'optparse'
+require 'bubing'
+
+options = {}
+options[:plugins] = []
+options[:plugin_dirs] = []
+
+options[:files] = []
+options[:file_dirs] = []
+
+options[:ld_paths] = []
+options[:envs] = []
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: bubing [options] BINARY DIRECTORY'
+
+  opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+    options[:verbose] = v
+  end
+
+  opts.on('-p', '--plugin LIBRARY',
+          'Add not linked library, eg plugin') do |plugin|
+    options[:plugins] << plugin
+  end
+
+  opts.on('-P', '--plugin_directory PATH',
+          'Add directory with additional libs, eg plugin directory') do |plugin_dir|
+    options[:plugin_dirs] << plugin_dir
+  end
+
+  opts.on('-f', '--file FILE=PATH',
+          'Add additional file, eg config') do |file|
+    options[:files] << file
+  end
+
+  opts.on('-F', '--file_directory PATH=PATH',
+          'Add directory with additional files, eg configs') do |file_dir|
+    options[:file_dirs] << file_dir
+  end
+
+  opts.on('-L', '--ld_path PATH',
+          'Look dependencies in PATH') do |ld_path|
+    options[:ld_paths] << ld_path
+  end
+
+  opts.on('-e', '--env VAR=VAL',
+          'Add environment variable to run.sh') do |env|
+    options[:envs] << env
+  end
+end.parse!
+
+if ARGV.count < 2
+  puts 'You must specify binary for bundling and output directory!'
+  exit(1)
+end
+
+directory = File.absolute_path(ARGV.pop)
+filename = File.absolute_path(ARGV.pop)
+
+unless File.exist?(filename)
+  puts "#{filename} does not exists!"
+  exit(1)
+end
+
+puts "Bundling #{filename} to #{directory}" if options[:verbose]
+
+begin
+  Bubing::BundlerFactory.new.build(filename, directory, **options).bundle!
+rescue Bubing::BundlingError
+  exit(1)
+end

data/lib/bubing.rb

@@ -0,0 +1,8 @@
+require 'bubing/binary_info'
+require 'bubing/bundler.rb'
+require 'bubing/executable_bundler'
+require 'bubing/shared_object_bundler'
+require 'bubing/bundler_factory'
+
+module Bubing
+end

data/lib/bubing/binary_info.rb

@@ -0,0 +1,61 @@
+module Bubing
+  class UnknownInterpreter < StandardError
+  end
+
+  class UnknownType < StandardError
+  end
+
+  class BinaryInfo
+    X86_32_RE = /ELF 32-bit/
+    X86_64_RE = /ELF 64-bit/
+
+    EXECUTABLE_RE = /LSB executable/
+    SHARED_OBJECT_RE = /LSB shared object/
+
+    X86_32_INTERPRETER = 'ld-linux.so'.freeze
+    X86_64_INTERPRETER = 'ld-linux-x86-64.so'.freeze
+
+    attr_reader :interpreter, :type
+
+    def initialize(binary)
+      @binary = binary
+      @file_output = `file #{@binary}`
+      @interpreter = detect_interpreter
+      @type = detect_type
+    end
+
+    private
+
+    def detect_type
+      case @file_output
+      when EXECUTABLE_RE
+        :executable
+      when SHARED_OBJECT_RE
+        :shared_object
+      else
+        raise Bubing::UnknownType
+      end
+    end
+
+    def detect_interpreter
+      case @file_output
+      when X86_32_RE
+        x86_32_interpreter
+      when X86_64_RE
+        x86_64_interpreter
+      else
+        raise Bubing::UnknownInterpreter
+      end
+    end
+
+    def x86_32_interpreter
+      libs = Dir['/lib/*']
+      libs.detect { |l| l.include?(X86_32_INTERPRETER) }
+    end
+
+    def x86_64_interpreter
+      libs = Dir['/lib/*']
+      libs.detect { |l| l.include?(X86_64_INTERPRETER) }
+    end
+  end
+end

data/lib/bubing/bundler.rb

@@ -0,0 +1,115 @@
+require 'fileutils'
+
+module Bubing
+  class DependencyNotFoundError < StandardError
+  end
+
+  class BundlingError < StandardError
+  end
+
+  class Bundler
+    PATH_RE = /=> (.+?(?=\())/
+
+    def initialize(binary, directory, interpreter:, plugins: [], plugin_dirs: [], files: [], file_dirs: [], ld_paths: [], envs: [], verbose: false)
+      @binary = binary
+      @directory = directory
+      @plugins = plugins
+      @plugin_dirs = plugin_dirs
+      @files = files
+      @file_dirs = file_dirs
+      @verbose = verbose
+      @interpreter = interpreter
+      @lib_dir = File.join(directory, 'lib')
+      @ld_paths = ld_paths
+
+      @copied = []
+    end
+
+    def bundle!
+      prepare_dir
+      log("Interpreter is #{@interpreter}")
+      copy_deps(@binary)
+      log('Copying plugins...')
+      log("Plugins to bundle #{@plugins.count}")
+      copy_plugins(@plugins)
+      log("Plugin dirs to bundle #{@plugin_dirs.count}")
+      copy_plugin_dirs
+      log('Copying files...')
+      log("Files to bundle #{@files.count}")
+      copy_files(@files)
+      log("File dirs to bundle #{@file_dirs.count}")
+      copy_files(@file_dirs)
+    rescue Bubing::DependencyNotFoundError => e
+      puts "#{e.message} not found!"
+      raise Bubing::BundlingError
+    end
+
+    protected
+
+    def prepare_dir
+      FileUtils.rm_rf(Dir.glob(File.join(@directory, '*')))
+      FileUtils.mkdir_p(@directory)
+      FileUtils.mkdir_p(@lib_dir)
+    end
+
+    def log(message)
+      puts message if @verbose
+    end
+
+    def extract_path(lib)
+      if lib.include?('not found')
+        raise DependencyNotFoundError.new(lib.split('=>')[0].strip)
+      end
+      File.absolute_path(PATH_RE.match(lib)[1].strip)
+    end
+
+    def get_deps(file)
+      ld_lib_path = if @ld_paths.any?
+                      "LD_LIBRARY_PATH=#{@ld_paths.join(':')}"
+                    else
+                      ''
+                    end
+      trace = `#{ld_lib_path} LD_TRACE_LOADED_OBJECTS=1 #{@interpreter} #{file}`
+      trace.split("\n").map(&:strip).select{|row| row.include?('=>')}.map{|dep| extract_path(dep)}
+    end
+
+    def copy_deps(binary)
+      log("Bundling #{binary}")
+      deps = get_deps(binary)
+      log("#{deps.count} dependencies found")
+      copy(deps, @lib_dir)
+    end
+
+    def copy(files, dst)
+      files = [files].flatten.select{|f| !@copied.include?(f)}
+      FileUtils.cp_r(files, dst)
+      @copied += files
+      @copied.flatten
+    end
+
+    def copy_plugins(plugins)
+      plugins.each do |plugin|
+        copy(plugin, @lib_dir)
+        copy_deps(plugin)
+      end
+    end
+
+    def copy_plugin_dirs
+      @plugin_dirs.each do |plugin_dir|
+        copy(plugin_dir, @lib_dir)
+        plugins = Dir[File.join(plugin_dir, '/**/*.so')]
+        copy_plugins(plugins)
+      end
+    end
+
+    def copy_files(files)
+      files.each do |file|
+        file, dst = file.split('=')
+        dst = File.join(@directory, dst)
+
+        FileUtils.mkdir_p(dst)
+        copy(file, dst)
+      end
+    end
+  end
+end

data/lib/bubing/bundler_factory.rb

@@ -0,0 +1,14 @@
+module Bubing
+  class BundlerFactory
+    def build(filename, directory, **options)
+      info = Bubing::BinaryInfo.new(filename)
+      options[:interpreter] = info.interpreter
+      case info.type
+      when :executable
+        Bubing::ExecutableBundler.new(filename, directory, **options)
+      when :shared_object
+        Bubing::SharedObjectBundler.new(filename, directory, **options)
+      end
+    end
+  end
+end

data/lib/bubing/executable_bundler.rb

@@ -0,0 +1,48 @@
+module Bubing
+  class ExecutableBundler < Bubing::Bundler
+    RUN_TEMPLATE = '%{envs} ./lib/%{interpreter} ./bin/%{binary}'
+
+    def initialize(binary, directory, interpreter:, plugins: [], plugin_dirs: [], files: [], file_dirs: [], ld_paths: [], envs: [], verbose: false)
+      super
+      @bin_dir = File.join(@directory, 'bin')
+
+      @envs = envs.each_with_object({}) do |env, h|
+        k, v = env.split('=')
+        h[k] = v
+      end
+      if @envs['LD_LIBRARY_PATH'].nil?
+        @envs['LD_LIBRARY_PATH'] = './lib'
+      end
+    end
+
+    def bundle!
+      super
+      copy(@interpreter, @lib_dir)
+      copy(@binary, @bin_dir)
+      log('Preparing run.sh...')
+      run_file = make_run
+
+      FileUtils.chmod('+x', run_file)
+    end
+
+    def make_run
+      run_file = File.join(@directory, 'run.sh')
+      envs = @envs.each_with_object([]) do |(k, v), ary|
+        ary << "#{k}=#{v}"
+      end.join(' ')
+      run = RUN_TEMPLATE % {envs: envs, interpreter: File.basename(@interpreter), binary: File.basename(@binary)}
+      File.open(run_file, 'w') do |file|
+        file.write("#!/bin/bash\n")
+        file.write("#{run}\n")
+      end
+      run_file
+    end
+
+    protected
+
+    def prepare_dir
+      super
+      FileUtils.mkdir_p(@bin_dir)
+    end
+  end
+end

data/lib/bubing/shared_object_bundler.rb

@@ -0,0 +1,8 @@
+module Bubing
+  class SharedObjectBundler < Bubing::Bundler
+    def bundle!
+      super
+      copy(@binary, @lib_dir)
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: bubing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gleb Sinyavsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-07 00:00:00.000000000 Z
+dependencies: []
+description: Script for bundling linux binaries
+email: zhulik.gleb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/bubing
+- lib/bubing.rb
+- lib/bubing/binary_info.rb
+- lib/bubing/bundler.rb
+- lib/bubing/bundler_factory.rb
+- lib/bubing/executable_bundler.rb
+- lib/bubing/shared_object_bundler.rb
+homepage: http://rubygems.org/gems/bubing
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Script for bundling linux binaries
+test_files: []