vcoworkflows-ruby2 0.2.3

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+require 'coveralls/rake/task'
+require 'yard'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new(:features)
+Coveralls::RakeTask.new
+
+task :style do
+  sh 'rubocop'
+end
+
+task :doc do
+  sh 'yard'
+end
+
+# task default: [:spec, :features, :style, :doc, 'coveralls:push']
+task default: [:style, :spec, :doc, 'coveralls:push']

data/bin/vcoworkflows

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# require 'vcoworkflows'
+require 'vcoworkflows/runner'
+
+VcoWorkflows::Runner.new(ARGV.dup).execute!
+# VcoWorkflows::CLI.start(ARGV.dup)

data/example.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require 'vcoworkflows'
+
+# What am I connecting to?
+url = 'https://myvco.example.com:8281/vco/api'
+username = 'myuser'
+password = 'secret!'
+
+# What's the workflow I want to work with?
+workflow_name = 'Do Something Cool'
+
+# Define the parameters for the workflow which we need to supply.
+# The 'Do Something Cool' workflow needs a name, version, and words (an array
+# of strings).
+input_parameters = { 'name'    => 'a string value',
+                     'version' => '2',
+                     'words'   => %w(fe fi fo fum) }
+
+# Fetch the workflow from vCO
+workflow = VcoWorkflows::Workflow.new(workflow_name,
+                                      url: url,
+                                      username: username,
+                                      password: password,
+                                      verify_ssl: false)
+
+# Set the parameters in the workflow
+workflow.parameters = input_parameters
+
+# Execute the workflow. This will also save the execution id in our
+# workflow object.
+workflow.execute
+
+# We're going to wait around until the execution is done, so we'll check
+# on it every 5 seconds until we see whether it completed or failed.
+finished = false
+until finished
+  sleep 5
+  # Fetch a new workflow token to check the status of the workflow execution
+  wftoken = workflow.token
+  # If the execution is no longer alive, exit the loop and report the results.
+  unless wftoken.alive?
+    finished = true
+    wftoken.output_parameters.each { |k, v| puts " #{k}: #{v}" }
+  end
+end

data/lib/vcoworkflows.rb

@@ -0,0 +1,33 @@
+require 'thor'
+
+require File.dirname(__FILE__) + '/vcoworkflows/version'
+require File.dirname(__FILE__) + '/vcoworkflows/constants'
+require File.dirname(__FILE__) + '/vcoworkflows/config'
+require File.dirname(__FILE__) + '/vcoworkflows/vcosession'
+require File.dirname(__FILE__) + '/vcoworkflows/workflowservice'
+require File.dirname(__FILE__) + '/vcoworkflows/workflow'
+require File.dirname(__FILE__) + '/vcoworkflows/workflowparameter'
+require File.dirname(__FILE__) + '/vcoworkflows/workflowtoken'
+require File.dirname(__FILE__) + '/vcoworkflows/cli/execute'
+require File.dirname(__FILE__) + '/vcoworkflows/cli/query'
+
+# Refer to README.md for use instructions
+module VcoWorkflows
+  # Start of main CLI processing
+  class CLI < Thor
+    package_name 'vcoworkflows'
+    map '--version' => :version
+    map '-v' => :version
+
+    desc 'version', DESC_VERSION
+
+    # Display the version of `vcoworkflows`
+    def version
+      puts VERSION
+    end
+
+    register(VcoWorkflows::Cli::Execute, 'execute', 'execute <WORKFLOW>', DESC_CLI_EXECUTE)
+    register(VcoWorkflows::Cli::Query, 'query', 'query <WORKFLOW>', DESC_CLI_QUERY)
+  end
+end
+# rubocop:enable LineLength

data/lib/vcoworkflows/cli/execute.rb

