vcoworkflows 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b98d551ecb8db61bdadef23f77d4b5a40bbd7b18
-  data.tar.gz: 3f9536b6642a09533c2fa5c2a3ed633edc4ef145
+  metadata.gz: 4aecbf8d560cb33986bb7724cb185dd4c674f979
+  data.tar.gz: afa37f3f01dc4e31e70121a5acb764192d0ea1f0
 SHA512:
-  metadata.gz: 27c314bdd27f89daa8dcd4f855447c80952f876dac2c81a6b876df26e8bea3db296e16ad3cb5d7ff33be351573e8f293cfe740fe804e3dffd077df4a4c655074
-  data.tar.gz: a2bf7d2fc6dd66e1b59711f2268440171a0ee37ac0e71e802e4e247a492da5932003c418c1aceeff6c51004c107596ec99e244def48830cb89b24643907bc2ab
+  metadata.gz: 2be9992176d0cde2177ade9b116047cb3cc2ee922d795efcfb9035c627ddc00dfac1aa68ac71859d896e7beb796af76bd1d7db7d252f21c271d6d00a7250b0e8
+  data.tar.gz: e298f6c3070df696fad7e3132798a55ad85522ad5890b99038fff2800ef03689c812175bc62cf3e8f5f3956e04697d607dbec5c4873f3b5ebb506861241a9334

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 vcoworkflows CHANGELOG
 ================
 
+## 0.2.0
+
+- Removes `VcoWorkflows::Cli::Auth`
+- Slightly breaks the behavior of `VcoWorkflows::VcoSession` from v0.1.x; all parameters for `VcoWorkflows::VcoSession.new()` are optional now, and if none are given, an attempt to load configuration from the default configuration file (currently `${HOME}/.vcoworkflows/config.json`) will be made.
+- Added `config` and `config_file` options to `VcoWorkflows::Workflow.new`. If only name is specified, attempt to grab configuration from `${HOME}/.vcoworkflows/config.json`
+
+## 0.1.4
+
 ## 0.1.3
 
 ### Third Time's the Charm

data/Guardfile

@@ -9,6 +9,15 @@ notification :growl, sticky:true
 #  * zeus: 'zeus rspec' (requires the server to be started separately)
 #  * 'just' rspec: 'rspec'
 
+guard :rubocop do
+  watch(%r{.+\.rb$})
+  watch(%r{bin/.+\.rb$})
+  watch(%r{lib/vcoworkflows/.+\.rb$})
+  watch(%r{spec/.+\.rb$})
+  watch(%r{spec/vcoworkflows/.+_spec\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.direname(m[0]) }
+end
+
 guard :rspec, cmd: "bundle exec rspec" do
   require "guard/rspec/dsl"
   dsl = Guard::RSpec::Dsl.new(self)
@@ -26,15 +35,6 @@ guard :rspec, cmd: "bundle exec rspec" do
   dsl.watch_spec_files_for(ruby.lib_files)
 end
 
-guard :rubocop do
-  watch(%r{.+\.rb$})
-  watch(%r{bin/.+\.rb$})
-  watch(%r{lib/vcoworkflows/.+\.rb$})
-  watch(%r{spec/.+\.rb$})
-  watch(%r{spec/vcoworkflows/.+_spec\.rb$})
-  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.direname(m[0]) }
-end
-
 guard 'yard' do
   watch(%r{bin/.+\.rb})
   watch(%r{lib/.+\.rb})

data/Rakefile

@@ -18,4 +18,4 @@ task :doc do
 end
 
 # task default: [:spec, :features, :style, :doc, 'coveralls:push']
-task default: [:spec, :style, :doc, 'coveralls:push']
+task default: [:style, :spec, :doc, 'coveralls:push']

data/lib/vcoworkflows.rb

@@ -2,6 +2,7 @@ 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'

data/lib/vcoworkflows/cli/execute.rb

@@ -1,5 +1,4 @@
 require 'vcoworkflows'
-require_relative 'auth'
 require 'thor/group'
 
 # rubocop:disable MethodLength, LineLength
@@ -31,7 +30,10 @@ module VcoWorkflows
 
       # rubocop:disable CyclomaticComplexity, PerceivedComplexity
       def execute
