cron-kubernetes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f95641f4e595e197c2205b213097349df8b5f93c4f4c6556416f66bb6c1dd636
+  data.tar.gz: 3fb3993388b2f631c1b73e297a18340b45c197368a24486b7b5f3ca7cb7395bc
+SHA512:
+  metadata.gz: 128dc9682185ff67c49804d099a05056f6403ef4f25ad6161401d8fbf10881b325e141b2dd631445db2570e67c8ba499fb05eef433372e1feedc08a813c4f03e
+  data.tar.gz: 267f422c41cceee4a2bef3293918504322c6f468573eb4158898c71027b3d6ee28973178021af25cc951f9b7d26606c12c9fc77e65a132ca442a6ca6bb506584

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,42 @@
+Documentation:
+  Exclude:
+    - "**/railtie.rb"
+    - "spec/**/*"
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Metrics/LineLength:
+  Max: 120
+Layout/AlignHash:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+Style/RaiseArgs:
+  EnforcedStyle: compact
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+Layout/IndentArray:
+  IndentationWidth: 4
+Layout/IndentHash:
+  IndentationWidth: 4
+Style/ConditionalAssignment:
+  EnforcedStyle: assign_inside_condition
+Layout/FirstParameterIndentation:
+  IndentationWidth: 4
+Layout/MultilineOperationIndentation:
+  IndentationWidth: 4
+  EnforcedStyle: indented
+Style/FormatStringToken:
+  EnforcedStyle: template
+Style/AsciiComments:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "*.gemspec"
+    - "spec/**/*"
+
+Layout/EmptyLinesAroundBlockBody:
+  Exclude:
+    - "spec/**/*"

data/.ruby-gemset

@@ -0,0 +1 @@
+cron-kubernetes-ruby

data/.ruby-version

