brpm_content 0.1.16

data/modules/bladelogic/lib/bl_soap/job_group.rb

@@ -0,0 +1,72 @@
+# does not support add/remove permissions or ACL, makes no sense in BRPM
+# does not support creating job groups
+# does not support setting descriptions
+class JobGroup < BsaSoapBase
+  def create_group_with_parent_name(options = {})
+    validate_cli_options_hash([:group_name, :parent_group_name], options)
+    integer_result = execute_cli_with_param_list(self.class, "createGroupWithParentName",
+                                                 [
+                                                     options[:group_name],			# group name to be created
+                                                     options[:parent_group_name]		# parent group name
+                                                 ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+
+  def create_job_group(options = {})
+    validate_cli_options_hash([:group_name, :parent_id], options)
+    integer_result = execute_cli_with_param_list(self.class, "createJobGroup",
+                                                 [
+                                                     options[:group_name],	# group name to be created
+                                                     options[:parent_id]		# parent group id
+                                                 ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+
+  def find_all_groups_by_parent_group_name(options = {})
+    validate_cli_options_hash([:job_group], options)
+    string_result = execute_cli_with_param_list(self.class, "findAllGroupsByParentGroupName",
+                                                [
+                                                    options[:job_group]	# Fully qualified parent job group name (/ for root group)
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def group_exists(options = {})
+    validate_cli_options_hash([:group_name], options)
+    boolean_result = execute_cli_with_param_list(self.class, "groupExists",
+                                                 [
+                                                     options[:group_name]	# Fully qualified job group name (/ for root group)
+                                                 ])
+    boolean_value = get_cli_return_value(boolean_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def group_name_to_db_key(options = {})
+    validate_cli_options_hash([:group_name], options)
+    db_key_result = execute_cli_with_param_list(self.class, "groupNameToDBKey",
+                                                [
+                                                    options[:group_name]	# Fully qualified job group name (/ for root group)
+                                                ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def group_name_to_id(options = {})
+    validate_cli_options_hash([:group_name], options)
+    integer_result = execute_cli_with_param_list(self.class, "groupNameToId",
+                                                 [
+                                                     options[:group_name]	# Fully qualified job group name (/ for root group)
+                                                 ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+end

data/modules/bladelogic/lib/bl_soap/job_management.rb

@@ -0,0 +1,22 @@
+class JobManagement < BsaSoapBase
+  def get_job_manager_full_status(options = {})
+    string_result = execute_cli_with_param_list(self.class, "getJobManagerFullStatus")
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_job_manager_status(options = {})
+    string_result = execute_cli_with_param_list(self.class, "getJobManagerStatus")
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_running_jobs_status(options = {})
+    string_result = execute_cli_with_param_list(self.class, "getRunningJobsStatus")
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+end

data/modules/bladelogic/lib/bl_soap/job_result.rb

@@ -0,0 +1,12 @@
+class JobResult < BsaSoapBase
+  def find_job_result_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    job_run_key_result = execute_cli_with_param_list(self.class, "findJobResultKey",
+                                                     [
+                                                         options[:job_run_key]	# Handle associated with a particular job run
+                                                     ])
+    job_run_key = get_cli_return_value(job_run_key_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+end

data/modules/bladelogic/lib/bl_soap/job_run.rb

@@ -0,0 +1,271 @@
+class JobRun < BsaSoapBase
+  def change_priority_of_running_job_by_job_run_id(options = {})
+    validate_cli_options_hash([:job_run_id, :priority_string], options)
+    void_result = execute_cli_with_param_list(self.class, "changePriorityOfRunningJobByJobRunId",
+                                              [
+                                                  options[:job_run_id],		# Job run ID number
+                                                  options[:priority_string]	# Priority to change job run to
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def find_all_run_keys_by_job_key(options = {})
+    validate_cli_options_hash([:job_key], options)
+    string_result = execute_cli_with_param_list(self.class, "findAllRunKeysByJobKey",
+                                                [
+                                                    options[:job_key]	# DBKey key for the job
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def find_last_run_key_by_job_key(options = {})
+    validate_cli_options_hash([:job_key], options)
+    db_key_result = execute_cli_with_param_list(self.class, "findLastRunKeyByJobKey",
+                                                [
+                                                    options[:job_key],							# DBKey for the job
+                                                # NIEK options[:exclude_deploy_attempts] || false	# Exclude deploy attempt run id
+                                                ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def find_last_run_key_by_job_key_ignore_version(options = {})
+    validate_cli_options_hash([:job_key], options)
+    db_key_result = execute_cli_with_param_list(self.class, "findLastRunKeyByJobKeyIgnoreVersion",
+                                                [
+                                                    options[:job_key]	# DBKey for the job
+                                                ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def find_run_count_by_job_key(options = {})
+    validate_cli_options_hash([:job_key], options)
+    integer_result = execute_cli_with_param_list(self.class, "findRunCountByJobKey",
+                                                 [
+                                                     options[:job_key]	# DBKey for the job
+                                                 ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def find_run_key_by_id(options = {})
+    #findRunKeyById_1 is deprecated => No support for job_key option
+    validate_cli_options_hash([:job_run_id], options)
+    db_key_result = execute_cli_with_param_list(self.class, "findRunKeyById",
+                                                [
+                                                    options[:job_run_id]	# Run number of the job run
+                                                ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_aborted_job_runs_by_end_date(options = {})
+    validate_cli_options_hash([:end_type], options)
+    string_result = execute_cli_with_param_list(self.class, "getAbortedJobRunsByEndDate",
+                                                [
+                                                    options[:end_time]	# Time to use as the earliest end date, only runs aborted after this date will be shown
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_end_time_by_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    object_result = execute_cli_with_param_list(self.class, "getEndTimeByRunKey",
+                                                [
+                                                    options[:job_run_key],						# Handle identifying a particular job run
+                                                    options[:format] || "yyyy/MM/dd HH:mm:ss"	# Format for presenting time
+                                                ])
+    object_value = get_cli_return_value(object_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_executing_user_and_role_by_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    string_result = execute_cli_with_param_list(self.class, "getExecutingUserAndRoleByRunKey",
+                                                [
+                                                    options[:job_run_key]	# Handle identifying a particular job run
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_job_run_had_errors(options = {})
+    # getJobRunHadErrors_1 deprecated => No support
+    validate_cli_options_hash([:job_run_key], options)
+    boolean_result = execute_cli_with_param_list(self.class, "getJobRunHadErrors",
+                                                 [
+                                                     options[:job_run_key]	# Handle identifying a particular job run
+                                                 ])
+    boolean_value = get_cli_return_value(boolean_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_job_run_had_errors_by_id(options = {})
+    validate_cli_options_hash([:job_run_id], options)
+    boolean_result = execute_cli_with_param_list(self.class, "getJobRunHadErrorsById",
+                                                 [
+                                                     options[:job_run_id]	# Run ID for the job run
+                                                 ])
+    boolean_value = get_cli_return_value(boolean_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_job_run_is_running_by_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    boolean_result = execute_cli_with_param_list(self.class, "getJobRunIsRunningByRunKey",
+                                                 [
+                                                     options[:job_run_key]	# Handle identifying a particular job run
+                                                 ])
+    boolean_value = get_cli_return_value(boolean_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_job_run_status_by_schedule_id(options = {})
+    validate_cli_options_hash([:schedule_id], options)
+    string_result = execute_cli_with_param_list(self.class, "getJobRunStatusByScheduleId",
+                                                [
+                                                    options[:schedule_id]	# Handle identifying a particular job run
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_log_items_by_job_run_id(options = {})
+    validate_cli_options_hash([:job_key, :job_run_id], options)
+    string_result = execute_cli_with_param_list(self.class, "getLogItemsByJobRunId",
+                                                [
+                                                    options[:job_key],		# DB Key of the job
+                                                    options[:job_run_id]	# Job run ID number
+                                                ])
+    string_value = get_cli_return_value(string_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_servers_status_by_job_run(options = {})
+    validate_cli_options_hash([:job_run_id], options)
+    map_result = execute_cli_with_param_list(self.class, "getServerStatusByJobRun",
+                                             [
+                                                 options[:job_run_id]	# Job run ID number
+                                             ])
+    map_value = get_cli_return_value(map_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_start_time_by_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    object_result = execute_cli_with_param_list(self.class, "getStartTimeByRunKey",
+                                                [
+                                                    options[:job_run_key],						# Handle identifying a particular job run
+                                                    options[:format] || "yyyy/MM/dd HH:mm:ss"	# Format for presenting time
+                                                ])
+    object_value = get_cli_return_value(object_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def job_run_key_to_job_run_id(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    integer_result = execute_cli_with_param_list(self.class, "jobRunKeyToJobRunId",
+                                                 [
+                                                     options[:job_run_key]	# Handle identifying a particular job run
+                                                 ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def pause_running_job_by_job_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    void_result = execute_cli_with_param_list(self.class, "pauseRunningJobByJobRunKey",
+                                              [
+                                                  options[:job_run_key]	# Handle identifying a particular job run
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def resume_paused_job_by_job_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    void_result = execute_cli_with_param_list(self.class, "resumePausedJobByJobRunKey",
+                                              [
+                                                  options[:job_run_key]	# Handle identifying a particular job run
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def show_all_running_batch_job_run_status(options = {})
+    void_result = execute_cli_with_param_list(self.class, "showAllRunningBatchJobRunStatus")
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def show_all_running_post_prov_batch_job_run_status(options = {})
+    list_result = execute_cli_with_param_list(self.class, "showAllRunningPostProvBatchJobRunStatus")
+    list_value = get_cli_return_value(list_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def show_batch_job_run_status_by_run_id(options = {})
+    validate_cli_options_hash([:run_id], options)
+    void_result = execute_cli_with_param_list(self.class, "showBatchJobRunStatusByRunId",
+                                              [
+                                                  options[:run_id]	# Handle identifying a particular job run
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def show_batch_job_run_status_by_run_key(options = {})
+    validate_cli_options_hash([:job_run_key], options)
+    void_result = execute_cli_with_param_list(self.class, "showBatchJobRunStatusByRunId",
+                                              [
+                                                  options[:job_run_key]	# Handle identifying a particular job run
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def show_running_jobs(options = {})
+    void_result = execute_cli_with_param_list(self.class, "showRunningJobs")
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+
+  def get_deploy_job_max_run_id(options = {})
+    validate_cli_options_hash([:db_key_of_deploy_job], options)
+    void_result = execute_cli_with_param_list(self.class, "getDeployJobMaxRunId",
+                                              [
+                                                  options[:db_key_of_deploy_job]	# Handle identifying a particular job run
+                                              ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Exception: #{exception.to_s}"
+  end
+end

data/modules/bladelogic/lib/bl_soap/login.rb

@@ -0,0 +1,47 @@
+class Login < BsaSoapBase
+  def initialize(integration_settings = BrpmAuto.integration_settings)
+    @url = integration_settings.dns
+    @username = integration_settings.username
+    @password = integration_settings.password
+    @role = integration_settings.details["role"]
+  end
+
+  def login
+    login_with_role(@url, @username, @password, @role)
+  end
+
+  def login_with_credentials(url, username, password, auth_type = DEFAULT_AUTH_TYPE)
+    client = Savon.client("#{url}#{LOGIN_WSDL}") do |wsdl, http|
+      http.auth.ssl.verify_mode = :none
+    end
+
+    response = client.request(:login_using_user_credential) do |soap|
+      soap.endpoint = "#{url}#{LOGIN_SERVICE}"
+      soap.body = {:userName => username, :password => password, :authenticationType => auth_type}
+    end
+
+    session_id = response.body[:login_using_user_credential_response][:return_session_id]
+  rescue Savon::Error => error
+    raise "Error while attempting BSA login,ensure connectivity and BSA Integration properties: #{error.to_s}"
+  end
+
+  def assume_role(url, role, session_id, http_timeout = HTTP_READ_TIMEOUT)
+    client = Savon.client("#{url}#{ROLE_WSDL}") do |wsdl, http|
+      http.auth.ssl.verify_mode = :none
+    end
+    client.http.read_timeout = http_timeout
+    response = client.request(:assume_role) do |soap|
+      soap.endpoint = "#{url}#{ROLE_SERVICE}"
+      soap.header = {"ins0:sessionId" => session_id}
+      soap.body = { :roleName => role }
+    end
+  rescue Savon::Error => error
+    raise "Error while acquiring BSA role(#{role}), ensure connectivity and BSA Integration properties: #{error.to_s}"
+  end
+
+  def login_with_role(url, username, password, role)
+    session_id = login_with_credentials(url, username, password)
+    assume_role(url, role, session_id)
+    return session_id
+  end
+end

data/modules/bladelogic/lib/bl_soap/nsh_script_job.rb

@@ -0,0 +1,14 @@
+# very basic support right now
+class NSHScriptJob < BsaSoapBase
+  def get_dbkey_by_group_and_name(options = {})
+    validate_cli_options_hash([:group_name, :job_name], options)
+    db_key_result = execute_cli_with_param_list(self.class, "getDBKeyByGroupAndName",
+                                                [
+                                                    options[:group_name],	# Fully qualified path to the job group containing the job
+                                                    options[:job_name]		# Name of the job
+                                                ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+end

data/modules/bladelogic/lib/bl_soap/patch_catalog.rb

@@ -0,0 +1,178 @@
+class PatchCatalog < BsaSoapBase
+  # internal function
+  def internal_delete_obsolete_patches(cmd, options = {})
+    validate_cli_options_hash([:catalog_name], options)
+    deleted_count_result = execute_cli_with_param_list(self.class, cmd,
+      [
+        options[:catalog_name]	# Fully qualified catalog name
+      ])
+    deleted_count = get_cli_return_value(deleted_count_result)
+  rescue => exception
+    raise "Problem executing #{self.class} command(#{cmd}): #{exception.to_s}"
+  end
+  
+  def internal_execute_update_and_wait(cmd, options = {})
+    validate_cli_options_hash([:group_name], options)
+    job_run_key_result = execute_cli_with_param_list(self.class, cmd,
+      [
+        options[:group_name]	# Fully qualified catalog name
+      ])
+    job_run_key = get_cli_return_value(job_run_key_result)
+  rescue => exception
+    raise "Problem executing #{self.class} command(#{cmd}): #{exception.to_s}"
+  end
+  
+  def delete_obsolete_patches_from_aix_catalog( options = {})
+    deleted_count = self.internal_delete_obsolete_patches("deleteObsoletePatchesFromAixCatalog", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def delete_obsolete_patches_from_other_linux_catalog(options = {})
+    deleted_count = self.internal_delete_obsolete_patches("deleteObsoletePatchesFromOtherLinuxCatalog", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def delete_obsolete_patches_from_redhat_linux_catalog(options = {})
+    deleted_count = self.internal_delete_obsolete_patches("deleteObsoletePatchesFromRedhatLinuxCatalog", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def delete_obsolete_patches_from_solaris_catalog(options = {})
+    deleted_count = self.internal_delete_obsolete_patches("deleteObsoletePatchesFromSolarisCatalog", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def delete_obsolete_patches_from_windows_catalog(options = {})
+    deleted_count = self.internal_delete_obsolete_patches("deleteObsoletePatchesFromWindowsCatalog", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def execute_aix_catalog_update_and_wait(options = {})
+    job_run_key = self.internal_delete_obsolete_patches("executeAixCatalogUpdateAndWait", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def execute_other_linux_catalog_update_and_wait(options = {})
+    job_run_key = self.internal_delete_obsolete_patches("executeOtherLinuxCatalogUpdateAndWait", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def execute_redhat_catalog_update_and_wait(options = {})
+    job_run_key = self.internal_delete_obsolete_patches("executeRedhatCatalogUpdateAndWait", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def execute_solaris_catalog_update_and_wait(options = {})
+    job_run_key = self.internal_delete_obsolete_patches("executeSolarisCatalogUpdateAndWait", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def execute_windows_catalog_update_and_wait(options = {})
+    job_run_key = self.internal_delete_obsolete_patches("executeWindowsCatalogUpdateAndWait", options)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def get_cuj_dbkey_by_fully_qualified_catalog_name(options = {})
+    validate_cli_options_hash([:type, :group_name], options)
+    validate_cli_option_hash_string_values(["WINDOWS", "REDHAT", "SOLARIS", "AIX", "OTHERLINUX"],options[:type])
+    db_key_result = execute_cli_with_param_list(self.class, "getCUJDBKeyByFullyQualifiedCatalogName",
+      [
+        options[:type],		# Type of catalog: WINDOWS, REDHAT, SOLARIS, AIX, OTHERLINUX
+        option[:group_name]	# Fully qualified name of patch catalog
+      ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def get_dbkey_by_type_and_name_from_catalog(options = {})
+    validate_cli_options_hash([:depot_group_type, :depot_object_type, :group_name, :depot_object_name], options)
+    validate_cli_options_hash_string_values(
+      [
+        "RED_HAT_CATALOG_GROUP",	# RedHat Catalog
+        "SOLARIS_CATALOG_GROUP",	# Solaris Catalog
+        "WINDOWS_CATALOG_GROUP",	# Windows Catalog
+        "OTHER_LINUX_CATALOG_GROUP"	# Other Linux Catalog
+      ], options[:depot_group_type])
+    validate_cli_options_hash_string_values(
+      [
+        "AIX_FILESET_INSTALLABLE",				# AIX Fileset
+        "AIX_CONTAINER_INSTALLABLE",			# AIX Patch Container
+        "RPM_INSTALLABLE",						# Linux RPM
+        "ERRATA_INSTALLABLE",					# Linux Errata
+        "SOLARIS_PATCH_INSTALLABLE",			# Solaris Path
+        "SOLARIS_PATCH_TCLUSTER_INSTALLABLE",	# Solaris Cluster
+        "HOTFIX_WINDOWS_INSTALLABLE", 			# Windows HotFix
+        "WINDOWS_BULLETIN_INSTALLABLE"			# Windows Bulletin
+      ], options[:dept_object_type])
+    db_key = execute_cli_with_param_list(self.class, "getDBKeyByTypeAndNameFromCatalog",
+      [
+        options[:depot_group_type],		# String representation of catalog type
+        options[:depot_object_type],	# String representation of depot object type
+        options[:group_name],			# Fully qualified path to parent depot group
+        options[:depot_object_name]		# Name of depot object
+      ])
+    db_key = get_cli_return_value(db_key_result)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def list_all_by_catalog_name_and_type(options = {})
+    validate_cli_options_hash([:qualified_group_name, :catalog_type_string], options)
+    validate_cli_options_hash_string_values(
+      [
+        "WINDOWS_CATALOG_GROUP",		# Windows Catalog
+        "SOLARIS_CATALOG_GROUP",		# Solaris Catalog
+        "RED_HAT_CATALOG_GROUP",		# Redhat Catalog
+        "OTHER_LINUX_CATALOG_GROUP",	# Other Linux Catalog
+        "AIX_CATALOG_GROUP"				# AIX Catalog
+      ], options[:catalog_type_string])
+    string_result = execute_cli_with_param_list(self.class, "listAllByCatalogNameAndType",
+      [
+        options[:qualified_group_name],	# Name of depot group whose objects you want to list
+        options[:catalog_type_string]	# String representation of depot object type
+      ])
+    str_value = get_cli_return_value(dstring_result)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+  
+  def recursively_set_property_for_catalog(options ={})
+    validate_cli_options_hash([:group_path, :property_name, :value, :catalog_type_string], options)
+    validate_cli_options_hash_string_values(
+      [
+        "RPM_INSTALLABLE",						# Linux RPM
+        "SOLARIS_PATCH_INSTALLABLE",			# Solaris Patch
+        "HOTFIX_WINDOWS_INSTALLABLE",			# Windows HotFix
+        "WINDOWS_BULLETIN_INSTALLABLE",			# Windows Bulletin
+        "ERRATA_INSTALLABLE",					# Redhat Errata
+        "SOLARIS_PATCH_TCLUSTER_INSTALLABLE",	# Solaris Patch Cluster
+        "AIX_FILESET_INSTALLABLE",				# AIX Fileset
+        "AIX_CONTAINER_INSTALLABLE"				# AIX Container
+      ], options[:catalog_type_string])
+    void_result = execute_cli_with_param_list(self.class, "recursivelySetPropertyForCatalog",
+      [
+        options[:group_path],			# The path to the folder
+        options[:property_name],		# The name of the property to set
+        options[:value],				# The value to set
+        options[:catalog_type_string]	# String representation of depot object type
+      ])
+    void_value = get_cli_return_value(void_result)
+  rescue => exception
+    raise "#{self.class} Execution Exception: #{exception.to_s}"
+  end
+end
+
+
+
+