fcl_rails_daemon 1.0.12 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79c1871eb19a254900c3c8b497dbbfaf65f82687
-  data.tar.gz: a5a8267fecd0986c3d6ae0ef15fb650841daa55f
+  metadata.gz: bb3a178dbd7dcf9df8c11820dcfcd11c572859eb
+  data.tar.gz: 8e0aaea8fdaff4feb3c9bf00b89b059a8b701d6a
 SHA512:
-  metadata.gz: 4d3316d2f2e0183125d0525be3e15fce097f3f33cbff834eead73c93af24185ba1b58ff8f73d432aec52e7a0f677ed9c9cd30405a4d6244f9bc087d08a4b8881
-  data.tar.gz: 36d09e367a26a656754f472f2bcc6ac9699f896ee00571b03ef6373f3456cc2c1e8c1130adae60880b39277cc7611da4d6cf0cf63bc2cf8a40ef3d12ea078d41
+  metadata.gz: 9f171f3e50486485a04a2f7ec1b3c7e6461c0a6ff91ecf560242d4a38e30c5beea33e89c8019af707fce5fa302b61acfa8e1d1a3b698df52046d5065281f64e3
+  data.tar.gz: 7d23cc4f62491883d5595ecb4ec5dff587ce333596fd30d126467432dd5a0e6bdcfafc12137fa48e2ea8adccf22f80f3543750cbc2e7fec0c53bddef86b9278c

data/README.md

@@ -1,63 +1,79 @@
 # FclRailsDaemon
 
-Esta gem foi desenvolvida com a partir da necessidade de gerenciamento através do terminal em processos que por sua vez
-executam determinados programas escritos em ruby.
+This gem was developed to facilitate through the CLI management processes running ruby programs.
 
-## Instalação
+## Installation
 
-A partir do Gemfile
+From Gemfile
 
 ```ruby
 gem 'fcl_rails_daemon'
 ```
 
-Então execute:
+Then run:
 
     $ bundle
 
-Ou somente instale:
+Or only install:
 
     $ gem install fcl_rails_daemon
 
 
-## Configuração
+## Configuration
 
-Após a instalação é necessário criar os diretórios e arquivos de configuração, para isso execute
+After installation you need to create the directories and configuration files for this run
 
     $ fcld --configure
 
-Serão criados:
+Will be created:
 
- * _config/fcld_rails_daemon.rb_ (Arquivo onde são registrados os comandos)
- * _tmp/pids/fcld.yml (Arquivo onde_ são registrados os pids dos comandos)
- * _lib/fcld_comandos/comando_exemplo.rb_ (Um modelo para criação de comandos)
+ * *config/fcld_rails_daemon.rb* (File where the commands are recorded)
+ * *tmp/pids/fcld.yml* (Pids file where the commands are recorded)
+ * *lib/fcl_rails_daemon/command_sample.rb* (A command template)
 
 
-## Como Usar?
+## How to use?
 
-#### Podemos adicionar comandos através do parametro --create
+#### [--create] Create a new command
 
-    $ fcld --create meu_primeiro_comando
+    $ fcld --create my_first_command
 
- * Cria um comando em lib/fcld_comandos
- * Efetua o registro em config/fcl_rails_daemon.rb
+ * Adds a command in lib/fcl_rails_daemon
+ * Records the command in config/fcl_rails_daemon.rb
 
 
-#### Podemos consultar o manual para descobrir quais os comandos disponíveis através do parametro --help
+#### [--help] Displays the manual for commands and options
 
     $ fcld --help
 
 
-#### Podemos consultar os pids de processos gerenciados pelo daemon através do parametro --pids
+#### [--pids] Displays the pids of the commands registered
 
     $ fcld --pids
 
 
-#### Podemos executar as ações básicas de um daemon (parametros start | stop | restart | status)
+#### [--logs] Displays the logs files for each registered command
+
+    $ fcld --logs
+
+
+#### [start|stop|restart|status] Performs action for all registered commands
 
     $ fcld start
 
 
-#### Podemos controlar processos individualnmente através do parametro --task
+#### [--env] Sets the environment for Rails application
+
+    $ fcld --env production start
+
+
+#### [--command] Individual action to run a registered command
+
+    $ fcld --command my_first_command start
+
+
+#### [--process_name] Sets a name to be assigned to the process (by default the name is the name of the command)
+
+    $ fcld --command my_first_command --process_name foo_my_first_command start
+
 
-    $ fcld --task meu_primeiro_comando start

data/bin/fcld

