kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/core/transfer.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Kanrisuru
+  module Core
+    module Transfer
+      extend OsPackage::Define
+
+      os_define :linux, :download
+      os_define :linux, :upload
+      os_define :linux, :wget
+
+      WGET_FILENAME_MODES = %w[unix windows nocontrol ascii lowercase uppercase].freeze
+      WGET_SSL_PROTO = %w[auto SSLv2 SSLv3 TLSv1].freeze
+
+      def download(remote_path, local_path = nil, opts = {})
+        if local_path.instance_of?(Hash)
+          opts = local_path
+          local_path = nil
+        end
+
+        tmp_path = "/tmp/kanrisuru-tmp-#{Time.now.to_i}-#{object_id}"
+
+        begin
+          result = cp(remote_path, tmp_path, force: true)
+          raise 'Unable to copy remote file to temp path' unless result.success?
+
+          result = ssh.scp.download!(tmp_path, local_path, opts)
+          Kanrisuru::Util.blank?(local_path) ? result : local_path
+        ensure
+          rm(tmp_path, force: true) if inode?(tmp_path)
+        end
+      end
+
+      def upload(local_path, remote_path, opts = {})
+        tmp_path = "/tmp/kanrisuru-tmp-#{Time.now.to_i}-#{object_id}"
+
+        begin
+          result = ssh.scp.upload!(local_path, tmp_path, opts)
+          raise 'Unable to upload file' unless result
+
+          result = mv(tmp_path, remote_path)
+          raise 'Unable to move file to remote path' unless result.success?
+
+          stat(remote_path)
+        ensure
+          rm(tmp_path, force: true) if inode?(tmp_path)
+        end
+      end
+
+      def wget(url, opts = {})
+        command = Kanrisuru::Command.new('wget')
+
+        ## Logging and input
+        command.append_flag('--quiet', opts[:quiet])
+
+        case opts[:verbose]
+        when true
+          command.append_flag('--verbose')
+        when false
+          command.append_flag('--no-verbose')
+        end
+
+        command.append_arg('--output-file', opts[:log_file])
+        command.append_arg('--append-output', opts[:append_log_file])
+
+        ## Download
+        command.append_arg('--bind-address', opts[:bind_address])
+        command.append_arg('--tries', opts[:retries])
+        command.append_arg('--output-document', opts[:output_document])
+        command.append_flag('--no-clobber', opts[:no_clobber])
+        command.append_flag('--continue', opts[:continue])
+        command.append_flag('--server-response', opts[:server_response])
+        command.append_flag('--spider', opts[:spider])
+        command.append_arg('--timeout', opts[:timeout])
+        command.append_arg('--dns-timeout', opts[:dns_timeout])
+        command.append_arg('--connect-timeout', opts[:connect_timeout])
+        command.append_arg('--read-timeout', opts[:read_timeout])
+        command.append_arg('--limit-rate', opts[:limit_rate])
+        command.append_arg('--wait', opts[:wait])
+        command.append_arg('--waitretry', opts[:waitretry])
+        command.append_flag('--random-wait', opts[:random_wait])
+        command.append_flag('--no-proxy', opts[:no_proxy])
+        command.append_flag('--no-dns-cache', opts[:no_dns_cache])
+
+        command.append_arg('--quota', opts[:quota])
+
+        if Kanrisuru::Util.present?(opts[:restrict_file_names])
+          command.append_arg('--restrict-file-names', Kanrisuru::Util.string_join_array(opts[:restrict_file_names]))
+        end
+
+        case opts[:family]
+        when 'inet'
+          command.append_flag('--inet4-only')
+        when 'inet6'
+          command.append_flag('--inet6-only')
+        end
+
+        command.append_flag('--retry-connrefused', opts[:retry_connrefused])
+        command.append_arg('--user', opts[:user])
+        command.append_arg('--password', opts[:password])
+        command.append_flag('--no-iri', opts[:no_iri])
+        command.append_arg('--local-encoding', opts[:local_encoding])
+        command.append_arg('--remote-encoding', opts[:remote_encoding])
+
+        ## Directories
+        command.append_flag('--no-directories', opts[:no_directories])
+        command.append_flag('--force-directories', opts[:force_directories])
+        command.append_flag('--no-host-directories', opts[:no_host_directories])
+        command.append_flag('--protocol-directories', opts[:protocol_directories])
+        command.append_arg('--cut-dirs', opts[:cut_dirs])
+        command.append_arg('--directory-prefix', opts[:directory_prefix])
+
+        ## HTTP
+        command.append_arg('--default-page', opts[:default_page])
+        command.append_flag('--adjust-extension', opts[:adjust_extension])
+        command.append_arg('--http-user', opts[:http_user])
+        command.append_arg('--http-password', opts[:http_password])
+        command.append_arg('--load-cookies', opts[:load_cookies])
+        command.append_arg('--save-cookies', opts[:save_cookies])
+        command.append_flag('--no-http-keep-alive', opts[:no_http_keep_alive])
+        command.append_flag('--no-cache', opts[:no_cache])
+        command.append_flag('--no-cookies', opts[:no_cookies])
+        command.append_flag('--keep-session-cookies', opts[:keep_session_cookies])
+        command.append_flag('--ignore-length', opts[:ignore_length])
+        command.append_arg('--header', opts[:header])
+        command.append_arg('--max-redirect', opts[:max_redirect])
+        command.append_arg('--proxy-user', opts[:proxy_user])
+        command.append_arg('--proxy-password', opts[:proxy_password])
+        command.append_arg('--referer', opts[:referer])
+        command.append_flag('--save-headers', opts[:save_headers])
+        command.append_arg('--user-agent', opts[:user_agent])
+
+        post_data = opts[:post_data]
+
+        if Kanrisuru::Util.present?(post_data)
+          post_data = post_data.instance_of?(Hash) ? URI.encode_www_form(post_data) : post_data
+          command.append_arg('--post-data', post_data)
+        end
+
+        command.append_arg('--post-file', opts[:post_file])
+        command.append_flag('--content-disposition', opts[:content_disposition])
+
+        ## SSL / TLS
+        if Kanrisuru::Util.present?(opts[:secure_protocol])
+          raise ArgumentError, 'invalid ssl protocol' unless WGET_SSL_PROTO.include?(opts[:secure_protocol])
+
+          command.append_arg('--secure-protocol', opts[:secure_protocol])
+        end
+
+        command.append_flag('--no-check-certificate', opts[:no_check_certificate])
+        command.append_arg('--certificate', opts[:certificate])
+        command.append_arg('--certificate-type', opts[:certificate_type])
+        command.append_arg('--private-key', opts[:private_key])
+        command.append_arg('--private-key-type', opts[:private_key_type])
+        command.append_arg('--ca-certificate', opts[:ca_certificate])
+        command.append_arg('--ca-directory', opts[:ca_directory])
+        command.append_arg('--random-file', opts[:random_file])
+        command.append_arg('--egd-file', opts[:egd_file])
+
+        ## FTP
+        command.append_arg('--ftp-user', opts[:ftp_user])
+        command.append_arg('--ftp-password', opts[:ftp_password])
+        command.append_flag('--no-remove-listing', opts[:no_remove_listing])
+        command.append_flag('--no-glob', opts[:no_glob])
+        command.append_flag('--no-passive-ftp', opts[:no_passive_ftp])
+        command.append_flag('--retr-symlinks', opts[:retr_symlinks])
+
+        ## Recursive Retrieval
+        command.append_flag('--recursive', opts[:recursive])
+        command.append_arg('--level', opts[:depth])
+        command.append_flag('--delete-after', opts[:delete_after])
+        command.append_flag('--convert-links', opts[:convert_links])
+        command.append_flag('--backup-converted', opts[:backup_converted])
+        command.append_flag('--mirror', opts[:mirror])
+        command.append_flag('--page-requisites', opts[:page_requisites])
+        command.append_flag('--strict-comments', opts[:strict_comments])
+
+        ## Recursive Accept/Reject
+        command.append_arg('--accept', Kanrisuru::Util.array_join_string(opts[:accept_list]))
+        command.append_arg('--reject', Kanrisuru::Util.array_join_string(opts[:reject_list]))
+        command.append_arg('--domains', Kanrisuru::Util.array_join_string(opts[:domain_list]))
+        command.append_arg('--exclude-domains', Kanrisuru::Util.array_join_string(opts[:exclude_domain_list]))
+        command.append_arg('--follow-tags', Kanrisuru::Util.array_join_string(opts[:follow_tags]))
+        command.append_arg('--ignore-tags', Kanrisuru::Util.array_join_string(opts[:ignore_tags]))
+        command.append_arg('--include-directories', Kanrisuru::Util.array_join_string(opts[:include_directories]))
+        command.append_arg('--exclude-directories', Kanrisuru::Util.array_join_string(opts[:exclude_directories]))
+        command.append_flag('--follow-ftp', opts[:follow_ftp])
+        command.append_flag('--ignore-case', opts[:ignore_case])
+        command.append_flag('--span-hosts', opts[:span_hosts])
+        command.append_flag('--relative', opts[:relative])
+        command.append_flag('--no-parent', opts[:no_parent])
+
+        command << url
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/user.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module User
+      extend OsPackage::Define
+
+      os_define :linux, :user?
+      os_define :linux, :get_uid
+      os_define :linux, :get_user
+      os_define :linux, :create_user
+      os_define :linux, :update_user
+      os_define :linux, :delete_user
+
+      User = Struct.new(:uid, :name, :home, :shell, :groups)
+      UserGroup = Struct.new(:gid, :name)
+      FilePath = Struct.new(:path)
+
+      def user?(user)
+        result = get_uid(user)
+        return false if result.failure?
+
+        Kanrisuru::Util.present?(result.data) && result.data.instance_of?(Integer)
+      end
+
+      def get_uid(user)
+        command = Kanrisuru::Command.new("id -u #{user}")
+
+        execute(command)
+
+        Kanrisuru::Result.new(command, &:to_i)
+      end
+
+      def get_user(user)
+        command = Kanrisuru::Command.new("id #{user}")
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          ## Get user id
+          result = get_uid(user)
+          break if result.failure?
+
+          uid = result.to_i
+
+          ## Get all groups for the user, with gid and group name
+          string = cmd.to_s
+          string = string.split('groups=')[1]
+          array = string.gsub(/\(/, '').gsub(/\)/, '').split(',')
+
+          groups = array.map do |str|
+            gid  = str.delete('^0-9').to_i
+            name = str.delete('0-9')
+
+            UserGroup.new(gid, name)
+          end
+
+          ## Get home / shell path information
+          cmd = Kanrisuru::Command.new("getent passwd #{user}")
+          cmd | "awk -F: '{print $6, $7}'"
+
+          execute(cmd)
+
+          result = Kanrisuru::Result.new(cmd) do |cmd2|
+            cmd2.to_s.split.map { |value| FilePath.new(value) }
+          end
+
+          ## TODO: Raise custom error to change parent result to use nested error and mark
+          ## as failure.
+          break if result.failure?
+
+          home = result[0]
+          shell = result[1]
+
+          User.new(uid, user, home, shell, groups)
+        end
+      end
+
+      def create_user(user, opts = {})
+        uid           = opts[:uid]
+        group         = opts[:group]
+        groups        = opts[:groups]
+        home          = opts[:home]
+        shell         = opts[:shell] || '/bin/false'
+        createhome    = opts[:createhome]
+        system_opt    = opts[:system]
+        skeleton      = opts[:skeleton]
+        non_unique    = opts[:non_unique]
+        password      = opts[:password]
+        expires       = opts[:expires] ## YYYY-MM-DD
+
+        command = Kanrisuru::Command.new("useradd #{user}")
+
+        if Kanrisuru::Util.present?(uid)
+          command.append_arg('-u', uid)
+          command.append_flag('-o', non_unique)
+        end
+
+        command.append_flag('-r', system_opt)
+        command.append_arg('-s', shell)
+        command.append_arg('-d', home)
+
+        case createhome
+        when true
+          command.append_flag('-m')
+          command.append_arg('-k', skeleton)
+        when false
+          command.append_flag('-M')
+        end
+
+        if Kanrisuru::Util.present?(group) && group?(group)
+          command.append_arg('-g', group)
+        elsif group?(user)
+          command.append_flag('-N')
+        end
+
+        command.append_arg('-G', groups.join(',')) if Kanrisuru::Util.present?(groups)
+
+        command.append_arg('-p', password)
+        command.append_arg('-e', expires)
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do
+          get_user(user).data
+        end
+      end
+
+      def update_user(user, opts = {})
+        uid           = opts[:uid]
+        group         = opts[:group]
+        groups        = opts[:groups]
+        append        = opts[:append]
+        home          = opts[:home]
+        move_home     = opts[:move_home]
+        shell         = opts[:shell] || '/bin/false'
+        non_unique    = opts[:non_unique]
+        password      = opts[:password]
+        expires       = opts[:expires] ## YYYY-MM-DD
+        locked        = opts[:locked]
+
+        command = Kanrisuru::Command.new("usermod #{user}")
+
+        if Kanrisuru::Util.present?(home)
+          command.append_arg('-d', home)
+          command.append_flag('-m', move_home)
+        end
+
+        command.append_arg('-s', shell)
+
+        if Kanrisuru::Util.present?(uid)
+          command.append_arg('-u', uid)
+          command.append_flag('-o', non_unique)
+        end
+
+        command.append_arg('-g', group) if Kanrisuru::Util.present?(group) && group_exists?(group)
+
+        if Kanrisuru::Util.present?(groups)
+          command.append_arg('-G', groups.join(','))
+          command.append_flag('-a', append)
+        end
+
+        case locked
+        when true
+          command.append_flag('-L')
+          command.append_arg('-e', 1)
+        when false
+          command.append_arg('-U')
+          command.append_arg('-e', 99_999)
+        else
+          ## Ensure expires isn't added twice.
+          command.append_arg('-e', expires)
+
+          ## Can't use password with lock / unlock flag.
+          command.append_arg('-p', password)
+        end
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |_command|
+          get_user(user).data
+        end
+      end
+
+      def delete_user(user, opts = {})
+        force = opts[:force]
+
+        return false unless get_uid(user)
+
+        command = Kanrisuru::Command.new("userdel #{user}")
+        command.append_flag('-f', force)
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+    end
+  end
+end

