bolt 1.43.0 → 1.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c237cb6fec506c63071962c4d8cf16fafb0b196abe720c5e0af8b9d8d350f11
-  data.tar.gz: b7505bc572e3e123b265b869ed2386bbb784882365102a3b816ab1b5e5599ab1
+  metadata.gz: 3e7033e924c3721ad51ea3ba221527831174bf0a962a09be2d01af56eea9d29a
+  data.tar.gz: 400125a4441d5df92ac45fae11e222be1b0d8925ea501144e61f82f4a60fc62a
 SHA512:
-  metadata.gz: '0178352d34985cdd7c2960a018ff4a502b813763df806e72dd21f302bf26b173eeaa54eb2b44092b340e82b682b141fca5f72ba6e11bda6475556983dcbcf0ee'
-  data.tar.gz: 4473441d248c6023b3fe87364439f6c32498b6a6ac71b61925116838ab72eab22a457e309189cac2d4a0ebd58b57e7ded0140c902dc2367c5f45d76cbba5932a
+  metadata.gz: b25b113a4b89a14c84aec41fe2e8e1fad3a41a82ac4b6e58e8ff3901e46ac2be2a71eafee0cc80545f9d03cdb6d93affd1e44dc90f426fdb415bbfd26e17d16d
+  data.tar.gz: 6b08cf2a56959c286622c1279b2583ef312c673cb08c719727ba4c29142f8e9ea2d449f12a811eba671a7658b1619a735203905d98bae6dfc66ecb7c00b958a0

data/bolt-modules/file/lib/puppet/functions/file/join.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Join file paths.
+Puppet::Functions.create_function(:'file::join') do
+  # @param paths The paths to join.
+  # @example Join file paths
+  #   file::join('./path', 'to/files')
+  dispatch :join do
+    required_repeated_param 'String', :paths
+    return_type 'String'
+  end
+
+  def join(*paths)
+    Puppet.lookup(:bolt_executor) {}&.report_function_call(self.class.name)
+    File.join(paths)
+  end
+end

data/lib/bolt/config.rb

@@ -223,7 +223,7 @@ module Bolt
           if @future
             to_expand = %w[private-key cacert token-file] & selected.keys
             to_expand.each do |opt|
-              selected[opt] = File.expand_path(selected[opt], @boltdir.path) if opt.is_a?(String)
+              selected[opt] = File.expand_path(selected[opt], @boltdir.path) if selected[opt].is_a?(String)
             end
           end
 

data/lib/bolt/util.rb

@@ -169,12 +169,23 @@ module Bolt
       # references to the same object and prevents endless recursion.
       # Credit to Jan Molic via https://github.com/rubyworks/facets/blob/master/LICENSE.txt
       def deep_clone(obj, cloned = {})
-        cloned[obj.object_id] if cloned.include?(obj.object_id)
+        return cloned[obj.object_id] if cloned.include?(obj.object_id)
+
+        # The `defined?` method will not reliably find the Java::JavaLang::CloneNotSupportedException constant
+        # presumably due to some sort of optimization that short-cuts doing a bunch of Java introspection.
+        # Java::JavaLang::<...> IS defining the constant (via const_missing or const_get magic perhaps) so
+        # it is safe to reference it in the error_types array when a JRuby interpreter is evaluating the code
+        # (detected by RUBY_PLATFORM == `java`). SO instead of conditionally adding the CloneNotSupportedException
+        # constant to the error_types array based on `defined?` detecting the Java::JavaLang constant it is added
+        # based on detecting a JRuby interpreter.
+        # TypeError handles unclonable Ruby ojbects (TrueClass, Fixnum, ...)
+        # CloneNotSupportedException handles uncloneable Java objects (JRuby only)
+        error_types = [TypeError]
+        error_types << Java::JavaLang::CloneNotSupportedException if RUBY_PLATFORM == 'java'
 
         begin
           cl = obj.clone
-        rescue TypeError
-          # unclonable (TrueClass, Fixnum, ...)
+        rescue *error_types
           cloned[obj.object_id] = obj
           obj
         else

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.43.0'
+  VERSION = '1.44.0'
 end

