arkrb 0.1.0

data/exe/arkrb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'arkrb/cli'
+
+Arkrb::CLI.start

data/lib/arkrb.rb

@@ -0,0 +1,44 @@
+require 'arkrb/version'
+require 'arkrb/constants'
+require 'arkrb/error_parsing'
+require 'arkrb/output_parsing'
+require 'open3'
+
+module Arkrb
+
+  # @return [Arkrb::Install]
+  def self.install
+    Arkrb::Install.new
+  end
+
+  # @return [String]
+  def self.executable(path = "#{USER_HOME}/bin")
+    arkmanager_exec = find_executable('arkmanager', path)
+    raise Arkrb::Error::ArkManagerExecutableNotFound, 'We could not find the ark_rb binary! Please install it by running Arkrb.install.server_tools or executing the command `ark_rb install tools``' if arkmanager_exec.nil?
+    arkmanager_exec
+  end
+
+  # @return [Integer, String]
+  def self.execute(command, command_opts = '', instance = 'main', sanitize = false)
+    exec_this = format('%s %s %s @%s', executable, command.to_s.tr('_', ''), command_opts, instance)
+    stdin, stdout, stderr = Open3.popen3(exec_this)
+    output = stdout.read.chomp
+    errors = stderr.read.chomp
+    errors += 'Your ARK server exec could not be found.' if output =~ /#{'ARK server exec could not be found'}/im
+
+    Arkrb::ErrorParsing.new.sanitize!(command, errors) unless errors.strip.empty?
+
+    # todo: Remove the sanatize equals true line below.
+    sanitize = true
+
+    if sanitize
+      output_parsing = Arkrb::OutputParsing.new
+      pp output_parsing.sanitize!(command, output)
+    else
+      puts output
+      puts errors
+    end
+
+  end
+
+end

data/lib/arkrb/cli.rb

