kanrisuru 0.12.0 → 0.15.0

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.#{os_name}.txt"
+      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

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'zypper' 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
+
+    def find_repo(host, repo_name)
+      repos = host.zypper('repos').data
+      repos.find { |repo| repo.alias == repo_name }
+    end
+
+    it 'lists repos' do
+      result = host.zypper('repos')
+      expect(result).to be_success
+    end
+
+    it 'installs a package' do
+      host.su('root')
+      result = host.zypper('install', packages: 'nginx')
+      expect(result).to be_success
+    end
+
+    it 'installs multiple packages' do
+      host.su('root')
+      result = host.zypper('install', packages: %w[curl nginx])
+      expect(result).to be_success
+    end
+
+    it 'removes a package' do
+      host.su('root')
+      result = host.zypper('remove', packages: ['nginx'])
+      expect(result).to be_success
+    end
+
+    it 'lists updates' do
+      result = host.zypper('list-updates')
+      expect(result).to be_success
+    end
+
+    it 'lists patches' do
+      result = host.zypper('list-patches')
+      expect(result).to be_success
+    end
+
+    it 'lists important and secure patches' do
+      result = host.zypper('list-patches', category: ['security'], severity: %w[important moderate])
+      expect(result).to be_success
+    end
+
+    it 'lists patch check counts' do
+      result = host.zypper('patch-check')
+      expect(result).to be_success
+    end
+
+    it 'updates a package' do
+      host.su('root')
+      result = host.zypper('update', packages: 'curl')
+      expect(result).to be_success
+    end
+
+    it 'gets info for one package' do
+      result = host.zypper('info', packages: 'curl')
+      expect(result).to be_success
+    end
+
+    it 'gets info for multiple packages' do
+      result = host.zypper('info', packages: %w[curl wget git sudo])
+      expect(result).to be_success
+    end
+
+    it 'gets info for type' do
+      result = host.zypper('info', type: 'package', packages: 'gc*')
+      expect(result).to be_success
+    end
+
+    it 'patches system' do
+      host.su('root')
+      result = host.zypper('patch', severity: 'moderate')
+      expect(result).to be_success
+    end
+
+    it 'performs a dist-upgrade' do
+      case os_name
+      when 'opensuse'
+        host.su('root')
+        result = host.zypper('dist-upgrade', dry_run: true)
+        expect(result).to be_success
+      when 'sles'
+        host.su('root')
+        result = host.zypper('dist-upgrade', dry_run: true, auto_agree_with_licenses: true)
+        expect(result).to be_success
+      end
+    end
+
+    it 'searches for single package with match' do
+      result = host.zypper('search', packages: 'gc*', sort_by_name: true)
+      expect(result).to be_success
+    end
+
+    it 'searches for multiple packages' do
+      result = host.zypper('search', packages: %w[nginx ffmpeg], sort_by_repo: true)
+      expect(result).to be_success
+    end
+
+    it 'manages a repo' do
+      repo_alias = 'graphics'
+      if os_name == 'opensuse'
+        repo_name = 'Graphics Project (openSUSE_Leap_15.2)'
+        repo_uri = 'https://download.opensuse.org/repositories/graphics/openSUSE_Leap_15.2/'
+      else
+        repo_name = 'Graphics Project (openSUSE_Leap_15.3)'
+        repo_uri = 'https://download.opensuse.org/repositories/graphics/openSUSE_Leap_15.3/'
+      end
+
+      url = "#{repo_uri}/#{repo_alias}.repo"
+
+      host.su('root')
+      result = host.zypper('addrepo', repos: url)
+      expect(result).to be_success
+
+      repo = find_repo(host, repo_alias)
+
+      expect(repo).to be_instance_of(Kanrisuru::Core::Zypper::Repo)
+      expect(repo.uri).to eq(repo_uri)
+      expect(repo.name).to eq(repo_name)
+
+      new_repo_alias = 'graphics-repo'
+      result = host.zypper('renamerepo', repo: repo_alias, alias: new_repo_alias)
+      expect(result).to be_success
+      repo = find_repo(host, new_repo_alias)
+      expect(repo.alias).to eq(new_repo_alias)
+
+      result = host.zypper('modifyrepo', repos: new_repo_alias, disable: true)
+      expect(result).to be_success
+      repo = find_repo(host, new_repo_alias)
+      expect(repo.enabled).to be_falsey
+
+      result = host.zypper('removerepo', repos: new_repo_alias)
+      expect(result).to be_success
+
+      repo = find_repo(host, new_repo_alias)
+      expect(repo).to be_nil
+    end
+
+    it 'refreshes repos' do
+      host.su('root')
+      result = host.zypper('refresh')
+      expect(result).to be_success
+    end
+
+    it 'cleans repo caches' do
+      host.su('root')
+      result = host.zypper('clean')
+      expect(result).to be_success
+    end
+
+    it 'lists services' do
+      result = host.zypper('services')
+      expect(result).to be_success
+    end
+
+    it 'refreshes services' do
+      host.su('root')
+      result = host.zypper('refresh-services')
+      expect(result).to be_success
+    end
+
+    it 'manages locks' do
+      host.su('root')
+      result = host.zypper('addlock', lock: 'nginx', type: 'package')
+      expect(result).to be_success
+
+      result = host.zypper('locks')
+      expect(result).to be_success
+
+      lock = result.first
+      expect(lock.name).to eq('nginx')
+      expect(lock.type).to eq('package')
+
+      result = host.zypper('removelock', lock: 'nginx')
+      expect(result).to be_success
+    end
+  end
+end

