whenever_systemd 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7074b14d9e4bafc762973076ad3a224ab09243736b19d0742658bbb29c78c142
+  data.tar.gz: b1ddc106d768eed86e517ea59a011cb8b188f6420e5e4f55a1052b31618d3e44
+SHA512:
+  metadata.gz: 3ba3be14419e7c72cc0f151a577105173072de22bb11b4053e896cfbb897164739d597606b3b7cf1734f07877a3de8968aba4179f12490082753e17189307e08
+  data.tar.gz: e61467600d7cb1d954c1efdfc71749a8c514b7e52b18cf35cc75573bf10a037e96dda5a6a69f6999381b6ac6b1d9c618f2a460fbf431f03f8d39f0f597a3cff7

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+pkg
+doc
+.*.sw[a-z]
+Gemfile.lock
+gemfiles/*.lock
+.ruby-version

data/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+
+before_install:
+  - gem install bundler
+  - unset _JAVA_OPTIONS
+rvm:
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+  - jruby-9.2.6.0
+
+gemfile:
+  - gemfiles/activesupport4.1.gemfile
+  - gemfiles/activesupport4.2.gemfile
+  - gemfiles/activesupport5.0.gemfile
+  - gemfiles/activesupport5.1.gemfile
+  - gemfiles/activesupport5.2.gemfile
+
+env:
+  global:
+    - JRUBY_OPTS=--debug

data/Appraisals

@@ -0,0 +1,19 @@
+appraise 'activesupport4.1' do
+  gem "activesupport", "~> 4.1.0"
+end
+
+appraise 'activesupport4.2' do
+  gem "activesupport", "~> 4.2.0"
+end
+
+appraise 'activesupport5.0' do
+  gem "activesupport", "~> 5.0.0"
+end
+
+appraise 'activesupport5.1' do
+  gem "activesupport", "~> 5.1.0"
+end
+
+appraise 'activesupport5.2' do
+  gem "activesupport", "~> 5.2.0beta2"
+end

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / October 27th, 2020
+
+* Forked from whenever [Anton Semenov]

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Javan Makhmali
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+
+WheneverSystemd is a fork of the gem [Whenever](https://github.com/javan/whenever), which generates & installs
+[systemd timers](https://www.freedesktop.org/software/systemd/man/systemd.timer.html#) from a similar `schedule.rb` file.
+
+Note: By some reasons there is no tests yet, if you want to add them, you are welcome.
+
+### Installation
+
+```sh
+$ gem install whenever_systemd
+```
+
+Or with Bundler in your Gemfile.
+
+```ruby
+gem 'whenever_systemd', require: false
+```
+
+### Getting started
+
+```sh
+$ cd /apps/my-great-project
+$ bundle exec wheneverize .
+```
+
+This will create an initial `config/schedule.rb` file for you (as long as the config folder is already present in your project).
+
+### The `whenever_systemd` command
+
+The `whenever_systemd` command will simply show you your `schedule.rb` file converted to cron syntax. It does not read or write your systemd units.
+
+```sh
+$ cd /apps/my-great-project
+$ bundle exec whenever_systemd
+```
+
+To write unit files for your jobs, execute this command:
+
+```sh
+$ whenever_systemd --update-units
+```
+
+Other commonly used options include:
+```sh
+$ whenever_systemd --load-file config/my_schedule.rb # set the schedule file
+$ whenever_systemd --install-path '/usr/lib/systemd/system/' # install units to specific dir
+```
+
+### Example schedule.rb file
+
+**Note the difference with whenever schedule.rb:**
+
+You should provide a name to your job in the first argument, i.e.:
+
+```ruby
+# instead of:
+runner "MyModel.some_process"
+
+# With whenever_systemd:
+runner "mymodel-some_process", "MyModel.some_process"
+```
+
+So, here is an example:
+
+```ruby
+set :prefix,        "myproject"
+set :timer,          { accuracy_sec: "1m" } # timer options
+set :install,        { wanted_by: "timers.target" } # project timers target
+
+every 3.hours do # 1.minute 1.day 1.week 1.month 1.year is also supported
+  runner  "mymodel-some_process", "MyModel.some_process"
+  rake    "myrake-task", "my:rake:task"
+  command "my_great_command", "/usr/bin/my_great_command"
+end
+
+# Helpers: minutely, hourly, daily, monthly, yearly, quarterly, semiannually
+# See: https://www.freedesktop.org/software/systemd/man/systemd.time.html#Calendar%20Events
+minutely do
+  runner "SomeModel.ladeeda"
+end
+
+# +every+ helper eats any calendar syntax described in the link above:
+every '*:1/15' do # Every 15 minutes, starting from 01, i.e.: 01,16,31,46
+  runner "mymode-task_to_run_in_15m", "Mymodel.task_to_run_in_15m"
+end
+
+# Folded blocks:
+daily do
+  at '00:00' do # run every day at 00:00
+    runner "task-do_something_great", "Task.do_something_great"
+    rake "app_server-task", "app_server:task"
+  end
+end
+
+weekly 'Sun' do
+  at '4:30' do # Run every Sunday at 04:30
+    runner "mymodel-sunday_task", "Mymodel.sunday_task"
+  end
+end
+```
+
+### Define your own job types
+
+Whenever ships with three pre-defined job types: command, runner, and rake. You can define your own with `job_type`.
+
+For example:
+
+```ruby
+job_type :awesome, '/usr/local/bin/awesome :task :fun_level'
+
+every 2.hours do
+  awesome "awesome-party", "party", fun_level: "extreme"
+end
+```
+
+Would run `/usr/local/bin/awesome party extreme` every two hours. `:task` is always replaced with the first argument, and any additional `:whatevers` are replaced with the options passed in or by variables that have been defined with `set`.
+
+The default job types that ship with Whenever are defined like so:
+
+```ruby
+job_type :command, ":task :output"
+job_type :rake,    "cd :path && :environment_variable=:environment bundle exec rake :task --silent :output"
+job_type :runner,  "cd :path && bin/rails runner -e :environment ':task' :output"
+job_type :script,  "cd :path && :environment_variable=:environment bundle exec script/:task :output"
+```
+
+If a `:path` is not set it will default to the directory in which `whenever` was executed. `:environment_variable` will default to 'RAILS_ENV'. `:environment` will default to 'production'. `:output` will be replaced with your output redirection settings which you can read more about here: <http://github.com/javan/whenever/wiki/Output-redirection-aka-logging-your-cron-jobs>
+
+All jobs are by default run with `bash -l -c 'command...'`. Among other things, this allows your cron jobs to play nice with RVM by loading the entire environment instead of cron's somewhat limited environment. Read more: <http://blog.scoutapp.com/articles/2010/09/07/rvm-and-cron-in-production>
+
+You can change this by setting your own `:job_template`.
+
+```ruby
+set :job_template, "bash -l -c ':job'"
+```
+
+Or set the job_template to nil to have your jobs execute normally.
+
+```ruby
+set :job_template, nil
+```
+
+### Credit
+
+WheneverSystemd is forked from Whenever not by a glory seeker, so I just copy the original credits:
+
+Whenever was created for use at Inkling (<http://inklingmarkets.com>). Their take on it: <http://blog.inklingmarkets.com/2009/02/whenever-easy-way-to-do-cron-jobs-from.html>
+
+Thanks to all the contributors who have made it even better: <http://github.com/javan/whenever/contributors>
+
+Copyright &copy; 2017 Javan Makhmali

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+# require 'rake/testtask'
+#
+# Rake::TestTask.new(:test) do |test|
+#   test.libs      << 'lib' << 'test'
+#   test.pattern   = 'test/{functional,unit}/**/*_test.rb'
+#   test.verbose   = true
+# end
+#
+# task :default => :test