@@ -1,61 +1,59 @@
 #!/usr/bin/env ruby
 require 'fileutils'
 require 'fcl_rails_daemon/config'
+COMMAND['fcld'] = true
 
 base = DAEMON_ROOT
-config_dir = "config"
-config_dir = File.join(base, config_dir)
+config_dir = File.join(base, DAEMON_CONFIG['config_path'])
 FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
-config_file = File.join(config_dir, 'fcld_rails_daemon.rb')
+commands_file = File.join(config_dir, 'fcl_rails_daemon.rb')
 
 if ARGV.include? "--configure"
-  config_file_content = <<-FILE
-# Carrega arquivo de environment (projeto rails)
-if File.exist?(File.join("#{DAEMON_ROOT}", "config", "environment.rb"))
-  require File.join("#{DAEMON_ROOT}", "config", "environment.rb")
-end
+  commands_file_content = <<-FILE
+# To register commands use the FclRailsDaemon::Recorder class
+#  :command is the command name
+#  :class_reference is the class to which it is
+#
+# FclRailsDaemon::Recorder.add(command: 'command_sample', class_reference: CommandSample)
 
-# Para registrar seus comandos é necessário adicioná-los conforme o exemplo abaixo
-# É necessário que seja informado o nome do comando e qual a classe ao qual ele representa
-# Ex:
-# FclRailsDaemon::Registrador.add(comando: 'comando_exemplo', classe: ComandoExemplo)
   FILE
 
-  File.open(config_file, 'wb') {|f| f.write(config_file_content) } unless File.exist?(config_file)
+  File.open(commands_file, 'wb') {|f| f.write(commands_file_content) } unless File.exist?(commands_file)
 
   command_sample_content = <<-FILE
-class ComandoExemplo < FclRailsDaemon::Daemon
+class CommandSample < FclRailsDaemon::Daemon
 
-  # Obrigatóriamente é necessário implementar o método "initialize"
+  # Is necessary to implement the method "initialize"
   def initialize
-    # Definir o parametro "task" (nome que será referenciado no comando digitado no terminal).
-    #
-    # O parametro "log" é opcional mas sugiro que seja definido um log para cada comando para evitar que muitos comandos
-    # escrevam no log deafult (caso tenha# muitos comandos)
-    super(task: "comando_exemplo", log: "log/comando_exemplo.log")
+    # Set the parameter "command" (name that will be referenced in the command entered in the terminal)
+    # The parameter "log" is optional but suggest it is set a log for each command to prevent many commands write on deafult log (if you have many commands in your application)
+    # The parameter "process_name" is optional (is the name that will be assigned to the process)
+    super(command: "command_sample", log: "log/command_sample.log", process_name: "command_sample")
   end
 
-  # Obrigatóriamente é necessário implementar o método self.help
+  # Is necessary to implement the method "self.help"
   def self.help
-    # Retornar Hash com "descricao" e "exemplo"
+    # Should return a hash with " description" and "example"
     {
-      descricao: "Descrição do comando comando_exemplo :) - Executado a cada 1 min",
-      exemplo: ["--task comando_exemplo start | stop | restart | status"]
+      description: "This command is a sample - Run every 1 minute",
+      sample: ["--command command_sample |start|stop|restart|status|"]
     }
   end
 
-  # Obrigatóriamente é necessário implementar o método run
+  # Is necessary to implement the method "run"
   def run
-    # Chamar o método run da classe pai (super) passando um bloco que vai conter seu código
+    # Call the run method of the parent class (super) through a block that will contain your code
     super do
-      # Caso deseje que o seu comando fique executando repetidamente coloque dentro de um loop
-      loop do
-        # Escreva seu código aqui!!
-        # Não use Process.exit(true), exit(), abort() em seu codigo pois infere na morte do processo do Daemon
-        puts "Está executando comando_exemplo!  :)"
-
-        # Espera em segundos antes de executar seu comando outra vez
-        # Util no caso de simular um processo cronológico (esse exemplo vai executar o comando a cada 10 segundos)
+      # If you want your command be running repeatedly put inside a loop
+        @counter_sample = 0
+        loop do
+        # Write your code here !!!
+        # Do not use Process.exit (true) , exit () , abort ( ) in your code because it infers the death of the Daemon process
+
+        @counter_sample += 1
+        puts "Running "+ @command +" for " + @counter_sample.to_s + " time :)"
+
+        # Wait in seconds before running your command again
         sleep(10)
       end
     end
@@ -69,7 +67,7 @@ end
   commands_dir = File.join(base, commands_dir)
   FileUtils.mkdir_p(commands_dir) unless File.directory?(commands_dir)
 