@@ -0,0 +1 @@
+2.5.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+- Initial Release

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jeremy Wadsack
+
+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,197 @@
+# CronKubernetes
+
+Configue and deploy Kubernetes [CronJobs](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/) 
+from ruby. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "cron-kubernetes"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cron_kubernetes
+
+## Configuration
+
+You can configure global settings for your cron jobs. Add a file to your source like the example
+below. If you are using Rails, you can add this to something like `config/initializers/cron_kuberentes.rb`.
+
+You _must_ configure the `identifier` and `manifest` settings. The other settings are optional
+and default values are shown below.
+
+```ruby
+CronKubernetes.configuration do |config|
+  # Required
+  config.identifier   = "my-application"
+  config.manifest     = YAML.load_file(File.join(Rails.root, "deploy", "kubernetes-job.yml"))
+
+  # Optional
+  config.output       = nil
+  config.job_template = %w[/bin/bash -l -c :job]
+end
+```
+
+### `identifier`
+Provide an identifier for this schedule. For example, you might use your application name.
+This is used by `CronKubernetes` to know which CronJobs are associated with this schedule
+so you should make sure it's unique within your cluster.
+
+`identifier` must be valid for a Kubernetes resource name and label value. Specifically,
+lowercase alphanumeric characters (`[a-z0-9A-Z]`), `-`, and `.`, and 63 characters or less.
+
+### `manifest`
+
+This is a Kubernetes Job manifest used as the job template within the Kubernetes 
+CronJob. That is, this is the job that's started at the specified schedule. For 
+example:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: scheduled-job
+spec:
+  template:
+    metadata:
+      name: scheduled-job
+    spec:
+      containers:
+      - name: my-shell
+        image: ubuntu
+      restartPolicy: OnFailure
+```
+
+In the example above we show the manifest loading a file, just to make it
+simple. But you could also read use a HEREDOC, parse a template and insert
+values, or anything else you want to do in the method, as long as you return
+a valid Kubernetes Job manifest as a `Hash`.
+
+When the job is run, the default command in the Docker instance is replaced with
+the command specified in the cron schedule (see below). The command is run on the 
+first container in the pod.
+
+### `output`
+
+By default no redirection is done; cron behaves as normal. If you would like you 
+can specify an option here to redirect as you would on a shell command. For example,
+`"2>&1` to collect STDERR in STDOUT or `>> /var/log/task.log` to append to a log file.
+
+### `job_template`
+
+This is a template that we use to execute your rake, rails runner, or shell command
+in the container. The default template executes it in a login shell so that environment
+variables (and profile) are loaded. 
+
+You can modify this. The value should be an array with a command and arguments that will
+replace both `ENTRYPOINT` and `CMD` in the Docker image. See
+[Define a Command and Arguments for a Container](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/)
+for a discussion of how `command` works in Kubernetes.
+
+## Usage
+
+### Create a Schedule
+Add a file to your source that defines the scheduled tasks. If you are using Rails, you could 
+put this in `config/initializers/cron_kuberentes.rb`. Or, if you want to make it work like the
+`whenever` gem you could add these lines to `config/schedule.rb` and then `require` that from your
+initializer.
+
+```ruby
+CronKubernetes.schedule do
+  command "ls -l", schedule: "0 0 1 1 *"
+  rake "audit:state", schedule: "0 20 1 * *", name: "audit-state"
+  runner "CleanSweeper.run", schedule: "30 3 * * *"
+end
+```
+
+For all jobs the command with change directories to either `Rails.root` if Rails is installed
+or the current working directory. These are evaluated when the scheduled tasks are loaded.
+
+For all jobs you may provide a `name` to name, which will be used with the `identifier` to name the
+CronJob. If you do not provide a name `CronKubernetes` will try to figure one out from the job and
+pod templates plus a hash of the schedule and command.
+
+#### Shell Commands
+
+A `command` runs any arbitrary shell command on a schedule. The first argument is the command to run.
+
+
+#### Rake Tasks
+
+A `rake` call runs a `rake` task on the schedule. Rake and Bundler must be installed and on the path 
+in the container The command it executes is `bundle exec rake ...`. 
+
+#### Runners
+
+A `runner` runs arbitrary ruby code under rails. Rails must be installed at `bin/rails` from the 
+working folder. The command it executes is `bin/rails runner '...'`.
+
+### Update Your Cluster
+
+Once you have configuration and cluster, then you can run the `cron_kubernetes` command
+to update your cluster. 
+
+```bash
+cron_kubernetes --configuration config/initializers/cron_kubernetes.rb --schedule config/schedule.rb
+```
+
+The command will read the provided configuration and current schedule, compare to any 
+CronJobs already in your cluster for this project (base on the `identifier`) and then 
+add/remove/update the CronJobs to bring match the schedule.
+
+You can provide either `--configuration` or `--schedule`, as long as between the files you have 
+loaded both a configuration and a schedule. For example, if they are in the same file, you would
+just pass a single value:
+
+```bash
+cron_kubernetes --schedule schedule.rb
+``` 
+
+If you are running in a Rails application where the initializers are auto-loaded, and your 
+schedule is defined in (or in a file required by) your initializer, you could run this within
+your Rails environment:
+
+```bash
+bin/rails runner cron_kubernetes
+``` 
+
+## To Do
+- In place of `schedule`, support `every`/`at` syntax:
+  ```
+  every: :minute, :hour, :day, :month, :year
+         3.minutes, 1.hour, 1.day, 1.week, 1.month, 1.year
+  at: "[H]H:mm[am|pm]"
+  ```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version, update the version number in `lib/cron_kubernets/version.rb` and the `CHANGELOG.md`, 
+and then run `bundle exec rake release`, which will create a git tag for the version, 
+push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/keylimetoolbox/cron-kubernetes.
+
+## Acknowledgments
+
+We have used the [`whenever` gem](https://github.com/javan/whenever) for years and we love it. 
+Much of the ideas for scheduling here were inspired by the great work that @javan and team 
+have put into that gem.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "bundler/audit/task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+Bundler::Audit::Task.new
+
+# Remove default and replace with a series of test tasks
+task default: []
+Rake::Task[:default].clear
+
+task default: %w[spec rubocop bundle:audit]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "cron_kubernetes"
+
+# 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(__FILE__)

data/bin/cron_kubernetes

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "cron_kubernetes"
+require "optparse"
+
+# Support looking up Google Default Application Credentials, if the gem is installed
+begin
+  require "googleauth"
+rescue LoadError
+  nil
+end
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: cron_kubernetes [options]"
+  opts.on("-c", "--configuration [file]", "Location of your configuration file") do |file|
+    require File.join(Dir.pwd, file) if file
+  end
+  opts.on("-c", "--schedule [file]", "Location of your schedule file") do |file|
+    require File.join(Dir.pwd, file) if file
+  end
+
+  opts.on("-v", "--version") do
+    puts "CronKubernetes v#{CronKubernetes::VERSION}"
+    exit(0)
+  end
+end.parse!
+
+CronKubernetes::CronTab.new.update

data/bin/setup

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

data/cron-kubernetes.gemspec

@@ -0,0 +1,38 @@
+
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cron_kubernetes/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cron-kubernetes"
+  spec.version       = CronKubernetes::VERSION
+  spec.authors       = ["Jeremy Wadsack"]
+  spec.email         = ["jeremy.wadsack@gmail.com"]
+
+  spec.summary       = "Configure and deploy Kubernetes CronJobs from ruby."
+  spec.description   = "Configure and deploy Kubernetes CronJobs from ruby with a single schedule."
+  spec.homepage      = "https://github.com/keylimetoolbox/cron-kubernetes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.bindir = "bin"
+  spec.executables << "cron_kubernetes"
+
+  spec.add_dependency "kubeclient", "~> 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler-audit", "~> 0"
+  spec.add_development_dependency "mocha", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 12.3"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rubocop", "~> 0.52", ">= 0.52.1"
+
+  # For connecting to a GKE cluster in development/test
+  spec.add_development_dependency "googleauth"
+end

data/lib/cron-kubernetes.rb

@@ -0,0 +1 @@
+require "cron_kubernetes"

data/lib/cron_kubernetes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "cron_kubernetes/configurable"
+require "cron_kubernetes/cron_job"
+require "cron_kubernetes/cron_tab"
+require "cron_kubernetes/kubeclient_context"
+require "cron_kubernetes/kubernetes_client"
+require "cron_kubernetes/scheduler"
+require "cron_kubernetes/version"
+
+# Configure and deploy Kubernetes CronJobs from ruby
+module CronKubernetes
+  extend Configurable
+
+  # Provide a CronJob manifest as a Hash
+  define_setting :manifest
+
+  # Provide shell output redirection (e.g. "2>&1" or ">> log")
+  define_setting :output
+
+  # For RVM support, and to load PATH and such, jobs are run through a bash shell.
+  # You can alter this with your own template, add `:job` where the job should go.
+  # Note that the job will be treated as a single shell argument or command.
+  define_setting :job_template, %w[/bin/bash -l -c :job]
+
+  # Provide an identifier for this schedule (e.g. your application name)
+  define_setting :identifier
+
+  class << self
+    def schedule(&block)
+      CronKubernetes::Scheduler.instance.instance_eval(&block)
+    end
+  end
+end

data/lib/cron_kubernetes/configurable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CronKubernetes
+  # Provides configuration settings, with default values, for the gem.
+  module Configurable
+    def configuration
+      yield self
+    end
+
+    # Define a configuration setting and its default value.
+    #
+    # name:    The name of the setting.
+    # default: A default value for the setting. (Optional)
+    def define_setting(name, default = nil)
+      class_variable_set("@@#{name}", default)
+
+      define_class_method "#{name}=" do |value|
+        class_variable_set("@@#{name}", value)
+      end
+
+      define_class_method name do
+        class_variable_get("@@#{name}")
+      end
+    end
+
+    private
+
+    def define_class_method(name, &block)
+      (class << self; self; end).instance_eval do
+        define_method(name, &block)
+      end
+    end
+  end
+end

data/lib/cron_kubernetes/cron_job.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module CronKubernetes
+  # A single job to run on a given schedule.
+  class CronJob
+    attr_accessor :schedule, :command, :job_manifest, :name, :identifier
+
+    def initialize(schedule: nil, command: nil, job_manifest: nil, name: nil, identifier: nil)
+      @schedule     = schedule
+      @command      = command
+      @job_manifest = job_manifest
+      @name         = name
+      @identifier   = identifier
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def cron_job_manifest
+      {
+          "apiVersion" => "batch/v1beta1",
+          "kind"       => "CronJob",
+          "metadata"   => {
+              "name"      => "#{identifier}-#{cron_job_name}",
+              "namespace" => namespace,
+              "labels"    => {"cron-kubernetes-identifier" => identifier}
+          },
+          "spec"       => {
+              "schedule"    => schedule,
+              "jobTemplate" => {
+                  "metadata" => job_metadata,
+                  "spec"     => job_spec
+              }
+          }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    def namespace
+      return job_manifest["metadata"]["namespace"] if job_manifest["metadata"]
+      "default"
+    end
+
+    def job_spec
+      spec = job_manifest["spec"].dup
+      first_container = spec["template"]["spec"]["containers"][0]
+      first_container["command"] = command
+      spec
+    end
+
+    def job_metadata
+      job_manifest["metadata"]
+    end
+
+    def cron_job_name
+      return name if name
+      return job_hash(job_manifest["metadata"]["name"]) if job_manifest["metadata"]
+      pod_template_name
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def pod_template_name
+      return nil unless job_manifest["spec"] &&
+            job_manifest["spec"]["template"] &&
+            job_manifest["spec"]["template"]["metadata"]
+      job_hash(job_manifest["spec"]["template"]["metadata"]["name"])
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def job_hash(name)
+      "#{name}-#{Digest::SHA1.hexdigest(schedule + command.join)[0..7]}"
+    end
+  end
+end

data/lib/cron_kubernetes/cron_tab.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module CronKubernetes
+  # The "table" of Kubernetes CronJobs that we manage in the cluster.
+  class CronTab
+    attr_reader :client
+    private :client
+
+    def initialize
+      @client = CronKubernetes::KubernetesClient.new.batch_beta1_client
+    end
+
+    # "Apply" the new configuration
+    #   - remove from cluster any cron_jobs that are no longer in the schedule
+    #   - add new jobs
+    #   - update cron_jobs that exist (deleting a cron_job deletes the job and pod)
+    def update(schedule = nil)
+      schedule ||= CronKubernetes::Scheduler.instance.schedule
+      add, change, remove = diff_schedules(schedule, current_cron_jobs)
+      remove.each { |job| remove_cron_job(job) }
+      add.each { |job| add_cron_job(job) }
+      change.each { |job| update_cron_job(job) }
+    end
+
+    private
+
+    # Define a label for our jobs based on an identifier
+    def label_selector
+      {"cron-kubernetes-identifier" => CronKubernetes.identifier}
+    end
+
+    # Find all k8s CronJobs by our label for the identifier
+    def current_cron_jobs
+      client.get_cron_jobs(label_selector)
+    end
+
+    def diff_schedules(new, existing)
+      new_index = index_cron_jobs(new)
+      existing_index = index_kubernetes_cron_jobs(existing)
+      add_keys    = new_index.keys - existing_index.keys
+      remove_keys = existing_index.keys - new_index.keys
+      change_keys = new_index.keys & existing_index.keys
+
+      [
+          new_index.values_at(*add_keys),
+          new_index.values_at(*change_keys),
+          existing_index.values_at(*remove_keys)
+      ]
+    end
+
+    # Remove a Kubeclient::Resource::CronJob from the Kubernetes cluster
+    def remove_cron_job(job)
+      client.delete_cron_job(job.metadata.name, job.metadata.namespace)
+    end
+
+    # Add a CronKubernetes::CronJob to the Kubernetes cluster
+    def add_cron_job(job)
+      client.create_cron_job(Kubeclient::Resource.new(job.cron_job_manifest))
+    end
+
+    def update_cron_job(job)
+      client.update_cron_job(Kubeclient::Resource.new(job.cron_job_manifest))
+    end
+
+    def index_cron_jobs(jobs)
+      jobs.map { |job| ["#{job.identifier}-#{job.name}", job] }.to_h
+    end
+
+    def index_kubernetes_cron_jobs(jobs)
+      jobs.map { |job| [job.metadata.name, job] }.to_h
+    end
+  end
+end

data/lib/cron_kubernetes/kubeclient_context.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "kubeclient"
+
+module CronKubernetes
+  # Create a context for `Kubeclient` depending on the environment.
+  class KubeclientContext
+    class << self
+      def context
+        # TODO: Add ability to load this from config
+
+        if File.exist?("/var/run/secrets/kubernetes.io/serviceaccount/token")
+          # When running in k8s cluster, use the service account secret token and ca bundle
+          well_known_context
+        elsif File.exist?(kubeconfig)
+          # When running in development, use the config file for `kubectl` and default application credentials
+          kubectl_context
+        end
+      end
+
+      private
+
+      def well_known_context
+        Kubeclient::Config::Context.new(
+            "https://kubernetes",
+            "v1",
+            {ca_file: "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"},
+            bearer_token_file: "/var/run/secrets/kubernetes.io/serviceaccount/token"
+        )
+      end
+
+      def kubectl_context
+        config = Kubeclient::Config.read(kubeconfig)
+        auth_options = config.context.auth_options
+
+        auth_options = google_default_application_credentials(config) if auth_options.empty?
+
+        Kubeclient::Config::Context.new(
+            config.context.api_endpoint,
+            config.context.api_version,
+            config.context.ssl_options,
+            auth_options
+        )
+      end
+
+      def kubeconfig
+        File.join(ENV["HOME"], ".kube", "config")
+      end
+
+      # TODO: Move this logic to kubeclient. See abonas/kubeclient#213
+      def google_default_application_credentials(config)
+        return unless defined?(Google) && defined?(Google::Auth)
+
+        _cluster, user = config.send(:fetch_context, config.instance_variable_get(:@kcfg)["current-context"])
+        return {} unless user["auth-provider"] && user["auth-provider"]["name"] == "gcp"
+
+        {bearer_token: new_google_token}
+      end
+
+      def new_google_token
+        scopes = ["https://www.googleapis.com/auth/cloud-platform"]
+        authorization = Google::Auth.get_application_default(scopes)
+        authorization.apply({})
+        authorization.access_token
+      end
+    end
+  end
+end

data/lib/cron_kubernetes/kubernetes_client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CronKubernetes
+  # Encapsulate access to Kubernetes API for different API versions.
+  class KubernetesClient
+    def batch_beta1_client
+      @batch_beta1_client ||= client("/apis/batch", "v1beta1")
+    end
+
+    private
+
+    def client(scope, version = nil)
+      context = KubeclientContext.context
+      return unless context
+
+      Kubeclient::Client.new(
+          context.api_endpoint + scope,
+          version || context.api_version,
+          ssl_options:  context.ssl_options,
+          auth_options: context.auth_options
+      )
+    end
+  end
+end

data/lib/cron_kubernetes/scheduler.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module CronKubernetes
+  # A singleton that creates and holds the scheduled commands.
+  class Scheduler
+    include Singleton
+    attr_reader :schedule
+
+    def initialize
+      @schedule   = []
+      @identifier = CronKubernetes.identifier
+    end
+
+    def rake(task, schedule:, name: nil)
+      rake_command = "bundle exec rake #{task} --silent"
+      rake_command = "RAILS_ENV=#{rails_env} #{rake_command}" if rails_env
+      @schedule << new_cron_job(schedule, rake_command, name)
+    end
+
+    def runner(ruby_command, schedule:, name: nil)
+      env = nil
+      env = "-e #{rails_env} " if rails_env
+      runner_command = "bin/rails runner #{env}'#{ruby_command}'"
+      @schedule << new_cron_job(schedule, runner_command, name)
+    end
+
+    def command(command, schedule:, name: nil)
+      @schedule << new_cron_job(schedule, command, name)
+    end
+
+    private
+
+    def make_command(command)
+      CronKubernetes.job_template.map do |arg|
+        if arg == ":job"
+          "cd #{root} && #{command} #{CronKubernetes.output}"
+        else
+          arg
+        end
+      end
+    end
+
+    def new_cron_job(schedule, command, name)
+      CronJob.new(
+          schedule:     schedule,
+          command:      make_command(command),
+          job_manifest: CronKubernetes.manifest,
+          name:         name,
+          identifier:   @identifier
+      )
+    end
+
+    def rails_env
+      ENV["RAILS_ENV"]
+    end
+
+    def root
+      return Rails.root if defined? Rails
+      Dir.pwd
+    end
+  end
+end

data/lib/cron_kubernetes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CronKubernetes
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: cron-kubernetes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy Wadsack
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  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'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  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: Configure and deploy Kubernetes CronJobs from ruby with a single schedule.
+email:
+- jeremy.wadsack@gmail.com
+executables:
+- cron_kubernetes
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/cron_kubernetes
+- bin/setup
+- cron-kubernetes.gemspec
+- lib/cron-kubernetes.rb
+- lib/cron_kubernetes.rb
+- lib/cron_kubernetes/configurable.rb
+- lib/cron_kubernetes/cron_job.rb
+- lib/cron_kubernetes/cron_tab.rb
+- lib/cron_kubernetes/kubeclient_context.rb
+- lib/cron_kubernetes/kubernetes_client.rb
+- lib/cron_kubernetes/scheduler.rb
+- lib/cron_kubernetes/version.rb
+homepage: https://github.com/keylimetoolbox/cron-kubernetes
+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: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: Configure and deploy Kubernetes CronJobs from ruby.
+test_files: []