data/bin/whenever_systemd

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'whenever_systemd'
+require 'whenever_systemd/version'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: whenever [options]"
+
+  opts.on('-p', '--prefix [unit prefix]', 'Unit prefix') do |prefix|
+    options[:prefix] = prefix
+  end
+
+  opts.on('-d', '--dir [install path]',
+          'Unit Search Path',
+          "  Default: #{WheneverSystemd::DEFAULT_INSTALL_PATH}") do |path|
+    options[:install_path] = path
+  end
+
+  opts.on('-i', '--update-units [schedule]',
+          'Install the schedule units.',
+          '  Default: full path to schedule.rb file') do |identifier|
+    options[:update] = true
+    options[:identifier] = identifier if identifier
+  end
+
+  opts.on('-c', '--clear-units [schedule]',
+          'Uninstall units',
+          '  Default: full path to schedule.rb file') do |identifier|
+    options[:clear] = true
+    options[:identifier] = identifier if identifier
+  end
+
+  opts.on('-s', '--set [variables]', 'Example: --set \'environment=staging&path=/my/sweet/path\'') do |set|
+    options[:set] = set if set
+  end
+
+  opts.on('-f', '--load-file [schedule file]', 'Default: config/schedule.rb') do |file|
+    options[:file] = file if file
+  end
+
+  opts.on('-u', '--user [user]', 'Default: current user') do |user|
+    options[:user] = user if user
+  end
+
+  opts.on('-r', '--roles [role1,role2]', 'Comma-separated list of server roles to generate cron jobs for') do |roles|
+    options[:roles] = roles.split(',').map(&:to_sym) if roles
+  end
+
+  opts.on('-S', '--dry-run', 'Only print script which will be executed') do |c|
+    options[:dry] = true
+  end
+
+  opts.on("--sudo", "Use sudo with operations") do
+    options[:sudo] = true
+  end
+
+  opts.on("--script [script]", "Use custom script to perform action") do |v|
+    options[:custom_script] = File.expand_path(v)
+  end
+
+  opts.on('-v', '--version') { puts "WheneverSystemd v#{WheneverSystemd::VERSION}"; exit(0) }
+end.parse!
+
+WheneverSystemd::CommandLine.execute(options)

