archfiend 0.1.0

data/lib/archfiend/generators/daemon/templates/Gemfile.tt

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'activesupport', require: 'active_support/time'
+gem 'activerecord', require: 'active_record'
+gem 'activerecord-migrations'
+gem 'archfiend', github: 'toptal/archfiend'
+gem 'clockwork', require: false
+gem 'config'
+gem 'daemons'
+gem 'pg', '~> 0.21'
+gem 'rbtrace', require: false
+
+group :development, :test do
+  gem 'factory_bot', require: false
+  gem 'pry'
+  gem 'pry-stack_explorer'
+  gem 'pry-byebug'
+  gem 'pry-doc', require: false
+  gem 'rspec', require: false
+  gem 'rubocop', require: false
+  gem 'rubocop-rspec', require: false
+  gem 'shoulda-matchers', '~> 3.1'
+  gem 'timecop', require: false
+  gem 'webmock', require: false
+end
+
+group :test do
+  gem 'database_cleaner'
+end

data/lib/archfiend/generators/daemon/templates/README.md.tt

@@ -0,0 +1,23 @@
+# <%= camelized_daemon_name %>
+
+## Running
+
+### In the foreground
+  Start in the foreground (ex. development)
+  ```bash
+    bin/start
+  ```
+
+### Daemonized
+  Start daemonized
+  ```bash
+    bin/start -d
+  ```
+
+  Kill daemonized:
+  ```bash
+    kill `cat [daemon_name].pid`
+  ```
+
+### Console
+  `bin/console`

data/lib/archfiend/generators/daemon/templates/Rakefile.tt

@@ -0,0 +1,13 @@
+require 'active_record'
+require 'active_record/migrations/tasks'
+ActiveRecord::Migrations.root = '.'
+require File.expand_path(File.join('..', 'config', 'application.rb'), __FILE__)
+
+<%= camelized_daemon_name %>.app.setup
+
+DATABASE_ENV = <%= camelized_daemon_name %>.app.env
+
+task :environment do
+end
+
+Dir["#{<%= camelized_daemon_name %>.root}/lib/tasks/*.rake"].each { |rake_file| load rake_file }

data/lib/archfiend/generators/daemon/templates/app/clockwork/clockwork.rb.tt

@@ -0,0 +1,14 @@
+# Uncomment the following code to have the Clockwork integration running in the daemon as a separate thread.
+# https://github.com/Rykian/clockwork
+
+# require 'clockwork'
+#
+# module Clockwork
+#   configure do |config|
+#     config[:logger] = <%= camelized_daemon_name %>.app.logger
+#   end
+#
+#   every(1.hour, 'label for logger') { Feed.send_later(:refresh) }
+#   every(10.seconds, 'label for logger') { run_something }
+#   every(1.day, 'label for logger', at: '01:30') { run_daily_processing }
+# end

data/lib/archfiend/generators/daemon/templates/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/lib/archfiend/generators/daemon/templates/app/subprocess_loops/foo_subprocess_loop.rb

@@ -0,0 +1,13 @@
+# A dummy SubprocessLoop that logs Hello World every 10 seconds, offseted by 5 seconds
+class FooSubprocessLoop < Archfiend::SubprocessLoop
+  def run
+    sleep 5
+    super
+  end
+
+  def iterate
+    msg = "Hello World from #{self.class.name}"
+    logger.info(msg)
+    sleep 10
+  end
+end

data/lib/archfiend/generators/daemon/templates/app/thread_loops/bar_thread_loop.rb

@@ -0,0 +1,8 @@
+# A dummy thread loop that logs Hello World every 5 seconds
+class BarThreadLoop < Archfiend::ThreadLoop
+  def iterate
+    msg = "Hello World from #{self.class.name}"
+    logger.info(msg)
+    sleep 5
+  end
+end

data/lib/archfiend/generators/daemon/templates/bin/console

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exec pry -r ./config/environment.rb

data/lib/archfiend/generators/daemon/templates/bin/start.tt

@@ -0,0 +1,6 @@
+#!/bin/bash
+if [ "$1" == "-d" ]; then
+  ruby ./config/daemon.rb
+else
+  ruby -r ./config/application.rb -e "<%= camelized_daemon_name %>.app.run"
+fi

data/lib/archfiend/generators/daemon/templates/config/application.rb.tt