@@ -0,0 +1,149 @@
+require 'thor'
+require 'colorize'
+require 'arkrb/constants'
+require 'arkrb/install'
+module Arkrb
+  class CLI < Thor
+
+    package_name 'arkrb'
+    class_option :instance, type: :string, default: 'main', aliases: '-i'
+
+    desc "install APP_NAME", "install one of the available apps" # [4]
+    method_option :list, type: :boolean, aliases: '-l'
+
+    def install(name = nil)
+      if options[:list] || name.nil?
+        arkmanager_status = (find_executable('arkmanager').nil?) ? 'Not Installed'.red : 'Installed'.green
+        ark_install_status = (ark_installed?(options[:instance])) ? 'Installed'.green : 'Not Installed'.red
+        # arkmanager_status = 'Not Installed'.red
+        printf format("%-20s Status %21s\n", 'APP_NAME', 'Description')
+        print_status('ark_manager', arkmanager_status, 'Installs ark-server-tools; Install with: ark_rb install tools')
+        print_status('ark_server', ark_install_status, 'Installs the ark server; Install with: ark_rb install ark')
+      end
+      unless name.nil?
+        case name.to_sym
+          when :arkmanager, :ark_manager, :tools
+            Arkrb.install.server_tools
+          when :ark
+            Arkrb.install.ark(options[:instance], false)
+          else
+            # do nothing
+        end
+      end
+    end
+
+    desc 'start', 'Starts the ark server'
+
+    def start
+      ark_server(options[:instance]).start!
+    end
+
+    desc 'stop', 'Stops the ark server'
+
+    def stop
+      ark_server(options[:instance]).stop!
+    end
+
+    desc 'restart', 'Restarts the ark server'
+
+    def restart
+      ark_server(options[:instance]).restart!
+    end
+
+    desc 'status', 'Displays the status of the server'
+
+    def status
+      ark_server(options[:instance]).status!
+    end
+
+    desc 'update', 'Updates the ark server'
+
+    def update
+      ark_server(options[:instance]).update!
+    end
+
+    desc 'backup', 'Backups the ark server'
+
+    def backup
+      ark_server(options[:instance]).backup!
+    end
+
+    desc 'saveworld', 'Saves the ark world'
+
+    def saveworld
+      ark_server(options[:instance]).save_world!
+    end
+
+    desc 'enablemod MOD_ID', 'Enables a mod via mod ID'
+
+    def enablemod(mod_id)
+      ark_server(options[:instance]).enable_mod mod_id
+    end
+
+    desc 'disablemod MOD_ID', 'Disables a mod via mod ID'
+
+    def disablemod(mod_id)
+      ark_server(options[:instance]).disable_mod mod_id
+    end
+
+    desc 'installmod MOD_ID', 'Installs a mod via mod ID'
+
+    def installmod(mod_id)
+      ark_server(options[:instance]).install_mod mod_id
+    end
+
+    desc 'uninstallmod MOD_ID', 'Uninstalls the mod via mod ID'
+
+    def uninstallmod(mod_id)
+      ark_server(options[:instance]).uninstall_mod mod_id
+    end
+
+    desc 'reinstallmod MOD_ID', 'Reinstalls the mod via mod ID'
+
+    def reinstallmod(mod_id)
+      ark_server(options[:instance]).reinstall_mod mod_id
+    end
+
+    desc 'broadcast MESSAGE', 'Broadcasts a message to the server. Make sure to put it in parentheses.'
+
+    def broadcast(message)
+      ark_server(options[:instance]).broadcast message
+    end
+
+    desc 'rcon COMMAND', 'Runs an rcon command on the ark server'
+
+    def rcon(command)
+      ark_server(options[:instance]).rcon_cmd command
+    end
+
+    desc 'checkupdate', 'Checks for updates to ark'
+
+    def checkupdate
+      ark_server(options[:instance]).update_available?
+    end
+
+    desc 'checkmodupdates', 'Checks for updates on installed mods'
+
+    def checkmodupdates
+      ark_server(options[:instance]).mod_updates_available?
+    end
+
+    private
+
+    # @return [Boolean]
+    def ark_installed?(instance = 'main')
+      Arkrb.install.ark_installed?(instance)
+    end
+
+    # @return [Arkrb::Server]
+    def ark_server(instance = 'main')
+      Arkrb::Server.new(instance, false)
+    end
+
+    def print_status(item, status, how_to)
+      printf format("%-20s %-30s %s\n", item, "[#{status}]", how_to)
+    end
+
+  end
+end
+

data/lib/arkrb/constants.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+module Arkrb
+
+  old_mkmf_log = MakeMakefile::Logging.instance_variable_get(:@logfile)
+  MakeMakefile::Logging.instance_variable_set(:@logfile, '/dev/null')
+  BASH_EXEC = find_executable0 'bash' unless defined? BASH_EXEC
+  CURL_EXEC = find_executable0 'curl' unless defined? CURL_EXEC
+  MakeMakefile::Logging.instance_variable_set(:@logfile, old_mkmf_log)
+
+  USER_HOME = Dir.home unless defined? USER_HOME
+  ARK_SERVER_TOOLS_MD5 = '773b17d67eff8944bcd0e2a39089c96d'
+
+end

data/lib/arkrb/error.rb

@@ -0,0 +1,53 @@
+module Arkrb
+  module Error
+
+    class CustomError < RuntimeError
+    end
+
+    class UnknownError < CustomError
+    end
+
+    class ExecutableAlreadyExists < CustomError
+    end
+
+    class ArkManagerExecutableNotFound < CustomError
+    end
+
+    class CURLNotInstalled < CustomError
+    end
+
+    class BASHNotInstalled < CustomError
+    end
+
+    class InstallScriptMD5Changed < CustomError
+    end
+
+    class SteamCMDError < CustomError
+    end
+
+    class ArkExecutableNotFound < CustomError
+    end
+
+    class ServerAlreadyRunning < CustomError
+    end
+
+    class ServerAlreadyStopped < CustomError
+    end
+
+    class SanitizationUnsupportedForThisMethod < CustomError
+    end
+
+    class ModIDNotFound < CustomError
+    end
+
+    class ModDoesNotExist < CustomError
+    end
+
+    class ModAlreadyExists < CustomError
+    end
+
+  end
+
+end
+
+