-  command_file = File.join(commands_dir, 'comando_exemplo.rb')
+  command_file = File.join(commands_dir, 'command_sample.rb')
   File.open(command_file, 'wb') {|f| f.write(command_sample_content) } unless File.exists?(command_file)
 
   log_dir = "log"
@@ -79,18 +77,23 @@ end
   pids_dir = File.join(base, "tmp/pids")
   pids_file = File.join(base, DAEMON_CONFIG['pids_file'])
   FileUtils.mkdir_p(pids_dir) unless File.directory?(pids_dir)
-  File.open(pids_file, 'wb') {|f| f << "default:" } unless File.exist?(pids_file)
+  File.open(pids_file, 'wb') {|f| f << "fcl_rails_daemon:" } unless File.exist?(pids_file)
 
-  puts "[Ok] Gem foi configurada!"
+  puts " ༼ つ ◕_◕ ༽つ OK... Gem has been set!!!    "
   exit
 end
 
-unless File.exist?(config_file)
-  puts "[Ooops] Gem ainda não foi configurada... Para configurar execute o comando fcld --configure "
+unless File.exist?(commands_file)
+  puts " ༼ つ ◕_◕ ༽つ OOOPS... Gem has not yet been set. To set run 'fcld --configure'    "
   exit
 end
 
 require 'fcl_rails_daemon'
 require 'fcl_rails_daemon/version'
 
-FclRailsDaemon::Gerenciador.run(ARGV)
+begin
+  FclRailsDaemon::Manager.run(ARGV)
+rescue => e
+  puts e.message
+end
+

data/fcl_rails_daemon.gemspec

@@ -16,9 +16,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
   spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.1.2'
 
-  spec.summary       = %q{Projeto utilizado para gerar comandos que podem ser executados em background (daemons).}
-  spec.description   = %q{Este tem como maior caracteristica a facilidade de gerar comandos e gerenciá-los de forma independente.}
+  spec.summary       = %q{Project designed to generate commands that run in the background (daemons).}
+  spec.description   = %q{ This aims to make it easy to create commands ( ruby scripts) and run them in the background (daemon).
+CLI has easy to use, where to control the processes related to commands.}
 
   spec.add_dependency "bundler"
   spec.add_dependency "activesupport"

data/lib/core/daemon.rb

@@ -1,16 +1,18 @@
 module FclRailsDaemon
   class Daemon
+    cattr_reader :commands_valid
+    attr_accessor :process_name
+    attr_accessor :log_file
 
-    cattr_reader :comandos_validos
     @@pids_file = File.join(DAEMON_ROOT, DAEMON_CONFIG['pids_file'])
-    @@comandos_validos = ['start', 'stop', 'restart', 'status']
+    @@commands_valid = ['start', 'stop', 'restart', 'status']
 
-
-    def initialize(task: nil, log: nil)
-      raise "Não foi definida o nome da task no construtor do comando" unless task
+    def initialize(command: nil, log: nil, process_name: nil)
+      raise " ༼ つ ◕_◕ ༽つ OOOPS... It was not set the 'command' name in the command initialize.    " unless command
       @daemon ||= nil
-      @task = task
-      @log = (log) ?  File.join(DAEMON_ROOT, log) : File.join(DAEMON_ROOT, DAEMON_CONFIG['default_log'])
+      @command = command
+      @log_file = (log) ?  File.join(DAEMON_ROOT, log) : File.join(DAEMON_ROOT, DAEMON_CONFIG['default_log'])
+      @process_name = (process_name) ? process_name : command
     end
 
     def self.pids
@@ -19,18 +21,24 @@ module FclRailsDaemon
     end
 
     def self.help
-      raise "Não foi implementado o método self.help no comando"
-    end
-
-    def log
-      puts "#{@log} (#{@task})"
+      raise " ༼ つ ◕_◕ ༽つ OOOPS... It was not implemented 'self.help' method in command    "
     end
 
     def run(&block)
-      @daemon = Daemons.call(multiple: true) do
-        # força a saída para o output definido
-        $stdout.reopen(@log, 'a')
-        $stderr.reopen(@log, 'a')
+      #Load environment file (rails project)
+      if COMMAND['fcld']
+        env_file = File.join(DAEMON_ROOT, "config", "environment.rb")
+        raise " ༼ つ ◕_◕ ༽つ OOOPS... Could not find the Rails environment file.    " unless File.exist? env_file
+        require env_file
+      end
+
+      @daemon = Daemons.call(multiple: true, app_name: @process_name) do
+        #set process_name
+        Process.setproctitle(@process_name)
+
+        # Force the output to the defined log
+        $stdout.reopen(@log_file, 'a')
+        $stderr.reopen(@log_file, 'a')
         $stdout.sync = true
 
         block.call