@@ -0,0 +1,27 @@
+require File.expand_path('boot', __dir__)
+require 'archfiend'
+
+# Your daemon namespace
+module <%= camelized_daemon_name %>
+  extend Archfiend::Utilities
+
+  # Main daemon application class
+  class Application < Archfiend::Application
+    # @return [Module] A module containing Archfiend::Utilities
+    def utils
+      ::<%= camelized_daemon_name %>
+    end
+  end
+
+  # @return [Pathname] An absolute path to the main directory of the daemon
+  def self.root
+    @root ||= Pathname.new(File.expand_path('..', __dir__))
+  end
+end
+
+Bundler.require(*<%= camelized_daemon_name %>.groups)
+
+silence_warnings do
+  Encoding.default_external = Encoding::UTF_8
+  Encoding.default_internal = Encoding::UTF_8
+end

data/lib/archfiend/generators/daemon/templates/config/boot.rb.tt

@@ -0,0 +1,3 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])

data/lib/archfiend/generators/daemon/templates/config/daemon.rb.tt

@@ -0,0 +1,18 @@
+require File.expand_path('application', __dir__)
+
+daemon_opts = {
+  app_name: '<%= daemon_name %>',
+  log_dir: File.join(File.expand_path(__dir__), 'log'),
+  logfilename: "#{<%= camelized_daemon_name %>.app.env}.log"
+}
+
+# Daemons.daemonize closes all file descriptors and prepares the app for the fork.
+# Make sure new code doesn't rely on connections / logs etc opened before this call
+Daemons.daemonize(daemon_opts)
+
+# Sets up Settings and many more
+<%= camelized_daemon_name %>.app.setup
+Process.setproctitle "#{Settings.app_name} (#{<%= camelized_daemon_name %>.app.env})"
+
+# Runs the actual application
+<%= camelized_daemon_name %>.app.run

data/lib/archfiend/generators/daemon/templates/config/database.yml.example.tt

@@ -0,0 +1,26 @@
+default: &default
+  adapter: postgresql
+  encoding: utf8
+  database: <%%= ENV.fetch('DATABASE_NAME', '<%= daemon_name %>_development') %>
+
+  username: <%%= ENV.fetch('DATABASE_USERNAME', 'username') %>
+  password: <%%= ENV.fetch('DATABASE_PASSWORD', 'password') %>
+
+  host: <%%= ENV.fetch('DATABASE_HOST', 'localhost') %>
+  port: <%%= ENV.fetch('DATABASE_PORT', 5432) %>
+
+  pool: 12
+  reconnect: true
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+  database:  <%= daemon_name %>_test
+
+staging:
+  <<: *default
+
+production:
+  <<: *default

data/lib/archfiend/generators/daemon/templates/config/environment.rb.tt

@@ -0,0 +1,4 @@
+# File required by spec_helper and by console. Loads the basic environment of the Producer
+require File.expand_path('application', __dir__)
+
+<%= camelized_daemon_name %>.app.setup

data/lib/archfiend/generators/daemon/templates/config/settings.yml.tt

@@ -0,0 +1,8 @@
+app_name: <%= camelized_daemon_name %>
+
+logger:
+  # :debug, :info, :error, :fatal, :unknown
+  level: :info
+
+debug:
+  rbtrace: false

data/lib/archfiend/generators/daemon/templates/config/settings/development.yml.tt

@@ -0,0 +1,2 @@
+debug:
+  rbtrace: true

data/lib/archfiend/generators/daemon/templates/config/settings/production.yml.tt

@@ -0,0 +1,2 @@
+logger:
+  level: :info

data/lib/archfiend/generators/daemon/templates/config/settings/staging.yml.tt

@@ -0,0 +1,5 @@
+logger:
+  level: :info
+
+debug:
+  rbtrace: true

data/lib/archfiend/generators/daemon/templates/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+ENV['APP_ENV'] = 'test'
+
+require File.expand_path('../config/environment', __dir__)
+require 'database_cleaner'
+require 'support/timecop'
+require 'support/factory_bot'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+    c.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.around do |example|
+    ActiveRecord::Base.logger = nil
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.cleaning { example.run }
+  end
+
+  config.include(Shoulda::Matchers::ActiveModel, type: :model)
+  config.include(Shoulda::Matchers::ActiveRecord, type: :model)
+end
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :active_record
+    with.library :active_model
+  end
+end

data/lib/archfiend/generators/daemon/templates/spec/subprocess_loops/foo_subprocess_loop_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe FooSubprocessLoop do
+  it 'has iterate method' do
+    expect(subject).to respond_to(:iterate)
+  end
+end

data/lib/archfiend/generators/daemon/templates/spec/support/factory_bot.rb

@@ -0,0 +1,9 @@
+require 'factory_bot'
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+end

data/lib/archfiend/generators/daemon/templates/spec/support/timecop.rb