-        auth = VcoWorkflows::Cli::Auth.new(username: options[:username], password: options[:password])
+        config = VcoWorkflows::Config.new(url:        options[:server],
+                                          username:   options[:username],
+                                          password:   options[:password],
+                                          verify_ssl: options[:verify_ssl])
 
         # Parse out the parameters
         parameters = {}
@@ -60,11 +62,8 @@ module VcoWorkflows
         # 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])
+                                        id:     options[:id],
+                                        config: config)
 
         # List out mandatory parameters
         puts "Required parameters:\n #{wf.required_parameters.keys.join(', ')}"

data/lib/vcoworkflows/cli/query.rb

@@ -1,5 +1,4 @@
 require 'vcoworkflows'
-require_relative 'auth'
 require 'thor/group'
 
 # rubocop:disable MethodLength, LineLength
@@ -35,7 +34,10 @@ module VcoWorkflows
       # Process the subcommand
       # rubocop:disable CyclomaticComplexity, PerceivedComplexity
       def query
-        auth = VcoWorkflows::Cli::Auth.new(username: options[:username], password: options[:password])
+        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]}"
@@ -47,11 +49,8 @@ module VcoWorkflows
         # 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])
+                                        id:     options[:id],
+                                        config: config)
 
         puts ''
         if options[:execution_id]

data/lib/vcoworkflows/config.rb

@@ -0,0 +1,93 @@
+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 LineLength, 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.
+      fail(IOError, ERR[:url_unset]) if @url.nil?
+      fail(IOError, ERR[:username_unset]) if @username.nil?
+      fail(IOError, ERR[:password_unset]) if @password.nil?
+    end
+    # rubocop:enable LineLength, MethodLength, CyclomaticComplexity, PerceivedComplexity
+
+    # rubocop:disable LineLength
+
+    # 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

@@ -2,6 +2,15 @@
 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
@@ -76,6 +85,7 @@ module VcoWorkflows
     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'
   }

data/lib/vcoworkflows/vcosession.rb

@@ -1,4 +1,5 @@
-require_relative 'constants'
+require 'vcoworkflows/constants'
+require 'vcoworkflows/config'
 require 'rest_client'
 
 # VcoWorkflows
@@ -9,20 +10,41 @@ module VcoWorkflows
     # Accessor for rest-client object, primarily for testing purposes
     attr_reader :rest_resource
 
+    # rubocop:disable MethodLength, LineLength
+
     # Initialize the session
     #
+    # When specifying a config, do not provide other parameters. Likewise,
+    # if providing uri, user, and password, a config object is not necessary.
+    #
+    # @param [VcoWorkflows::Config] config Configuration object for the connection
     # @param [String] uri URI for the vCenter Orchestrator API endpoint
     # @param [String] user User name for vCO
     # @param [String] password Password for vCO
     # @param [Boolean] verify_ssl Whether or not to verify SSL certificates
-    def initialize(uri, user: nil, password: nil, verify_ssl: true)
-      api_url = "#{uri.gsub(%r{\/$}, '')}/vco/api"
+    def initialize(config: nil, uri: nil, user: nil, password: nil, verify_ssl: true)
+      # If a configuration object was provided, use it.
+      # If we got a URL and no config, build a new config with the URL and any
+      # other options that passed in.
+      # Otherwise, load the default config file if possible...
+      if config
+        config = config
+      elsif uri && config.nil?
+        config = VcoWorkflows::Config.new(url:        uri,
+                                          username:   user,
+                                          password:   password,
+                                          verify_ssl: verify_ssl)
+      elsif uri.nil? && config.nil?
+        config = VcoWorkflows::Config.new
+      end
+
       RestClient.proxy = ENV['http_proxy'] # Set a proxy if present
-      @rest_resource = RestClient::Resource.new(api_url,
-                                                user: user,
-                                                password: password,
-                                                verify_ssl: verify_ssl)
+      @rest_resource = RestClient::Resource.new(config.url,
+                                                user:       config.username,
+                                                password:   config.password,
+                                                verify_ssl: config.verify_ssl)
     end
+    # rubocop:enable MethodLength, LineLength
 
     # Perform a REST GET operation against the specified endpoint
     #

data/lib/vcoworkflows/version.rb

@@ -1,5 +1,5 @@
 # VcoWorkflows
 module VcoWorkflows
   # Gem Version
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

data/lib/vcoworkflows/workflow.rb

@@ -29,27 +29,24 @@ module VcoWorkflows
     # @return [String] workflow description
     attr_reader :description
 