data/bin/wheneverize

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# This file is based heavily on Capistrano's `capify` command
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+unless ARGV.empty?
+  if !File.exist?(ARGV.first)
+    abort "`#{ARGV.first}' does not exist."
+  elsif !File.directory?(ARGV.first)
+    abort "`#{ARGV.first}' is not a directory."
+  elsif ARGV.length > 1
+    abort "Too many arguments; please specify only the directory to wheneverize."
+  end
+end
+
+content = <<-FILE
+# Use this file to easily define all of your cron jobs.
+#
+# It's helpful, but not entirely necessary to understand cron before proceeding.
+# http://en.wikipedia.org/wiki/Cron
+
+# Example:
+#
+# set :output, "/path/to/my/cron_log.log"
+#
+# every 2.hours do
+#   command "/usr/bin/some_great_command"
+#   runner "MyModel.some_method"
+#   rake "some:great:rake:task"
+# end
+#
+# every 4.days do
+#   runner "AnotherModel.prune_old_records"
+# end
+
+# Learn more: http://github.com/javan/whenever
+FILE
+
+file = 'config/schedule.rb'
+base = ARGV.empty? ? '.' : ARGV.shift
+
+file = File.join(base, file)
+if File.exist?(file)
+  warn "[skip] `#{file}' already exists"
+elsif File.exist?(file.downcase)
+  warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+else
+  dir = File.dirname(file)
+  if !File.exist?(dir)
+    warn "[add] creating `#{dir}'"
+    FileUtils.mkdir_p(dir)
+  end
+  puts "[add] writing `#{file}'"
+  File.open(file, "w") { |f| f.write(content) }
+end
+
+puts "[done] wheneverized!"

data/gemfiles/activesupport5.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "activesupport", "~> 5.2"
+
+gemspec path: "../"