data/lib/bolt_server/transport_app.rb

@@ -188,6 +188,11 @@ module BoltServer
       [200, GC.stat.to_json]
     end
 
+    get '/admin/status' do
+      stats = Puma.stats
+      [200, stats.is_a?(Hash) ? stats.to_json : stats]
+    end
+
     get '/500_error' do
       raise 'Unexpected error'
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.43.0
+  version: 1.44.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-18 00:00:00.000000000 Z
+date: 2020-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -367,6 +367,7 @@ files:
 - bolt-modules/ctrl/lib/puppet/functions/ctrl/do_until.rb
 - bolt-modules/ctrl/lib/puppet/functions/ctrl/sleep.rb
 - bolt-modules/file/lib/puppet/functions/file/exists.rb
+- bolt-modules/file/lib/puppet/functions/file/join.rb
 - bolt-modules/file/lib/puppet/functions/file/read.rb
 - bolt-modules/file/lib/puppet/functions/file/readable.rb
 - bolt-modules/file/lib/puppet/functions/file/write.rb
@@ -485,12 +486,6 @@ files:
 - lib/bolt_spec/plans/publish_stub.rb
 - lib/bolt_spec/run.rb
 - lib/logging_extensions/logging.rb
-- lib/plan_executor/app.rb
-- lib/plan_executor/applicator.rb
-- lib/plan_executor/config.rb
-- lib/plan_executor/executor.rb
-- lib/plan_executor/orch_client.rb
-- lib/plan_executor/schemas/run_plan.json
 - libexec/apply_catalog.rb
 - libexec/bolt_catalog
 - libexec/custom_facts.rb

data/lib/plan_executor/app.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require 'sinatra'
-require 'bolt'
-require 'bolt/error'
-require 'bolt/inventory'
-require 'bolt/pal'
-require 'bolt/puppetdb'
-require 'bolt/version'
-require 'plan_executor/applicator'
-require 'plan_executor/executor'
-require 'json'
-require 'json-schema'
-
-module PlanExecutor
-  class App < Sinatra::Base
-    # This disables Sinatra's error page generation
-    set :show_exceptions, false
-    # Global var to capture output for testing
-    result = nil
-
-    helpers do
-      def puppetdb_client
-        return @puppetdb_client if @puppetdb_client
-        @puppetdb_client = Bolt::PuppetDB::Client.new({})
-      end
-    end
-
-    def initialize(config)
-      # lazy-load expensive gem code
-      require 'concurrent'
-
-      @http_client = create_http(config)
-
-      # Use an empty inventory until we figure out where this data comes from.
-      @inventory = Bolt::Inventory.new(nil)
-
-      # PAL is not threadsafe. Part of the work of making the plan executor
-      # functional will be making changes to Puppet that remove the need for
-      # global Puppet state.
-      # https://github.com/puppetlabs/bolt/blob/master/lib/bolt/pal.rb#L166
-      @pal = Bolt::PAL.new(config['modulepath'], nil, nil)
-
-      @schema = JSON.parse(File.read(File.join(__dir__, 'schemas', 'run_plan.json')))
-      @worker = Concurrent::SingleThreadExecutor.new
-      @modulepath = config['modulepath']
-
-      super(nil)
-    end
-
-    def create_http(config)
-      base_url = config['orchestrator-url'].chomp('/') + '/orchestrator/v1/'
-      agent_name = "Bolt/#{Bolt::VERSION}"
-      http = JSONClient.new(base_url: base_url, agent_name: agent_name)
-      http.ssl_config.set_client_cert_file(config['ssl-cert'], config['ssl-key'])
-      http.ssl_config.add_trust_ca(config['ssl-ca-cert'])
-      http
-    end
-
-    def validate_schema(schema, body)
-      schema_error = JSON::Validator.fully_validate(schema, body)
-      if schema_error.any?
-        Bolt::Error.new("There was an error validating the request body.",
-                        'boltserver/schema-error',
-                        schema_error)
-      end
-    end
-
-    get '/' do
-      200
-    end
-
-    if ENV['RACK_ENV'] == 'dev'
-      get '/admin/gc' do
-        GC.start
-        200
-      end
-
-      get '/admin/gc_stat' do
-        [200, GC.stat.to_json]
-      end
-    end
-
-    get '/500_error' do
-      raise 'Unexpected error'
-    end
-
-    post '/plan/run' do
-      content_type :json
-
-      body = JSON.parse(request.body.read)
-      error = validate_schema(@schema, body)
-      return [400, error.to_json] unless error.nil?
-      name = body['plan_name']
-      # We need to wrap all calls to @pal (not just plan_run) in a future
-      # to ensure that the process always uses the SingleThreadExecutor
-      # worker and forces one call to @pal at a time regardless of the number
-      # of concurrent calls to POST /plan_run
-      result = Concurrent::Future.execute(executor: @worker) do
-        @pal.get_plan_info(name)
-      end
-      # .value! will fail if the internal process of the thread fails
-      result.value!
-      executor = PlanExecutor::Executor.new(body['job_id'], @http_client)
-      applicator = PlanExecutor::Applicator.new(@inventory, executor, nil)
-      params = body['params']
-      # This provides a wait function, which promise doesn't
-      result = Concurrent::Future.execute(executor: @worker) do
-        pal_result = @pal.run_plan(name, params, executor, @inventory, puppetdb_client, applicator)
-        executor.finish_plan(pal_result)
-        pal_result
-      end
-      [200, { status: 'running' }.to_json]
-    end
-
-    # Provided for testing
-    get '/plan/result' do
-      result.wait_or_cancel(20)
-      if result.fulfilled?
-        return [200, result.value.to_json]
-      elsif result.rejected?
-        raise result.reason.to_s
-      else
-        return [200, result.state.to_s]
-      end
-    end
-
-    error 404 do
-      err = Bolt::Error.new("Could not find route #{request.path}",
-                            'boltserver/not-found')
-      [404, err.to_json]
-    end
-
-    error 500 do
-      e = env['sinatra.error']
-      err = Bolt::Error.new("500: Unknown error: #{e.message}",
-                            'boltserver/server-error')
-      [500, err.to_json]
-    end
-  end
-end