-    # Workflow Input Parameters
-    # @return [Hash<VcoWorkflows::WorkflowParameter>] Hash of
-    #   WorkflowParameter objects, keyed by name
+    # Workflow Input Parameters: Hash of WorkflowParameters, keyed by name
+    # @return [Hash<VcoWorkflows::WorkflowParameter>]
     attr_reader :input_parameters
 
-    # Workflow Output Parameters
-    # @return [Hash<VcoWorkflows::WorkflowParameter>] Hash of
-    #   WorkflowParameter objects, keyed by name
+    # Workflow Output Parameters: Hash of WorkflowParameters, keyed by name
+    # @return [Hash<VcoWorkflows::WorkflowParameter>]
     attr_reader :output_parameters
 
-    # Workflow Service
-    # @return [VcoWorkflows::WorkflowService] The WorkflowService
-    #   currently being used to interface with vCO
+    # Workflow Service in use by this Workflow
+    # @return [VcoWorkflows::WorkflowService]
     attr_accessor :service
 
     # Workflow execution ID
-    # @return [String] workflow execution ID
+    # @return [String]
     attr_reader :execution_id
 
     # Workflow source JSON
-    # @return [String] the source JSON returned by vCO for this workflow
+    # @return [String]
     attr_reader :source_json
 
     # rubocop:enable LineLength
@@ -60,10 +57,20 @@ module VcoWorkflows
     #
     # When passed `url`, `username` and `password` the necessary session and
     # service objects will be created behind the scenes. Alternatively you can
-    # pass in a VcoSession object or a WorkflowService object if you have
-    # constructed them yourself.
+    # pass in a Config or a WorkflowService object if you have
+    # constructed them yourself. You may also pass in the path to a
+    # configuration file (`config_file`).
+    #
     # @param [String] name Name of the requested workflow
-    # @param [Hash] options Hash of options, see README.md for details
+    # @param [Hash] options Hash of options:
+    #  - id: (String) GUID for the Workflow
+    #  - url: (String) vCO REST API URL
+    #  - username: (String) User to authenticate as
+    #  - password: (String) Password for username
+    #  - verify_ssl: (Boolean) Perform TLS/SSL certificate validation
+    #  - service: (VcoWorkflows::WorkflowService) WorkflowService to use for communicating to vCO
+    #  - config: (VcoWorkflows::Config) Configuration object to use for this workflow's session
+    #  - config_file: (String) Path to load configuration file from for this workflow's session
     # @return [VcoWorkflows::Workflow]
     def initialize(name = nil, options = {})
       @options = {
@@ -72,9 +79,12 @@ module VcoWorkflows
         username: nil,
         password: nil,
         verify_ssl: true,
-        service: nil
+        service: nil,
+        config: nil,
+        config_file: nil
       }.merge(options)
 
+      config = nil
       @service = nil
       @execution_id = nil
 
@@ -84,11 +94,29 @@ module VcoWorkflows
 
       if options[:service]
         @service = options[:service]
-      elsif @options[:url] && @options[:username] && @options[:password]
-        session = VcoWorkflows::VcoSession.new(@options[:url],
-                                               user: @options[:username],
-                                               password: @options[:password],
-                                               verify_ssl: @options[:verify_ssl])
+      else
+        # If we were given a configuration object, use it
+        # If we were given a config file path, use it
+        # If we have a url, username and password, use them
+        # If all we have is a URL, try anyway, maybe we'll get username and
+        # password from ENV values (hey, it might work...)
+        if @options[:config]
+          config = @options[:config]
+        elsif @options[:config_file]
+          config = VcoWorkflows::Config.new(config_file: @options[:config_file])
+        elsif @options[:url] && @options[:username] && @options[:password]
+          config = VcoWorkflows::Config.new(url:        @options[:url],
+                                            username:   @options[:username],
+                                            password:   @options[:password],
+                                            verify_ssl: @options[:verify_ssl])
+        elsif @options[:url]
+          config = VcoWorkflows::Config.new(url:        @options[:url],
+                                            verify_ssl: @options[:verify_ssl])
+        end
+
+        # If we got a config object above, great. If it's still nil, VcoSession
+        # will accept that and try to load the default config file.
+        session  = VcoWorkflows::VcoSession.new(config: config)
         @service = VcoWorkflows::WorkflowService.new(session)
       end
 