@@ -0,0 +1,109 @@
+require 'vcoworkflows'
+require 'thor/group'
+
+# rubocop:disable MethodLength
+
+# VcoWorkflows
+module VcoWorkflows
+  # Cli
+  module Cli
+    # Execute a workflow with the given options.
+    class Execute < Thor::Group
+      include Thor::Actions
+
+      argument :workflow, type: :string, desc: DESC_CLI_WORKFLOW
+      class_option :server, type: :string, aliases: '-s', required: true, desc: DESC_CLI_SERVER
+      class_option :username, type: :string, aliases: '-u', desc: DESC_CLI_USERNAME
+      class_option :password, type: :string, aliases: '-p', desc: DESC_CLI_PASSWORD
+      class_option :id, type: :string, aliases: '-i', desc: DESC_CLI_WORKFLOW_ID
+      class_option :verify_ssl, type: :boolean, default: true, desc: DESC_CLI_VERIFY_SSL
+      class_option :dry_run, type: :boolean, default: false, desc: DESC_CLI_DRY_RUN
+      class_option :verbose, type: :boolean, default: true, desc: DESC_CLI_VERBOSE
+      class_option :watch, type: :boolean, default: true, desc: DESC_CLI_EXECUTE_WATCH
+
+      class_option :parameters, type: :string, required: true, desc: DESC_CLI_EXECUTE_PARAMETERS
+
+      # Thor
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+      def execute
+        config = VcoWorkflows::Config.new(url:        options[:server],
+                                          username:   options[:username],
+                                          password:   options[:password],
+                                          verify_ssl: options[:verify_ssl])
+
+        # Parse out the parameters
+        parameters = {}
+        options[:parameters].split(/,/).each do |p|
+          k, v = p.split(/=/)
+          parameters[k] = v
+        end
+        if parameters.key?('runlist')
+          parameters['runlist'] = parameters['runlist'].split(/:/)
+        end
+
+        puts "Executing against vCO REST endpoint: #{options[:server]}"
+        puts "Requested execution of workflow: '#{workflow}'"
+        puts "Will call workflow by GUID (#{options[:id]})" if options[:id]
+        if options[:verbose] || options[:dry_run]
+          puts 'Parameters:'
+          parameters.each do |k, v|
+            v = v.join(',') if v.is_a?(Array)
+            puts " - #{k}: #{v}"
+          end
+          puts ''
+        end
+
+        return if options[:dry_run]
+
+        # Get the workflow
+        puts "Retrieving workflow '#{workflow}' ..."
+        wf = VcoWorkflows::Workflow.new(workflow,
+                                        id:     options[:id],
+                                        config: config)
+
+        # List out mandatory parameters
+        puts "Required parameters:\n #{wf.required_parameters.keys.join(', ')}"
+
+        # Set the input parameters
+        puts 'Setting workflow input parameters...' if options[:verbose]
+        parameters.each do |k, v|
+          puts "setting #{k} to #{v}" if options[:verbose]
+          wf.set_parameter(k, v)
+        end
+
+        # Execute the workflow
+        puts 'Executing workflow...'
+        wf.execute
+
+        # Fetch the results
+        wftoken = wf.token
+        puts "#{wftoken.id} started at #{Time.at(wftoken.start_date / 1000)}"
+
+        # If we don't care about the results, move on.
+        return unless options[:watch]
+
+        # Check for update results until we get one who's state
+        # is not "running" or "waiting"
+        puts "\nChecking status...\n"
+        while wftoken.alive?
+          sleep 10
+          wftoken = wf.token
+          puts "#{Time.now} state: #{wftoken.state}"
+        end
+        puts "\nFinal status of execution:"
+        puts wftoken
+
+        # Print out the execution log
+        puts "\nWorkflow #{wf.name} log for execution #{wftoken.id}:"
+        log = wf.log(wftoken.id)
+        puts "\n#{log}"
+      end
+      # rubocop:enable CyclomaticComplexity, PerceivedComplexity
+    end
+  end
+end
+# rubocop:enable MethodLength, LineLength

