cronicle 0.1.0

data/lib/cronicle/ext/hash_ext.rb

@@ -0,0 +1,8 @@
+class Hash
+  def assert_valid_keys(*valid_keys)
+    each_key do |k|
+      next if valid_keys.include?(k)
+      raise ArgumentError, "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+    end
+  end
+end

data/lib/cronicle/ext/sshkit_ext.rb

@@ -0,0 +1,147 @@
+SSHKit::Backend::Netssh.config.pty = true
+
+class SSHKit::Backend::Netssh
+  def sudo(command, *args)
+    opts = args.last.kind_of?(Hash) ? args.pop : {}
+
+    password = host.options[:sudo_password] || ''
+    password = Shellwords.shellescape(password)
+
+    with_sudo = [:echo, password, '|', :sudo, '-S']
+    with_sudo << '-u' << opts[:user] if opts[:user]
+    with_sudo.concat(args)
+
+    raise_on_non_zero_exit = opts.fetch(:raise_on_non_zero_exit, true)
+    retval = send(command, *with_sudo, :raise_on_non_zero_exit => raise_on_non_zero_exit)
+    Cronicle::Utils.remove_prompt!(retval) if retval.kind_of?(String)
+    retval
+  end
+
+  CRON_DIRS = %w(/var/spool/cron/crontabs /var/spool/cron)
+
+  def find_cron_dir
+    @cron_dir ||= CRON_DIRS.find do |path|
+      execute(:test, '-d', path, :raise_on_non_zero_exit => false)
+    end
+
+    unless @cron_dir
+      raise "Cannot find cron directory: #{CRON_DIRS.join(', ')}"
+    end
+
+    @cron_dir
+  end
+
+  def list_crontabs
+    cron_dir = find_cron_dir
+    @crontab_list ||= sudo(:capture, :find, cron_dir, '-type', :f, '-maxdepth', 1, '2> /dev/null',
+                        :raise_on_non_zero_exit => false).each_line.map(&:strip)
+  end
+
+  def fetch_crontabs
+    return @crontabs if @crontabs
+
+    @crontabs = {}
+
+    list_crontabs.each do |path|
+      user = File.basename(path)
+      crontab = sudo(:capture, :cat, path)
+      @crontabs[user] = crontab
+    end
+
+    @crontabs
+  end
+
+  def list_libexec_scripts
+    @libexec_scripts ||= capture(:find, libexec_dir, '-type', :f, '2> /dev/null',
+                           :raise_on_non_zero_exit => false).each_line.map(&:strip)
+  end
+
+  def fetch_libexec_scripts
+    script_contents = {}
+
+    list_libexec_scripts.each do |script|
+      script_contents[script] = crlf_to_lf(capture(:cat, script))
+    end
+
+    script_contents
+  end
+
+  def delete_cron_entry(user, name = nil)
+    sed_cmd = '/' + Cronicle::Utils.sed_escape(script_path(user, name)) + ' /d'
+    sed_cmd = Shellwords.shellescape(sed_cmd)
+
+    sudo(:execute, :sed, '-i', sed_cmd, user_crontab(user), :raise_on_non_zero_exit => false)
+  end
+
+  def add_cron_entry(user, name, schedule, temp_dir)
+    script = script_path(user, name)
+    temp_entry = [temp_dir, name + '.entry'].join('/')
+
+    cron_entry = "#{schedule}\\t#{script} 2>&1 | logger -t cronicle/#{user}/#{name}"
+    cron_entry = Shellwords.shellescape(cron_entry)
+    sudo(:execute, :echo, '-e', cron_entry, '>', temp_entry)
+
+    entry_cat = "cat #{temp_entry} >> #{user_crontab(user)}"
+    entry_cat = Shellwords.shellescape(entry_cat)
+    sudo(:execute, :bash, '-c', entry_cat)
+  end
+
+  def upload_script(temp_dir, name, content)
+    temp_script = [temp_dir, name].join
+    upload!(StringIO.new(content), temp_script)
+    execute(:chmod, 755, temp_script)
+    yield(temp_script)
+  end
+
+  def mktemp(user = nil)
+    temp_dir = capture(:mktemp, '-d', '/var/tmp/cronicle.XXXXXXXXXX')
+    block_args = [temp_dir]
+
+    begin
+      execute(:chmod, 755, temp_dir)
+
+      if user
+        user_temp_dir = [temp_dir, user].join('/')
+        execute(:mkdir, '-p', user_temp_dir)
+        execute(:chmod, 755, user_temp_dir)
+        block_args << user_temp_dir
+      end
+
+      yield(*block_args)
+    ensure
+      execute(:rm, '-rf', temp_dir, :raise_on_non_zero_exit => false) rescue nil
+    end
+  end
+
+  def libexec_dir
+    host.options.fetch(:libexec)
+  end
+
+  def user_libexec_dir(user)
+    [libexec_dir, user].join('/')
+  end
+
+  def user_crontab(user)
+    cron_dir = find_cron_dir
+    [cron_dir, user].join('/')
+  end
+
+  def script_path(user, name)
+    [libexec_dir, user, name].join('/')
+  end
+
+  def log_for_cronicle(level, message, opts = {})
+    opts = host.options.merge(opts)
+    Cronicle::Logger.log(level, message, opts)
+  end
+
+  private
+
+  def crlf_to_lf(str)
+    str.gsub("\r\n", "\n")
+  end
+end
+
+class SSHKit::Host
+  attr_reader :options
+end