data/lib/whenever_systemd/command_line.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module WheneverSystemd
+  class CommandLine
+    def self.execute(options={})
+      new(options).run
+    end
+
+    def initialize(options={})
+      @options = options
+
+      @options[:install_path]    ||= WheneverSystemd::DEFAULT_INSTALL_PATH
+      @options[:temp_path]       ||= "#{ENV['HOME']}/tmp/whenever-#{Time.now.to_i}"
+      @options[:file]            ||= "config/schedule.rb"
+      @options[:cut]             ||= 0
+      @options[:identifier]      ||= default_identifier
+
+      if !File.exist?(@options[:file]) && @options[:clear].nil?
+        warn("[fail] Can't find file: #{@options[:file]}")
+        exit(1)
+      end
+    end
+
+    def run
+      if @options[:dry]
+        dry_run
+      elsif @options[:clear]
+        clear_units
+      elsif @options[:update]
+        update_units
+      else
+        show_units
+        exit(0)
+      end
+    end
+
+    def show_units
+      puts job_list.dry_units(@options[:install_path])
+      puts "## [message] Above is your schedule file converted to systemd units."
+      puts "## [message] Your active units was not updated."
+      puts "## [message] Run `whenever --help' for more options."
+    end
+
+    def dry_run
+      if @options[:clear]
+        puts job_list.generate_clear_script(@options[:install_path])
+      elsif @options[:update]
+        puts job_list.generate_update_script(@options[:install_path])
+      else
+        show_units
+      end
+      exit(0)
+    end
+
+    def update_units
+      make_and_run_script(:update_units)
+    end
+
+    def clear_units
+      make_and_run_script(:clear_units)
+    end
+
+    def job_list
+      @job_list ||= JobList.new(@options)
+    end
+
+    private
+
+    def make_and_run_script(name)
+      script_name = [@options[:prefix], name].compact.join(?-)
+
+      script_path = make_script(script_name) do
+        job_list.generate_update_script(@options[:install_path])
+      end
+
+      cmd =
+        if @options[:custom_script]
+          binding.eval(Pathname(@options[:custom_script]).read)
+        else
+          sudo_if_need(script_path)
+        end
+
+      system(cmd)
+    end
+
+    def sudo_if_need(*cmd)
+      Shellwords.join(@options[:sudo] ? ["sudo", "bash", *cmd] : ["bash", *cmd])
+    end
+
+    def make_script(name)
+      FileUtils.mkdir_p(@options[:temp_path])
+      script_file = Pathname(@options[:temp_path])/"#{name}.sh"
+      script_file.write(yield)
+      # script_file.chmod(0755)
+      script_file.to_path
+    end
+
+    protected
+
+    def default_identifier
+      File.expand_path(@options[:file])
+    end
+  end
+end

data/lib/whenever_systemd/formatters.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module WheneverSystemd
+  module Formatters
+    factory = proc { |tpl, args| tpl % args }.curry(2).freeze
+
+    ParamPair = factory["%s=%s"].freeze
+
+    capitalize = -> (part) do
+      part.match?(/\A[a-z][a-z0-9]+\z/) ? part.capitalize : part
+    end
+
+    ParamKey = -> (key) do
+      key.to_s.split('_').map(&capitalize).join
+    end
+
+    hash_join_params = -> (hash) do
+      hash.transform_keys(&ParamKey).map(&ParamPair) * "\n"
+    end
+
+    ParamsHash = -> (hash) do
+      hash.transform_values(&hash_join_params)
+    end
+
+    IntervalMinutes = factory["*:0/%{minutes}"]
+    IntervalHours   = factory["0/%{hours}:0/%{minutes}"] >> proc { |v| v.chomp("/0") }
+    IntervalSeconds = factory["0:0:0/%d"]
+
+    NormalizeInterval = {
+      "daily" => "*-*-*"
+    }
+
+    Duration = -> (freq) do
+      case freq
+      when 0...3600;     IntervalMinutes[freq.parts]  # 1 second to hour
+      when 3600...86400; IntervalHours[freq.parts]    # 1 hour to day
+      else               IntervalSeconds[freq.to_i]
+      end
+    end
+
+    Freq = -> (freq) do
+      ActiveSupport::Duration === freq ? Duration[freq] : freq
+    end
+
+    Service = ParamsHash >> factory[<<~INI]
+      [Unit]
+      %{unit}
+
+      [Service]
+      %{service}
+    INI
+
+    Timer = ParamsHash >> factory[<<~INI]
+      [Unit]
+      %{unit}
+
+      [Timer]
+      %{timer}
+
+      [Install]
+      %{install}
+    INI
+
+    Target = ParamsHash >> factory[<<~INI]
+      [Unit]
+      %{unit}
+
+      [Install]
+      WantedBy=timers.target
+    INI
+
+    MaterializeUnit = factory[<<~BASH]
+      cat > %{path}/%{filename} <<'EOF'
+      %{content}
+      EOF
+    BASH
+
+    MaterializeUnits = proc do |list|
+      list.map(&MaterializeUnit) * "\n"
+    end
+
+    DryUnit = factory[<<~EOF]
+      # filepath: %{path}/%{filename}
+      %{content}
+
+    EOF
+
+    DryUnits = proc { |list| list.map(&DryUnit) * "\n" }
+  end
+end

