aro 0.2.4 → 0.2.6

data/sys/aos/abot.rb

@@ -1,255 +0,0 @@
-=begin
-
-  abot.rb
-
-  abot.
-
-  by i2097i
-
-=end
-
-module Aos
-  class Abot
-    include Singleton
-
-    attr_accessor :display_lines
-
-    CMDS = {
-      AGODO: {
-        key: :agodo,
-        description: I18n.t("abot.commands.description.agodo"),
-        usage: I18n.t("abot.commands.usage.agodo"),
-      },
-      DEREZ: {
-        key: :derez,
-        description: I18n.t("abot.commands.description.derez"),
-        usage: I18n.t("abot.commands.usage.derez"),
-      },
-      RATE: {
-        key: :rate,
-        description: I18n.t("abot.commands.description.rate"),
-        usage: I18n.t("abot.commands.usage.rate"),
-      },
-      STOP: {
-        key: :stop,
-        description: I18n.t("abot.commands.description.stop"),
-        usage: I18n.t("abot.commands.usage.stop"),
-      },
-      START: {
-        key: :start,
-        description: I18n.t("abot.commands.description.start"),
-        usage: I18n.t("abot.commands.usage.start"),
-      },
-    }
-
-    def self.cron_pid_file
-      return "" if Aro::Dom.dom_root.nil? || Aro::Dom.room_path(:abot).nil?
-      File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:abot), "abot.pid")
-    end
-
-    def self.cron
-      Aro::D.say("abot cron is disabled currently. you can still manage them but they do not run.")
-      not_currently_enabled = true
-      return if not_currently_enabled || File.exist?(Aos::Abot.cron_pid_file)
-
-      abot_pid = fork {
-        log = File.open(File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:abot), "abot.log"), "w+")
-        STDOUT.reopen(log)
-        STDERR.reopen(log)
-        STDOUT.sync = true
-        loop do
-          Aos::Agodo.where(power: :on).each{|a|
-            a.godo
-          }
-          sleep(Aro::Mancy::S)
-        end
-      }
-      Process.detach(abot_pid)
-      File.open(Aos::Abot.cron_pid_file, "w+") do |f|
-        f.write(abot_pid)
-      end
-    end
-
-    def self.terminate
-      if File.exist?(Aos::Abot.cron_pid_file)
-        system("kill -9 #{File.read(Aos::Abot.cron_pid_file)}")
-        FileUtils.rm(Aos::Abot.cron_pid_file)
-      end
-    end
-
-    def self.process_cmd(args)
-      args = Aos::Os.sanitize_you(args)
-      if args[Aro::Mancy::S].nil?
-        Aos::Abot.abot
-        return true
-      elsif CLI::FLAGS[:HELP].include?(args[Aro::Mancy::S].to_sym)
-        self.instance.display_lines = [I18n.t("abot.usage")]
-        return true
-      end
-
-      processed = false
-      # clear display
-      self.instance.display_lines = []
-      case args[Aro::Mancy::S].to_sym
-      when Aos::Abot::CMDS[:AGODO][:key]
-        Aos::Abot.agodo(args)
-        processed = true
-      when Aos::Abot::CMDS[:DEREZ][:key]
-        Aos::Abot.derez(args[Aro::Mancy::OS])
-        processed = true
-      when Aos::Abot::CMDS[:RATE][:key]
-        Aos::Abot.rate(args)
-        processed = true
-      when Aos::Abot::CMDS[:STOP][:key]
-        Aos::Abot.stop(args[Aro::Mancy::OS])
-        processed = true
-      when Aos::Abot::CMDS[:START][:key]
-        Aos::Abot.start(args[Aro::Mancy::OS])
-        processed = true
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-
-      return processed
-    end
-
-    def self.abot
-      self.instance.display_lines = Aos::Abot.base_lines
-    end
-
-    # create and list agodos
-    def self.agodo(args)
-      args = Aos::Os.sanitize_you(args)
-      if args[Aro::Mancy::OS].nil?
-        # list agodos
-        self.instance.display_lines = Aos::Abot.agodo_lines
-        return
-      end
-
-      if !args[Aro::Mancy::OS].nil? &&
-        !args[Aro::Mancy::E].nil? &&
-        !args[Aro::Mancy::N].nil?
-        # create mode
-        # abot agodo var_go var_do var_rate
-        arg_go = args[Aro::Mancy::OS]
-        arg_do = args[Aro::Mancy::E]
-        arg_rate = args[Aro::Mancy::N]
-
-        agodo_record = Aos::Agodo.new
-        agodo_record.go = arg_go
-        agodo_record.do = arg_do
-        agodo_record.rate = arg_rate
-        if agodo_record.save
-          self.instance.display_lines = ["successfully created an agodo named #{agodo_record.you.name}."] + Aos::Abot.agodo_lines
-        else
-          self.instance.display_lines = agodo_record.errors.to_a.map(&:downcase)
-        end
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-    end
-
-    # update agodo rate
-    def self.rate(args)
-      agodo_you = Aos::You.find_by(
-        name: args[Aro::Mancy::OS]&.strip&.upcase
-      )
-
-      if !agodo_you.nil? &&
-        Aos::Cor.int_valid?(args[Aro::Mancy::E]&.to_i)
-        agodo_record = agodo_you.agodo
-        agodo_record.update(rate: args[Aro::Mancy::E].to_i)
-        self.instance.display_lines = ["#{agodo_record.you.name} rate updated."] + Aos::Abot.agodo_lines
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-    end
-
-    # destroy an agodo
-    def self.derez(agodo_name)
-      n = agodo_name&.strip&.upcase
-      agodo_you = Aos::You.find_by(name: n)
-      unless agodo_you.nil?
-        lines = ["derezing #{agodo_you.name} agodo."]
-        agodo_record = agodo_you.agodo
-        agodo_record&.destroy
-        agodo_you.ilogs.destroy_all
-        agodo_you.destroy
-        requery = Aos::You.find_by(name: n)
-        if requery.nil? && requery&.agodo.nil?
-          lines << "successfully destroyed #{n} agodo."
-        else
-          lines << "unable to destroyed the #{n} agodo."
-        end
-        self.instance.display_lines = lines
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-    end
-
-    # power off an agodo
-    def self.stop(agodo_name)
-      agodo_you = Aos::You.find_by(
-        name: agodo_name&.strip&.upcase
-      )
-      unless agodo_you.nil?
-        agodo_record = agodo_you.agodo
-        agodo_record.update(power: :off)
-        self.instance.display_lines = ["#{agodo_record.you.name} stopped."] + Aos::Abot.agodo_lines
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-    end
-
-    # power on an agodo
-    def self.start(agodo_name)
-      agodo_you = Aos::You.find_by(
-        name: agodo_name&.strip&.upcase
-      )
-      unless agodo_you.nil?
-        agodo_record = agodo_you.agodo
-        agodo_record.update(power: :on)
-
-        self.instance.display_lines = ["#{agodo_record.you.name} started."] + Aos::Abot.agodo_lines
-      else
-        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
-      end
-    end
-
-    # abot help
-    def self.base_lines
-      # print abot commands
-      lines = []
-      lines << ""
-      lines << I18n.t("aos.constants.commands")
-      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:ABOT])
-      lines << I18n.t("aos.constants.subcommands")
-      Aos::Abot::CMDS.keys.each{|k|
-        lines += Aos::Vw::Base.lines_for_cmd(Aos::Abot::CMDS[k])
-      }
-      lines << ""
-
-      lines
-    end
-
-    # show agodos
-    def self.agodo_lines(agodos = nil)
-      # list input agodos
-      lines = []
-      lines << ""
-      agodos ||= Aos::Agodo.all
-      unless agodos.any?
-        lines << I18n.t("abot.messages.no_agodos")
-      else
-        lines << I18n.t("abot.messages.listing_agodos")
-        agodos.each{|a|
-          lines += a.you.get_lines
-          lines += a.get_lines
-        }
-      end
-      lines << ""
-
-      lines
-    end
-  end
-end