data/lib/cronicle/ext/string_ext.rb

@@ -0,0 +1,11 @@
+class String
+  def undent
+    min_space_num = self.split("\n").delete_if {|s| s =~ /^\s*$/ }.map {|s| (s[/^\s+/] || '').length }.min
+
+    if min_space_num and min_space_num > 0
+      gsub(/^[ \t]{,#{min_space_num}}/, '')
+    else
+      self
+    end
+  end
+end

data/lib/cronicle/host_list.rb

@@ -0,0 +1,89 @@
+class Cronicle::HostList
+  def initialize(src, options = {})
+    @hosts = Set.new
+    @host_by_role = Hash.new {|h, k| h[k] = Set.new }
+
+    options.assert_valid_keys(:roles)
+    target_roles = Cronicle::Utils.regexp_union(options[:roles])
+
+    begin
+      host_list = JSON.parse(src)
+    rescue JSON::ParserError
+      host_list = {'servers' => {}}
+
+      src.split(/[,\s]+/).each do |host|
+        host.strip!
+        host_list['servers'][host] = [] unless host.empty?
+      end
+    end
+
+    host_list.assert_valid_keys('servers', 'roles')
+    servers = host_list['servers'] || {}
+    roles = host_list['roles'] || {}
+
+    unless roles.kind_of?(Hash)
+      raise TypeError, "wrong roles type #{roles.class} (expected Hash)"
+    end
+
+    initialize_servers(servers, target_roles)
+    initialize_roles(roles, target_roles)
+  end
+
+  def all
+    @hosts.to_a
+  end
+
+  def select(options = {})
+    options.assert_valid_keys(:servers, :roles)
+    target_servers, target_roles = options.values_at(:servers, :roles)
+
+    target_servers = Cronicle::Utils.regexp_union(target_servers)
+    target_roles = Cronicle::Utils.regexp_union(target_roles)
+
+    host_set = Set.new
+
+    @hosts.each do |host|
+      host_set << host if host =~ target_servers
+    end
+
+    @host_by_role.each do |role, hosts|
+      host_set.merge(hosts) if role =~ target_roles
+    end
+
+    host_set.to_a
+  end
+
+  private
+
+  def initialize_servers(servers, target_roles)
+    unless servers.kind_of?(Hash)
+      servers_hash = {}
+
+      Array(servers).each do |host|
+        servers_hash[host.to_s] = []
+      end
+
+      servers = servers_hash
+    end
+
+    servers.each do |host, roles|
+      roles = Array(roles).map(&:to_s)
+
+      if target_roles.nil? or roles.any? {|r| r =~ target_servers }
+        @hosts << host
+        roles.each {|r| @host_by_role[r] << host }
+      end
+    end
+  end
+
+  def initialize_roles(roles, target_roles)
+    roles.each do |role, hosts|
+      hosts = Array(hosts).map(&:to_s)
+
+      if target_roles.nil? or roles.any? {|r| r =~ target_servers }
+        @hosts.merge(hosts)
+        @host_by_role[role].merge(hosts)
+      end
+    end
+  end
+end

data/lib/cronicle/logger.rb

@@ -0,0 +1,92 @@
+class Cronicle::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = INFO
+  end
+
+  def set_debug(value)
+    if value
+      self.level = DEBUG
+      SSHKit.config.output_verbosity = :debug
+    else
+      self.level = INFO
+      SSHKit.config.output_verbosity = :warn
+    end
+  end
+
+  class << self
+    def log(level, message, opts = {})
+      message = "#{level.to_s.downcase}: #{message}" unless level == :info
+      message << ' (dry-run)' if opts[:dry_run]
+      message.gsub!(/\s+\z/, '')
+      message = message.send(opts[:color]) if opts[:color]
+
+      job_info = ''
+
+      if opts[:job]
+        job_info << opts[:job]
+      end
+
+      host_user = [:host, :user].map {|key|
+        value = opts[key]
+        value = Cronicle::Utils.short_hostname(value) if key == :host
+        value
+      }.compact
+
+      unless host_user.empty?
+        job_info << ' on ' unless job_info.empty?
+        job_info << host_user.join('/')
+      end
+
+      unless job_info.empty?
+        job_info = "#{job_info}>".light_black
+        message = "#{job_info} #{message}"
+      end
+
+      logger = opts[:logger] || Cronicle::Logger.instance
+      logger.send(level, message)
+    end
+  end # of class methods
+
+  # XXX:
+  module Helper
+    def log(level, message, opts = {})
+      opts = (@options || {}).merge(opts)
+      Cronicle::Logger.log(level, message, opts)
+    end
+  end
+
+  class SSHKitIO
+    def initialize(io = $stdout)
+      @io = io
+    end
+
+    def <<(obj)
+      @io << mask_password(obj)
+    end
+
+    private
+
+    MASK_REGEXP = /\becho\s+([^|]+)\s+\|\s+sudo\s+-S\s+/
+    MASK = 'XXXXXXXX'
+
+    def mask_password(obj)
+      if obj.kind_of?(String) and obj =~ MASK_REGEXP
+        password = $1
+        obj.sub(password, MASK)
+      else
+        obj
+      end
+    end
+  end
+end
+
+SSHKit.config.output = SSHKit::Formatter::Pretty.new(Cronicle::Logger::SSHKitIO.new)
+SSHKit.config.output_verbosity = :warn

data/lib/cronicle/utils.rb

@@ -0,0 +1,43 @@
+class Cronicle::Utils
+  class << self
+    def regexp_union(list)
+      return nil if list.nil?
+      return list if list.kind_of?(Regexp)
+
+      list = Array(list)
+      return nil if list.empty?
+
+      Regexp.union(list.map {|str_or_reg|
+        if str_or_reg.kind_of?(Regexp)
+          str_or_reg
+        else
+          /\A#{str_or_reg}\z/
+        end
+      })
+    end
+
+    IPADDR_REGEXP = /\A\d+(?:\.\d+){3}\z/
+
+    def short_hostname(hostname)
+      if hostname =~ IPADDR_REGEXP
+        hostname
+      else
+        hostname.split('.').first
+      end
+    end
+
+    def sed_escape(cmd)
+      cmd.gsub('/', '\\/')
+    end
+
+    def remove_prompt!(str)
+      str.sub!(/\A[^:]*:\s*/, '')
+    end
+
+    def diff(file1, file2)
+      file1 = file1.chomp + "\n"
+      file2 = file2.chomp + "\n"
+      Diffy::Diff.new(file1, file2).to_s(:text)
+    end
+  end # of class methods
+end

data/lib/cronicle/version.rb

@@ -0,0 +1,3 @@
+module Cronicle
+  VERSION = '0.1.0'
+end

data/spec/cronicle_create_spec.rb

@@ -0,0 +1,295 @@
+describe 'Cronicle::Client#apply (create)' do
+  context 'when empty cron' do
+    let(:jobfile) do
+      <<-RUBY.undent
+        on servers: /.*/ do
+          job :foo, user: :root, schedule: '1 2 * * *' do
+            puts `uname`
+            puts `whoami`
+          end
+        end
+
+        on servers: /.*/ do
+          job :bar, user: :root, schedule: :@hourly, content: <<-SH.undent
+            #!/bin/sh
+            echo hello
+          SH
+        end
+
+        on servers: /amazon_linux/ do
+          job :foo, user: 'ec2-user', schedule: '1 * * * *' do
+            puts 100
+          end
+        end
+
+        on servers: /ubuntu/ do
+          job :foo, user: :ubuntu, schedule: :@daily do
+            puts 200
+          end
+        end
+      RUBY
+    end
+
+    let(:amzn_crontab) do
+      {
+        "/var/spool/cron/ec2-user" =>
+"1 * * * *\t/var/lib/cronicle/libexec/ec2-user/foo 2>&1 | logger -t cronicle/ec2-user/foo
+",
+        "/var/spool/cron/root" =>
+"1 2 * * *\t/var/lib/cronicle/libexec/root/foo 2>&1 | logger -t cronicle/root/foo
+@hourly\t/var/lib/cronicle/libexec/root/bar 2>&1 | logger -t cronicle/root/bar
+"
+      }
+    end
+
+    let(:ubuntu_crontab) do
+      {
+        "/var/spool/cron/crontabs/root" =>
+"1 2 * * *\t/var/lib/cronicle/libexec/root/foo 2>&1 | logger -t cronicle/root/foo
+@hourly\t/var/lib/cronicle/libexec/root/bar 2>&1 | logger -t cronicle/root/bar
+",
+        "/var/spool/cron/crontabs/ubuntu" =>
+"@daily\t/var/lib/cronicle/libexec/ubuntu/foo 2>&1 | logger -t cronicle/ubuntu/foo
+"
+      }
+    end
+
+    before do
+      cronicle(:apply) { jobfile }
+    end
+
+    it do
+      on :amazon_linux do
+        expect(get_uname).to match /amzn/
+        expect(get_crontabs).to eq amzn_crontab
+
+        expect(get_file('/var/lib/cronicle/libexec/root/foo')).to eq <<-EOS.undent
+          #!/usr/bin/env ruby
+          puts `uname`
+          puts `whoami`
+        EOS
+
+        expect(get_file('/var/lib/cronicle/libexec/root/bar')).to eq <<-EOS.undent
+          #!/bin/sh
+          echo hello
+        EOS
+
+        expect(get_file('/var/lib/cronicle/libexec/ec2-user/foo')).to eq <<-EOS.undent
+          #!/usr/bin/env ruby
+          puts 100
+        EOS
+      end
+    end
+
+    it do
+      on :ubuntu do
+        expect(get_uname).to match /Ubuntu/
+        expect(get_crontabs).to eq ubuntu_crontab
+
+        expect(get_file('/var/lib/cronicle/libexec/root/foo')).to eq <<-EOS.undent
+          #!/usr/bin/env ruby
+          puts `uname`
+          puts `whoami`
+        EOS
+
+        expect(get_file('/var/lib/cronicle/libexec/root/bar')).to eq <<-EOS.undent
+          #!/bin/sh
+          echo hello
+        EOS
+
+        expect(get_file('/var/lib/cronicle/libexec/ubuntu/foo')).to eq <<-EOS.undent
+          #!/usr/bin/env ruby
+          puts 200
+        EOS
+      end
+    end
+  end
+
+  context 'when default cron' do
+    before do
+      on TARGET_HOSTS do |ssh_options|
+        user = ssh_options[:user]
+
+        set_crontab user, <<-CRON.undent
+          FOO=bar
+          ZOO=baz
+          1 1 1 1 1 echo #{user} > /dev/null
+        CRON
+
+        set_crontab :root, <<-CRON.undent
+          FOO=bar
+          ZOO=baz
+          1 1 1 1 1 echo root > /dev/null
+        CRON
+      end
+    end
+
+    let(:jobfile) do
+      <<-RUBY.undent
+        on servers: /.*/ do
+          job :foo, user: :root, schedule: '1 2 * * *' do
+            puts `uname`
+            puts `whoami`
+          end
+        end
+
+        on servers: /.*/ do
+          job :bar, user: :root, schedule: :@hourly, content: <<-SH.undent
+            #!/bin/sh
+            echo hello
+          SH
+        end
+
+        on servers: /amazon_linux/ do
+          job :foo, user: 'ec2-user', schedule: '1 * * * *' do
+            puts 100
+          end
+        end
+
+        on servers: /ubuntu/ do
+          job :foo, user: :ubuntu, schedule: :@daily do
+            puts 200
+          end
+        end
+      RUBY
+    end
+
+    context 'when apply' do
+      let(:amzn_crontab) do
+        {
+          "/var/spool/cron/ec2-user" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo ec2-user > /dev/null
+1 * * * *\t/var/lib/cronicle/libexec/ec2-user/foo 2>&1 | logger -t cronicle/ec2-user/foo
+",
+        "/var/spool/cron/root" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo root > /dev/null
+1 2 * * *\t/var/lib/cronicle/libexec/root/foo 2>&1 | logger -t cronicle/root/foo
+@hourly\t/var/lib/cronicle/libexec/root/bar 2>&1 | logger -t cronicle/root/bar
+"
+        }
+      end
+
+      let(:ubuntu_crontab) do
+        {
+          "/var/spool/cron/crontabs/root" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo root > /dev/null
+1 2 * * *\t/var/lib/cronicle/libexec/root/foo 2>&1 | logger -t cronicle/root/foo
+@hourly\t/var/lib/cronicle/libexec/root/bar 2>&1 | logger -t cronicle/root/bar
+",
+        "/var/spool/cron/crontabs/ubuntu" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo ubuntu > /dev/null
+@daily\t/var/lib/cronicle/libexec/ubuntu/foo 2>&1 | logger -t cronicle/ubuntu/foo
+"
+        }
+      end
+
+      before do
+        cronicle(:apply) { jobfile }
+      end
+
+      it do
+        on :amazon_linux do
+          expect(get_uname).to match /amzn/
+          expect(get_crontabs).to eq amzn_crontab
+
+          expect(get_file('/var/lib/cronicle/libexec/root/foo')).to eq <<-EOS.undent
+            #!/usr/bin/env ruby
+            puts `uname`
+            puts `whoami`
+          EOS
+
+          expect(get_file('/var/lib/cronicle/libexec/root/bar')).to eq <<-EOS.undent
+            #!/bin/sh
+            echo hello
+          EOS
+
+          expect(get_file('/var/lib/cronicle/libexec/ec2-user/foo')).to eq <<-EOS.undent
+            #!/usr/bin/env ruby
+            puts 100
+          EOS
+        end
+      end
+
+      it do
+        on :ubuntu do
+          expect(get_uname).to match /Ubuntu/
+          expect(get_crontabs).to eq ubuntu_crontab
+
+          expect(get_file('/var/lib/cronicle/libexec/root/foo')).to eq <<-EOS.undent
+            #!/usr/bin/env ruby
+            puts `uname`
+            puts `whoami`
+          EOS
+
+          expect(get_file('/var/lib/cronicle/libexec/root/bar')).to eq <<-EOS.undent
+            #!/bin/sh
+            echo hello
+          EOS
+
+          expect(get_file('/var/lib/cronicle/libexec/ubuntu/foo')).to eq <<-EOS.undent
+            #!/usr/bin/env ruby
+            puts 200
+          EOS
+        end
+      end
+    end
+
+    context 'when apply (dry-run)' do
+      let(:amzn_crontab) do
+        {
+          "/var/spool/cron/ec2-user" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo ec2-user > /dev/null
+",
+        "/var/spool/cron/root" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo root > /dev/null
+"
+        }
+      end
+
+      let(:ubuntu_crontab) do
+        {
+          "/var/spool/cron/crontabs/root" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo root > /dev/null
+",
+        "/var/spool/cron/crontabs/ubuntu" =>
+"FOO=bar
+ZOO=baz
+1 1 1 1 1 echo ubuntu > /dev/null
+"
+        }
+      end
+
+      before do
+        cronicle(:apply, dry_run: true) { jobfile }
+      end
+
+      it do
+        on :amazon_linux do
+          expect(get_uname).to match /amzn/
+          expect(get_crontabs).to eq amzn_crontab
+        end
+      end
+
+      it do
+        on :ubuntu do
+          expect(get_uname).to match /Ubuntu/
+          expect(get_crontabs).to eq ubuntu_crontab
+        end
+      end
+    end
+  end
+end