data/lib/whenever_systemd/job.rb

@@ -0,0 +1,118 @@
+require 'shellwords'
+require "whenever_systemd/formatters"
+
+module WheneverSystemd
+  class Job
+    attr_reader :at, :roles, :mailto, :name
+
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+      @at = options.delete(:at)
+      @template = options.delete(:template)
+      @mailto                           = options.fetch(:mailto, :default_mailto)
+      @job_template                     = options.delete(:job_template) || ":job"
+      @roles                            = Array(options.delete(:roles))
+      @options[:output]                 = options.has_key?(:output) ? Output::Redirection.new(options[:output]).to_s : ''
+      @options[:environment_variable] ||= "RAILS_ENV"
+      @options[:environment]          ||= :production
+      @options[:path]                   = Shellwords.shellescape(@options[:path] || WheneverSystemd.path)
+
+      description = options.delete(:description)
+      install = options.delete(:install) { { wanted_by: "timers.target" } }
+
+      timer = options.delete(:timer).to_h
+      timer[:on_calendar] ||= compose_on_calendar(options.delete(:interval), @at)
+
+      unit = options.delete(:unit).to_h
+      unit[:description] = description
+
+      service = options.delete(:service).to_h
+      service[:type] ||= "oneshot"
+      service[:exec_start] = output
+
+      @service_options = { unit: unit, service: service }
+      @timer_options = { unit: { description: description }, timer: timer, install: install }
+    end
+
+    def compose_on_calendar(*args)
+      args.compact!
+      if args.size > 1 && Formatters::NormalizeInterval.key?(args[0])
+        args[0] = Formatters::NormalizeInterval[args[0]]
+      end
+      args.join(" ")
+    end
+
+    def output
+      job = process_template(@template, @options)
+      out = process_template(@job_template, @options.merge(:job => job))
+      out.gsub(/%/, '\%')
+    end
+
+    def unprefixed_name(prefix = nil)
+      prefix ||= @options[:prefix]
+      if @name.rindex(prefix) == 0
+        prefix_end = prefix.size.next
+        @name[prefix_end, @name.size - prefix_end]
+      else
+        @name
+      end
+    end
+
+    def service_name
+      "#{@name}.service"
+    end
+
+    def timer_name
+      "#{@name}.timer"
+    end
+
+    def unit_expansion
+      "#{@name}.{service,timer}"
+    end
+
+    def systemd_units(path)
+      [
+        { path: path, filename: service_name, content: systemd_service },
+        { path: path, filename: timer_name,   content: systemd_timer }
+      ]
+    end
+
+    def systemd_service
+      Formatters::Service[@service_options]
+    end
+
+    def systemd_timer
+      Formatters::Timer[@timer_options]
+    end
+
+    def has_role?(role)
+      roles.empty? || roles.include?(role)
+    end
+
+  protected
+
+    def process_template(template, options)
+      template.gsub(/:\w+/) do |key|
+        before_and_after = [$`[-1..-1], $'[0..0]]
+        option = options[key.sub(':', '').to_sym] || key
+
+        if before_and_after.all? { |c| c == "'" }
+          escape_single_quotes(option)
+        elsif before_and_after.all? { |c| c == '"' }
+          escape_double_quotes(option)
+        else
+          option
+        end
+      end.gsub(/\s+/m, " ").strip
+    end
+
+    def escape_single_quotes(str)
+      str.gsub(/'/) { "'\\''" }
+    end
+
+    def escape_double_quotes(str)
+      str.gsub(/"/) { '\"' }
+    end
+  end
+end

data/lib/whenever_systemd/job_list.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "whenever_systemd/formatters"
+require "active_support/duration"
+require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/object/deep_dup"
+
+module WheneverSystemd
+  class JobList
+    attr_reader :roles
+
+    def initialize(options)
+      @jobs, @env, @set_variables, @pre_set_variables = [], {}, {}, {}
+
+      if options.is_a? String
+        options = { :string => options }
+      end
+      @temp_path = options[:temp_path]
+      pre_set(options[:set])
+      @roles = options[:roles] || []
+
+      setup_file = File.expand_path('../setup.rb', __FILE__)
+      setup = File.read(setup_file)
+      schedule = if options[:string]
+        options[:string]
+      elsif options[:file]
+        File.read(options[:file])
+      end
+
+      instance_eval(setup, setup_file)
+      instance_eval(schedule, options[:file] || '<eval>')
+    end
+
+    def set(variable, value)
+      variable = variable.to_sym
+      return if @pre_set_variables[variable]
+
+      instance_variable_set("@#{variable}".to_sym, value)
+      @set_variables[variable] = value
+    end
+
+    def method_missing(name, *args, &block)
+      @set_variables.has_key?(name) ? @set_variables[name] : super
+    end
+
+    def self.respond_to?(name, include_private = false)
+      @set_variables.has_key?(name) || super
+    end
+
+    def env(variable, value)
+      @env[variable.to_s] = value
+    end
+
+    def every(frequency, at: nil, **timer)
+      @options_was = @options
+      @options = @options.to_h.merge(interval: Formatters::Freq[frequency], timer: timer, at: at)
+      yield
+    ensure
+      @options, @options_was = @options_was, nil
+    end
+
+    def daily(at: "00:00:00", **options, &block)
+      every("*-*-*", at: at, **options, &block)
+    end
+
+    %w(minutely hourly monthly yearly quarterly semiannually).each do |k|
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{k}(**options, &block)
+          every(:#{k}, **options, &block)
+        end
+      RUBY
+    end
+
+    def weekly(*on_days, **options, &block)
+      if on_days.size > 0
+        every("#{on_days * ?,} *-*-*", **options, &block)
+      else
+        every(:weekly, **options, &block)
+      end
+    end
+
+    def at(time)
+      @options_was, @options = @options, @options.to_h.merge(at: time)
+      yield
+    ensure
+      @options, @options_was = @options_was, nil
+    end
+
+    attr_reader :jobs
+
+    def job_type(name, template)
+      singleton_class.class_eval do
+        define_method(name) do |job_name, task, *args|
+          options = { :task => task, :template => template }
+          options.merge!(args[0]) if args[0].is_a? Hash
+          options[:description] ||= options.delete("?") { "WheneverSystemd-generated Job" }
+
+          @jobs ||= []
+          @jobs << Job.new("#{@prefix}-#{job_name}", @set_variables.deep_merge(@options).deep_merge(options).deep_dup)
+        end
+      end
+    end
+
+    def generate(name, path)
+      case name.to_sym
+      when :units;        generate_units_script(path)
+      when :update_units; generate_update_script(path)
+      when :clear_units;  generate_clear_script(path)
+      else raise ArgumentError, %(available names: units, update_units, clear_units, given: #{name})
+      end
+    end
+
+    def generate_units_script(path)
+      Formatters::MaterializeUnits[systemd_units(path)]
+    end
+
+    def generate_update_script(path)
+      [
+        make_backup_dir,
+        backup_previous_units_from(path, all: true),
+        systemctl_timers('disable', '--now', all: true),
+        generate_units_script(@temp_path),
+        copy_updated_units_to(path),
+        Shellwords.join(["/usr/bin/systemctl", "daemon-reload"]),
+        systemctl_timers('enable', '--now')
+      ].join("\n\n")
+    end
+
+    def generate_clear_script(path)
+      [
+        make_backup_dir,
+        backup_previous_units_from(path, all: true),
+        systemctl_timers('disable', '--now', all: true),
+        format(%(/usr/bin/rm -rfI %{target}/%{expansion}), target: Shellwords.escape(path), expansion: units_expansion(all: true))
+      ].join("\n\n")
+    end
+
+    def backup_previous_units_from(path, **opts)
+      format(%(/usr/bin/cp -rvf %{source}/%{expansion} -t %{target}),
+        source: Shellwords.escape(path),
+        expansion: units_expansion(**opts),
+        target: Shellwords.escape("#{@temp_path}/backup")
+      )
+    end
+
+    def copy_updated_units_to(path)
+      format(%(/usr/bin/cp -rvf %{source}/*.{service,timer} -t %{target}),
+        source: Shellwords.escape(@temp_path),
+        target: Shellwords.escape(path)
+      )
+    end
+
+    def make_backup_dir
+      Shellwords.join(["mkdir", "-p", "#{@temp_path}/backup"])
+    end
+
+    def systemctl_timers(*args, **opts)
+      case args[0]
+      when "enable", "disable"
+        format(%(for timer in %s; do %s $timer; done),
+          units_expansion('timer', sub: true, **opts),
+          Shellwords.join(["/usr/bin/systemctl", *args])
+        )
+      else
+        Shellwords.join(["/usr/bin/systemctl", *args, units_expansion('timer', **opts)])
+      end
+    end
+
+    def timers
+      @jobs.map(&:timer_name)
+    end
+
+    def unit_files(path)
+      Dir.glob("#{path}/#{units_expansion}")
+    end
+
+    def units_expansion(ext = "{service,timer}", all: false, sub: false)
+      suffixes = all ? "*" : format("{%s}", @jobs.map { |j| Shellwords.escape(j.unprefixed_name) }.join(?,))
+      pattern = "#{@prefix}-#{suffixes}.#{ext}"
+      return pattern unless sub
+      if all
+        format(%($(/usr/bin/systemctl list-unit-files '%s' | /usr/bin/cut -d ' ' -f 1 | /usr/bin/head -n -2 | /usr/bin/tail -n +2)), pattern)
+      else
+        format(%($(/usr/bin/echo %s)), pattern)
+      end
+    end
+
+    def dry_units(path)
+      Formatters::DryUnits[systemd_units(path)]
+    end
+
+    def systemd_units(path, include_target = true)
+      wanted_by = @set_variables.dig(:install, :wanted_by)
+      if include_target && wanted_by != "timers.target"
+        [timers_target(path), *systemd_units("#{path}/#{wanted_by}.wants", false)]
+      else
+        @jobs.flat_map { |job| job.systemd_units(path) }
+      end
+    end
+
+    def timers_target(path)
+      {
+        path: path,
+        filename: @set_variables.dig(:install, :wanted_by),
+        content: Formatters::Target[unit: { description: "Timers target" }]
+      }
+    end
+
+    private
+
+    #
+    # Takes a string like: "variable1=something&variable2=somethingelse"
+    # and breaks it into variable/value pairs. Used for setting variables at runtime from the command line.
+    # Only works for setting values as strings.
+    #
+    def pre_set(variable_string = nil)
+      return if variable_string.nil? || variable_string == ""
+
+      pairs = variable_string.split('&')
+      pairs.each do |pair|
+        next unless pair.index('=')
+        variable, value = *pair.split('=')
+        unless variable.nil? || variable == "" || value.nil? || value == ""
+          variable = variable.strip.to_sym
+          set(variable, value.strip)
+          @pre_set_variables[variable] = value
+        end
+      end
+    end
+
+    def environment_variables
+      return if @env.empty?
+
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val.nil? || val == "" ? '""' : val}\n"
+      end
+      output << "\n"
+
+      output.join
+    end
+  end
+end

data/lib/whenever_systemd/os.rb

@@ -0,0 +1,7 @@
+module WheneverSystemd
+  module OS
+    def self.solaris?
+      (/solaris/ =~ RUBY_PLATFORM)
+    end
+  end
+end

data/lib/whenever_systemd/output_redirection.rb

@@ -0,0 +1,57 @@
+module WheneverSystemd
+  module Output
+    class Redirection
+      def initialize(output)
+        @output = output
+      end
+
+      def to_s
+        return '' unless defined?(@output)
+        case @output
+          when String   then redirect_from_string
+          when Hash     then redirect_from_hash
+          when NilClass then ">> /dev/null 2>&1"
+          when Proc     then @output.call
+          else ''
+        end
+      end
+
+    protected
+
+      def stdout
+        return unless @output.has_key?(:standard)
+        @output[:standard].nil? ? '/dev/null' : @output[:standard]
+      end
+
+      def stderr
+        return unless @output.has_key?(:error)
+        @output[:error].nil? ? '/dev/null' : @output[:error]
+      end
+
+      def redirect_from_hash
+        case
+          when stdout == '/dev/null' && stderr == '/dev/null'
+            "> /dev/null 2>&1"
+          when stdout && stderr == '/dev/null'
+            ">> #{stdout} 2> /dev/null"
+          when stdout && stderr
+            ">> #{stdout} 2>> #{stderr}"
+          when stderr == '/dev/null'
+            "2> /dev/null"
+          when stderr
+            "2>> #{stderr}"
+          when stdout == '/dev/null'
+            "> /dev/null"
+          when stdout
+            ">> #{stdout}"
+          else
+            ''
+        end
+      end
+
+      def redirect_from_string
+        ">> #{@output} 2>&1"
+      end
+    end
+  end
+end

data/lib/whenever_systemd/setup.rb

@@ -0,0 +1,30 @@
+# Environment variable defaults to RAILS_ENV
+set :environment_variable, "RAILS_ENV"
+# Environment defaults to production
+set :environment, "production"
+# Path defaults to the directory `whenever` was run from
+set :path, WheneverSystemd.path
+
+# All jobs are wrapped in this template.
+# http://blog.scoutapp.com/articles/2010/09/07/rvm-and-cron-in-production
+set :job_template, "/bin/bash -l -c ':job'"
+
+set :prefix, "myproject"
+set :timer,   { accuracy_sec: "1m" }
+set :install, { wanted_by: "timers.target" }
+
+set :runner_command, case
+  when WheneverSystemd.bin_rails?
+    "bin/rails runner"
+  when WheneverSystemd.script_rails?
+    "script/rails runner"
+  else
+    "script/runner"
+  end
+
+set :bundle_command, WheneverSystemd.bundler? ? "bundle exec" : ""
+
+job_type :command, ":task :output"
+job_type :rake,    "cd :path && :environment_variable=:environment :bundle_command rake :task --silent :output"
+job_type :script,  "cd :path && :environment_variable=:environment :bundle_command script/:task :output"
+job_type :runner,  "cd :path && :bundle_command :runner_command -e :environment ':task' :output"

data/lib/whenever_systemd/version.rb

@@ -0,0 +1,3 @@
+module WheneverSystemd
+  VERSION = '0.0.2'
+end

data/lib/whenever_systemd.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'whenever_systemd/job_list'
+require 'whenever_systemd/job'
+require 'whenever_systemd/command_line'
+require 'whenever_systemd/output_redirection'
+require 'whenever_systemd/os'
+
+module WheneverSystemd
+  DEFAULT_INSTALL_PATH = "/etc/systemd/system"
+
+  def self.cron(options)
+    JobList.new(options).dry_units(options[:install_path])
+  end
+
+  def self.path
+    Dir.pwd
+  end
+
+  def self.bin_rails?
+    File.exist?(File.join(path, 'bin', 'rails'))
+  end
+
+  def self.script_rails?
+    File.exist?(File.join(path, 'script', 'rails'))
+  end
+
+  def self.bundler?
+    File.exist?(File.join(path, 'Gemfile'))
+  end
+end

data/whenever_systemd.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "whenever_systemd/version"
+
+Gem::Specification.new do |s|
+  s.name        = "whenever_systemd"
+  s.version     = WheneverSystemd::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Javan Makhmali", "Anton Semenov"]
+  s.email       = ["javan@javan.us", "anton.estum@gmail.com"]
+  s.license     = "MIT"
+  s.homepage    = "https://github.com/estum/whenever"
+  s.summary     = %q{Systemd Timers in ruby.}
+  s.description = %q{Clean ruby syntax for writing and deploying systemd timers.}
+  s.files         = `git ls-files`.split("\n")
+  # s.test_files    = `git ls-files -- test/{functional,unit}/*`.split("\n")
+  s.executables   = ["whenever_systemd", "wheneverize"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 2.6"
+
+  s.add_dependency "activesupport", ">= 5.2"
+  s.add_development_dependency "bundler"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: whenever_systemd
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Javan Makhmali
+- Anton Semenov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: Clean ruby syntax for writing and deploying systemd timers.
+email:
+- javan@javan.us
+- anton.estum@gmail.com
+executables:
+- whenever_systemd
+- wheneverize
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Appraisals
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/whenever_systemd
+- bin/wheneverize
+- gemfiles/activesupport5.2.gemfile
+- lib/whenever_systemd.rb
+- lib/whenever_systemd/command_line.rb
+- lib/whenever_systemd/formatters.rb
+- lib/whenever_systemd/job.rb
+- lib/whenever_systemd/job_list.rb
+- lib/whenever_systemd/os.rb
+- lib/whenever_systemd/output_redirection.rb
+- lib/whenever_systemd/setup.rb
+- lib/whenever_systemd/version.rb
+- whenever_systemd.gemspec
+homepage: https://github.com/estum/whenever
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Systemd Timers in ruby.
+test_files: []