data/lib/plan_executor/applicator.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'bolt/error'
-
-module PlanExecutor
-  class Applicator
-    def initialize(inventory, executor, config)
-      @inventory = inventory
-      @executor = executor
-      @config = config
-    end
-
-    def raise_not_implemented(feature)
-      raise Bolt::Error.new("#{feature} not implemented for plan executor service.",
-                            'bolt.plan-executor/not-implemented')
-    end
-
-    def apply(_args, _apply_body, _scope)
-      raise_not_implemented("apply")
-    end
-
-    def build_plugin_tarball
-      raise_not_implemented("build_plugin_tarball")
-    end
-
-    def custom_facts_task
-      raise_not_implemented('custom_facts_task')
-    end
-  end
-end

data/lib/plan_executor/config.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'hocon'
-require 'bolt_server/base_config'
-require 'bolt/error'
-
-module PlanExecutor
-  class Config < BoltServer::BaseConfig
-    def config_keys
-      super + %w[modulepath workers orchestrator-url]
-    end
-
-    def defaults
-      super.merge(
-        'port' => 62659,
-        'workers' => 1
-      )
-    end
-
-    def service_name
-      'plan-executor'
-    end
-
-    def required_keys
-      super + ['orchestrator-url']
-    end
-
-    def load_env_config
-      env_keys.each do |key|
-        transformed_key = "BOLT_#{key.tr('-', '_').upcase}"
-        next unless ENV.key?(transformed_key)
-        @data[key] = ENV[transformed_key]
-      end
-    end
-
-    def validate
-      super
-      unless natural?(@data['workers'])
-        raise Bolt::ValidationError, "Configured 'workers' must be a positive integer"
-      end
-    end
-  end
-end

