seijaku 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 473323709a5634fbd29899d6745d1145f5bfbd69c073b94739aa988e6851f13e
-  data.tar.gz: 5ed3dd59fa73d5bcd30664b480d1c1dcef7b826447c9e2229ab90e0115c1de05
+  metadata.gz: 638106c6524b04b68139b67af16ff6b1f66d74fa82b05d15be1b2c26f42e5684
+  data.tar.gz: 40b3f7a10c0575df85225a04ebc040c5d6d09521ebc789148a6f888319e9ec31
 SHA512:
-  metadata.gz: 72e7fcf802e5e1ad2c9813eca4a7cf1f5e88db0d083ce29afb64e94c14453cbe0494f9f7bb71ebd5844b8d2ce947418b2d02e5099b476446505be2999c85cdc1
-  data.tar.gz: a5e9f5c1459a24fcb327d2d272589f84a3ec1eb323da7afe93e6f2840605e3f70d0c833cb706c21df60a0f384020991c34ed738d1009aff64e0e2cb8553be460
+  metadata.gz: 4387d2f340c6d3552f6ad91529ae5600e94ce1fd02e49556fef4e8bd1a125b4a078d5fcaca099a5ca766116db8481e08e1889214b92d8422bac1f14ed01ba646
+  data.tar.gz: 2bd4543e36d3ae4abbeaf8317995c2a689be7fd1ae0409f1b3ed34842ac58779802577399116608242979153d92f271df7db663aa999baa694ae1fbc3dd56c42

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.2.0] - 2023-12-12
+
+- SSH executor added with `ssh` YAML dictionnary and `host` Task support.
+- Documentation added in `./docs` directory
+
 ## [0.1.0] - 2023-12-11
 
 - Initial release

data/README.md

@@ -1,22 +1,32 @@
 # Seijaku
 