@@ -38,20 +46,20 @@ module FclRailsDaemon
     end
 
     def start
-      pid = get_pid @task
+      pid = get_pid @command
       if running?(pid)
-        puts "proc: processo com pid #{pid} está rodando. (#{@task})"
+        puts "#{@process_name}: process with pid #{pid} is already running."
         return
       end
       run
-      set_pid(@task, @daemon.pid.pid) if @daemon
+      set_pid(@command, @daemon.pid.pid) if @daemon
     end
 
     def stop
-      pid = get_pid @task
+      pid = get_pid @command
 
       unless running? pid
-        puts "proc: processo não está rodando. (#{@task})"
+        puts "#{@process_name}: process is not running."
         return
       end
       kill pid
@@ -63,23 +71,23 @@ module FclRailsDaemon
     end
 
     def status
-      pid = get_pid @task
+      pid = get_pid @command
       if running? pid
-        puts "proc: processo com pid #{pid} está rodando. (#{@task}) "
+        puts "#{@process_name}: process with pid #{pid} is running."
       else
-        puts "proc: processo não está rodando. (#{@task}) "
+        puts "#{@process_name}: process is not running."
       end
     end
 
     private
-    def get_pid(task)
+    def get_pid(command)
       pids = YAML.load_file(@@pids_file)
-      (pids.has_key?(task)) ? pids[task] : nil
+      (pids.has_key?(command)) ? pids[command] : nil
     end
 
-    def set_pid(task, pid)
+    def set_pid(command, pid)
       pids = YAML.load_file(@@pids_file)
-      pids[task] = pid
+      pids[command] = pid
       File.open(@@pids_file, 'wb') do |f|
         f <<  pids.to_yaml
       end
@@ -103,20 +111,20 @@ module FclRailsDaemon
       if pid
         begin
           Process.kill("KILL", pid)
-          set_pid(@task, nil)
+          set_pid(@command, nil)
           status = true
         rescue Errno::ESRCH
-          puts "proc: não existe processo com pid #{pid}. (#{@task})"
+          puts "#{@process_name}: there is no process with pid #{pid}."
           status = false
         ensure
           if status == false
-            puts "proc: processo com pid #{pid} está parado. (#{@task})"
+            puts "#{@process_name}: process is not running."
           else
-            puts "proc: processo com pid #{pid} foi parado. (#{@task})"
+            puts "#{@process_name}: process was stopped."
           end
         end
       else
-        puts "proc: não existe processo com pid #{pid}. (#{@task})"
+        puts "#{@process_name}: there is no process with pid #{pid}."
       end
     end
 

data/lib/core/manager.rb