data/lib/plan_executor/executor.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-# Used for $ERROR_INFO. This *must* be capitalized!
-require 'English'
-require 'json'
-require 'logging'
-require 'set'
-require 'bolt/result'
-require 'bolt/config'
-require 'bolt/result_set'
-require 'bolt/puppetdb'
-require 'plan_executor/orch_client'
-
-module PlanExecutor
-  class Executor
-    attr_reader :noop, :logger
-    attr_accessor :orch_client
-
-    def initialize(job_id, http_client, noop = nil)
-      @logger = Logging.logger[self]
-      @plan_logging = false
-      @noop = noop
-      @logger.debug { "Started" }
-      @orch_client = PlanExecutor::OrchClient.new(job_id, http_client, @logger)
-    end
-
-    # This handles running the job, catching errors, and turning the result
-    # into a result set
-    def as_resultset(targets)
-      result_array = begin
-                       yield
-                     rescue StandardError => e
-                       @logger.warn(e)
-                       # CODEREVIEW how should we fail if there's an error?
-                       Array(Bolt::Result.from_exception(targets[0], e))
-                     end
-      Bolt::ResultSet.new(result_array)
-    end
-
-    # BOLT-1098
-    def log_action(description, targets)
-      # When running a plan, info messages like starting a task are promoted to notice.
-      log_method = @plan_logging ? :notice : :info
-      target_str = if targets.length > 5
-                     "#{targets.count} targets"
-                   else
-                     targets.map(&:uri).join(', ')
-                   end
-
-      @logger.send(log_method, "Starting: #{description} on #{target_str}")
-
-      start_time = Time.now
-      results = yield
-      duration = Time.now - start_time
-
-      failures = results.error_set.length
-      plural = failures == 1 ? '' : 's'
-
-      @logger.send(log_method, "Finished: #{description} with #{failures} failure#{plural} in #{duration.round(2)} sec")
-
-      results
-    end
-
-    # BOLT-1098
-    def log_plan(plan_name)
-      log_method = @plan_logging ? :notice : :info
-      @logger.send(log_method, "Starting: plan #{plan_name}")
-      start_time = Time.now
-
-      results = nil
-      begin
-        results = yield
-      ensure
-        duration = Time.now - start_time
-        @logger.send(log_method, "Finished: plan #{plan_name} in #{duration.round(2)} sec")
-      end
-
-      results
-    end
-
-    def run_command(targets, command, options = {})
-      description = options.fetch(:description, "command '#{command}'")
-      log_action(description, targets) do
-        results = as_resultset(targets) do
-          @orch_client.run_command(targets, command, options)
-        end
-
-        results
-      end
-    end
-
-    def run_script(targets, script, arguments, options = {})
-      description = options.fetch(:description, "script #{script}")
-      log_action(description, targets) do
-        results = as_resultset(targets) do
-          @orch_client.run_script(targets, script, arguments, options)
-        end
-
-        results
-      end
-    end
-
-    def run_task(targets, task, arguments, options = {})
-      description = options.fetch(:description, "task #{task.name}")
-      log_action(description, targets) do
-        arguments['_task'] = task.name
-
-        results = as_resultset(targets) do
-          @orch_client.run_task(targets, task, arguments, options)
-        end
-
-        results
-      end
-    end
-
-    def upload_file(targets, source, destination, options = {})
-      description = options.fetch(:description, "file upload from #{source} to #{destination}")
-      log_action(description, targets) do
-        results = as_resultset(targets) do
-          @orch_client.file_upload(targets, source, destination, options)
-        end
-
-        results
-      end
-    end
-
-    class TimeoutError < RuntimeError; end
-
-    def wait_until_available(targets,
-                             description: 'wait until available',
-                             wait_time: 120,
-                             retry_interval: 1)
-      log_action(description, targets) do
-        begin
-          wait_until(wait_time, retry_interval) { @orch_client.connected?(targets) }
-          targets.map { |target| Bolt::Result.new(target) }
-        rescue TimeoutError => e
-          targets.map { |target| Bolt::Result.from_exception(target, e) }
-        end
-      end
-    end
-
-    def wait_until(timeout, retry_interval)
-      start = wait_now
-      until yield
-        raise(TimeoutError, 'Timed out waiting for target') if (wait_now - start).to_i >= timeout
-        sleep(retry_interval)
-      end
-    end
-
-    def finish_plan(plan_result)
-      @orch_client.finish_plan(plan_result)
-    end
-
-    def without_default_logging
-      old_log = @plan_logging
-      @plan_logging = false
-      yield
-    ensure
-      @plan_logging = old_log
-    end
-
-    def report_bundled_content(mode, name); end
-
-    def report_function_call(function); end
-  end
-end