data/lib/vcoworkflows/cli/query.rb

@@ -0,0 +1,106 @@
+require 'vcoworkflows'
+require 'thor/group'
+
+# rubocop:disable MethodLength, LineLength
+
+# VcoWorkflows
+module VcoWorkflows
+  # Cli
+  module Cli
+    # Query
+    class Query < Thor::Group
+      include Thor::Actions
+
+      argument :workflow, type: :string, desc: DESC_CLI_WORKFLOW
+      class_option :server, type: :string, aliases: '-s', required: true, desc: DESC_CLI_SERVER
+      class_option :username, type: :string, aliases: '-u', desc: DESC_CLI_USERNAME
+      class_option :password, type: :string, aliases: '-p', desc: DESC_CLI_PASSWORD
+      class_option :id, type: :string, aliases: '-i', desc: DESC_CLI_WORKFLOW_ID
+      class_option :verify_ssl, type: :boolean, default: true, desc: DESC_CLI_VERIFY_SSL
+      class_option :dry_run, type: :boolean, default: false, desc: DESC_CLI_DRY_RUN
+
+      class_option :executions, type: :boolean, aliases: '-e', default: false, desc: DESC_CLI_QUERY_EXECS
+      class_option :last, type: :numeric, aliases: '-l', default: 0, desc: DESC_CLI_QUERY_EXEC_LIM
+      class_option :execution_id, type: :string, aliases: ['-I', '--execution'], desc: DESC_CLI_QUERY_EXEC_ID
+      class_option :state, type: :boolean, aliases: '-r', desc: DESC_CLI_QUERY_EXEC_STATE
+      class_option :logs, type: :boolean, aliases: ['-L', '--log'], desc: DESC_CLI_QUERY_EXEC_LOG
+      class_option :show_json, type: :boolean, default: false, desc: DESC_CLI_QUERY_JSON
+
+      # Thor
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      # Process the subcommand
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+      def query
+        config = VcoWorkflows::Config.new(url:        options[:server],
+                                          username:   options[:username],
+                                          password:   options[:password],
+                                          verify_ssl: options[:verify_ssl])
+
+        if options[:dry_run]
+          puts "\nQuerying against vCO REST endpoint:\n  #{options[:server]}"
+          puts "Will search for workflow: '#{workflow}'"
+          puts "Will query workflow by GUID (#{options[:id]})" if options[:id]
+          return
+        end
+
+        # Get the workflow
+        puts "\nRetrieving workflow '#{workflow}' ..."
+        wf = VcoWorkflows::Workflow.new(workflow,
+                                        id:     options[:id],
+                                        config: config)
+
+        puts ''
+        if options[:execution_id]
+          puts "Fetching data for execution #{options[:execution_id]}..."
+          execution = wf.token(options[:execution_id])
+          if options[:state]
+            puts "Execution started at #{Time.at(execution.start_date / 1000)}"
+            puts "Execution #{execution.state} at #{Time.at(execution.end_date / 1000)}"
+          else
+            puts ''
+            if options[:show_json]
+              puts execution.to_json
+            else
+              puts execution
+            end
+          end
+
+          if options[:logs]
+            puts ''
+            wflog = wf.log(options[:execution_id])
+            if options[:show_json]
+              puts wflog.to_json
+            else
+              puts wflog
+            end
+          end
+        else
+          puts wf unless options[:executions]
+        end
+
+        # Last thing we're checking for, so if it's not wanted, just return
+        return unless options[:executions]
+        puts "\nWorkflow:   #{wf.name}"
+        puts "ID:           #{wf.id}"
+        puts "Description:  #{wf.description}"
+        puts "Version:      #{wf.version}"
+        puts "\nExecutions: "
+        executions = {}
+        wf.executions.each_value { |attrs| executions[attrs['startDate']] = attrs }
+        keys = executions.keys.sort
+        keys = keys.slice(keys.size - options[:last], keys.size) if options[:last] > 0
+        keys.each do |timestamp|
+          dataline = timestamp.to_s
+          dataline << " [#{executions[timestamp]['id']}]"
+          dataline << " #{executions[timestamp]['state']}"
+          puts dataline
+        end
+      end
+      # rubocop:enable CyclomaticComplexity, PerceivedComplexity
+    end
+  end
+end
+# rubocop:enable MethodLength, LineLength