+[![Seijaku version](https://badge.fury.io/rb/seijaku.svg)](https://badge.fury.io/rb/seijaku)
+
 Seijaku is a program that allows you to execute shell commands listed in YAML payload files, ensuring that they are executed correctly.
+It includes a lightweight scheduler that will take care of executing payloads with specific delay between two executions.
 
 ## Concepts
 
 Payloads are YAML files that describe the various tasks Seijaku will have to perform (in order). Each task contains one or more steps.
 
-A step is a shell command to be executed. Seijaku currently supports the following shells: bash and sh.
+A step is a shell command to be executed. Seijaku currently supports the following shells: bash, sh and ssh.
 
 Each task can have "pre" and "post" tasks, for example to create and delete folders, or install and uninstall software needed to run a task.
 
 A step sometimes needs variables in order to be performed correctly: Seijaku supports the direct definition of variables or from an environment variable of the shell running Seijaku.
 
+A scheduler is a file listing payloads that must be executed with unique specifications: a name, a delay between two runs and the path to the concerned payload.
+
 ## Example
 
 ```yaml
 name: my payload
 
+ssh:
+  - host: my-host
+    user: user
+    port: 22
+
 variables:
   MY_VARIABLE: a static variable
   MY_ENV_VARIABLE: $MY_ENV_VARIABLE
@@ -37,6 +47,26 @@ tasks:
         soft_fail: true
     post:
       - sh: "do something after"
+  
+  - name: task with SSH executor
+    host: my-host
+    steps:
+      - ssh: echo "executed on host"
+```
+
+### Scheduler
+
+```yaml
+name: my-scheduler
+
+payloads:
+  - payload: ./test/my-payload.yaml
+    name: My test Payload
+    every: 3600				# executed every hour
+
+  - payload: ./test/another-payload.yaml
+    name: Another payload
+    every: 60				# executed every minute
 ```
 
 ## Installation
@@ -46,11 +76,16 @@ tasks:
 * Ruby 2.5+
 * Rubygem
 
-
 Install Seijaku using Gem:
 
 ```bash
 gem install seijaku
 ```
 
+## Usage
 
+```bash
+seijaku -h
+seijaku -f ./my-payload.yaml # one-time payload execution
+seijaku -s ./my-scheduler.yaml # recurrent payloads execution with delay
+```

data/bin/seijaku

@@ -19,6 +19,7 @@ module App
   opts = OptionParser.new
   opts.banner = "Seijaku: simply runs YAML tasks with shell"
   opts.on("-f", "--file FILE", "Payload file path") { |o| options[:payload] = o }
+  opts.on("-s", "--scheduler FILE", "Scheduler file") { |o| options[:scheduler] = o }
   opts.on("-h", "--help", "Shows help and exit") do
     puts opts
     exit(0)
@@ -26,17 +27,41 @@ module App
 
   opts.parse!
 
-  if options[:payload].nil?
+  if options[:payload].nil? and options[:scheduler].nil?
     puts opts
-    exit 0
+    puts "Either -f or -s must be set"
+    exit 1
   end
 
-  payload_file = YAML.safe_load(
-    File.read(options[:payload])
-  )
+  if options[:payload] and options[:scheduler]
+    puts opts
+    puts "Either -f or -s must be set"
+    exit 1
+  end
 
-  logger.info "Starting Seijaku. Payload: #{payload_file["name"]}"
+  if options[:payload]
+    payload_file = YAML.safe_load(
+      File.read(options[:payload])
+    )
 
-  payload = Payload.new(payload_file, logger)
-  payload.execute!
+    logger.info "Starting Seijaku. Payload: #{payload_file["name"]}"
+
+    payload = Payload.new(payload_file, logger)
+    payload.execute!
+  end
+
+  if options[:scheduler]
+    scheduler_file = YAML.safe_load(
+      File.read(options[:scheduler])
+    )
+
+    logger.info "Starting Seijaku. Scheduler: #{scheduler_file["name"]}"
+    begin
+      scheduler = Scheduler.new(scheduler_file, logger)
+      scheduler.monitor!
+    rescue Interrupt
+      scheduler.soft_exit!
+      puts "All payloads did stop their execution gracefully."
+    end
+  end
 end

data/docs/1 - basic.md

@@ -0,0 +1,10 @@
+# Basic
+
+```yaml
+name: basic payload
+tasks:
+  - name: do something useful
+    steps:
+      - sh: echo "sh executor"
+      - bash: echo "bash executor"
+```

data/docs/2 - variables.md

@@ -0,0 +1,24 @@
+# Variables
+
+Steps can call environment variables, listed in the `variables` dictionary.
+
+Variable values can either be given in the payload (static) or be defined from the executive shell.
+
+```yaml
+name: payload with variables
+
+variables:
+  ENV_VARIABLE: value
+  PROVIDED_ENV_VARIABLE: $PROVIDED_ENV_VARIABLE
+
+tasks:
+  - name: do something useful
+    steps:
+      - sh: echo "sh executor: $ENV_VARIABLE"
+      - bash: echo "bash executor: $PROVIDED_ENV_VARIABLE"
+```
+
+```bash
+export PROVIDED_ENV_VARIABLE=value 
+seijaku -f ./docs/variables.yaml
+```

data/docs/3 - ssh.md

@@ -0,0 +1,78 @@
+# SSH
+
+Since version `0.1.0`, Seijaku implements a SSH step executor. Only one SSH host can be set per task.
+
+
+```yaml
+name: payload with SSH executor
+
+ssh:
+  - host: my-host
+    port: 22
+    user: ubuntu
+
+tasks:
+  - name: do something useful
+    host: my-host
+    steps:
+      - ssh: echo "connection test"
+```
+
+It is recommended to run `ssh-add` before running Seijaku, as each step would require you to enter your password.
+
+## Variables
+
+Variables can be set from the Seijaku executive host and ran in the SSH host context:
+
+```yaml
+name: payload with SSH executor (variables)
+
+ssh:
+  - host: my-host
+    port: 22
+    user: ubuntu
+
+variables:
+  ENV_VARIABLE: value
+  PROVIDED_ENV_VARIABLE: $PROVIDED_ENV_VARIABLE
+
+tasks:
+  - name: do something useful
+    host: my-host
+    steps:
+      - ssh: echo "connection test"
+      - ssh: echo "$ENV_VARIABLE"
+      - ssh: echo "$PROVIDED_ENV_VARIABLE"
+```
+
+## Bastion / Jump host / Proxy
+
+You sometimes need to jump over a publicly exposed server to reach another one. Seijaku supports SSH Proxy, with a maximum of 1 hop.
+
+```yaml
+name: payload with SSH executor (bastion)
+
+ssh:
+  - host: bastion-host
+    port: 22
+    user: bastion_user
+
+  - host: my-host
+    port: 22
+    user: ubuntu
+    bastion: bastion-host
+
+variables:
+  ENV_VARIABLE: value
+  PROVIDED_ENV_VARIABLE: $PROVIDED_ENV_VARIABLE
+
+tasks:
+  - name: do something useful
+    host: my-host
+    steps:
+      - ssh: echo "connection test"
+      - ssh: echo "$ENV_VARIABLE"
+      - ssh: echo "$PROVIDED_ENV_VARIABLE"
+```
+
+The `ssh.[].host` must be a reachable address (domain name or IP).

data/docs/4 - scheduler.md

@@ -0,0 +1,54 @@
+# Schedulers
+
+Since version `0.3.0`, Seijaku implements a task scheduler that permits us to execute payloads with interval between two runs.
+
+Instead of using the `-f` parameter to run a payload, you can use the `-s (--scheduler)` parameter to pass a `schedulerfile` to Seijaku.
+
+## How it works ?
+
+Ruby isn't great at parallelism, but it does integrate `Threads`. The Scheduler will assign a Thread to all the payloads to execute.
+
+## Example
+
+Here is a really basic payload for example purpose:
+
+```yaml
+name: my-payload
+tasks:
+  - name: say hello world
+    steps:
+      - sh: echo "hello world"
+```
+
+If you want to run this payload every 10 seconds, you can create a scheduler file (call it whatever you want), describing the awaited behavior.
+
+```yaml
+name: "my-scheduler"
+
+payloads:
+  - payload: ./my-payload.yaml
+    every: 10
+    name: say-hello-world-10-s
+```
+
+## Graceful stop
+
+CTRL+C (Interrupt signal) sends an information to all the SchedulerExecutors running, asking them to do not re-schedule the payload execution they are in charge of once the current execution is finished.
+
+```
+...
+> CTRL+C
+[2023-12-14T18:48:12.509483 #8841]  INFO -- : Soft exit asked by user, waiting for payloads to stop naturally...
+I, [2023-12-14T18:48:12.509789 #8841]  INFO -- : test payload: still waiting...
+I, [2023-12-14T18:48:12.509856 #8841]  INFO -- : another-payload: still waiting...
+I, [2023-12-14T18:48:13.515211 #8841]  INFO -- : test payload: still waiting...
+I, [2023-12-14T18:48:13.515496 #8841]  INFO -- : another-payload: still waiting...
+I, [2023-12-14T18:48:14.520005 #8841]  INFO -- : test payload: still waiting...
+I, [2023-12-14T18:48:14.520262 #8841]  INFO -- : another-payload: stopped gracefully.
+I, [2023-12-14T18:48:15.524617 #8841]  INFO -- : test payload: stopped gracefully.
+All payloads did stop their execution gracefully.
+```
+
+## Work in progress
+
+* at the moment, only `every` is accepted. Cron formulas could one day be an option but its implementation is more complex.

data/lib/seijaku/executors/bash.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Seijaku
+  # executes `bash` commands
+  class BashExecutor
+    def initialize(raw, variables)
+      @command = ["bash", "-c", "'#{raw}'"]
+      @variables = variables
+    end
+
+    def run!
+      stdout, stderr, exit_status = Open3.capture3(
+        @variables,
+        @command.join(" ")
+      )
+
+      {
+        stdout: stdout.chomp,
+        stderr: stderr.chomp,
+        exit_status: exit_status.exitstatus,
+        command: @command.join(" ")
+      }
+    end
+  end
+end

data/lib/seijaku/executors/sh.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Seijaku
+  # Execute `sh` commands
+  class SHExecutor
+    def initialize(raw, variables)
+      @command = ["sh", "-c", "'#{raw}'"]
+      @variables = variables
+    end
+
+    def run!
+      stdout, stderr, exit_status = Open3.capture3(
+        @variables,
+        @command.join(" ")
+      )
+
+      {
+        stdout: stdout.chomp,
+        stderr: stderr.chomp,
+        exit_status: exit_status.exitstatus,
+        command: @command.join(" ")
+      }
+    end
+  end
+end

data/lib/seijaku/executors/ssh.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "net/ssh"
+require "net/ssh/proxy/jump"
+
+module Seijaku
+  # SSHExecutor connects to SSH host and runs command
+  class SSHExecutor
+    def initialize(raw, variables, task, ssh_hosts)
+      @command = ["sh", "-c", "'#{raw}'"]
+      @hosts = ssh_hosts
+      @variables = variables
+      @task = task
+      @ssh_hosts = ssh_hosts
+
+      raise SSHExecutorError, "no ssh host defined in payload", [] if ssh_hosts.nil?
+    end
+
+    def run!
+      machine = @ssh_hosts.hosts[@task.host]
+      result = { command: @command.join(" "), stdout: nil, stderr: nil }
+      status = {}
+      options = machine.bastion ? { proxy: bastion_setup } : {}
+      ssh = Net::SSH.start(machine.host, machine.user, port: machine.port, **options)
+      ssh.exec!(@command.join(" "), status: status) do |_ch, stream, data|
+        result[:stdout] = data.chomp if stream == :stdout
+        result[:stderr] = data.chomp unless stream == :stdout
+      end
+      ssh.close
+
+      result[:exit_status] = status[:exit_code]
+      result
+    end
+
+    def bastion_setup
+      bastion_name = @ssh_hosts.hosts[@task.host].bastion
+      bastion_host = @ssh_hosts.hosts[bastion_name]
+
+      connect_str = "#{bastion_host.user}@#{bastion_host.host}:#{bastion_host.port}"
+      Net::SSH::Proxy::Jump.new(connect_str)
+    end
+  end
+end

data/lib/seijaku/payload.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # Payload refers to the payload YAML file submitted by the user.
+  # it includes tasks, steps, variables and name.
+  class Payload
+    attr_reader :name
+
+    def initialize(payload, logger)
+      @name = payload.fetch("name")
+      @variables = get_variables(payload.fetch("variables"))
+      @ssh_hosts = SSHGroup.new(payload.fetch("ssh", []))
+      @tasks = payload.fetch("tasks").map do |task|
+        Task.new(task, @variables, logger, @ssh_hosts)
+      end
+    end
+
+    def execute!
+      @tasks.each(&:execute!)
+    end
+
+    def get_variables(payload_variables)
+      sorted_variables = {}
+      variables = payload_variables.map do |var|
+        Variable.new(var)
+      end
+
+      variables.each do |var|
+        sorted_variables.merge!({ var.key => var.value })
+      end
+
+      sorted_variables
+    end
+  end
+end

data/lib/seijaku/scheduler.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Seijaku
+  class Scheduler
+    def initialize(scheduler, logger)
+      @name = scheduler.fetch("name", nil)
+      @logger = logger
+      @scheduler_executors = scheduler.fetch("payloads", []).map do |payload_spec|
+        payload = File.read(payload_spec["payload"]).then do |data|
+          YAML.safe_load(data).then do |data|
+            Payload.new(data, logger)
+          end
+        end
+
+        SchedulerExecutor.new(payload, payload_spec, logger)
+      end
+    end
+
+    def monitor!
+      thd = []
+      @scheduler_executors.each do |scheduler_executor|
+        @logger.info "scheduling... #{scheduler_executor.name}"
+        thd << Thread.new do
+          scheduler_executor.execute!
+        end
+      end
+
+      thd.each &:join
+    end
+
+    def soft_exit!
+      @logger.info "Soft exit asked by user, waiting for payloads to stop naturally..."
+      thd = []
+      @scheduler_executors.each do |scheduler_executor|
+        thd << Thread.new do
+          scheduler_executor.status = :exiting
+          while scheduler_executor.status != :exited
+            @logger.info "#{scheduler_executor.name}: still waiting..."
+            sleep 1
+          end
+
+          @logger.info "#{scheduler_executor.name}: stopped gracefully"
+        end
+      end
+      thd.each &:join
+    end
+  end
+end

data/lib/seijaku/scheduler_executor.rb

@@ -0,0 +1,31 @@
+module Seijaku
+  class SchedulerExecutor
+    attr_reader :name
+    attr_accessor :status
+
+    def initialize(payload_obj, scheduler_spec, logger)
+      @name = scheduler_spec.fetch("name", nil)
+      @every = scheduler_spec.fetch("every", nil)
+      @payload_file = scheduler_spec.fetch("payload")
+
+      @logger = logger
+      @payload = payload_obj
+      @status = :awaiting
+    end
+
+    def execute!
+      while @status != :exiting do
+        @logger.info "[SCHEDULER] <<- starting execution: #{@name}"
+
+        @status = :started
+        @payload.execute!
+        @status = :awaiting
+
+        @logger.info "[SCHEDULER] <<- finished execution: #{@name} (#{@every}s)"
+        sleep @every
+      end
+
+      @status = :exited
+    end
+  end
+end

data/lib/seijaku/ssh/group.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # Group of SSH hosts
+  class SSHGroup
+    attr_reader :hosts
+
+    def initialize(ssh_group)
+      @hosts = {}
+      ssh_group.each do |host|
+        @hosts[host["host"]] = Host.new(host)
+      end
+    end
+  end
+end

data/lib/seijaku/ssh/host.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # Host of SSHGroup
+  class Host
+    attr_reader :host, :port, :user, :bastion
+
+    def initialize(host)
+      @host = host.fetch("host", "localhost")
+      @port = host.fetch("port", 22)
+      @bastion = host.fetch("bastion", nil)
+      @user = host.fetch("user", "root")
+    end
+  end
+end

data/lib/seijaku/step.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # A step is a bash or sh command that must be executed.
+  # steps execution is always fifo.
+  class Step
+    attr_reader :command, :pipeline
+
+    def initialize(step, variables, pipeline, logger, task, ssh_hosts = nil)
+      @sh = step.fetch("sh", nil)
+      @bash = step.fetch("bash", nil)
+      @ssh = step.fetch("ssh", nil)
+      @soft_fail = step.fetch("soft_fail", false)
+      @output = step.fetch("output", false)
+      @variables = variables
+      @pipeline = pipeline
+      @logger = logger
+      @task = task
+      @ssh_hosts = ssh_hosts
+
+      @command = (@sh || @bash) || @ssh
+    end
+
+    def execute!
+      result = SHExecutor.new(@sh, @variables).run! if @sh
+      result = BashExecutor.new(@bash, @variables).run! if @bash
+      result = SSHExecutor.new(@ssh, @variables, @task, @ssh_hosts).run! if @ssh
+
+      if result[:exit_status] != 0
+        logger_output(result)
+        exit(1) unless @soft_fail
+      end
+
+      return unless @output
+
+      %i[stdout stderr].each do |stream|
+        puts format("%<stream>s:\t %<result>s", stream: stream, result: result[stream])
+      end
+    end
+
+    def logger_output(result)
+      @logger.info <<~OUTPUT
+        command: `#{result[:command]}`
+        exit_code: #{result[:exit_status]}
+        stdout: #{result[:stdout]}
+        stderr: #{result[:stderr]}"
+      OUTPUT
+    end
+  end
+end

data/lib/seijaku/task.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # Task is composed of a name, an array of Step (Pre, Post)
+  class Task
+    attr_reader :host
+
+    def initialize(task, variables, logger, ssh_hosts = nil)
+      @name = task.fetch("name", nil)
+      @host = task.fetch("host", nil)
+      @steps = task.fetch("steps", []).map { |step| Step.new(step, variables, :steps, logger, self, ssh_hosts) }
+      @pre_steps = task.fetch("pre", []).map { |step| Step.new(step, variables, :pre, logger, self, ssh_hosts) }
+      @post_steps = task.fetch("post", []).map { |step| Step.new(step, variables, :post, logger, self, ssh_hosts) }
+      @logger = logger
+
+      raise TaskError, "no name set in task", [] if @name.nil?
+    end
+
+    def execute!
+      [@pre_steps, @steps, @post_steps].each do |pipeline_steps|
+        pipeline_steps.each do |step|
+          @logger.info(format("[%<name>s:%<pipeline>s] running %<command>s",
+                              name: @name,
+                              pipeline: step.pipeline,
+                              command: step.command))
+
+          step.execute!
+        end
+      end
+    end
+  end
+end

data/lib/seijaku/variable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Seijaku
+  # variable
+  class Variable
+    attr_reader :key, :value
+
+    def initialize(variable)
+      @key = variable.first
+
+      value = variable.last
+      @value = value
+
+      return unless value.start_with?("$")
+
+      env_key = value.split("$").last
+      env_value = ENV.fetch(env_key, nil)
+
+      raise VariableError, "no value set for #{env_key}", [] if env_value.nil?
+
+      @value = env_value
+    end
+  end
+end

data/lib/seijaku/version.rb

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

data/lib/seijaku.rb

@@ -5,12 +5,19 @@ require_relative "seijaku/payload"
 require_relative "seijaku/variable"
 require_relative "seijaku/task"
 require_relative "seijaku/step"
+require_relative "seijaku/ssh/group"
+require_relative "seijaku/ssh/host"
 
 require_relative "seijaku/executors/sh"
 require_relative "seijaku/executors/bash"
+require_relative "seijaku/executors/ssh"
+
+require_relative "seijaku/scheduler"
+require_relative "seijaku/scheduler_executor"
 
 module Seijaku
   class Error < StandardError; end
   class VariableError < Error; end
   class TaskError < Error; end
+  class SSHExecutorError < Error; end
 end

data/seijaku.gemspec

@@ -32,9 +32,7 @@ Gem::Specification.new do |spec|
   spec.executables = %w[seijaku]
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency "bcrypt_pbkdf", "~> 1.1"
+  spec.add_dependency "ed25519", "~> 1.3"
+  spec.add_dependency "net-ssh", "~> 7.2"
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: seijaku
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kohlrabbit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-11 00:00:00.000000000 Z
-dependencies: []
+date: 2023-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcrypt_pbkdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
 description: CLI tool ingesting YAML files to execute tasks on different shells with
   pre and post routines.
 email:
@@ -26,7 +68,22 @@ files:
 - README.md
 - Rakefile
 - bin/seijaku
+- docs/1 - basic.md
+- docs/2 - variables.md
+- docs/3 - ssh.md
+- docs/4 - scheduler.md
 - lib/seijaku.rb
+- lib/seijaku/executors/bash.rb
+- lib/seijaku/executors/sh.rb
+- lib/seijaku/executors/ssh.rb
+- lib/seijaku/payload.rb
+- lib/seijaku/scheduler.rb
+- lib/seijaku/scheduler_executor.rb
+- lib/seijaku/ssh/group.rb
+- lib/seijaku/ssh/host.rb
+- lib/seijaku/step.rb
+- lib/seijaku/task.rb
+- lib/seijaku/variable.rb
 - lib/seijaku/version.rb
 - seijaku.gemspec
 - sig/seijaku.rbs