data/lib/arkrb/error_parsing.rb

@@ -0,0 +1,51 @@
+require 'arkrb/error'
+module Arkrb
+  class ErrorParsing
+    def sanitize!(command, error_output, command_opts = nil)
+      ark_exe_not_found = potential_errors[:ark_exe_not_found]
+      raise ark_exe_not_found[:class], ark_exe_not_found[:message] if error_output =~ /#{ark_exe_not_found[:cause]}/im
+
+      case command
+        when :install
+          install_command(error_output)
+        else
+          raise_unknown_error(command, error_output, command_opts)
+      end
+    end
+
+    def install_command(error_output)
+      missing_32_gcc = potential_errors[:missing_32_gcc]
+      case error_output
+        when /#{missing_32_gcc[:cause]}/im
+          raise missing_32_gcc[:class], missing_32_gcc[:message]
+        else
+          raise_unknown_error('install', error_output)
+      end
+    end
+
+    private
+
+    def potential_errors
+      @potential_errors ||= {
+        missing_32_gcc: {
+          cause: '/steamcmd/linux32/steamcmd: No such file or directory',
+          class: Arkrb::Error::SteamCMDError,
+          message: 'It appears that you are missing the lib32gcc1 package please have an Administrator install it!'
+        },
+        ark_exe_not_found: {
+          cause: 'ARK server exec could not be found',
+          class: Arkrb::Error::ArkExecutableNotFound,
+          message: 'Whooah! The Ark Server Executable was not found, please install the ark server using `arkrb install ark`'
+        }
+      }
+    end
+
+    def raise_unknown_error(command, error_output, command_opts = nil)
+      error_message = (command_opts.nil?) ?
+                        format("An unknown error has occurred while attempting to run command %s\n%s", command, error_output) :
+                        format("An unknown error has occurred while attempting to run command %s with opts %s\n%s", command, command_opts, error_output)
+      raise Arkrb::Error::UnknownError, error_message
+    end
+
+  end
+end

data/lib/arkrb/install.rb

@@ -0,0 +1,34 @@
+require 'mkmf'
+require 'digest'
+require 'arkrb/server'
+require 'arkrb/constants'
+
+module Arkrb
+  class Install
+
+    # @return [True, Exception]
+    def server_tools
+      server_tools_install_sh_path = "/tmp/server_tools_install_#{Time.now.strftime('%Y%m%d-%H%M%S')}.sh"
+      File.delete(server_tools_install_sh_path) if File.exist?(server_tools_install_sh_path)
+
+      `#{CURL_EXEC} -sL http://git.io/vtf5N > #{server_tools_install_sh_path}`
+      file_md5 = Digest::MD5.hexdigest File.read(server_tools_install_sh_path)
+
+      raise Arkrb::Error::InstallScriptMD5Changed, "Uhh oh!!! #{file_md5} did not match #{Arkrb::ARK_SERVER_TOOLS_MD5}; Please report this issue at https://github.com/mbround18/Arkrb" unless file_md5.eql? Arkrb::ARK_SERVER_TOOLS_MD5
+
+      `#{BASH_EXEC} #{server_tools_install_sh_path} --me --perform-user-install`
+
+      unless find_executable('arkmanager', "#{Arkrb::USER_HOME}/bin")
+        File.open("#{Arkrb::USER_HOME}/.bashrc", 'a') do |file|
+          file.write "export PATH=$PATH:#{File.expand_path(Arkrb::USER_HOME + '/bin')}"
+        end
+        puts 'arkmanager was successfully added to your path' if find_executable('arkmanager', "#{Arkrb::USER_HOME}/bin")
+      end
+    end
+
+    def ark(instance = 'main', sanitize_output = false)
+      Arkrb::Server.new(instance, sanitize_output).install
+    end
+
+  end
+end

data/lib/arkrb/output_parsing.rb