@@ -0,0 +1,219 @@
+module FclRailsDaemon
+  class Manager
+    @@commands = FclRailsDaemon::Recorder.load
+
+    def self.run(argv)
+      COMMAND['fcld'] = true
+      self.set_env(argv) if argv.include?('--env')
+      self.pids if argv.include?('--pids')
+      self.logs if argv.include?('--logs')
+      self.set_process_name(argv) if (argv.include?('--command') && argv.include?('--process_name'))
+      self.create_command(argv) if argv.include?('--create')
+      self.help(ARGV) unless self.valid?(argv)
+
+      command ||= nil
+      action = argv.last
+      if argv.include?('--command')
+        i = argv.index('--command') + 1
+        command = argv[i]
+      end
+      registered = self.get_registered command
+      registered.each { |command| command.send(action) }
+    end
+
+    def self.help(argv)
+      action = argv.last
+      command ||= nil
+      if (argv.include?('--command') && argv.include?('--help'))
+        i = argv.index('--command') + 1
+        command = argv[i]
+      end
+      helpers = self.get_helpers(command)
+      self.show_helpers helpers
+    end
+
+    def self.valid?(argv)
+      Daemon.commands_valid.include?(argv.last) && !(argv.include?('--help'))
+    end
+
+    private
+
+    def self.get_registered(command = nil)
+      list = []
+      @@registered ||= {}
+      if command
+        raise " ༼ つ ◕_◕ ༽つ OOOPS... Command '#{command}' is not registered.    " unless @@commands.has_key? command
+        @@registered[command] = (@@registered.has_key? command) ? @@registered[command] : @@commands[command].new
+        list << @@registered[command]
+        return list
+      end
+      @@commands.each do |k, c|
+        list << @@registered[k] = (@@registered.has_key? k) ? @@registered[k] : c.new
+      end
+      list
+    end
+
+    def self.get_helpers(command = nil)
+      list = []
+      @@helpers ||= {}
+      if command
+        raise " ༼ つ ◕_◕ ༽つ OOOPS... Command '#{command}' is not registered.    " unless @@commands.has_key? command
+        @@helpers[command] = (@@helpers.has_key? command) ? @@helpers[command] : @@commands[command].help
+        list << @@helpers[command]
+        return list
+      end
+      @@commands.each do |k, c|
+        list << @@helpers[k] = c.help unless @@helpers.has_key?(k)
+      end
+      list
+    end
+
+    def self.show_helpers(helpers)
+      prefix = DAEMON_CONFIG['command_prefix']
+
+      puts "\n------------------------------------------------------------------------------------------------------------\n"
+      puts "  FCL_RAILS_DAEMON\n"
+      puts "------------------------------------------------------------------------------------------------------------\n"
+      puts "  [start|stop|restart|status] option to control all processes at once"
+      puts "    #{prefix} start\n\n"
+      puts "  [--help] to view the manual \n"
+      puts "    #{prefix} --help\n"
+      puts "    [--command] to see the manual of a specific command\n"
+      puts "      #{prefix} --command sample_command --help\n\n"
+      puts "  [--env] to define the environment of the Rails application"
+      puts "    #{prefix} --env production start\n\n"
+      puts "  [--create] to create a new command"
+      puts "    #{prefix} --create my_first_command\n\n"
+      puts "  [--command] to control specific command"
+      puts "    #{prefix} --command sample_command start\n"
+      puts "    [--process_name] to define a name for the process"
+      puts "      #{prefix} --command sample_command --process_name my_process start\n\n"
+      puts "  [--pids] option to see pids process for each command"
+      puts "    #{prefix} --pids\n\n"
+      puts "  [--logs] option to see the log files set for each command"
+      puts "    #{prefix} --logs\n\n"
+      puts "------------------------------------------------------------------------------------------------------------\n"
+      puts "  COMMANDS REGISTERED\n"
+      puts "------------------------------------------------------------------------------------------------------------\n"
+
+      helpers.each do |h|
+        puts "  #{h[:description]}"
+        h[:sample].each do |e|
+          puts "   #{e}"
+        end
+        puts ""
+      end
+      exit
+    end
+
+    def self.set_env(argv)
+      i = argv.index('--env') + 1
+      env = argv[i]
+      ENV['RAILS_ENV'] = env
+    end
+
+    def self.create_command(argv)
+      i = argv.index('--create') + 1
+      command = argv[i]
+      unless command
+        puts " ༼ つ ◕_◕ ༽つ OOOPS... The command name has not been defined    "
+        exit
+      end
+      if Daemon.commands_valid.include? command
+        puts " ༼ つ ◕_◕ ༽つ OOOPS... The command can not be named #{command}    "
+        exit
+      end
+
+      command_camel = ActiveSupport::Inflector.camelize(command)
+      command_undescore = ActiveSupport::Inflector.underscore(command)
+
+      content = <<-FILE
+class #{command_camel} < FclRailsDaemon::Daemon
+
+  # Is necessary to implement the method "initialize"
+  def initialize
+    # Set the parameter "command" (name that will be referenced in the command entered in the terminal)
+    # The parameter "log" is optional but suggest it is set a log for each command to prevent many commands write on deafult log (if you have many commands in your application)
+    # The parameter "process_name" is optional (is the name that will be assigned to the process)
+    super(command: "#{command_undescore}", log: "log/#{command_undescore}.log", process_name: "#{command_undescore}")
+  end
+
+  # Is necessary to implement the method "self.help"
+  def self.help
+    # Should return a hash with " description" and "example"
+    {
+      description: "This command is a sample - Run every 1 minute",
+      sample: ["--command #{command_undescore} |start|stop|restart|status|"]
+    }
+  end
+
+  # Is necessary to implement the method "run"
+  def run
+    # Call the run method of the parent class (super) through a block that will contain your code
+    super do
+      # If you want your command be running repeatedly put inside a loop
+        @counter_sample = 0
+        loop do
+        # Write your code here !!!
+        # Do not use Process.exit (true) , exit () , abort ( ) in your code because it infers the death of the Daemon process
+
+        @counter_sample += 1
+        puts "Running "+ @command +" for " + @counter_sample.to_s + " time :)"
+
+        # Wait in seconds before running your command again
+        sleep(10)
+      end
+    end
+  end
+
+end
+      FILE
+
+      file = File.join(DAEMON_ROOT, DAEMON_CONFIG['command_path'], command_undescore + '.rb' )
+
+      if File.exist?(file)
+        puts " ༼ つ ◕_◕ ༽つ OOOPS... Command already exists.   "
+      else
+        File.open(file, 'wb') {|f| f.write(content) }
+
+        file_record = File.join(DAEMON_ROOT, DAEMON_CONFIG['register_file'] )
+        content_to_register = "\nFclRailsDaemon::Recorder.add(command: '#{command_undescore}', ref_class: #{command_camel})"
+        File.open(file_record, 'a+') {|f| f << content_to_register }
+
+        puts " ༼ つ ◕_◕ ༽つ OK... Command created and registered!!!   "
+        puts "New command: #{file}    "
+        puts "Commands registered: #{file_record}    "
+      end
+      exit
+    end
+
+    def self.set_process_name(argv)
+      i = argv.index('--command') + 1
+      command = argv[i]
+      i = argv.index('--process_name') + 1
+      name = argv[i]
+      if Daemon.commands_valid.include? command
+        puts " ༼ つ ◕_◕ ༽つ OOOPS... The command can not be named #{command}    "
+        exit
+      end
+      if Daemon.commands_valid.include? name
+        puts " ༼ つ ◕_◕ ༽つ OOOPS... The process can not be named #{command}    "
+        exit
+      end
+      registered = self.get_registered command
+      registered.each { |command| command.process_name = name }
+    end
+
+    def self.logs
+      registered = self.get_registered nil
+      registered.each { |command| puts "#{command.process_name}: #{command.log_file}" }
+      exit
+    end
+
+    def self.pids
+      puts Daemon.pids
+      exit
+    end
+
+  end
+end