data/lib/kanrisuru/logger.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Kanrisuru
+  class Logger < ::Logger
+  end
+end

data/lib/kanrisuru/mode.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  class Mode
+    class Permission
+      attr_reader :symbolic
+
+      def initialize(numeric, symbolic)
+        @numeric = numeric
+        @symbolic = symbolic
+
+        update_symbolic_rwx
+      end
+
+      def to_i
+        numeric.to_i
+      end
+
+      def to_s
+        symbolic
+      end
+
+      def numeric
+        @numeric.to_s
+      end
+
+      def all?
+        read? && write? && execute?
+      end
+
+      def symbolic=(symbolic)
+        @symbolic = symbolic
+
+        update_symbolic_rwx
+        update_numeric
+      end
+
+      def numeric=(numeric)
+        @numeric = numeric
+
+        update_numeric_rwx
+        update_symbolic
+      end
+
+      def read=(boolean)
+        @readable = boolean
+
+        update_numeric
+        update_symbolic
+      end
+
+      def write=(boolean)
+        @writeable = boolean
+
+        update_numeric
+        update_symbolic
+      end
+
+      def execute=(boolean)
+        @executable = boolean
+
+        update_numeric
+        update_symbolic
+      end
+
+      def read?
+        @readable
+      end
+
+      def write?
+        @writeable
+      end
+
+      def execute?
+        @executable
+      end
+
+      private
+
+      def update_symbolic_rwx
+        @readable   = @symbolic.include?('r')
+        @writeable  = @symbolic.include?('w')
+        @executable = @symbolic.include?('x')
+      end
+
+      def update_numeric_rwx
+        mode = @numeric.to_i(8)
+
+        @readable   = ((mode >> 2) & 0b001) == 1
+        @writeable  = ((mode >> 1) & 0b001) == 1
+        @executable = ((mode >> 0) & 0b001) == 1
+      end
+
+      def update_numeric
+        @numeric = (((read? ? 1 : 0) << 2) + ((write? ? 1 : 0) << 1) + (execute? ? 1 : 0)).to_s
+      end
+
+      def update_symbolic
+        @symbolic = "#{read? ? 'r' : '-'}#{write? ? 'w' : '-'}#{execute? ? 'x' : '-'}"
+      end
+    end
+
+    attr_reader :owner, :group, :other
+
+    def initialize(mode)
+      if mode.instance_of?(Integer)
+        init_mode(mode.to_s(8))
+      elsif mode.instance_of?(String)
+        init_mode(mode)
+      else
+        raise 'Invalid mode type'
+      end
+    end
+
+    def directory?
+      @directory == 'd'
+    end
+
+    def symbolic
+      @directory + @owner.symbolic + @group.symbolic + @other.symbolic
+    end
+
+    def symbolic=(string)
+      raise ArgumentErorr, 'Invalid symbolic type' if string.class != String
+
+      if string.length == 10 && !string.include?(',')
+        modes = string[1..-1]
+
+        @owner.symbolic = modes[0..2]
+        @group.symbolic = modes[3..5]
+        @other.symbolic = modes[6..8]
+      else
+        operations = string.split(',')
+        operations.each do |operation|
+          flags = operation.split(/[=+-]/)
+
+          commands = flags[0] == '' ? 'a' : flags[0]
+          fields = flags[1]
+
+          commands = commands.chars
+
+          commands.each do |command|
+            case command
+            when 'a'
+              apply_operation(operation, fields, @owner)
+              apply_operation(operation, fields, @group)
+              apply_operation(operation, fields, @other)
+            when 'u'
+              apply_operation(operation, fields, @owner)
+            when 'g'
+              apply_operation(operation, fields, @group)
+            when 'o'
+              apply_operation(operation, fields, @other)
+            end
+          end
+        end
+      end
+    end
+
+    def numeric
+      @owner.numeric + @group.numeric + @other.numeric
+    end
+
+    def numeric=(numeric)
+      string =
+        if numeric.instance_of?(Integer)
+          numeric.to_s(8)
+        else
+          numeric
+        end
+
+      tokens = string.chars
+
+      @owner.numeric = tokens[0]
+      @group.numeric = tokens[1]
+      @other.numeric = tokens[2]
+    end
+
+    def inspect
+      format('#<Kanrisuru::Mode:0x%<object_id>s @numeric=%<numeric>s @symbolic=%<symbolic>s>',
+             object_id: object_id, numeric: numeric, symbolic: symbolic)
+    end
+
+    def to_s
+      symbolic
+    end
+
+    def to_i
+      numeric.to_i(8)
+    end
+
+    private
+
+    def apply_operation(operation, fields, permission)
+      if operation.include?('=')
+        remaining_fields = 'rwx'
+
+        fields.chars.each do |field|
+          apply_field_to_permission(field, permission, true)
+
+          ## remove any field that shouldn't be set to false
+          remaining_fields = remaining_fields.gsub(field, '')
+        end
+
+        ## Apply false to any remaining fields
+        apply_field_to_permission(remaining_fields, permission, false)
+      elsif operation.include?('-')
+        apply_field_to_permission(fields, permission, false)
+      elsif operation.include?('+')
+        apply_field_to_permission(fields, permission, true)
+      end
+    end
+
+    def apply_field_to_permission(fields, permission, boolean)
+      permission.read = boolean if fields.include?('r')
+      permission.write = boolean if fields.include?('w')
+      permission.execute = boolean if fields.include?('x')
+    end
+
+    def init_mode(string)
+      string = parse_acl(string)
+
+      if string.length == 3
+        @directory = '-'
+        tokens = string.chars
+
+        @owner = Kanrisuru::Mode::Permission.new(tokens[0], numeric_to_symbolic(tokens[0].to_i))
+        @group = Kanrisuru::Mode::Permission.new(tokens[1], numeric_to_symbolic(tokens[1].to_i))
+        @other = Kanrisuru::Mode::Permission.new(tokens[2], numeric_to_symbolic(tokens[2].to_i))
+      elsif string.length == 10 && !string.include?(',')
+        @directory = string[0]
+        modes = string[1..-1]
+
+        @owner = Kanrisuru::Mode::Permission.new(symbolic_to_numeric(modes[0..2]), modes[0..2])
+        @group = Kanrisuru::Mode::Permission.new(symbolic_to_numeric(modes[3..5]), modes[3..5])
+        @other = Kanrisuru::Mode::Permission.new(symbolic_to_numeric(modes[6..8]), modes[6..8])
+      else
+        raise ArgumentErorr, "Invalid format for mode #{string}"
+      end
+    end
+
+    def parse_acl(string)
+      @acl = string[-1] == '.' ? 'selinux' : 'general'
+      string.gsub(/[.+]/, '')
+    end
+
+    def symbolic_to_numeric(ref)
+      conversions = {
+        '---' => 0,
+        '---x' => 1,
+        '-w-' => 2,
+        '-wx' => 3,
+        'r--' => 4,
+        'r-x' => 5,
+        'rw-' => 6,
+        'rwx' => 7
+      }
+
+      conversions[ref]
+    end
+
+    def numeric_to_symbolic(int)
+      conversions = {
+        0 => '---',
+        1 => '--x',
+        2 => '-w-',
+        3 => '-wx',
+        4 => 'r--',
+        5 => 'r-x',
+        6 => 'rw-',
+        7 => 'rwx'
+      }
+
+      conversions[int]
+    end
+  end
+end