@@ -0,0 +1,188 @@
+module Arkrb
+  class OutputParsing
+
+    def sanitize!(command, output)
+      if public_methods(false).include?(command.to_sym)
+        method(command.to_sym).call(output)
+      else
+        raise Arkrb::Error::SanitizationUnsupportedForThisMethod, "\n#{output}"
+      end
+    end
+
+
+    def install(output)
+      if output.strip.empty?
+        true
+      else
+        if output =~ /#{'server already running'}/im
+          raise Arkrb::Error::ServerAlreadyRunning, output
+        else
+          raise_unknown_error(:install, output)
+        end
+      end
+    end
+
+    # @return [True, Exception]
+    def start(output)
+      if output =~ /#{'the server is now running'}/im
+        true
+      else
+        if output =~ /#{'server already running'}/im
+          raise Arkrb::Error::ServerAlreadyRunning, output
+        else
+          raise_unknown_error(:start, output)
+        end
+      end
+    end
+
+    # @return [True, Exception]
+    def stop(output)
+      if output =~ /#{'The server has been stopped'}/im
+        true
+      else
+        if output =~ /#{'The server is already stopped'}/im
+          raise Arkrb::Error::ServerAlreadyStopped, output
+        else
+          raise_unknown_error(__method__.to_sym, output)
+        end
+      end
+    end
+
+    # @return [True, Exception]
+    def restart(output)
+      if output =~ /#{'server has been stopped'}/im &&
+          output =~ /#{'the server is now running'}/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    def status(output)
+      status_items = {}
+      status = output.gsub(/\e\[([;\d]+)?m/, '')
+      if status =~ /Server running/im
+        status = status.split("\n").map {|s| s.strip }
+        status.shift
+        status.each do |item|
+          item_info = item.split(':', 2)
+          status_items[item_info.first.gsub('Server', '').strip.downcase.tr(' ', '_').to_sym] = item_info[1].strip
+        end
+        status_items[:arkservers_link] = status_items.delete(:arks_link)
+        status_items
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def update(output)
+      if output =~ /#{'already up to date '}/im || output =~ /#{'updated'}/im
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+
+    # @return [True, Exception]
+    def backup(output)
+      if output =~ /Created Backup/im
+        console_response = output.split("\n").map {|x| x.gsub(/\e\[([;\d]+)?m/, '').strip}
+        dir_path = console_response.find {|x| x =~ /Saved arks directory is/im}.split('directory is').last.strip
+        file_name = console_response.find {|x| x =~ /Created Backup/im}.split(':').last.strip
+        {
+            status: 'success',
+            path: File.join(dir_path, file_name)
+        }
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def save_world(output)
+      if output =~ /world saved/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def enable_mod(output)
+      if output =~ /enable mod/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def disable_mod(output)
+      if output =~ /disablemod/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def install_mod(output)
+      if output =~ /mod [0-9]+ installed/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output.gsub("\r", "\n"))
+      end
+    end
+
+    # @return [True, Exception]
+    def uninstall_mod(output)
+      if output =~ /uninstallmod/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output)
+      end
+    end
+
+    # @return [True, Exception]
+    def reinstall_mod(output)
+      if output =~ /mod [0-9]+ installed/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output.gsub("\r", "\n"))
+      end
+    end
+
+    # @return [True, Exception]
+    def broadcast(output)
+      if output =~ /command processed/im
+        true
+      else
+        raise_unknown_error(__method__.to_sym, output.gsub("\r", "\n"))
+      end
+    end
+
+    # @return [Object]
+    # def rcon_cmd(output)
+    #   arkmanager_exec(:rcon, command)
+    # end
+
+    # @return [Boolean]
+    # def update_available?(output)
+    #   arkmanager_exec :check_update
+    # end
+
+    # @return [Boolean]
+    # def mod_updates_available?(output)
+    #   output
+    # end
+
+    private
+
+    def raise_unknown_error(command, output)
+      error_message = format("An unknown error has occurred while attempting to run command %s\n%s", command, output)
+      raise Arkrb::Error::UnknownError, error_message
+    end
+
+  end
+end