data/lib/core/recorder.rb

@@ -0,0 +1,16 @@
+module FclRailsDaemon
+  class Recorder
+    @@commands ||= {}
+
+    def self.add(command: nil, class_reference: nil)
+      raise " ༼ つ ◕_◕ ༽つ OOOPS... Attribute 'command' does not set." unless command
+      raise " ༼ つ ◕_◕ ༽つ OOOPS... Attribute 'ref_class' does not set." unless class_reference
+      @@commands[command] = class_reference
+    end
+
+    def self.load
+      @@commands
+    end
+
+  end
+end

data/lib/fcl_rails_daemon/config.rb

@@ -1,9 +1,10 @@
+COMMAND = {'fcld' => false}
 DAEMON_ROOT = File.expand_path("")
-
 DAEMON_CONFIG = {
   "pids_file" => 'tmp/pids/fcld.yml',
   "default_log" => 'log/fcld.log',
   "command_prefix" => 'fcld',
-  "command_path" => 'lib/fcld_comandos',
-  "register_file" => 'config/fcld_rails_daemon.rb'
+  "command_path" => 'lib/fcl_rails_daemon',
+  "config_path" => 'config',
+  "register_file" => 'config/fcl_rails_daemon.rb'
 }

data/lib/fcl_rails_daemon/version.rb

@@ -1,3 +1,3 @@
 module FclRailsDaemon
-  VERSION = "1.0.12"
+  VERSION = "2.0.0"
 end

data/lib/fcl_rails_daemon.rb

@@ -1,3 +1,4 @@
+require "rails"
 require "fcl_rails_daemon/version"
 require "fcl_rails_daemon/config"
 require 'fileutils'
@@ -6,13 +7,14 @@ require 'daemons'
 require 'active_support'
 
 module FclRailsDaemon end
-
 require_relative "core/daemon"
-comandos_dir = File.join(DAEMON_ROOT, DAEMON_CONFIG['command_path'])
-if File.directory?(comandos_dir)
-  Dir[File.join(comandos_dir, "**/*.rb")].each {|file| require file }
-end
-require_relative "core/registrador.rb"
-require_relative "core/gerenciador.rb"
+require_relative "core/recorder.rb"
+require_relative "core/manager.rb"
+
+# Load commands files
+command_dir = File.join(DAEMON_ROOT, DAEMON_CONFIG['command_path'])
+raise " ༼ つ ◕_◕ ༽つ OOOPS... Could not find the command directory. Run 'fcld --configure'   " unless File.directory? command_dir
+Dir[File.join(command_dir, "**/*.rb")].each {|file| require file }
+
+require File.join(DAEMON_ROOT, "config", "fcl_rails_daemon.rb")
 
