kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/util/os_family.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  class Util
+    class OsFamily
+      @os_dict = {
+        unix: {
+          name: 'UNIX',
+          os_family: 'unix',
+          model: 'open_source',
+          type: 'abstract'
+        },
+        unix_like: {
+          name: 'unix-like',
+          os_family: 'unix',
+          type: 'abstract'
+        },
+        bsd: {
+          name: 'BSD',
+          os_family: 'unix',
+          upstream: 'unix',
+          model: 'open_source',
+          state: 'discontinued',
+          type: 'distribution'
+        },
+        solaris: {
+          name: 'Solaris',
+          os_family: 'unix',
+          upstream: 'bsd',
+          model: 'mixed',
+          state: 'current',
+          type: 'distribution'
+        },
+        free_bsd: {
+          name: 'FreeBSD',
+          os_family: 'unix_like',
+          upstream: 'bsd',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        dragon_fly_bsd: {
+          name: 'DragonFly BSD',
+          os_family: 'unix_like',
+          upstream: 'free_bsd',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        net_bsd: {
+          name: 'NetBSD',
+          os_family: 'unix_like',
+          upstream: 'bsd',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        open_bsd: {
+          name: 'OpenBSD',
+          os_family: 'unix_like',
+          upstream: 'net_bsd',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        darwin: {
+          name: 'Darwin',
+          os_family: 'unix_like',
+          upstream: 'free_bsd',
+          model: 'open_source',
+          state: 'current',
+          type: 'kernel'
+        },
+        pure_darwin: {
+          name: 'Pure Darwin',
+          os_family: 'darwin',
+          upstream: 'darwin',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        mac_os: {
+          name: 'MacOS',
+          os_family: 'darwin',
+          upstream: 'darwin',
+          model: 'closed_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        mac: {
+          name: 'Mac',
+          type: 'alias',
+          to: 'mac_os'
+        },
+        mac_osx: {
+          name: 'MacOSX',
+          type: 'alias',
+          to: 'mac_os'
+        },
+        linux: {
+          name: 'GNU/Linux',
+          os_family: 'unix_like',
+          upstream: 'unix',
+          model: 'open_source',
+          state: 'current',
+          type: 'kernel'
+        },
+        debian: {
+          name: 'Debian',
+          os_family: 'linux',
+          upstream: 'linux',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        ubuntu: {
+          name: 'Ubuntu',
+          os_family: 'linux',
+          upstream: 'debian',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        linux_mint: {
+          name: 'Linux Mint',
+          os_family: 'linux',
+          upstream: 'ubuntu',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        fedora: {
+          name: 'Fedora',
+          os_family: 'linux',
+          upstream: 'linux',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        redhat: {
+          name: 'RHEL',
+          os_family: 'linux',
+          upstream: 'fedora',
+          model: 'commercial',
+          state: 'current',
+          type: 'distribution'
+        },
+        centos: {
+          name: 'CentOS',
+          type: 'alias',
+          to: 'cent_os'
+        },
+        cent_os: {
+          name: 'CentOS',
+          os_family: 'linux',
+          upstream: 'redhat',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        opensuse: {
+          name: 'openSUSE',
+          os_family: 'linux',
+          upstream: 'linux',
+          model: 'open_source',
+          state: 'current',
+          type: 'distribution'
+        },
+        opensuse_leap: {
+          name: 'openSUSE Leap',
+          type: 'alias',
+          to: 'opensuse'
+        },
+        sles: {
+          name: 'SUSE Linux Enterprise Server',
+          os_family: 'linux',
+          upstream: 'linux',
+          model: 'commercial',
+          state: 'current',
+          type: 'distribution'
+        }
+      }
+
+      def self.family_include_distribution?(family, dist)
+        if OsFamily[dist].nil?
+          false
+        elsif OsFamily[dist][:type] == 'alias'
+          family_include_distribution?(family, OsFamily[dist][:to])
+        elsif OsFamily[dist][:os_family] == family
+          true
+        else
+          family_include_distribution?(family, OsFamily[dist][:upstream])
+        end
+      end
+
+      def self.upstream_include_distribution?(upstream, dist)
+        if OsFamily[dist].nil?
+          false
+        elsif OsFamily[dist][:type] == 'alias'
+          upstream_include_distribution?(upstream, OsFamily[dist][:to])
+        elsif OsFamily[dist][:upstream] == upstream && OsFamily[dist][:type] == 'distribution'
+          true
+        else
+          upstream_include_distribution?(upstream, OsFamily[dist][:upstream])
+        end
+      end
+
+      def self.[](name)
+        @os_dict[name.to_sym] if !name.nil? && @os_dict.include?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/kanrisuru/util/signal.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  class Util
+    class Signal
+      @linux = {
+        'HUP' => 1,
+        'INT' => 2,
+        'QUIT' => 3,
+        'ILL' => 4,
+        'TRAP' => 5,
+        'ABRT' => 6,
+        'BUS' => 7,
+        'FPE' => 8,
+        'KILL' => 9,
+        'USR1' => 10,
+        'SEGV' => 11,
+        'USR2' => 12,
+        'PIPE' => 13,
+        'ALRM' => 14,
+        'TERM' => 15,
+        'STKFLT' => 16,
+        'CHLD' => 17,
+        'CONT' => 18,
+        'STOP' => 19,
+        'TSTP' => 20,
+        'TTIN' => 21,
+        'TTOU' => 22,
+        'URG' => 23,
+        'XCPU' => 24,
+        'XFSZ' => 25,
+        'VTALRM' => 26,
+        'PROF' => 27,
+        'WINCH' => 28,
+        'IO' => 29,
+        'PWR' => 30,
+        'SYS' => 31,
+        'RTMIN' => 34,
+        'RTMIN+1' => 35,
+        'RTMIN+2' => 36,
+        'RTMIN+3' => 37,
+        'RTMIN+4' => 38,
+        'RTMIN+5' => 39,
+        'RTMIN+6' => 40,
+        'RTMIN+7' => 41,
+        'RTMIN+8' => 42,
+        'RTMIN+9' => 43,
+        'RTMIN+10' => 44,
+        'RTMIN+11' => 45,
+        'RTMIN+12' => 46,
+        'RTMIN+13' => 47,
+        'RTMIN+14' => 48,
+        'RTMIN+15' => 49,
+        'RTMAX-14' => 50,
+        'RTMAX-13' => 51,
+        'RTMAX-12' => 52,
+        'RTMAX-11' => 53,
+        'RTMAX-10' => 54,
+        'RTMAX-9' => 55,
+        'RTMAX-8' => 56,
+        'RTMAX-7' => 57,
+        'RTMAX-6' => 58,
+        'RTMAX-5' => 59,
+        'RTMAX-4' => 60,
+        'RTMAX-3' => 61,
+        'RTMAX-2' => 62,
+        'RTMAX-1' => 63,
+        'RTMAX' => 64
+      }
+
+      @linux_inverted = {
+        1 => 'HUP',
+        2 => 'INT',
+        3 => 'QUIT',
+        4 => 'ILL',
+        5 => 'TRAP',
+        6 => 'ABRT',
+        7 => 'BUS',
+        8 => 'FPE',
+        9 => 'KILL',
+        10 => 'USR1',
+        11 => 'SEGV',
+        12 => 'USR2',
+        13 => 'PIPE',
+        14 => 'ALRM',
+        15 => 'TERM',
+        16 => 'STKFLT',
+        17 => 'CHLD',
+        18 => 'CONT',
+        19 => 'STOP',
+        20 => 'TSTP',
+        21 => 'TTIN',
+        22 => 'TTOU',
+        23 => 'URG',
+        24 => 'XCPU',
+        25 => 'XFSZ',
+        26 => 'VTALRM',
+        27 => 'PROF',
+        28 => 'WINCH',
+        29 => 'IO',
+        30 => 'PWR',
+        31 => 'SYS',
+        34 => 'RTMIN',
+        35 => 'RTMIN+1',
+        36 => 'RTMIN+2',
+        37 => 'RTMIN+3',
+        38 => 'RTMIN+4',
+        39 => 'RTMIN+5',
+        40 => 'RTMIN+6',
+        41 => 'RTMIN+7',
+        42 => 'RTMIN+8',
+        43 => 'RTMIN+9',
+        44 => 'RTMIN+10',
+        45 => 'RTMIN+11',
+        46 => 'RTMIN+12',
+        47 => 'RTMIN+13',
+        48 => 'RTMIN+14',
+        49 => 'RTMIN+15',
+        50 => 'RTMAX-14',
+        51 => 'RTMAX-13',
+        52 => 'RTMAX-12',
+        53 => 'RTMAX-11',
+        54 => 'RTMAX-10',
+        55 => 'RTMAX-9',
+        56 => 'RTMAX-8',
+        57 => 'RTMAX-7',
+        58 => 'RTMAX-6',
+        59 => 'RTMAX-5',
+        60 => 'RTMAX-4',
+        61 => 'RTMAX-3',
+        62 => 'RTMAX-2',
+        63 => 'RTMAX-1',
+        64 => 'RTMAX'
+      }
+
+      def self.[](signal)
+        return unless valid?(signal)
+
+        if key.instance_of?(Integer)
+          @linux_inverted[signal]
+        else
+          @linux[translate(signal)]
+        end
+      end
+
+      def self.valid?(signal)
+        if signal.instance_of?(Integer)
+          @linux_inverted.key?(signal)
+        elsif signal.instance_of?(String)
+          @linux.key?(translate(signal))
+        else
+          raise ArgumentError, 'Invalid data type'
+        end
+      end
+
+      def self.translate(signal)
+        signal.gsub('SIG', '')
+      end
+    end
+  end
+end

data/lib/kanrisuru/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kanrisuru
-  VERSION = "0.1.0"
+  VERSION = '0.2.1'
 end

data/spec/functional/core/archive_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Archive do
+  TestHosts.each_os do |os_name|
+    context "with #{os_name}" do
+      before(:all) do
+        host_json = TestHosts.host(os_name)
+        host = Kanrisuru::Remote::Host.new(
+          host: host_json['hostname'],
+          username: host_json['username'],
+          keys: [host_json['ssh_key']]
+        )
+
+        host.mkdir("#{host_json['home']}/.kanrisuru_spec_files", silent: true)
+        host.disconnect
+      end
+
+      let(:host_json) { TestHosts.host(os_name) }
+      let(:host) do
+        Kanrisuru::Remote::Host.new(
+          host: host_json['hostname'],
+          username: host_json['username'],
+          keys: [host_json['ssh_key']]
+        )
+      end
+
+      let(:spec_dir) { "#{host_json['home']}/.kanrisuru_spec_files" }
+
+      after do
+        host.disconnect
+      end
+
+      after(:all) do
+        host_json = TestHosts.host(os_name)
+        host = Kanrisuru::Remote::Host.new(
+          host: host_json['hostname'],
+          username: host_json['username'],
+          keys: [host_json['ssh_key']]
+        )
+
+        host.rmdir("#{host_json['home']}/.kanrisuru_spec_files")
+        host.rmdir("#{host_json['home']}/extract-tar-files") if host.dir?("#{host_json['home']}/extract-tar-files")
+        host.disconnect
+      end
+
+      it 'tars an archive' do
+        archive = 'archive.tar'
+        archive2 = 'archive2.tar'
+        directory = spec_dir
+
+        host.touch("#{spec_dir}/test-file.txt")
+        host.touch("#{spec_dir}/test1.txt")
+        host.touch("#{spec_dir}/test2.txt")
+        host.touch("#{spec_dir}/test3.txt")
+
+        host.touch("#{spec_dir}/test1.config")
+        host.touch("#{spec_dir}/test2.config")
+        host.touch("#{spec_dir}/test3.config")
+
+        host.cd(spec_dir)
+        result = host.tar('create', archive, paths: ['*.txt'], exclude: 'test-file.txt', directory: directory)
+
+        expect(result.success?).to eq(true)
+
+        file = host.file("#{spec_dir}/#{archive}")
+
+        expect(file.path).to eq("#{spec_dir}/archive.tar")
+        expect(file.user).to eq(host_json['username'])
+
+        case os_name
+        when 'opensuse', 'sles'
+          expect(file.group).to eq('users')
+        else
+          expect(file.group).to eq(host_json['username'])
+        end
+
+        result = host.tar('list', archive, directory: directory)
+        expect(result.success?).to eq(true)
+        paths = result.map(&:path)
+        expect(paths.include?('test-file.txt')).to eq(false)
+
+        result = host.tar('append', archive, paths: 'test-file.txt', directory: directory)
+        expect(result.success?).to eq(true)
+
+        result = host.tar('list', archive, directory: directory)
+        paths = result.map(&:path)
+
+        expect(paths.include?('test-file.txt')).to eq(true)
+
+        result = host.tar('create', archive2, paths: '*.config', directory: directory)
+        expect(result.success?).to eq(true)
+
+        file = host.file("#{spec_dir}/#{archive2}")
+
+        expect(file.path).to eq("#{spec_dir}/archive2.tar")
+        expect(file.user).to eq(host_json['username'])
+
+        case os_name
+        when 'opensuse', 'sles'
+          expect(file.group).to eq('users')
+        else
+          expect(file.group).to eq(host_json['username'])
+        end
+
+        result = host.tar('concat', archive, paths: archive2, directory: directory)
+        expect(result.success?).to eq(true)
+
+        result = host.tar('list', archive, directory: directory)
+        expect(result.success?).to eq(true)
+        paths = result.map(&:path)
+
+        expect(paths.include?('test1.config')).to eq(true)
+        expect(paths.include?('test2.config')).to eq(true)
+        expect(paths.include?('test3.config')).to eq(true)
+
+        result = host.tar('diff', archive, directory: directory)
+        expect(result.success?).to eq(true)
+
+        result = host.tar('delete', archive, directory: directory, paths: 'test2.config')
+        expect(result.success?).to eq(true)
+
+        result = host.tar('list', archive, directory: directory)
+        expect(result.success?).to eq(true)
+        paths = result.map(&:path)
+        expect(paths.include?('test2.config')).to eq(false)
+
+        host.mkdir("#{host_json['home']}/extract-tar-files", silent: true)
+        host.tar('extract', 'archive.tar', directory: "#{host_json['home']}/extract-tar-files")
+
+        result = host.ls(path: "#{host_json['home']}/extract-tar-files")
+        paths = result.map(&:path)
+
+        expect(paths.include?('test1.config')).to eq(true)
+        expect(paths.include?('test3.config')).to eq(true)
+        expect(paths.include?('test-file.txt')).to eq(true)
+        expect(paths.include?('test1.txt')).to eq(true)
+        expect(paths.include?('test2.txt')).to eq(true)
+        expect(paths.include?('test3.txt')).to eq(true)
+      end
+
+      it 'compresses archive while tar' do
+        archive = 'archive.tar'
+        directory = spec_dir
+
+        host.touch("#{spec_dir}/test1.log")
+        host.touch("#{spec_dir}/test2.log")
+        host.touch("#{spec_dir}/test3.log")
+
+        host.cd(spec_dir)
+        result = host.tar('create', "#{archive}.gz", compress: 'gzip', paths: ['*.log'], directory: directory)
+        expect(result.success?).to eq(true)
+
+        file = host.file("#{spec_dir}/#{archive}.gz")
+        expect(file.path).to eq("#{spec_dir}/archive.tar.gz")
+        expect(file.uid).to eq(1000)
+
+        case os_name
+        when 'opensuse', 'sles'
+          expect(file.gid).to eq(100)
+        else
+          expect(file.gid).to eq(1000)
+        end
+
+        case os_name
+        when 'debian', 'ubuntu'
+          result = host.tar('create', "#{archive}.bz", compress: 'bzip2', paths: ['*.log'], directory: directory)
+          expect(result.success?).to eq(true)
+
+          file = host.file("#{spec_dir}/#{archive}.bz")
+          expect(file.path).to eq("#{spec_dir}/archive.tar.bz")
+          expect(file.uid).to eq(1000)
+          expect(file.gid).to eq(1000)
+        end
+
+        # case os_name
+        # when 'opensuse', 'sles'
+        #   expect(file.gid).to eq(100)
+        # else
+        # end
+
+        case os_name
+        when 'debian'
+          ## no op
+        else
+          result = host.tar('create', "#{archive}.xz", compress: 'xz', paths: ['*.log'], directory: directory)
+          expect(result.success?).to eq(true)
+
+          file = host.file("#{spec_dir}/#{archive}.xz")
+          expect(file.path).to eq("#{spec_dir}/archive.tar.xz")
+          expect(file.uid).to eq(1000)
+
+          case os_name
+          when 'opensuse', 'sles'
+            expect(file.gid).to eq(100)
+          else
+            expect(file.gid).to eq(1000)
+          end
+        end
+
+        case os_name
+        when 'centos', 'rhel', 'debian'
+          ## no op
+        else
+          result = host.tar('create', "#{archive}.lzma", compress: 'lzma', paths: ['*.log'], directory: directory)
+          expect(result.success?).to eq(true)
+
+          file = host.file("#{spec_dir}/#{archive}.lzma")
+          expect(file.path).to eq("#{spec_dir}/archive.tar.lzma")
+          expect(file.uid).to eq(1000)
+
+          case os_name
+          when 'opensuse', 'sles'
+            expect(file.gid).to eq(100)
+          else
+            expect(file.gid).to eq(1000)
+          end
+        end
+
+        expect do
+          host.tar('create', "#{archive}.lzop", compress: 'lzop', paths: ['*.log'],
+                                                directory: directory)
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+end