data/spec/{integration/remote/cluster_spec.rb → support/shared_examples/integration/remote/cluster.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-RSpec.describe Kanrisuru::Remote::Cluster do
-  context 'with ubuntu' do
+RSpec.shared_examples 'cluster' do |os_name, _host_json, _spec_dir|
+  context "with #{os_name}" do
     it 'gets hostname for cluster' do
       cluster = described_class.new({
                                       host: 'localhost',

data/spec/support/shared_examples/integration/remote/cpu.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'cpu' 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
+      expect(host.cpu.cores).to eq(1)
+      expect(host.cpu.total).to eq(1)
+      expect(host.cpu.count).to eq(1)
+
+      expect(host.cpu.threads_per_core).to eq(1)
+      expect(host.cpu.cores_per_socket).to eq(1)
+      expect(host.cpu.sockets).to eq(1)
+
+      expect(host.cpu.hyperthreading?).to eq(false)
+    end
+
+    it 'gets cpu load average' do
+      expect(host.cpu.load_average).to be_instance_of(Array)
+      expect(host.cpu.load_average1).to be_instance_of(Float)
+      expect(host.cpu.load_average5).to be_instance_of(Float)
+      expect(host.cpu.load_average15).to be_instance_of(Float)
+    end
+  end
+end

data/spec/support/shared_examples/integration/remote/env_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_examples 'env' 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 'sets env var' do
+      host.env['HELLO'] = 'world'
+      host.env['KANRISURU'] = 'manage'
+
+      expect(host.env['KANRISURU']).to eq('manage')
+      expect(host.env.to_s).to eq('export HELLO=world; export KANRISURU=manage;')
+      expect(host.env.to_h).to eq({ 'HELLO' => 'world', 'KANRISURU' => 'manage' })
+
+      command = Kanrisuru::Command.new('echo $KANRISURU $HELLO')
+      host.execute_shell(command)
+
+      expect(command.to_s).to eq('manage world')
+    end
+  end
+end

data/spec/support/shared_examples/integration/remote/fstab.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'fstab' 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 'outputs string version of fstab' do
+      host.su('root')
+
+      result = host.cat('/etc/fstab')
+      expect(result).to be_success
+      raw_file_lines = []
+      result.each do |line|
+        next if line.match(/^#/) || line == ''
+
+        raw_file_lines << line.split.join(' ')
+      end
+
+      raw_file_output = raw_file_lines.join("\n")
+      expect(raw_file_output).to eq(host.fstab.to_s)
+    end
+
+    it 'parses fstab' do
+      host.su('root')
+      fstab = host.fstab
+
+      entry =
+        case os_name
+        when 'opensuse'
+          fstab['/dev/vda3']
+        when 'sles'
+          fstab['/dev/xvda1']
+        else
+          fstab['/dev/vda1']
+        end
+
+      expect(fstab.get_entry(entry.uuid)).to eq(entry)
+      expect(fstab.get_entry(entry.label)).to eq(entry)
+
+      fstab << Kanrisuru::Remote::Fstab::Entry.new(
+        device: '/dev/vda14',
+        mount_point: '/mnt/test',
+        type: 'ext4',
+        opts: { defaults: true },
+        freq: '0',
+        passno: '0'
+      )
+
+      entry = fstab['/dev/vda14']
+      expect(entry.to_s).to eq('/dev/vda14 /mnt/test ext4 defaults 0 0')
+      expect(entry.device).to eq('/dev/vda14')
+      expect(entry.mount_point).to eq('/mnt/test')
+      expect(entry.type).to eq('ext4')
+      expect(entry.opts.to_s).to eq('defaults')
+      expect(entry.freq).to eq('0')
+      expect(entry.passno).to eq('0')
+
+      entry.opts['defaults'] = false
+      entry.opts['user'] = true
+      entry.opts['exec'] = true
+      entry.opts['rw'] = true
+      entry.opts['auto'] = true
+      entry.opts['relatime'] = true
+      entry.opts['async'] = true
+      entry.opts[:nodev] = true
+      entry.opts[:nosuid] = true
+      entry.opts[:owner] = true
+      entry.opts[:group] = true
+
+      entry.mount_point = '/mnt/test3'
+
+      expect(fstab['/dev/vda14'].to_s).to eq '/dev/vda14 /mnt/test3 ext4 ' \
+                                             'user,exec,rw,auto,relatime,async,nodev,nosuid,owner,group 0 0'
+
+      fstab << '/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0'
+      expect(fstab['/dev/vda16'].to_s).to eq('/dev/vda16 /mnt/test2 fat defaults,user,uid=1000,gid=1000 0 0')
+    end
+  end
+end