-require File.join(DAEMON_ROOT, "config", "fcld_rails_daemon.rb")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fcl_rails_daemon
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 2.0.0
 platform: ruby
 authors:
 - Washington Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-21 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,8 +80,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Este tem como maior caracteristica a facilidade de gerar comandos e gerenciá-los
-  de forma independente.
+description: |2-
+   This aims to make it easy to create commands ( ruby scripts) and run them in the background (daemon).
+  CLI has easy to use, where to control the processes related to commands.
 email:
 - w-osilva@hotmail.com
 executables:
@@ -104,6 +105,7 @@ files:
 - fcl_rails_daemon-1.0.1.gem
 - fcl_rails_daemon-1.0.10.gem
 - fcl_rails_daemon-1.0.11.gem
+- fcl_rails_daemon-1.0.12.gem
 - fcl_rails_daemon-1.0.2.gem
 - fcl_rails_daemon-1.0.3.gem
 - fcl_rails_daemon-1.0.4.gem
@@ -114,8 +116,8 @@ files:
 - fcl_rails_daemon-1.0.9.gem
 - fcl_rails_daemon.gemspec
 - lib/core/daemon.rb
-- lib/core/gerenciador.rb
-- lib/core/registrador.rb
+- lib/core/manager.rb
+- lib/core/recorder.rb
 - lib/fcl_rails_daemon.rb
 - lib/fcl_rails_daemon/config.rb
 - lib/fcl_rails_daemon/version.rb
@@ -133,7 +135,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -144,6 +146,5 @@ rubyforge_project: fcl_rails_daemon
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: Projeto utilizado para gerar comandos que podem ser executados em background
-  (daemons).
+summary: Project designed to generate commands that run in the background (daemons).
 test_files: []

data/lib/core/gerenciador.rb