data/lib/plan_executor/orch_client.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require 'jsonclient'
-
-module PlanExecutor
-  class OrchClient
-    attr_reader :plan_job, :http
-
-    BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
-    BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
-    BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
-
-    def initialize(plan_job, http_client, logger)
-      @plan_job = plan_job
-      @logger = logger
-      @http = http_client
-      @environment = 'production'
-    end
-
-    def finish_plan(plan_result)
-      body = {
-        plan_job: @plan_job,
-        result: plan_result.value || '',
-        status: plan_result.status
-      }
-      post_command('internal/plan_finish', body)
-    rescue StandardError => e
-      @logger.error("Failed to finish plan #{plan_job}: #{e.message}")
-    end
-
-    def run_task_job(targets, task, arguments, options)
-      # unpack any Sensitive data
-      arguments = unwrap_sensitive_args(arguments)
-      results = send_request(targets, task, arguments, options)
-
-      process_run_results(targets, results)
-    rescue OrchestratorClient::ApiError => e
-      targets.map do |target|
-        Bolt::Result.new(target, error: e.data)
-      end
-    rescue StandardError => e
-      targets.map do |target|
-        Bolt::Result.from_exception(target, e)
-      end
-    end
-
-    def get(url)
-      response = @http.get(url)
-      if response.status != 200
-        raise Bolt::Error.new(response.body['msg'], response.body['kind'], response.body['details'])
-      end
-      response.body
-    end
-
-    def post_command(url, body)
-      response = @http.post(url, body)
-      if response.status != 202
-        raise Bolt::Error.new(response.body['msg'], response.body['kind'], response.body['details'])
-      end
-      response.body
-    end
-
-    def send_request(targets, task, arguments, options = {})
-      description = options[:description]
-      body = { task: task.name,
-               environment: @environment,
-               noop: arguments['_noop'],
-               params: arguments.reject { |k, _| k.start_with?('_') },
-               scope: {
-                 nodes: targets.map(&:host)
-               } }
-      body[:description] = description if description
-      body[:plan_job] = @plan_job if @plan_job
-
-      url = post_command('internal/plan_task', body).dig('job', 'id')
-
-      job = get(url)
-      until %w[stopped finished failed].include?(job['state'])
-        sleep 1
-        job = get(url)
-      end
-
-      get(job.dig('nodes', 'id'))['items']
-    end
-
-    def process_run_results(targets, results)
-      targets_by_name = Hash[targets.map(&:host).zip(targets)]
-      results.map do |node_result|
-        target = targets_by_name[node_result['name']]
-        state = node_result['state']
-        result = node_result['result']
-
-        # If it's finished or already has a proper error simply pass it to the
-        # the result otherwise make sure an error is generated
-        if state == 'finished' || (result && result['_error'])
-          Bolt::Result.new(target, value: result)
-        elsif state == 'skipped'
-          Bolt::Result.new(
-            target,
-            value: { '_error' => {
-              'kind' => 'puppetlabs.tasks/skipped-node',
-              'msg' => "Node #{target.host} was skipped",
-              'details' => {}
-            } }
-          )
-        else
-          # Make a generic error with a unkown exit_code
-          Bolt::Result.for_task(target, result.to_json, '', 'unknown')
-        end
-      end
-    end
-
-    def run_task(targets, task, arguments, options = {})
-      run_task_job(targets, task, arguments, options)
-    end
-
-    def run_command(targets, command, options = {})
-      params = { 'command' => command }
-      run_task_job(targets, BOLT_COMMAND_TASK, params, options)
-    end
-
-    def run_script(targets, script, arguments, options = {})
-      content = File.open(script, &:read)
-      content = Base64.encode64(content)
-      params = {
-        'content' => content,
-        'arguments' => arguments,
-        'name' => Pathname(script).basename.to_s
-      }
-      callback ||= proc {}
-      results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)
-      results.map! { |result| unwrap_bolt_result(result.target, result) }
-      results.each do |result|
-        callback.call(type: :node_result, result: result)
-      end
-    end
-
-    def pack(directory)
-      # lazy-load expensive gem code
-      require 'minitar'
-      require 'zlib'
-
-      start_time = Time.now
-      io = StringIO.new
-      output = Minitar::Output.new(Zlib::GzipWriter.new(io))
-      Find.find(directory) do |file|
-        next unless File.file?(file)
-
-        tar_path = Pathname.new(file).relative_path_from(Pathname.new(directory))
-        @logger.debug("Packing #{file} to #{tar_path}")
-        stat = File.stat(file)
-        content = File.binread(file)
-        output.tar.add_file_simple(
-          tar_path.to_s,
-          data: content,
-          size: content.size,
-          mode: stat.mode & 0o777,
-          mtime: stat.mtime
-        )
-      end
-
-      duration = Time.now - start_time
-      @logger.debug("Packed upload in #{duration * 1000} ms")
-
-      output.close
-      io.string
-    ensure
-      # Closes both tar and sgz.
-      output&.close
-    end
-
-    def file_upload(targets, source, destination, options = {})
-      stat = File.stat(source)
-      content = if stat.directory?
-                  pack(source)
-                else
-                  File.open(source, &:read)
-                end
-      content = Base64.encode64(content)
-      mode = File.stat(source).mode
-      params = {
-        'path' => destination,
-        'content' => content,
-        'mode' => mode,
-        'directory' => stat.directory?
-      }
-      results = run_task_job(targets, BOLT_UPLOAD_TASK, params, options)
-      results.map! do |result|
-        if result.error_hash
-          result
-        else
-          Bolt::Result.for_upload(result.target, source, destination)
-        end
-      end
-    end
-
-    # Unwraps any Sensitive data in an arguments Hash, so the plain-text is passed
-    # to the Task/Script.
-    #
-    # This works on deeply nested data structures composed of Hashes, Arrays, and
-    # and plain-old data types (int, string, etc).
-    def unwrap_sensitive_args(arguments)
-      # Skip this if Puppet isn't loaded
-      return arguments unless defined?(Puppet::Pops::Types::PSensitiveType::Sensitive)
-
-      case arguments
-      when Array
-        # iterate over the array, unwrapping all elements
-        arguments.map { |x| unwrap_sensitive_args(x) }
-      when Hash
-        # iterate over the arguments hash and unwrap all keys and values
-        arguments.each_with_object({}) { |(k, v), h|
-          h[unwrap_sensitive_args(k)] = unwrap_sensitive_args(v)
-        }
-      when Puppet::Pops::Types::PSensitiveType::Sensitive
-        # this value is Sensitive, unwrap it
-        unwrap_sensitive_args(arguments.unwrap)
-      else
-        # unknown data type, just return it
-        arguments
-      end
-    end
-
-    # run_task generates a result that makes sense for a generic task which
-    # needs to be unwrapped to extract stdout/stderr/exitcode.
-    #
-    def unwrap_bolt_result(target, result)
-      if result.error_hash
-        # something went wrong return the failure
-        return result
-      end
-
-      Bolt::Result.for_command(target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
-    end
-
-    def connected?(targets)
-      response = @http.post('inventory', nodes: targets.map(&:host))
-      response.body['items'].all? { |node| node['connected'] }
-    end
-  end
-end

data/lib/plan_executor/schemas/run_plan.json

@@ -1,29 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "title": "run_plan request",
-  "description": "POST plan/run request schema",
-  "type": "object",
-  "properties": {
-    "plan_name": {
-      "type": "string",
-      "description": "Name of the plan"
-    },
-    "job_id": {
-      "type": "string",
-      "description": "The job ID initialized in Orchestrator"
-    },
-    "environment": {
-      "type": "string",
-      "description": "Environment used for plan execution"
-    },
-    "description": {
-      "type": "string",
-      "description": "Describes this execution of the plan"
-    },
-    "params": {
-      "type": "object",
-      "description": "JSON formatted parameters to be provided to plan"
-    }
-  },
-  "required": ["plan_name", "job_id", "params"]
-}