data/lib/vcoworkflows/config.rb

@@ -0,0 +1,91 @@
+require 'vcoworkflows/constants'
+require 'uri'
+
+# VcoWorkflows
+module VcoWorkflows
+  # Class Config
+  class Config
+    # URL for the vCenter Orchestrator REST API
+    attr_reader :url
+
+    # User name to authenticate to vCenter Orchestrator
+    attr_accessor :username
+
+    # Password to authenticate to vCenter Orchestrator
+    attr_accessor :password
+
+    # Whether or not to do SSL/TLS Certificate verification
+    attr_accessor :verify_ssl
+
+    # rubocop:disable MethodLength, CyclomaticComplexity, PerceivedComplexity
+
+    # Constructor
+    # @param [String] config_file Path to config file to load
+    # @param [String] url URL for vCO server
+    # @param [String] username Username for vCO server
+    # @param [String] password Password for vCO server
+    # @param [Boolean] verify_ssl Verify SSL Certificates?
+    # @return [VcoWorkflows::Config]
+    def initialize(config_file: nil, url: nil, username: nil, password: nil, verify_ssl: true)
+      # If we're given a URL and no config_file, then build the configuration
+      # from the values we're given (or can scrape from the environment).
+      # Otherwise, load the given config file or the default config file if no
+      # config file was given.
+      if url && config_file.nil?
+        self.url    = url
+        @username   = username.nil? ? ENV['VCO_USER'] : username
+        @password   = password.nil? ? ENV['VCO_PASSWD'] : password
+        @verify_ssl = verify_ssl
+      else
+        # First, check if an explicit config file was given
+        config_file = DEFAULT_CONFIG_FILE if config_file.nil?
+        load_config(config_file)
+      end
+
+      # Fail if we don't have both a username and a password.
+      raise(IOError, ERR[:url_unset]) if @url.nil?
+      raise(IOError, ERR[:username_unset]) if @username.nil?
+      raise(IOError, ERR[:password_unset]) if @password.nil?
+    end
+    # rubocop:enable LineLength, MethodLength, CyclomaticComplexity, PerceivedComplexity
+
+    # Set the URL for the vCO server, force the path component.
+    # @param [String] vco_url
+    def url=(vco_url)
+      url = URI.parse(vco_url)
+      url.path = '/vco/api'
+      @url = url.to_s
+    end
+    # rubocop:enable LineLength
+
+    # load config file
+    # @param [String] config_file Path for the configuration file to load
+    def load_config(config_file)
+      config_data = JSON.parse(File.read(config_file))
+      return if config_data.nil?
+      self.url    = config_data['url']
+      @username   = config_data['username']
+      @password   = config_data['password']
+      @verify_ssl = config_data['verify_ssl']
+    end
+
+    # Return a String representation of this object
+    # @return [String]
+    def to_s
+      puts "url:        #{@url}"
+      puts "username:   #{@username}"
+      puts "password:   #{@password}"
+      puts "verify_ssl: #{@verify_ssl}"
+    end
+
+    # Return a JSON document for this object
+    def to_json
+      config = {}
+      config['url'] = @url
+      config['username'] = @username
+      config['password'] = @password
+      config['verify_ssl'] = @verify_ssl
+      puts JSON.pretty_generate(config)
+    end
+  end
+end

data/lib/vcoworkflows/constants.rb