@@ -1,188 +0,0 @@
-module FclRailsDaemon
-  class Gerenciador
-    @@comandos = Registrador.load
-
-    def self.run(argv)
-
-      if argv.include?('--pids')
-        puts Daemon.pids
-        exit
-      end
-
-      if argv.include?('--logs')
-        registrados = self.get_registrados nil
-        registrados.each { |comando| comando.send('log') }
-        exit
-      end
-
-      self.criar_comando(argv) if argv.include?('--create')
-
-      self.help(ARGV) unless self.valid?(argv)
-
-      task ||= nil
-      acao = argv.last
-      if argv.include?('--task')
-        i = argv.index('--task') + 1
-        task = argv[i]
-      end
-      registrados = self.get_registrados task
-      registrados.each { |comando| comando.send(acao) }
-    end
-
-
-    def self.help(argv)
-      acao = argv.last
-      task ||= nil
-      if (argv.include?('--task') && argv.include?('--help'))
-        i = argv.index('--task') + 1
-        task = argv[i]
-      end
-      helpers = self.get_helpers(task)
-      self.show helpers
-    end
-
-    def self.valid?(argv)
-      Daemon.comandos_validos.include?(argv.last) && !(argv.include?('--help'))
-    end
-
-    private
-    def self.show(helpers)
-      prefixo = DAEMON_CONFIG['command_prefix']
-
-      puts "\n------------------------------------------------------------------------------------------------------------\n"
-      puts "  FCL_RAILS_DAEMON\n"
-      puts "------------------------------------------------------------------------------------------------------------\n"
-      puts "  * Use a opção --help para ver o manual (--task para ver o manual de um comando expecifico)\n"
-      puts "    #{prefixo} --help\n"
-      puts "    #{prefixo} --task comando --help\n\n"
-      puts "  * Use a opção --create para criar um novo comando\n"
-      puts "    #{prefixo} --create meu_primeiro_comando\n\n"
-      puts "  * Use a opção start| stop | restart | status para controlar todos processos de uma vez\n"
-      puts "    #{prefixo} start\n\n"
-      puts "  * Use a opção --pids para ver os pids de processos\n"
-      puts "    #{prefixo} --pids\n\n"
-      puts "  * Use a opção --logs para ver os arquivos de log configurados para os comandos\n"
-      puts "    #{prefixo} --logs\n\n"
-      puts "  * Use a opção --task nome_comando start | stop | restart | status para controlar processos individualmente\n"
-      puts "    #{prefixo} --task comando start\n\n"
-      puts "------------------------------------------------------------------------------------------------------------\n"
-      puts "  LISTA DE COMANDOS REGISTRADOS\n"
-      puts "------------------------------------------------------------------------------------------------------------\n"
-
-      helpers.each do |h|
-        puts "  * #{h[:descricao]}"
-        h[:exemplo].each do |e|
-          puts "   #{e}"
-        end
-        puts ""
-      end
-      exit
-    end
-
-    def self.get_registrados(task = nil)
-      lista = []
-      @@registrados ||= {}
-      if task
-        raise "Comando não registrado # #{task} #" unless @@comandos.has_key? task
-        @@registrados[task] = (@@registrados.has_key? task) ? @@registrados[task] : @@comandos[task].new
-        lista << @@registrados[task]
-        return lista
-      end
-      @@comandos.each do |k, c|
-        lista << @@registrados[k] = (@@registrados.has_key? k) ? @@registrados[k] : c.new
-      end
-      lista
-    end
-
-    def self.get_helpers(task = nil)
-      lista = []
-      @@helpers ||= {}
-      if task
-        raise "Comando não registrado # #{task} #" unless @@comandos.has_key? task
-        @@helpers[task] = (@@helpers.has_key? task) ? @@helpers[task] : @@comandos[task].help
-        lista << @@helpers[task]
-        return lista
-      end
-      @@comandos.each do |k, c|
-        lista << @@helpers[k] = c.help unless @@helpers.has_key?(k)
-      end
-      lista
-    end
-
-    def self.criar_comando(argv)
-
-      i = argv.index('--create') + 1
-      comando = argv[i]
-      unless comando
-        puts "O nome do comando não foi definido"
-        exit
-      end
-      if Daemon.comandos_validos.include? comando
-        puts "O comando não pode ter o nome #{comando}"
-        exit
-      end
-
-      comando_camel = ActiveSupport::Inflector.camelize(comando)
-      comando_undescore = ActiveSupport::Inflector.underscore(comando)
-
-      conteudo = <<-FILE
-class #{comando_camel} < FclRailsDaemon::Daemon
-
-  # Obrigatóriamente é necessário implementar o método "initialize"
-  def initialize
-    # Definir o parametro "task" (nome que será referenciado no comando digitado no terminal).
-    #
-    # O parametro "log" é opcional mas sugiro que seja definido um log para cada comando para evitar que muitos comandos
-    # escrevam no log deafult (caso tenha# muitos comandos)
-    super(task: "#{comando_undescore}", log: "log/#{comando_undescore}.log")
-  end
-
-  # Obrigatóriamente é necessário implementar o método self.help
-  def self.help
-    # Retornar Hash com "descricao" e "exemplo"
-    {
-      descricao: "Descrição do comando #{comando_undescore} :) - Executado a cada 1 min",
-      exemplo: ["--task #{comando_undescore} start | stop | restart | status"]
-    }
-  end
-
-  # Obrigatóriamente é necessário implementar o método run
-  def run
-    # Chamar o método run da classe pai (super) passando um bloco que vai conter seu código
-    super do
-      # Caso deseje que o seu comando fique executando repetidamente coloque dentro de um loop
-      loop do
-        # Escreva seu código aqui!!
-        # Não use Process.exit(true), exit(), abort() em seu codigo pois infere na morte do processo do Daemon
-        puts "Está executando #{comando_undescore}!  :)"
-
-        # Espera em segundos antes de executar seu comando outra vez
-        # Util no caso de simular um processo cronológico (esse exemplo vai executar o comando a cada 10 segundos)
-        sleep(10)
-      end
-    end
-  end
-
-end
-      FILE
-
-      arquivo = File.join(DAEMON_ROOT, DAEMON_CONFIG['command_path'], comando_undescore + '.rb' )
-
-      if File.exist?(arquivo)
-        puts "Comando já existe..."
-      else
-        File.open(arquivo, 'wb') {|f| f.write(conteudo) }
-
-        arquivo_registro = File.join(DAEMON_ROOT, DAEMON_CONFIG['register_file'] )
-        conteudo_registrar = "\nFclRailsDaemon::Registrador.add(comando: '#{comando_undescore}', classe: #{comando_camel})"
-        File.open(arquivo_registro, 'a+') {|f| f << conteudo_registrar }
-
-        puts "Comando criado e registrado... "
-        puts "Arquivo: #{arquivo} "
-        puts "Registro: #{arquivo_registro} "
-      end
-      exit
-    end
-
-  end
-end

data/lib/core/registrador.rb

@@ -1,16 +0,0 @@
-module FclRailsDaemon
-  class Registrador
-    @@comandos ||= {}
-
-    def self.add(comando: nil, classe: nil)
-      raise "Comando não definido" unless comando
-      raise "Classe não definida" unless classe
-      @@comandos[comando] = classe
-    end
-
-    def self.load
-      @@comandos
-    end
-
-  end
-end