kanrisuru 0.11.1 → 0.14.0

data/spec/support/shared_examples/integration/core/stat.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'stat' do |os_name, host_json, _spec_dir|
+  context "with #{os_name}" do
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    it 'checks file type correctly' do
+      expect(host.dir?('/')).to eq(true)
+      expect(host.file?('/etc/hosts')).to eq(true)
+
+      case os_name
+      when 'sles'
+        expect(host.block_device?('/dev/xvda')).to eq(true)
+      else
+        expect(host.block_device?('/dev/vda')).to eq(true)
+      end
+
+      expect(host.char_device?('/dev/tty')).to eq(true)
+      expect(host.symlink?('/etc/mtab')).to eq(true)
+      expect(host.inode?('/proc/uptime')).to eq(true)
+    end
+
+    it 'gets file stat' do
+      result = host.stat(host_json['home'])
+
+      expect(result.mode).to be_instance_of(Kanrisuru::Mode)
+      expect(result.mode.directory?).to eq(true)
+
+      case os_name
+      when 'centos', 'rhel', 'fedora'
+        expect(result.mode.numeric).to eq('700')
+        expect(result.mode.to_i).to eq(0o700)
+
+        expect(result.mode.group.read?).to eq(false)
+        expect(result.mode.group.write?).to eq(false)
+        expect(result.mode.group.execute?).to eq(false)
+
+        expect(result.mode.other.read?).to eq(false)
+        expect(result.mode.other.write?).to eq(false)
+        expect(result.mode.other.execute?).to eq(false)
+
+        expect(result.mode.owner.read?).to eq(true)
+        expect(result.mode.owner.write?).to eq(true)
+        expect(result.mode.owner.execute?).to eq(true)
+
+        expect(result.mode.symbolic).to eq('drwx------')
+      else
+        expect(result.mode.numeric).to eq('755')
+        expect(result.mode.to_i).to eq(0o755)
+
+        expect(result.mode.group.read?).to eq(true)
+        expect(result.mode.group.write?).to eq(false)
+        expect(result.mode.group.execute?).to eq(true)
+
+        expect(result.mode.other.read?).to eq(true)
+        expect(result.mode.other.write?).to eq(false)
+        expect(result.mode.other.execute?).to eq(true)
+
+        expect(result.mode.owner.read?).to eq(true)
+        expect(result.mode.owner.write?).to eq(true)
+        expect(result.mode.owner.execute?).to eq(true)
+
+        expect(result.mode.symbolic).to eq('drwxr-xr-x')
+      end
+
+      expect(result.file_type).to eq('directory')
+
+      case os_name
+      when 'opensuse', 'sles'
+        expect(result.gid).to eq(100)
+        expect(result.group).to eq('users')
+      else
+        expect(result.gid).to eq(1000)
+        expect(result.group).to eq(host_json['username'])
+      end
+
+      expect(result.uid).to eq(1000)
+      expect(result.user).to eq(host_json['username'])
+
+      expect(result.fsize).to be >= 0
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/stream.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'stream' do |os_name, host_json, spec_dir|
+  context "with #{os_name}" do
+    before(:all) do
+      host = Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+
+      host.mkdir(spec_dir, silent: true)
+      host.disconnect
+    end
+
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    after(:all) do
+      host = Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+
+      host.rmdir(spec_dir)
+      host.disconnect
+    end
+
+    it 'outputs beginning of a file' do
+      file = host.file("#{spec_dir}/test-file.txt")
+      file.touch
+      file.append do |f|
+        f << 'This'
+        f << 'is'
+        f << 'a'
+        f << 'file!'
+      end
+
+      result = host.head("#{spec_dir}/test-file.txt", lines: 2)
+      expect(result).to be_success
+      expect(result.data.length).to eq(2)
+      expect(result.data).to eq(%w[This is])
+    end
+
+    it 'outputs end of a file' do
+      file = host.file("#{spec_dir}/test-file.txt")
+      file.touch
+      file.append do |f|
+        f << 'This'
+        f << 'is'
+        f << 'a'
+        f << 'file!'
+      end
+
+      result = host.tail("#{spec_dir}/test-file.txt", lines: 2)
+      expect(result).to be_success
+      expect(result.data.length).to eq(2)
+      expect(result.data).to eq(['a', 'file!'])
+    end
+
+    it 'reads a chunk of text from a file' do
+      file = host.file("#{spec_dir}/test-file-chunk.txt")
+      file.touch
+      file.append do |f|
+        f << 'This'
+        f << 'is'
+        f << 'is'
+        f << 'a'
+        f << 'file'
+        f << 'forever...'
+      end
+
+      result = host.read_file_chunk("#{spec_dir}/test-file-chunk.txt", 2, 4)
+      expect(result).to be_success
+      expect(result.data.length).to eq(3)
+      expect(result.data).to eq(%w[is is a])
+    end
+
+    it 'cats a file' do
+      result = host.cat('/etc/group')
+      expect(result.success?).to eq(true)
+      expect(result.data.include?('root:x:0:')).to eq(true)
+    end
+
+    it 'echoes to stdout' do
+      result = host.echo('Hello world')
+      expect(result.data).to eq('Hello world')
+    end
+
+    it 'seds file to stdout' do
+      path = "#{spec_dir}/test-file.txt"
+      result = host.echo("Hello world, this is a Cat test file.\nCat\nCat\nDog", new_file: path, mode: 'write')
+      expect(result).to be_success
+
+      result = host.sed(path, 'Cat', 'Dog')
+      expect(result).to be_success
+      expect(result.data).to eq("Hello world, this is a Dog test file.\nDog\nDog\nDog")
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/system.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'system' do |os_name, host_json, _spec_dir|
+  context "with #{os_name}" do
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    it 'gets cpu details' do
+      result = host.lscpu
+      expect(result).to be_success
+      expect(result.data).to be_instance_of(Kanrisuru::Core::System::CPUArchitecture)
+    end
+
+    it 'gets environment variables' do
+      result = host.load_env
+      expect(result).to be_success
+      expect(result.data).to be_instance_of(Hash)
+    end
+
+    it 'gets open files' do
+      host.su('root')
+      result = host.lsof
+      expect(result).to be_success
+      expect(result.data).to be_instance_of(Array)
+    end
+
+    it 'gets uptime' do
+      result = host.uptime
+      expect(result).to be_success
+
+      expect(result).to respond_to(
+        :boot_time, :uptime, :seconds,
+        :hours, :minutes, :days
+      )
+
+      expect(result.seconds).to be > 0
+      expect(result.minutes).to be >= 0
+      expect(result.hours).to be >= 0
+      expect(result.days).to be >= 0
+    end
+
+    it 'kills pids' do
+      command = 'sleep 100000 > /dev/null 2>&1 &'
+
+      host.execute_shell("nohup #{command}")
+      result = host.ps(user: host_json['username'])
+      expect(result.success?).to eq(true)
+
+      process = result.select do |proc|
+        proc.command == 'sleep 100000'
+      end
+
+      pids = process.map(&:pid)
+      result = host.kill('SIGKILL', pids)
+      expect(result.success?).to eq(true)
+
+      result = host.ps(user: host_json['username'])
+      process = result.select do |proc|
+        proc.command == 'sleep 100000'
+      end
+
+      expect(process).to be_empty
+    end
+
+    it 'gets kernel statistics' do
+      result = host.kernel_statistics
+      expect(result).to be_success
+
+      expect(result.data).to respond_to(
+        :cpu_total,
+        :cpus,
+        :interrupt_total,
+        :interrupts,
+        :ctxt,
+        :btime,
+        :processes,
+        :procs_running,
+        :procs_blocked,
+        :softirq_total,
+        :softirqs
+      )
+
+      expect(result.cpus.length).to eq(host.cpu.cores)
+    end
+
+    it 'gets login details' do
+      host.su('root')
+
+      result = host.last
+      expect(result).to be_success
+    end
+
+    it 'gets failed login attempts' do
+      host.su('root')
+
+      result = host.last(failed_attempts: true)
+      expect(result).to be_success
+    end
+
+    it 'gets process details' do
+      result = host.ps
+
+      expect(result.data).to be_instance_of(Array)
+      process = result[0]
+
+      expect(process).to respond_to(
+        :uid, :user, :gid, :group,
+        :pid, :ppid, :cpu_usage, :memory_usage,
+        :stat, :priority, :flags, :policy_abbr, :policy,
+        :cpu_time, :command
+      )
+
+      result = host.ps(user: [host_json['username']])
+
+      expect(result.data).to be_instance_of(Array)
+
+      process = result.find do |proc|
+        proc.command == result.command.raw_command
+      end
+
+      expect(process.command).to eq(result.command.raw_command)
+    end
+
+    it 'gets information for users' do
+      result = host.who
+      expect(result.success?).to eq(true)
+    end
+
+    it 'cancels rebooting system' do
+      host.su('root')
+      result = host.reboot(time: 1000)
+      expect(result).to be_success
+
+      result = host.reboot(cancel: true)
+      expect(result).to be_success
+
+      result = host.reboot(time: '11:11', message: 'Rebooting system')
+      expect(result).to be_success
+
+      result = host.reboot(cancel: true)
+      expect(result).to be_success
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/transfer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'transfer' do |os_name, host_json, spec_dir|
+  context "with #{os_name}" do
+    before(:all) do
+      host = Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+
+      host.mkdir(spec_dir, silent: true)
+      host.disconnect
+    end
+
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    after(:all) do
+      host = Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+
+      host.rmdir(spec_dir)
+      host.disconnect
+    end
+
+    it 'uploads a template file' do
+      path = '../templates/test.conf.erb'
+      dest_path = "#{spec_dir}/test.conf"
+
+      template = Kanrisuru::Template.new(path, array: %w[this is an array])
+      result = host.upload(template.read, dest_path)
+
+      expect(result).to be_success
+      expect(result.mode.numeric).to eq('640')
+      expect(result.user).to eq(host_json['username'])
+
+      case os_name
+      when 'sles', 'opensuse'
+        expect(result.gid).to eq(100)
+        expect(result.group).to eq('users')
+      else
+        expect(result.gid).to eq(1000)
+        expect(result.group).to eq(host_json['username'])
+      end
+
+      expect(host.cat(dest_path).to_a).to eq([
+                                               '<h1>Hello World</h1>',
+                                               'this',
+                                               'is',
+                                               'an',
+                                               'array'
+                                             ])
+    end
+
+    it 'uploads a dir' do
+      path = '../meta/'
+      dest_path = "#{spec_dir}/meta"
+
+      result = host.upload(path, dest_path, recursive: true)
+      expect(result).to be_success
+    end
+
+    it 'downloads a file to local fs' do
+      path = '../hosts-file'
+      src_path = '/etc/hosts'
+
+      result = host.download(src_path, path)
+      expect(result).to eq(path)
+      FileUtils.rm(path)
+    end
+
+    it 'downloads a file directly' do
+      src_path = '/etc/hosts'
+
+      result = host.download(src_path)
+      expect(result).to be_instance_of(String)
+      lines = result.split("\n")
+      expect(lines.length).to be >= 1
+    end
+
+    it 'wgets url' do
+      result = host.wget('https://example.com', directory_prefix: spec_dir)
+      expect(result).to be_success
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/user.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'user' do |os_name, host_json, _spec_dir|
+  context "with #{os_name}" do
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    after(:all) do
+      host = Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+
+      host.su('root')
+      host.user?('rails')
+      host.delete_user('rails').inspect if host.user?('rails')
+      host.rmdir('/home/rails') if host.dir?('/home/rails')
+      host.disconnect
+    end
+
+    it 'gets uid for user' do
+      expect(host.get_uid(host_json['uername']).to_i).to eq(1000)
+      expect(host.get_uid('asdf').to_i).to eq(nil)
+    end
+
+    it 'gets a user details' do
+      result = host.get_user(host_json['username'])
+      expect(result.uid).to eq(1000)
+      expect(result.name).to eq(host_json['username'])
+      expect(result.home.path).to eq(host_json['home'])
+
+      case os_name
+      when 'opensuse', 'sles'
+        expect(result.groups[0]).to have_attributes(gid: 100, name: 'users')
+      else
+        expect(result.groups[0]).to have_attributes(gid: 1000, name: host_json['username'])
+      end
+    end
+
+    it 'manages a user' do
+      ## Need priviledge escalation to manage group
+      host.su('root')
+
+      result = host.create_user('rails', password: '123456', groups: %w[mail tty])
+      expect(result.success?).to eq(true)
+      expect(result.uid).to eq(1001)
+      expect(result.groups.length).to eq(3)
+      expect(result.shell.path).to eq('/bin/false')
+      expect(result.home.path).to eq('/home/rails')
+
+      result = host.update_user('rails', uid: 1002, shell: '/bin/bash', groups: ['audio'], append: true)
+
+      expect(result.uid).to eq(1002)
+      expect(result.shell.path).to eq('/bin/bash')
+      expect(result.groups.length).to eq(4)
+
+      expect(host.delete_user('rails').success?).to eq(true) if host.user?('rails')
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/yum.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'yum' do |os_name, host_json, _spec_dir|
+  context "with #{os_name}" do
+    let(:host) do
+      Kanrisuru::Remote::Host.new(
+        host: host_json['hostname'],
+        username: host_json['username'],
+        keys: [host_json['ssh_key']]
+      )
+    end
+
+    after do
+      host.disconnect
+    end
+
+    it 'upgrades packages' do
+      host.su('root')
+      result = host.yum('upgrade')
+      expect(result).to be_success
+    end
+
+    it 'updates packages' do
+      host.su('root')
+      result = host.yum('update')
+      expect(result).to be_success
+    end
+
+    it 'installs local package from RPM' do
+      case os_name
+      when 'fedora'
+        package = 'rpmfusion-free-release-32.noarch.rpm'
+        url = "https://download1.rpmfusion.org/free/fedora/#{package}"
+
+        result = host.wget(url)
+        expect(result).to be_success
+        file = host.file("~/#{package}")
+        expect(file).to be_exists
+
+        host.su('root')
+        result = host.yum('localinstall', repos: file.expand_path)
+        expect(result).to be_success
+      end
+    end
+
+    it 'lists installed packages' do
+      result = host.yum('list', installed: true)
+      expect(result).to be_success
+    end
+
+    it 'lists repos' do
+      result = host.yum('repolist')
+      expect(result).to be_success
+    end
+
+    it 'lists installed repos' do
+      result = host.yum('repolist', repos: 'updates')
+      expect(result).to be_success
+    end
+
+    it 'searches a single package' do
+      result = host.yum('search', packages: 'curl')
+      expect(result).to be_success
+    end
+
+    it 'searches all packages' do
+      result = host.yum('search', all: true, packages: %w[curl ffmpeg])
+      expect(result).to be_success
+    end
+
+    it 'installs a package' do
+      host.su('root')
+      result = host.yum('install', packages: %(ffmpeg curl))
+      expect(result).to be_success
+    end
+
+    it 'removes installed packages' do
+      host.su('root')
+      result = host.yum('remove', packages: ['ffmpeg'])
+      expect(result).to be_success
+    end
+
+    it 'purges installed packages' do
+      host.su('root')
+      result = host.yum('erase', packages: ['ffmpeg'])
+      expect(result).to be_success
+    end
+
+    it 'gets info for one package' do
+      host.su('root')
+      result = host.yum('info', packages: 'yum')
+      expect(result).to be_success
+    end
+
+    it 'gets info for installed packages' do
+      host.su('root')
+      result = host.yum('info', installed: true)
+      expect(result).to be_success
+    end
+
+    it 'cleans packages' do
+      host.su('root')
+      result = host.yum('clean', all: true)
+      expect(result).to be_success
+    end
+
+    it 'autoremoves packages' do
+      host.su('root')
+      result = host.yum('autoremove')
+      expect(result).to be_success
+    end
+  end
+end