data/spec/vcoworkflows/config_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../spec_helper.rb'
+require 'vcoworkflows'
+
+# rubocop:disable LineLength
+
+describe VcoWorkflows::Config, 'Config' do
+  before(:each) do
+    @url = 'https://vcoserver.example.com:8281/vco/api'
+    @username = 'johndoe'
+    @password = 's3cr3t'
+
+    @config_file = '/tmp/vcoconfig.json'
+    @config_data = {
+      url: @url,
+      username: @username,
+      password: @password
+    }.to_json
+
+    allow(File).to receive(:read).and_call_original
+    allow(File).to receive(:read).with(@config_file).and_return(@config_data)
+  end
+
+  it 'should configure the URL from parameters' do
+    config = VcoWorkflows::Config.new(url: @url, username: @username, password: @password)
+
+    expect(config.url).to eql(@url)
+  end
+
+  it 'should configure the username from parameters' do
+    config = VcoWorkflows::Config.new(url: @url, username: @username, password: @password)
+
+    expect(config.username).to eql(@username)
+  end
+
+  it 'should configure the password from parameters' do
+    config = VcoWorkflows::Config.new(url: @url, username: @username, password: @password)
+
+    expect(config.password).to eql(@password)
+  end
+
+  it 'should configure the URL from a configuration file' do
+    config = VcoWorkflows::Config.new(config_file: @config_file)
+
+    expect(config.url).to eql(@url)
+  end
+
+  it 'should configure the username from a configuration file' do
+    config = VcoWorkflows::Config.new(config_file: @config_file)
+
+    expect(config.username).to eql(@username)
+  end
+
+  it 'should configure the password from a configuration file' do
+    config = VcoWorkflows::Config.new(config_file: @config_file)
+
+    expect(config.password).to eql(@password)
+  end
+end

data/spec/vcoworkflows/vcosession_spec.rb

@@ -8,23 +8,44 @@ describe VcoWorkflows::VcoSession, 'VcoSession' do
     @uri = 'https://vcoserver.example.com:8281'
     @username = 'johndoe'
     @password = 's3cr3t'
+
+    @config = VcoWorkflows::Config.new(url: @uri, username: @username, password: @password)
+  end
+
+  it 'should set the URL from parameters' do
+    vs = VcoWorkflows::VcoSession.new(uri: @uri, user: @username, password: @password)
+    api_url = '/vco/api'
+
+    expect(vs.rest_resource.url).to eql(@uri << api_url)
+  end
+
+  it 'should set the username from parameters' do
+    vs = VcoWorkflows::VcoSession.new(uri: @uri, user: @username, password: @password)
+
+    expect(vs.rest_resource.user).to eql(@username)
+  end
+
+  it 'should set the password from parameters' do
+    vs = VcoWorkflows::VcoSession.new(uri: @uri, user: @username, password: @password)
+
+    expect(vs.rest_resource.password).to eql(@password)
   end
 
-  it 'should set the URL' do
-    vs = VcoWorkflows::VcoSession.new(@uri, user: @username, password: @password)
+  it 'should set the URL from configuration' do
+    vs = VcoWorkflows::VcoSession.new(config: @config)
     api_url = '/vco/api'
 
     expect(vs.rest_resource.url).to eql(@uri << api_url)
   end
 
-  it 'should set the username' do
-    vs = VcoWorkflows::VcoSession.new(@uri, user: @username, password: @password)
+  it 'should set the username from configuration' do
+    vs = VcoWorkflows::VcoSession.new(config: @config)
 
     expect(vs.rest_resource.user).to eql(@username)
   end
 
-  it 'should set the password' do
-    vs = VcoWorkflows::VcoSession.new(@uri, user: @username, password: @password)
+  it 'should set the password from configuration' do
+    vs = VcoWorkflows::VcoSession.new(config: @config)
 
     expect(vs.rest_resource.password).to eql(@password)
   end

data/spec/vcoworkflows/workflow_spec.rb

@@ -30,9 +30,42 @@ describe VcoWorkflows::Workflow, 'Workflow' do
 
     # Mock the WorkflowService
     @service = double('service')