@@ -0,0 +1,94 @@
+# VcoWorkflows
+module VcoWorkflows
+  # rubocop:disable LineLength
+
+  #
+  class Config
+    # Where we nominally expect configuration files to be
+    DEFAULT_CONFIG_DIR  = File.join((ENV['HOME'] || ENV['HOMEDRIVE']), '.vcoworkflows')
+
+    # Default configuration file
+    DEFAULT_CONFIG_FILE = File.join(DEFAULT_CONFIG_DIR, 'config.json')
+  end
+
+  # Options description messages
+
+  # Version
+  DESC_VERSION = 'Display the installed version of the VcoWorkflows gem'.freeze
+
+  # Execute
+  DESC_CLI_EXECUTE = 'Execute the specified workflow'.freeze
+
+  # Query
+  DESC_CLI_QUERY = 'Query vCO for a workflow'.freeze
+
+  # Workflow
+  DESC_CLI_WORKFLOW = 'Name of the workflow'.freeze
+
+  # ID
+  DESC_CLI_WORKFLOW_ID = 'GUID of the workflow'.freeze
+
+  # dry-run
+  DESC_CLI_DRY_RUN = 'Dry run; do not actually perform operations against vCO'.freeze
+
+  # verbose
+  DESC_CLI_VERBOSE = 'Show extra information'.freeze
+
+  # name
+  DESC_CLI_NAME = 'Name of the workflow to execute'.freeze
+
+  # server
+  DESC_CLI_SERVER = 'VMware vCenter Orchestrator server URL'.freeze
+
+  # username
+  DESC_CLI_USERNAME = 'vCO user name'.freeze
+
+  # password
+  DESC_CLI_PASSWORD = 'vCO password'.freeze
+
+  # verify certificates
+  DESC_CLI_VERIFY_SSL = 'Perform TSL Certificate verification'.freeze
+
+  # watch execution
+  DESC_CLI_EXECUTE_WATCH = 'Wait around for workflow results'.freeze
+
+  # execution parameter list
+  DESC_CLI_EXECUTE_PARAMETERS = 'Comma-separated list of key=value parameters for workflow'.freeze
+
+  # query exeuction list
+  DESC_CLI_QUERY_EXECS = 'Fetch a list of executions for the workflow'.freeze
+
+  # limit queried execution list size
+  DESC_CLI_QUERY_EXEC_LIM = 'Limit the number of returned executions to the most recent N'.freeze
+
+  # exeuction id
+  DESC_CLI_QUERY_EXEC_ID = 'Fetch the execution data for this execution GUID'.freeze
+
+  # execution state
+  DESC_CLI_QUERY_EXEC_STATE = 'Fetch the state of the specified workflow execution'.freeze
+
+  # execution log
+  DESC_CLI_QUERY_EXEC_LOG = 'In addition to execution data, show the execution log'.freeze
+
+  # show JSON
+  DESC_CLI_QUERY_JSON = 'Show the JSON document for the requested information'.freeze
+
+  # What do all the vCO REST URIs start with?
+  API_URL_BASE = '/vco/api'.freeze
+
+  # error messages
+  ERR = {
+    wtf: 'vcoworkflows: I have no idea what just went wrong.',
+    no_workflow_found: 'vcoworkflows: no workflow found!',
+    too_many_workflows: 'vcoworkflows: more than one workflow found for given name!',
+    wrong_workflow_wtf: 'vcoworkflows: search returned the wrong workflow! (?)',
+    no_workflow_service_defined: 'vcoworkflows: Attempted to execute a workflow with a nil workflow service!',
+    param_verify_failed: 'vcoworkflows: Attempt to verify required parameter failed!',
+    no_such_parameter: 'Attempted to set a parameter that does not exist!',
+    url_unset: 'No URL was configured, nothing to connect to!',
+    username_unset: 'No username was specified, either by $VCO_USER or --username',
+    password_unset: 'No password was specified, either by $VCO_PASSWD or --password'
+  }.freeze
+
+  # rubocop:enable LineLength
+end