vcoworkflows 0.1.1

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: [:spec, :style, :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,45 @@
+#!/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
+input_parameters.each { |k, v| workflow.set_parameter(k, v) }
+
+# Execute the workflow.
+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,34 @@
+require 'thor'
+
+require File.dirname(__FILE__) + '/vcoworkflows/version'
+require File.dirname(__FILE__) + '/vcoworkflows/constants'
+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'
+
+# rubocop:disable LineLength
+
+# 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/auth.rb

@@ -0,0 +1,27 @@
+require 'vcoworkflows/constants'
+
+# VcoWorkflows
+module VcoWorkflows
+  # Cli
+  module Cli
+    # Auth
+    class Auth
+      attr_reader :username
+      attr_reader :password
+
+      # Initialize the Auth object
+      # @param [String] username
+      # @param [String] password
+      def initialize(username: nil, password: nil)
+        # Set username and password from parameters, if provided, or
+        # environment variables $VCO_USER and $VCO_PASSWD, if not.
+        @username = username.nil? ? ENV['VCO_USER'] : username
+        @password = password.nil? ? ENV['VCO_PASSWD'] : password
+
+        # Fail if we don't have both a username and a password.
+        fail(IOError, ERR[:username_unset]) if @username.nil?
+        fail(IOError, ERR[:password_unset]) if @password.nil?
+      end
+    end
+  end
+end

data/lib/vcoworkflows/cli/execute.rb

@@ -0,0 +1,109 @@
+require 'vcoworkflows'
+require_relative 'auth'
+require 'thor/group'
+
+# rubocop:disable MethodLength, LineLength
+
+# VcoWorkflows
+module VcoWorkflows
+  # Cli
+  module Cli
+    # Execute
+    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
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+      def execute
+        auth = VcoWorkflows::Cli::Auth.new(username: options[:username], password: options[:password])
+
+        # 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,
+                                        url: options[:server],
+                                        username: auth.username,
+                                        password: auth.password,
+                                        verify_ssl: options[:verify_ssl],
+                                        id: options[:id])
+
+        # 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_relative 'auth'
+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
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      # Process the subcommand
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+      def query
+        auth = VcoWorkflows::Cli::Auth.new(username: options[:username], password: options[:password])
+
+        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,
+                                        url: options[:server],
+                                        username: auth.username,
+                                        password: auth.password,
+                                        verify_ssl: options[:verify_ssl],
+                                        id: options[:id])
+
+        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}"
+          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/constants.rb

@@ -0,0 +1,44 @@
+# VcoWorkflows
+module VcoWorkflows
+  # rubocop:disable LineLength
+
+  # Options description messages
+  DESC_VERSION = 'Display the installed version of the VcoWorkflows gem'
+  DESC_CLI_EXECUTE = 'Execute the specified workflow'
+  DESC_CLI_QUERY = 'Query vCO for a workflow'
+  DESC_CLI_WORKFLOW = 'Name of the workflow'
+  DESC_CLI_WORKFLOW_ID = 'GUID of the workflow'
+  DESC_CLI_DRY_RUN = 'Dry run; do not actually perform operations against vCO'
+  DESC_CLI_VERBOSE = 'Show extra information'
+  DESC_CLI_NAME = 'Name of the workflow to execute'
+  DESC_CLI_SERVER = 'VMware vCenter Orchestrator server URL'
+  DESC_CLI_USERNAME = 'vCO user name'
+  DESC_CLI_PASSWORD = 'vCO password'
+  DESC_CLI_VERIFY_SSL = 'Perform TSL Certificate verification'
+  DESC_CLI_EXECUTE_WATCH = 'Wait around for workflow results'
+  DESC_CLI_EXECUTE_PARAMETERS = 'Comma-separated list of key=value parameters for workflow'
+  DESC_CLI_QUERY_EXECS = 'Fetch a list of executions for the workflow'
+  DESC_CLI_QUERY_EXEC_LIM = 'Limit the number of returned executions to the most recent N'
+  DESC_CLI_QUERY_EXEC_ID = 'Fetch the execution data for this execution GUID'
+  DESC_CLI_QUERY_EXEC_STATE = 'Fetch the state of the specified workflow execution'
+  DESC_CLI_QUERY_EXEC_LOG = 'In addition to execution data, show the execution log'
+  DESC_CLI_QUERY_JSON = 'Show the JSON document for the requested information'
+
+  # What do all the vCO REST URIs start with?
+  API_URL_BASE = '/vco/api'
+
+  # 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!',
+    username_unset: 'No username was specified, either by $VCO_USER or --username',
+    password_unset: 'No password was specified, either by $VCO_PASSWD or --password'
+  }
+
+  # rubocop:enable LineLength
+end

data/lib/vcoworkflows/runner.rb

@@ -0,0 +1,44 @@
+require 'vcoworkflows'
+
+# rubocop:disable all
+module VcoWorkflows
+  # wrapper to assist aruba in single process execution
+  class Runner
+    # Allow everything fun to be injected from the outside while defaulting to normal implementations.
+    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+    end
+
+    # Do the things!
+    def execute!
+      exit_code = begin
+        # Thor accesses these streams directly rather than letting them be
+        # injected, so we replace them...
+        $stderr = @stderr
+        $stdin = @stdin
+        $stdout = @stdout
+
+        VcoWorkflows::CLI.start(@argv)
+
+        # Thor::Base#start does not have a return value, assume success if no
+        # exception is raised.
+        0
+      rescue StandardError => e
+        # The ruby interpreter would pipe this to STDERR and exit 1 in the
+        # case of an unhandled exception
+        b = e.backtrace
+        b.unshift("#{b.shift}: #{e.message} (#{e.class})")
+        @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n"))
+        1
+      ensure
+        # put them back.
+        $stderr = STDERR
+        $stdin = STDIN
+        $stdout = STDOUT
+      end
+      # Proxy exit code back to the injected kernel.
+      @kernel.exit(exit_code)
+    end
+  end
+end
+# rubocop:enable all