fcl_rails_daemon 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 998be626e5fb47732b6b04730e443d413c71cf04
+  data.tar.gz: 94bdd36d38f2d01e9f823eb4b1dabb24ad304b63
+SHA512:
+  metadata.gz: 1c97416f21d3266e0780871bf60864c74862e9d3a48c9b35043f83a53a6b306add86495e81a5b61151e5640ed1d80bdad6aa9077d7a4af7692073096f2040b29
+  data.tar.gz: 0d71952e33958860d328068a662b0aee15653fed92a0d9f12e038348c1561bff13382fa5c38c0b67b88d2f011753e1a01d24bab5661c4f6bc7a24a40441e4839

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/log/
+.idea/*
+/config/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fcl_rails_daemon.gemspec
+gemspec

data/README.md

@@ -0,0 +1,64 @@
+# 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.
+
+## Instalação
+
+A partir do Gemfile
+
+```ruby
+gem 'fcl_rails_daemon'
+```
+
+Então execute:
+
+    $ bundle
+
+Ou somente instale:
+
+    $ gem install fcl_rails_daemon
+
+
+## Configuração
+
+Após a instalação é necessário criar os diretórios e arquivos de configuração, para isso execute
+
+    $ fcld --configure
+
+Serão criados:
+
+ * _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)
+
+
+## Como Usar?
+
+#### Podemos adicionar comandos através do parametro --create
+
+    $ fcld --create meu_primeiro_comando
+
+ * Cria um comando em lib/fcld_comandos
+ * Efetua o registro em config/fcl_rails_daemon.rb
+
+
+#### Podemos consultar o manual para descobrir quais os comandos disponíveis através do parametro --help
+
+     $ fcld --help
+
+
+#### Podemos consultar os pids de processos gerenciados pelo daemon através do parametro --pids
+
+     $ fcld --pids
+
+
+#### Podemos executar as ações básicas de um daemon (parametros start | stop | restart | status)
+
+     $ fcld start
+
+
+#### Podemos controlar processos individualnmente através do parametro --task
+
+     $ fcld --task meu_primeiro_comando start
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fcl_rails_daemon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/fcld

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'fcl_rails_daemon/config'
+
+base = DAEMON_ROOT
+config_dir = "config"
+config_dir = File.join(base, config_dir)
+FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
+config_file = File.join(config_dir, 'fcld_rails_daemon.rb')
+
+if ARGV.include? "--configure"
+  config_file_content = <<-FILE
+# 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)
+
+  command_sample_content = <<-FILE
+class ComandoExemplo < 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_exemplo", log: "log/comando_exemplo.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_exemplo :) - Executado a cada 1 min",
+      exemplo: ["--task comando_exemplo 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_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)
+        sleep(10)
+      end
+    end
+  end
+
+end
+
+  FILE
+
+  commands_dir = DAEMON_CONFIG['command_path']
+  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')
+  File.open(command_file, 'wb') {|f| f.write(command_sample_content) } unless File.exists?(command_file)
+
+  log_dir = "log"
+  log_dir = File.join(base, log_dir)
+  FileUtils.mkdir_p(log_dir) unless File.directory?(log_dir)
+
+  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)
+
+  puts "[Ok] Gem foi configurada!"
+  exit
+end
+
+unless File.exist?(config_file)
+  puts "[Ooops] Gem ainda não foi configurada... Para configurar execute o comando fcld --configure "
+  exit
+end
+
+require 'fcl_rails_daemon'
+require 'fcl_rails_daemon/version'
+
+FclRailsDaemon::Gerenciador.run(ARGV)

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fcl_rails_daemon.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fcl_rails_daemon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fcl_rails_daemon"
+  spec.version       = FclRailsDaemon::VERSION
+  spec.licenses      = ['MIT']
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ["Washington Silva"]
+  spec.email         = ["w-osilva@hotmail.com"]
+  spec.homepage      = ""
+  spec.rubyforge_project = "fcl_rails_daemon"
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.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.add_dependency "bundler"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "rake"
+  spec.add_dependency "daemons", "~> 1.2"
+
+  spec.add_development_dependency "rspec"
+end

data/lib/core/comando_exemplo.rb

@@ -0,0 +1,46 @@
+module FclRailsDaemon
+  class ComandoExemplo < FclRailsDaemon::Daemon
+
+    # Obrigatóriamente é necessário implementar o método "initialize" e 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 mesmo arquivo ocasionando dificuldade em compreender qual saída pertence a qual comando (caso tenha
+    # muitos comandos)
+    def initialize
+      super(task: 'meu_comando', log: 'log/meu_comando.log')
+    end
+
+    # Obrigatóriamente é necessário implementar o método self.help e retornar um Hash com "descricao" e "exemplo"
+    def self.help
+      {
+        descricao: 'Executa meu comando :) - Executado a cada 1 min',
+        exemplo: ['--task meu_comando start | stop | restart | status']
+      }
+    end
+
+    # Obrigatóriamente é necessário implementar o método run e chamar o mesmo método run da classe pai (super) passando
+    # um bloco que vai conter seu código
+    def run
+      super do
+
+        # Caso deseje que o seu comando fique executando repetidamente coloque dentro de um loop
+        loop do
+
+          # Escreva seu código aqui!!
+          # É importante que não exista nenhuma chamada para Process.exit(true), exit(), abort() pois infere na morte do
+          # processo do Daemon
+          puts "#{Time.now.to_s} - Está executando meu comando!  :)"
+
+          # Espera em segundos antes de iniciar novamente
+          # Util para que possa simular um processo cronológico (neste exemplo o comando será executado repetidamente
+          # a cada 60 segundos)
+          sleep(60)
+
+        end
+
+      end
+    end
+
+  end
+end

data/lib/core/daemon.rb

@@ -0,0 +1,124 @@
+module FclRailsDaemon
+  class Daemon
+
+    cattr_reader :comandos_validos
+    @@pids_file = File.join(DAEMON_ROOT, DAEMON_CONFIG['pids_file'])
+    @@comandos_validos = ['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
+      @daemon ||= nil
+      @task = task
+      @log = (log) ?  File.join(DAEMON_ROOT, log) : File.join(DAEMON_ROOT, DAEMON_CONFIG['default_log'])
+    end
+
+    def self.pids
+      f = File.open(@@pids_file, 'rb')
+      f.read
+    end
+
+    def self.help
+      raise "Não foi implementado o método self.help no comando"
+    end
+
+    def log
+      puts "#{@log} (#{@task})"
+    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')
+        $stdout.sync = true
+
+        block.call
+      end
+    end
+
+    def start
+      pid = get_pid @task
+      if running?(pid)
+        puts "proc: processo com pid #{pid} está rodando. (#{@task})"
+        return
+      end
+      run
+      set_pid(@task, @daemon.pid.pid) if @daemon
+    end
+
+    def stop
+      pid = get_pid @task
+
+      unless running? pid
+        puts "proc: processo não está rodando. (#{@task})"
+        return
+      end
+      kill pid
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def status
+      pid = get_pid @task
+      if running? pid
+        puts "proc: processo com pid #{pid} está rodando. (#{@task}) "
+      else
+        puts "proc: processo não está rodando. (#{@task}) "
+      end
+    end
+
+    private
+    def get_pid(task)
+      pids = YAML.load_file(@@pids_file)
+      (pids.has_key?(task)) ? pids[task] : nil
+    end
+
+    def set_pid(task, pid)
+      pids = YAML.load_file(@@pids_file)
+      pids[task] = pid
+      File.open(@@pids_file, 'wb') do |f|
+        f <<  pids.to_yaml
+      end
+    end
+
+    def running?(pid)
+      status = false
+      if pid
+        begin
+          Process.getpgid(pid)
+          status = true
+        rescue Errno::ESRCH
+          status = false
+        end
+      end
+      status
+    end
+
+    def kill(pid)
+      status = false
+      if pid
+        begin
+          Process.kill("KILL", pid)
+          set_pid(@task, nil)
+          status = true
+        rescue Errno::ESRCH
+          puts "proc: não existe processo com pid #{pid}. (#{@task})"
+          status = false
+        ensure
+          if status == false
+            puts "proc: processo com pid #{pid} está parado. (#{@task})"
+          else
+            puts "proc: processo com pid #{pid} foi parado. (#{@task})"
+          end
+        end
+      else
+        puts "proc: não existe processo com pid #{pid}. (#{@task})"
+      end
+    end
+
+  end
+end

data/lib/core/gerenciador.rb

@@ -0,0 +1,185 @@
+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 "  FOOTSTATSD\n"
+      puts "------------------------------------------------------------------------------------------------------------\n"
+      puts "  * Use a opção --help para ver os manual para os comandos\n"
+      puts "    #{prefixo} --help\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 TASKS\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

@@ -0,0 +1,16 @@
+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

data/lib/fcl_rails_daemon.rb

@@ -0,0 +1,19 @@
+require "fcl_rails_daemon/version"
+require "fcl_rails_daemon/config"
+require 'fileutils'
+require 'yaml'
+require 'daemons'
+require 'active_support'
+
+
+module FclRailsDaemon end
+
+require_relative "core/daemon"
+comandos_dir = File.join(DAEMON_ROOT, "lib", "comandos")
+if File.directory?(comandos_dir)
+  Dir["#{comandos_dir}/*.rb"].each {|file| require file }
+end
+require_relative "core/registrador.rb"
+require_relative "core/gerenciador.rb"
+
+require File.join(DAEMON_ROOT, "config", "fcld_rails_daemon.rb")

data/lib/fcl_rails_daemon/config.rb

@@ -0,0 +1,9 @@
+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'
+}

data/lib/fcl_rails_daemon/version.rb

@@ -0,0 +1,3 @@
+module FclRailsDaemon
+  VERSION = "1.0.1"
+end

data/spec/fcl_rails_daemon_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe FclRailsDaemon do
+  it 'has a version number' do
+    expect(FclRailsDaemon::VERSION).not_to be nil
+  end
+
+  it 'does something useful' do
+    expect(false).to eq(false)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'fcl_rails_daemon'

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: fcl_rails_daemon
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Washington Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Este tem como maior caracteristica a facilidade de gerar comandos e gerenciá-los
+  de forma independente.
+email:
+- w-osilva@hotmail.com
+executables:
+- console
+- fcld
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/fcld
+- bin/setup
+- fcl_rails_daemon-1.0.0.gem
+- fcl_rails_daemon.gemspec
+- lib/core/comando_exemplo.rb
+- lib/core/daemon.rb
+- lib/core/gerenciador.rb
+- lib/core/registrador.rb
+- lib/fcl_rails_daemon.rb
+- lib/fcl_rails_daemon/config.rb
+- lib/fcl_rails_daemon/version.rb
+- spec/fcl_rails_daemon_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+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).
+test_files: []