-    allow(@service).to receive(:get_workflow_for_id) { @workflow_json }
-    allow(@service).to receive(:get_workflow_for_name) { @workflow_json }
-    allow(@service).to receive(:get_presentation) { @presentation_json }
+    allow(@service).to receive(:get_workflow_for_id).and_return(@workflow_json)
+    allow(@service).to receive(:get_workflow_for_name).and_return(@workflow_json)
+    allow(@service).to receive(:get_presentation).and_return(@presentation_json)
+
+    # Config object, file, data for constructor testing
+    @config_file = '/tmp/vcoconfig.json'
+    @config_data = {
+      url: @url,
+      username: @username,
+      password: @password
+    }.to_json
+    @config = VcoWorkflows::Config.new(url: 'https://vcoserver.example.com:8281/vco/api',
+                                       username: 'johndoe',
+                                       password: 's3cre3t')
+    allow(VcoWorkflows::VcoSession).to receive(:new).and_return(true)
+    allow(VcoWorkflows::WorkflowService).to receive(:new).and_return(@service)
+    allow(File).to receive(:read).and_call_original
+    allow(File).to receive(:read).with(@config_file).and_return(@config_data)
+  end
+
+  it 'should not explode when created with service' do
+    wf = VcoWorkflows::Workflow.new(@workflow_name, service: @service)
+
+    expect(wf).to_not eq(nil)
+  end
+
+  it 'should not explode when created with config' do
+    wf = VcoWorkflows::Workflow.new(@workflow_name, config: @config)
+
+    expect(wf).to_not eq(nil)
+  end
+
+  it 'should not explode when created with config_file' do
+    wf = VcoWorkflows::Workflow.new(@workflow_name)
+
+    expect(wf).to_not eq(nil)
   end
 
   it 'should parse a single string parameter' do
@@ -79,12 +112,6 @@ describe VcoWorkflows::Workflow, 'Workflow' do
     expect(wfparams['arrayparam'].value).to eql(%w(a b c))
   end
 
-  it 'should not explode' do
-    wf = VcoWorkflows::Workflow.new(@workflow_name, service: @service)
-
-    expect(wf).to_not eq(nil)
-  end
-
   it 'should have input and output parameters' do
     input_param_count = 13
     output_param_count = 3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vcoworkflows
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Gregory Ruiz-ade
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2015-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -226,9 +226,9 @@ files:
 - bin/vcoworkflows
 - example.rb
 - lib/vcoworkflows.rb
-- lib/vcoworkflows/cli/auth.rb
 - lib/vcoworkflows/cli/execute.rb
 - lib/vcoworkflows/cli/query.rb
+- lib/vcoworkflows/config.rb
 - lib/vcoworkflows/constants.rb
 - lib/vcoworkflows/runner.rb
 - lib/vcoworkflows/vcosession.rb
@@ -240,6 +240,7 @@ files:
 - lib/vcoworkflows/workflowservice.rb
 - lib/vcoworkflows/workflowtoken.rb
 - spec/spec_helper.rb
+- spec/vcoworkflows/config_spec.rb
 - spec/vcoworkflows/vcosession_spec.rb
 - spec/vcoworkflows/workflow_spec.rb
 - spec/vcoworkflows/workflowexecutionlog_spec.rb
@@ -268,12 +269,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: vCO Workflows REST API Wrapper
 test_files:
 - spec/spec_helper.rb
+- spec/vcoworkflows/config_spec.rb
 - spec/vcoworkflows/vcosession_spec.rb
 - spec/vcoworkflows/workflow_spec.rb
 - spec/vcoworkflows/workflowexecutionlog_spec.rb

data/lib/vcoworkflows/cli/auth.rb

@@ -1,41 +0,0 @@
-require 'vcoworkflows/constants'
-
-# VcoWorkflows
-module VcoWorkflows
-  # Cli
-  module Cli
-    # Auth is a very small helper class to allow pulling authentication
-    # credentials from the environment when using one of the executable
-    # commands.
-    #
-    # If credentials aren't passed in as options to the command, we'll
-    # also check the environment for $VCO_USER and $VCO_PASSWD and use
-    # those. Otherwise, command line options will override environment
-    # values.
-    class Auth
-      # username
-      # @return [String]
-      attr_reader :username
-
-      # password
-      # @return [String]
-      attr_reader :password
-
-      # Initialize the Auth object. If the paramaters are nil, look
-      # for values in the environment instead.
-      # @param [String] username vCenter Orchestrator user name
-      # @param [String] password vCenter Orchestrator password
-      # @return [VcoWorkflows::Cli::Auth]
-      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