data/sys/aos/amg.rb

@@ -1,184 +0,0 @@
-=begin
-
-  amg.rb
-
-  aos system management.
-
-  by i2097i
-
-=end
-
-module Aos
-  class Amg
-    include Singleton
-
-    attr_accessor :display_lines
-
-    CMDS = {
-      INST: {
-        key: :inst,
-        description: I18n.t("amg.commands.description.inst"),
-        usage: I18n.t("amg.commands.usage.inst"),
-      },
-      INSTUN: {
-        key: :instun,
-        description: I18n.t("amg.commands.description.instun"),
-        usage: I18n.t("amg.commands.usage.instun"),
-      },
-    }
-
-    def initialize
-      self.display_lines = Aos::Amg.base_lines
-    end
-
-    def self.process_cmd(args)
-      self.instance.display_lines = []
-      if args[Aro::Mancy::S].nil? ||
-        CLI::FLAGS[:HELP].include?(args[Aro::Mancy::S].to_sym)
-        Aos::Amg.amg
-        return true
-      end
-
-      case args[Aro::Mancy::S].to_sym
-      when Aos::Amg::CMDS[:INST][:key]
-        unless args[Aro::Mancy::OS].nil?
-          ilib_name = args[Aro::Mancy::OS]
-          ilib = Aos::Ilib.find_by(name: ilib_name)
-          unless ilib.nil?
-            if ilib.installed?
-              self.instance.display_lines << I18n.t("amg.messages.already_installed", name: ilib_name)
-            else
-              Aos::Amg.install(ilib)
-              if ilib.reload.installed?
-                self.instance.display_lines << I18n.t("amg.messages.install_success", name: ilib_name)
-                self.instance.display_lines += self.inst_lines
-                return true
-              else
-                self.instance.display_lines << I18n.t("amg.messages.install_failure", name: ilib_name)
-              end
-            end
-          else
-            self.instance.display_lines << I18n.t("amg.messages.cannot_locate", name: ilib_name)
-          end
-        else
-          # list installed ilibs
-          Aos::Amg.inst
-          return true
-        end
-      when Aos::Amg::CMDS[:INSTUN][:key]
-        unless args[Aro::Mancy::OS].nil?
-          ilib_name = args[Aro::Mancy::OS]
-          ilib = Aos::Ilib.find_by(name: ilib_name)
-          unless ilib.nil?
-            if ilib.available?
-              self.instance.display_lines << I18n.t("amg.messages.not_installed", name: ilib_name)
-            else
-              Aos::Amg.uninstall(ilib)
-              if ilib.reload.available?
-                self.instance.display_lines << I18n.t("amg.messages.uninstall_success", name: ilib_name)
-                self.instance.display_lines += self.instun_lines
-                return true
-              else
-                self.instance.display_lines << I18n.t("amg.messages.uninstall_failure", name: ilib_name)
-              end
-            end
-          else
-            self.instance.display_lines << I18n.t("amg.messages.cannot_locate", name: ilib_name)
-          end
-        else
-          # list available ilibs
-          Aos::Amg.instun
-          return true
-        end
-      end
-
-      return false
-    end
-
-    def self.load(ilib_name)
-      Aos::Ilib.find_or_create_by(name: ilib_name)
-    end
-
-    def self.install(ilib)
-      return unless ilib.kind_of?(Aos::Ilib)
-      ilib.installed!
-    end
-
-    def self.uninstall(ilib)
-      return unless ilib.kind_of?(Aos::Ilib)
-      ilib.available!
-    end
-
-    def self.inst
-      self.instance.display_lines = Aos::Amg.inst_lines
-    end
-
-    def self.instun
-      self.instance.display_lines = Aos::Amg.instun_lines
-    end
-
-    def self.amg
-      self.instance.display_lines = Aos::Amg.base_lines
-    end
-
-    def self.base_lines
-      # print amg commands
-      lines = []
-      lines << ""
-      lines << I18n.t("aos.constants.commands")
-      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:AMG])
-      lines << I18n.t("aos.constants.subcommands")
-      Aos::Amg::CMDS.keys.each{|k|
-        lines += Aos::Vw::Base.lines_for_cmd(Aos::Amg::CMDS[k])
-      }
-      lines << ""
-
-      lines
-    end
-
-    def self.inst_lines
-      # list installed ilibs
-      lines = []
-      lines << ""
-      installed_ilibs = Aos::Ilib.where(status: :installed)
-      unless installed_ilibs.any?
-        lines << I18n.t("amg.messages.none_installed")
-      else
-        lines << I18n.t("amg.messages.listing_installed")
-        lines += Aos::Amg.ilib_lines(installed_ilibs)
-      end
-      lines << ""
-
-      lines
-    end
-
-    def self.instun_lines
-      # list installed ilibs
-      lines = []
-      lines << ""
-      available_ilibs = Aos::Ilib.where(status: :available)
-      unless available_ilibs.any?
-        lines << I18n.t("amg.messages.none_available")
-      else
-        lines << I18n.t("amg.messages.listing_available")
-        lines += Aos::Amg.ilib_lines(available_ilibs)
-      end
-      lines << ""
-
-      lines
-    end
-
-    def self.ilib_lines(ilibs)
-      lines = []
-      ilibs.each_with_index{|ilib, i|
-        lines << "[#{i + Aro::Mancy::S} of #{ilibs.count}]"
-        lines << I18n.t("amg.messages.ilib_name", name: ilib.name)
-        lines << I18n.t("amg.messages.ilib_path", path: ilib.so_path.split("/").last(Aro::Mancy::N).join("/"))
-        lines << I18n.t("amg.messages.ilib_usage", usage: ilib.usage)
-      }
-
-      lines
-    end
-
-  end
-end