@@ -0,0 +1,9 @@
+require 'timecop'
+
+RSpec.configure do |config|
+  config.around(:each, freeze: true) do |example|
+    # Default is current time rounded to seconds
+    time = Time.zone.at(Time.now.to_i)
+    Timecop.freeze(time) { example.run }
+  end
+end

data/lib/archfiend/generators/daemon/templates/spec/thread_loops/bar_thread_loop_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe BarThreadLoop do
+  it 'has iterate method' do
+    expect(subject).to respond_to(:iterate)
+  end
+end

data/lib/archfiend/generators/extensions.rb

@@ -0,0 +1,119 @@
+module Archfiend
+  module Generators
+    class Extensions
+      PHASES = %i[init exec].freeze
+      CALLBACK_TYPES = %i[before after].freeze
+
+      # @param generator_options [Archfiend::Generators::Options] Options, source of potential extensions
+      # @param action_context [Thor::Group] Contex of the extended action/group of actions
+      # @param generator_name [String] Underscore form name of the generator, ex. daemon
+      def initialize(generator_options, action_context, generator_name)
+        @generator_options = generator_options
+        @action_context = action_context
+        @generator_name = generator_name
+
+        @extensions = activate_extensions
+        expose_extensions
+      end
+
+      def run_with_init_callbacks
+        run_callback(:init, :before)
+
+        yield unless skip_default_action?(:init)
+
+        run_callback(:init, :after)
+      end
+
+      def run_with_exec_callbacks
+        run_callback(:exec, :before)
+
+        yield unless skip_default_action?(:exec)
+
+        run_callback(:exec, :after)
+      end
+
+      private
+
+      def skip_default_action?(phase)
+        generator_extensions.any? do |ge|
+          method_name = "skip_default_#{phase}_action?"
+          ge.respond_to?(method_name) && ge.public_send(method_name)
+        end
+      end
+
+      def run_callback(phase, callback_type)
+        fail(ArgumentError, "Unsupported phase #{phase}") unless PHASES.include?(phase)
+        fail(ArgumentError, "Unsupported callback_type #{callback_type}") unless CALLBACK_TYPES.include?(callback_type)
+
+        callback_action = [callback_type, phase].join('_')
+        generator_extensions.select { |ge| ge.respond_to?(callback_action) }.each { |ge| ge.public_send(callback_action) }
+      end
+
+      def run_before_create_extensions
+        generator_extensions.select { |ge| ge.respond_to?(:before_create) }.each(&:before_create)
+      end
+
+      def run_after_create_extensions
+        generator_extensions.select { |ge| ge.respond_to?(:after_create) }.each(&:after_create)
+      end
+
+      def generator_extensions
+        @generator_extensions ||= @extensions.map do |extension_module|
+          next unless extension_module.const_defined?(generator_extensions_class_name)
+          extension_klass = extension_module.const_get(generator_extensions_class_name)
+          next if extension_klass.respond_to?(:target_generator_name) && extension_klass.target_generator_name != @generator_name
+
+          extension_klass.new(@action_context, @generator_options)
+        end.compact
+      end
+
+      def generator_extensions_class_name
+        "Generators::#{@generator_name.camelize}Extensions" # example: Generators::DaemonExtensions
+      end
+
+      def expose_extensions # rubocop:disable Metrics/AbcSize
+        generator_extensions.each do |generator_extension|
+          exposed_name = if generator_extension.respond_to?(:exposed_name)
+                           generator_extension.exposed_name
+                         else
+                           generator_extension.class.name.split(':').first.underscore
+                         end
+
+          if @action_context.respond_to?(exposed_name)
+            puts "Extension's exposed_name #{exposed_name.inspect} conflicts with existing method defined in #{@action_context.method(exposed_name).source_location}."
+            puts "Please define a method #{generator_extension.class.name}#exposed_name with some other value."
+            exit 1
+          end
+
+          @action_context.instance_variable_set("@#{exposed_name}", generator_extension)
+          @action_context.class.attr_reader(exposed_name)
+        end
+      end
+
+      def activate_extensions # rubocop:disable Metrics/AbcSize
+        extensions = []
+
+        @generator_options.extensions.each do |extension|
+          begin
+            Kernel.gem(extension)
+            Kernel.require(extension)
+          rescue LoadError => e
+            puts "Unable to load requested extension gem #{extension}, aborting"
+            puts e.inspect.to_s
+            exit 1
+          end
+          module_name = extension.camelize
+          if Object.const_defined?(module_name)
+            extensions << Object.const_get(module_name)
+            puts "Activated extension gem #{module_name}"
+          else
+            puts "Failed to recognize extension module #{module_name} in gem #{extension}, aborting"
+            exit 1
+          end
+        end
+
+        extensions
+      end
+    end
+  end
+end