vcseif 1.2.0

data/lib/vcseif/utils/auxloader.rb

@@ -0,0 +1,255 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+#################################################################################################
+#
+# auxload  - Auxiliary functionality loader
+#              Contains classes to load auxiliary (plugin and extension) classes
+#              or the *_connection classes.
+#            A specification for functionality looks like:
+#                               class_name.method_name
+#              or
+#                 facility_name.class_name.method_name
+#
+#################################################################################################
+
+class AuxLoader
+
+    @@facility_class_name  = ""
+    @@facility_class       = nil
+    @@facility = {}  # key by @@facility_class_name, value is @@facility_class object
+
+    def self.getFacility(facility_type, facility_class_name, facility_name=nil)
+        """
+            Given a facility_class_name, look into @@facility for a key match.
+            If found return the corresponding value, which must be the
+            class object for the facility_class.
+        """
+        if not @@facility.include?(facility_class_name)
+            loadFacility(facility_type, facility_class_name, facility_name)
+        end
+        return @@facility[facility_class_name] || nil
+    end
+
+    def self.is_qualified?(target_dir, fn)
+        qualified = fn.end_with?('.rb') and File.file?('%s/%s' % [target_dir, fn])
+        return qualified
+    end
+           
+    def self.loadFacility(subdir, class_name, facility=nil, method_existence=nil)
+        %{
+            Work the Ruby machinery to require in a Ruby file such that 
+            a subsequent Kernel.const_get(class_name) works successfully.
+            The subdir parm is relative to ENV['VCS_APP_ROOT'].
+            The optional facility parm can "name" a specific file the class
+            must exist in.
+            Caller can also specify a string or an array of strings with method
+            names that must exist in the loaded class.
+        }
+        fq_facility_dir = "#{ENV['VCS_APP_ROOT']}/#{subdir}"  # fully qualified path to subdir
+##
+##    puts "  loadFacility fq_facility_dir value: |%s|" % fq_facility_dir
+##    $stdout.flush()
+##
+
+        if not File.exists?(fq_facility_dir)
+            raise StandardError, 'target subdir: %s not found' % [fq_facility_dir]
+        end
+        if not File.directory?(fq_facility_dir)
+            raise StandardError, 'target path %s is not a directory' % [fq_facility_dir]
+        end
+
+        if facility.nil?
+            target_dir = fq_facility_dir
+            rbfiles = Dir.entries(target_dir).select {|fn| self.is_qualified?(target_dir, fn)}
+            facility_names = rbfiles.collect {|fn| fn[0...-3]}  # squeeze off the '.rb' portion of the name
+        else
+            facility_path = '%s/%s.rb' % [fq_facility_dir, facility]
+            if not File.file?(facility_path)
+                raise StandardError, 'No such %s module: %s found' % [subdir, facility_path]
+            end
+            facility_names = [facility]
+        end
+##
+##    puts "  facility_names: #{facility_names.inspect}"
+##    $stdout.flush()
+##
+
+        target_classes_found = 0
+        tc_facility = {}   # target class facility lookup dict
+        # look in all facilities, record the facility name if the facility_class_name is defined in there
+        facility_names.each do |facility_name|
+            facility_file = '%s/%s.rb' % [fq_facility_dir, facility_name]
+            File.open(facility_file) do |ff|
+                target_class_defs = ff.readlines.select {|line| line =~ /^class #{class_name}\s*/}
+                if target_class_defs.length > 0
+                    tc_facility[class_name] = "%s/%s" % [subdir, facility_name]
+                    target_classes_found +=1 
+                end
+            end
+        end
+
+        if target_classes_found < 1
+            problem = "No class: '%s' defined in any file located in the '%s' directory"
+            raise StandardError, problem % [class_name, fq_facility_dir]
+        end
+        if target_classes_found > 1
+            problem = "%s class: '%s' defined in more than one file located in the '%s' directory"
+            raise StandardError, problem % [subdir, class_name, fq_facility_dir]
+        end
+
+        begin
+            require "#{tc_facility[class_name]}"
+        rescue Exception => ex
+            $stderr.write("Auxloader detected exception on require of #{tc_facility[class_name]}:\n")
+            $stderr.write("    #{ex.message}\n")
+            $stderr.flush()
+            raise
+        end
+
+        begin
+            @@facility_class = Kernel.const_get(class_name)
+        rescue Exception => ex
+            $stderr.write("Caught exception loading #{class_name}: #{ex.message}\n")
+            raise
+        end
+
+        if method_existence != nil
+            if method_existence.class.name == 'String'
+                method_existence = method_existence.split(',').collect {|mn| mn.strip()}
+            elsif method_existence.class.name != 'Array'
+                raise Exception, "method_existence parm must be a String or an Array of Strings"
+            end
+            for method_name in method_existence do
+                method = @@facility_class.instance_methods.select {|m| m == method_name.to_sym}
+                if method == nil or method == false
+                    puts "Unable to validate that the %s class has a %s method" % [class_name,  method_name]
+                end
+            end
+        end
+
+        @@facility[class_name]  = @@facility_class
+        return @@facility[class_name]
+    end
+
+end
+
+#################################################################################################
+
+class ClassLoader < AuxLoader
+
+    def self.loadConnectionClass(subdir, class_name, facility_name=nil)
+        %{
+            A generalized means of loading a class. 
+            The priority ladder is to first attempt to find and load
+            the class_name from the specific subdir named in any facility_name supplied,
+            In the event that fails, the next attempt to get the class loaded in 
+            looks in the '#{ENV['VCS_APP_ROOT']}/lib/vcseif' subdirectory.
+            If that also fails, an attempt is made to load the class via 
+            Kernel.const_get in the event that the class is in an already loaded gem.
+            If a facility_name is given, it restricts the location of the class
+            to a specific Ruby file (named by facility_name, which would be the part of 
+            the filename without the ".rb" suffix).
+         }
+##
+##        $stdout.write("call of ClassLoader.loadConnectionClass(#{subdir}, #{class_name}, #{facility_name})\n")
+##        $stdout.flush()
+##
+        candidates = [[1, subdir], [2, 'lib/vcseif']]
+        for rung, candidate in candidates do
+            fq_facility_dir = "#{ENV['VCS_APP_ROOT']}/#{candidate}"  # fully qualified path to candidate
+            if not File.exists?(fq_facility_dir) or not File.directory?(fq_facility_dir)
+##
+##              $stdout.write("    rung ##{rung} of loadConnectionClass skipped\n")
+##
+                next
+            end
+
+            success = false
+            begin
+                conn_class = loadFacility(candidate, class_name, facility_name)
+##
+##              $stdout.write("    rung ##{rung} of loadConnectionClass succeeded\n")
+##              $stdout.flush()
+##
+                success = true
+            rescue Exception => ex
+##
+##              $stdout.write("    rung ##{rung} of loadConnectionClass failed...\n")
+##              $stdout.flush()
+##
+                raise if ex.message.include?("defined in more than one file")
+            end
+            return conn_class if success
+
+        end
+
+        #
+        # try a Kernel.const_get(class_name) to see
+        # if we can obtain the class from an already loaded relevant *eif gem
+        #
+        begin
+            @@facility_class = Kernel.const_get(class_name)
+            success = true
+        rescue Exception => ex
+            $stderr.write("Caught exception attempting to load #{class_name}: #{ex.message}\n")
+            raise
+        end
+        return @@facility_class if success
+
+        return nil
+    end
+
+end
+
+#################################################################################################
+
+class PluginLoader < AuxLoader
+
+    def self.loadFacility(facility_type, facility_class_name, facility_name)
+        super('plugin', facility_class_name, facility_name, 'service')
+    end
+
+    def self.getPlugin(plugin_class_name) 
+        """
+            Given a plugin_class_name as a String, return the corresponding class
+            if such a class exists in the conventional location.
+        """
+        return getFacility('plugin', plugin_class_name)
+    end
+
+end
+
+##########################################################################################################
+
+class ExtensionLoader < AuxLoader
+
+    def self.loadFacility(facility_type, facility_class_name, facility_name)
+        super('extension', facility_class_name, facility_name, 'service')
+    end
+
+    def self.getExtension(extension_spec)
+        """
+            Given an extension_spec as a String (in either 'ClassName or facility.ClassName' 
+            format), return the corresponding class if such a class exists in the 
+            extension subdirectory.
+        """
+##
+##      puts "ExtensionLoader.getExtension extension_spec: |%s|" % extension_spec
+##
+        facility_name = nil
+        #split the extension_spec on '.'
+        if not extension_spec.include?('.')
+            extension_class_name = extension_spec
+        elsif extension_spec.count('.') == 1
+            facility_name, extension_class_name = extension_spec.split('.')
+            # where facility_name is the basename of a Ruby file containing the extension_class_name
+        else
+            raise StandardError, 'Invalid extension specification: %s' % extension_spec
+        end
+            
+        return getFacility('extension', extension_class_name, facility_name)
+    end
+
+end
+
+

data/lib/vcseif/utils/exceptions.rb

@@ -0,0 +1,101 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+module VCSEIF_Exceptions
+
+######################################################################################
+
+$_blurt  = false
+$_logger = nil
+
+######################################################################################
+
+def self.logAllExceptions(truthiness, logger=nil)
+    """
+        Call this method when you want the convenience of raising the 
+        Exception subclasses defined in this file module without having to supply
+        an instance of a logger for each raise statement. 
+        Simply supply the logger to be used in this call and you're set
+        for the duration!
+    """
+    if truthiness and !logger.nil?
+        $_blurt = true
+        $_logger = logger
+    else
+        $_blurt = false
+        $_logger = nil
+    end
+end
+
+######################################################################################
+
+class VCSEIF_Exception < StandardError
+
+    @@log_level = 'info'
+
+    attr_accessor :verbiage
+
+    def initialize(msg, logger=nil)
+        mod_name, class_name = self.class.name.split("::")
+        if !logger.nil?
+            logger.send(@@log_level, msg, self)
+        elsif ($_blurt and !$_logger.nil?)
+          $_logger.send(@@log_level, msg, self)
+        #else
+        ## prepend the specific exception class name to the msg text
+        #    $stderr.write("%s: %s\n" % [class_name, msg])
+        end
+        @verbiage = msg
+    end
+end
+
+class RecoverableException < VCSEIF_Exception
+    """
+        This brand of VCSEIF_Exception is intended be used when a single atomic operation
+        has failed but further processing can be attempted.
+    """
+    @@log_level = 'warn'
+end
+
+class UnrecoverableException < VCSEIF_Exception
+    """
+        This brand of VCSEIF_Exception is intended be used when an operation has failed and
+        no further processing can or should be attempted.  
+        The condition that caused this operation failure is either caused by a 
+        bad configuration or something else that won't be different with the passage
+        of time.
+    """
+    @@log_level = 'error'
+end
+
+class ConfigurationError < VCSEIF_Exception
+    """
+        This brand of VCSEIF_Exception is intended to be used when a configuration error
+        has been detected. Because of the configuration error no further processing
+        can or should proceed. The configuration will have to be fixed or this 
+        exception would be raised again in a future invocation.
+    """
+    @@log_level = 'fatal'
+end
+
+class NonFatalConfigurationError < VCSEIF_Exception
+    """
+        This brand of VCSEIF_Exception is intended to be used when a configuration error
+        has been detected. This exception differs from the ConfigurationError
+        in that the configuration error detected will not prevent reasonable operation
+        from proceeding but should be noted for future correction.
+    """
+    @@log_level = 'error'
+end
+
+class OperationalError < VCSEIF_Exception
+    """
+        This brand of VCSEIF_Exception is intendedto be used when an operation has failed and
+        no further processing can or should be attempted.  
+        The condition that caused this though may not be in place if the operation were
+        attempted again at a later time.
+    """
+    @@log_level = 'error'
+end
+
+end  # of the VCSEIF_Exceptions Module
+

data/lib/vcseif/utils/fuzzer.rb

@@ -0,0 +1,71 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+require "base64"
+
+# This really basic algorithm encodes but does not encrypt strings
+
+#Thanks to Erika for the idea about adding some text at the beginning of the encoded password
+# This clues people in that the password is encoded and also makes sure that the encoding decoding will never fail.
+# Without the extra text, "It will fail if a password has the same number of SEPARATORs as characters"
+
+class Fuzzer
+  SEPARATOR = "-"
+  ENCODED = "encoded" + SEPARATOR
+
+  def self.encode(string)
+    return string if string.class.name != 'String'
+    return string if string.empty?
+    encoded = ""
+    Base64.encode64(string).each_byte { |b|
+      if ( b != 10 ) # \n
+        encoded = encoded + b.chr + SEPARATOR
+      end 
+    }
+    return ENCODED + encoded
+  end
+
+  def self.fuzz(string)
+    # would have been nice to be able to do alias_method :fuzz, :encode
+    return self.encode(string) 
+  end
+
+
+  def self.decode(string)
+    return string if string.class.name != 'String'
+    return string if string.empty?
+    if self.is_encoded?(string)
+      decoded = self.remove_every_second_char(string.slice(ENCODED.length,string.length))
+      return Base64.decode64(decoded)
+    else
+      return string
+    end
+  end
+
+  def self.defuzz(string)
+    #would have been nice to be able to do alias_method :defuzz, :decode
+    return self.decode(string)
+  end
+
+
+  def self.is_encoded?(string)
+    %{
+       Does the string arg  start with "encoded-" and are there an 
+       equal number of separator strings and regular characters?
+     } 
+    return false if string.class.name != 'String'
+    sliced = string.slice(ENCODED.length, string.length)
+    return string.slice(0,ENCODED.length) == ENCODED && sliced.length == sliced.count(SEPARATOR)*2
+  end
+
+  private
+  def self.remove_every_second_char(string)
+    scrunched = ""
+    for i in 0..string.length-1
+      if i%2 == 0
+        scrunched = scrunched + string.slice(i, 1)
+      end
+    end
+    return scrunched
+  end
+
+end

data/lib/vcseif/utils/konfigger.rb

@@ -0,0 +1,421 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+__doc__ = %{
+  The Konfabulator class defined in this file handles deconstructing a Hash based
+  configuration to enable easy access to the semantics of the configuration specification.
+  In addition, the Konfabulator encodes any clear text passwords in the underlying file
+  from which the Hash was populated.
+}
+
+#################################################################################################
+
+require 'fileutils'   # for copy, move, remove_file 
+
+require_relative "exceptions" # for ConfigurationError, NonFatalConfigurationError
+require_relative "fuzzer"     # for Fuzzer
+
+#################################################################################################
+
+SUPPORTED_VCS_TARGETS = ['Mercurial', 'Git', 'Subversion', 'Perforce', 'TFS', 'Bazaar']
+
+#################################################################################################
+
+class Konfabulator
+    %{
+        An instance of this class provides a means to slurp configuration information
+        from a Ruby Hash structure and arrange it within the instance for easy consumption
+        by holders of a Konfabulator instance.
+        An instance also offers the capability to "fuzz" clear-text passwords in a
+        config file into an encoded (but not encrypted) form and to be able to handle
+        defuzzing those encoded passwords for holders of the instance when they access
+        those values in the instance.
+     }
+    attr_accessor :top_level_sequence
+    attr_reader   :config, :config_name, :log, :vcs_header, :content
+
+    def initialize(config_spec, logger)
+        """
+            config_spec is a Hash 
+        """
+        
+        @config      = config_spec
+        @config_name = config_spec['ConfigName']
+        @log = logger
+        @top_level_sequence = []
+
+        content = []
+        begin
+          cf = File.open(config_spec['ConfigPath'], "r")
+          @content = cf.readlines()
+          cf.close()
+        rescue IOError => ex
+          raise
+        end
+
+        conf_lines = @content.select { |line| line.class.name == "String" and line !~ /^\s*#/ }
+        section_headers = conf_lines.select { |line| line =~ /^[A-Z][A-Za-z_]+.+\s*:/}
+        if section_headers.length < 2
+            problem = 'Insufficient content in config file: %s' % @config['ConfigPath']
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+        if section_headers.length > 5
+            admonition = 'Excess content in config file: %s' % @config['ConfigPath']
+            confex = VCSEIF_Exceptions::NonFatalConfigurationError.new(admonition)
+            raise confex, admonition
+        end
+        section_headers = section_headers.collect {|sh| sh.strip().sub(/\s*:.*$/, '')}
+
+        connector_ident_header = section_headers.shift()
+        if connector_ident_header !~ /Connector/
+            problem = 'First section in config file must identify the Connector type'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        rally_header = section_headers.shift()
+        if not rally_header.start_with?('Rally')
+            problem = 'Second section in config file must be Rally section'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+        @top_level_sequence << 'Rally'
+
+        @vcs_header = section_headers.shift
+
+        known = SUPPORTED_VCS_TARGETS.include?(@vcs_header)
+        if known.nil? or not known
+            problem = 'Third section in config file must identify a known VCS identifier'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+        @top_level_sequence << @vcs_header
+
+        # set up defaults for the Services and Transforms sections if those sections aren't in the config file
+        if not @config.has_key?('Services')
+            @config['Services'] = {}
+            @config['Services']['LogLevel'] = 'Info'
+            @config['Services']['Preview']  = false
+            @config['Services']['PostBatchExtension']  = nil
+            @log.info('no Services section specified in the config, using default settings')
+            @top_level_sequence << 'Services'
+        end
+
+        if not @config.has_key?('Transforms')
+            @config['Transforms'] = {}
+            @log.info('no Transforms section specified in the config')
+            @top_level_sequence << 'Transforms'
+        end
+
+        while section_headers.length > 0 do
+            header = section_headers.shift
+            begin
+                if not ['Services', 'Transforms'].include?(header)
+                    problem = 'Unrecognized section header "%s" found in config' % header
+                    confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+                    raise confex, problem
+                else
+                    @top_level_sequence << header
+                end
+            rescue VCSEIF_Exceptions::ConfigurationError => ex
+              # noop
+            end
+        end
+
+        checkRallySectionSanity
+        checkTargetVCSSectionSanity
+
+        # defuzz the passwords for our internal use if they are fuzzed, 
+        # and if they are not, fuzz them in the file
+        defuzzPasswords()
+    end
+
+
+    private
+    def checkRallySectionSanity() 
+        """ do some rudimentary checking for Rally section subitems of Server, 
+            Protocol, Username, Password, Workspace, RepositoryName
+        """
+        rally = @config['Rally']
+
+        server_spec = rally['Server'] || nil
+        if server_spec.nil? or server_spec.empty?
+            problem = 'No Server specification item value detected in the Rally section of the config'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        proto_spec = rally['Protocol'] || nil
+        if proto_spec.nil? or proto_spec.empty?
+            proto_spec = 'https'
+            rally['Protocol'] = proto_spec
+        end
+        if not ['http', 'https'].include?(proto_spec)
+            problem = "Invalid Protocol specification item value '%s' detected in the Rally section of the config" % proto_spec
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        user_name = rally['Username']   || nil
+        if user_name.nil? or user_name.empty?
+            problem = 'No Username value detected in the Rally section of the config'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        password  = rally['Password']   || nil
+        if password.nil? or password.empty?
+            problem = 'No Password value detected in the Rally section of the config'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        workspace = rally['Workspace']  || nil
+        if workspace.nil? or workspace.empty?
+            problem = 'No Workspace value detected in the Rally section of the config'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        repo_name = rally['RepositoryName'] || nil
+        if repo_name.nil? or repo_name.empty?
+            problem = 'No RepositoryName value detected in the Rally section of the config'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+
+        lookback = rally['Lookback'] || nil
+        if lookback.nil? #or lookback.class.name != "Fixnum"
+            rally['Lookback'] = 90  # default to 90 minutes if not specified
+        end
+
+        upd_art_state = rally['UpdateArtifactState'] || nil
+        if upd_art_state.nil?
+            rally['UpdateArtifactState'] = false
+        end
+
+        if rally['UpdateArtifactState']
+            statex_class_name = rally['StateExtractorClass'] || nil
+            if statex_class_name.nil?
+                rally['StateExtractorClass'] = 'BasicActionsAndArtifactsExtractor'
+                @log.warn('Defaulting StateExtractorClass to %s, as UpdateArtifactState was set to true but no value was provided for the StateExtractorClass' % rally['StateExtractorClass'])
+            end
+        end
+
+    end
+
+    def checkTargetVCSSectionSanity()
+        """
+            Need to have RepositoryBase for non TFS VCS systems (Git, Hg, Subversion)
+            Can have  Server, Username, Password
+                      Uri, Lookback, MaxItems, Debug
+        """
+        non_vcs_sections = ['Rally', 'Transforms', 'Services'] 
+        sections = topLevels().select {|name| non_vcs_sections.include?(name) == false}
+        vcs_section_name = sections.first
+        vcs = @config[vcs_section_name]
+
+        if not vcs_section_name.start_with?('TFS')
+          repo_base = vcs['RepositoryBase'] || nil
+          if repo_base.nil?
+            problem = 'No RepositoryBase value detected in the %s section of the config' % vcs_section_name
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+          end
+        else
+          collection_name = vcs['CollectionName'] || nil
+          if collection_name.nil? || collection_name.empty?
+            problem = 'No CollectionName value detected in the %s section of the config' % vcs_section_name
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+          end
+          team_project_name = vcs['TeamProject'] || nil
+          if team_project_name.nil? || team_project_name.empty?
+            problem = 'No TeamProject value detected in the %s section of the config' % vcs_section_name
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+          end
+          tfs_server_version = vcs['TfsServerVersion'] || nil
+          if tfs_server_version.nil? || tfs_server_version.to_s.empty?
+            problem = 'No TfsServerVersion value detected in the %s section of the config' % vcs_section_name
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+          end
+        end
+
+        # default VCS Lookback value to 90 if not set or not set correctly
+        lookback = vcs['Lookback'] || nil
+        if lookback.nil? #or lookback.class.name != "Fixnum"
+            vcs['Lookback'] = 90 
+        end
+
+        # default VCS MaxItems to 1000 if not set or not set correctly
+        max_items = vcs['MaxItems'] || nil
+        if max_items.nil? or max_items.class.name != "Fixnum"
+            vcs['MaxItems'] = 1000  
+        end
+    end
+
+    public
+    def topLevels()
+        return @top_level_sequence
+    end
+
+
+    def topLevel(section_name)
+        if section_name == 'VCS'
+            non_vcs_sections = ['Rally', 'Transforms', 'Services'] 
+            sections = topLevels().select {|name| non_vcs_sections.include?(name) == false}
+            section_name = sections.first
+        end
+            
+        if @top_level_sequence.include?(section_name) and @config.has_key?(section_name)
+            return @config[section_name]
+        else
+            problem = 'Attempt to retrieve non-existent top level config section for %s'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem % section_name)
+            raise confex, problem % section_name
+        end
+    end
+
+
+    def connectionClassName(section_name)
+        if not @config.has_key?(section_name)
+            problem = 'Attempt to identify connection class name for %s, operation not supported'
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem % section_name)
+            raise confex, problem % section_name
+        end
+        if not ['Rally', @vcs_header].include?(section_name)
+            problem ='Candidate connection class name "%s" not viable for operation' % section_name
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem % section_name
+        end
+        section = @config[section_name]
+        if section.has_key?('Class')
+            class_name = section['Class']
+        else
+            class_name = 'RallyVCSConnection' 
+            if section_name != 'Rally'
+                class_name = '%sConnection' % @vcs_header
+            end
+        end
+
+        return class_name
+    end
+
+       
+    private
+    def defuzzPasswords()
+        rpw = @config['Rally']['Password']
+        if Fuzzer.is_encoded?(rpw)
+            @config['Rally']['Password'] = Fuzzer.defuzz(rpw)
+        else
+            fuzzPassword('Rally', 'Password', rpw)
+        end
+
+        proxy_pw = @config['Rally']['ProxyPassword']
+        unless proxy_pw.nil?
+          if Fuzzer.is_encoded?(proxy_pw)
+              @config['Rally']['ProxyPassword'] = Fuzzer.defuzz(proxy_pw)
+          else
+              fuzzPassword('Rally', 'ProxyPassword', proxy_pw)
+          end
+        end
+
+        # in many cases, there isn't a requirement that the VCS section have a Password entry
+        vpw = @config[@vcs_header]['Password'] || nil
+        if not vpw.nil?
+            if Fuzzer.is_encoded?(vpw)
+                @config[@vcs_header]['Password'] = Fuzzer.defuzz(vpw)
+            else
+                fuzzPassword(@vcs_header, 'Password', vpw)
+            end
+        end
+    end
+
+
+    def fuzzPassword(conn_section, password_section, clear_text_password)
+        """
+            Check to see whether or not the Password entries in one or both of the connection
+            sections are not encoded.  If not, encode them and write out the config file
+            changing *only* those two entries.
+        """
+        return false if Fuzzer.is_encoded?(clear_text_password)
+        encoded_password = Fuzzer.encode(clear_text_password)
+            
+        conf_lines = []
+        begin
+            cf = File.open(@config['ConfigPath'], 'r')
+        rescue IOError => ex
+            problem = 'Unable to open %s for reading, %s' % [@config['ConfigPath'], ex.message]
+            confex = VCSEIF_Exceptions::ConfigurationError.new(problem)
+            raise confex, problem
+        end
+        conf_lines = cf.readlines()
+        cf.close()
+
+        out_lines = []
+        ix = 0
+
+        # objective:   Find index of conn_section entry in conf_lines
+        #              then find index of next occurring Password : xxxx entry
+        #              substitute entry for Password : current with Password : encoded_password
+        hits = []
+        conf_lines.each_with_index do |line, ix|
+            hits << ix if line =~ /^#{conn_section}\s*:/
+        end
+        return false if hits.length == 0
+
+        section_ix = hits.first
+        hits = []
+        conf_lines.each_with_index do |line, ix|
+            hits << ix if line =~ /^\s+#{password_section}\s*:\s*/ and ix > section_ix
+        end
+        return false if hits.length == 0
+
+        pwent_ix = hits.first
+        conf_lines[pwent_ix] = "    #{password_section}  : %s\n" % encoded_password
+
+        enc_file_name = "#{@config['ConfigPath']}.pwenc"
+        enf = File.open(enc_file_name, 'w')
+        enf.write(conf_lines.join(""))
+        enf.close()
+       
+        bkup_name = "#{@config['ConfigPath']}.bak"
+        begin
+            FileUtils.copy(@config['ConfigPath'], bkup_name)
+        rescue Exception => ex
+            problem = "Unable to write a temporary backup file '%s' with config info, %s"
+            @log.warn(problem % [bkup_name, ex.message])
+            return false
+        end
+
+        begin
+            FileUtils.remove_file(@config['ConfigPath'])
+        rescue Exception => ex
+            problem =  "Unable to remove config file prior to replacement with "
+            problem << "password encoded version of the file, %s"
+            @log.warn(problem % ex.message)
+            return false
+        end
+
+        begin
+            FileUtils.move(enc_file_name, @config['ConfigPath'])
+        rescue Exception => ex
+            problem =  "Unable to rename config file with password encoded "
+            problem << "to standard config filename of %s, %s"
+            @log.error(problem % [@onfig['ConfigPath'], ex.message])
+            return false
+        end
+
+        begin
+            FileUtils.remove_file(bkup_name)
+        rescue Exception => ex
+            @log.warn("Unable to remove temporary backup file for config, %s" % ex.message)
+            return false
+        end
+
+        return true
+    end
+
+end  # of Konfabulator