brpm_content 0.1.16

data/modules/bladelogic/automations/deploy_package.txt

@@ -0,0 +1,53 @@
+###
+# depot_group_path:
+#   name: Depot group path
+#   position: A1:F1
+# bl_package_name:
+#   name: Bladelogic package name
+#   position: A2:D2
+# deploy_job_group_path:
+#   name: Deploy job group path
+#   position: A3:F3
+# deploy_job_name:
+#   name: Deploy job name
+#   position: A4:D4
+# target_type:
+#   name: Target type
+#   type: in-list-single
+#   list_pairs: 0,Server group|1,Component group
+#   position: A5:C5
+# target_path:
+#   name: Target path
+#   position: A6:F6
+# job_status:
+#   name: Job Status
+#   type: out-text
+#   position: A1:C1
+# results_summary:
+#   name: Summary
+#   type: out-text
+#   position: A2:E2
+# results:
+#   name: Installs
+#   type: out-table
+#   position: A3:E3
+# results_link:
+#   name: Link
+#   type: out-file
+#   position: A4:E4
+###
+
+#=== BMC Application Automation Integration Server: BladeLogic on aws ===#
+# [integration_id=6]
+#=== End ===#
+
+require "#{params["SS_script_support_path"]}/git_repos/brpm_content/modules/framework/brpm_script_executor.rb"
+
+params["direct_execute"] = true
+
+params["SS_integration_dns"] = SS_integration_dns
+params["SS_integration_username"] = SS_integration_username
+params["SS_integration_password_enc"] = SS_integration_password_enc
+params["SS_integration_details"] = YAML.load(SS_integration_details)
+
+BrpmScriptExecutor.execute_automation_script("bladelogic", "deploy_package", params)

data/modules/bladelogic/config.yml

@@ -0,0 +1,7 @@
+dependencies:
+ - brpm
+
+integration_servers:
+ - BladeLogic
+
+version: 1.0.0

data/modules/bladelogic/lib/bl_rest/bsa_rest_client.rb

@@ -0,0 +1,65 @@
+class BsaRestClient
+  def initialize(integration_settings = BrpmAuto.integration_settings)
+    @url = integration_settings.dns
+    @username = integration_settings.username
+    @password = integration_settings.password
+    @role = integration_settings.details["role"]
+
+    @api_url = "#{@url}/rest/api/2"
+  end
+
+  def get_component_by_name(component_name)
+    result = run_query("SELECT * FROM \"SystemObject/Component\" WHERE NAME equals \"#{component_name}\"")
+
+    raise "BSA component '#{component_name}' not found" if result.empty?
+
+    result[0]
+  end
+
+  def run_query(query)
+    path = "query?bquery=#{query}"
+
+    BrpmAuto.log "Running query #{path}..."
+    result = bl_get(path)
+    response = result["response"]
+
+    if response.has_key? "ErrorResponse"
+      raise "#{response["ErrorResponse"]["Error"]}"
+    end
+
+    if response["PropertySetClassChildrenResponse"] && response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]
+      unless response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["PropertySetInstances"]["Elements"].empty?
+        return response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["PropertySetInstances"]["Elements"]
+      end
+      unless response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["Groups"]["Elements"].empty?
+        return response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["Groups"]["Elements"]
+      end
+      unless response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["PropertySetClasses"]["Elements"].empty?
+        return response["PropertySetClassChildrenResponse"]["PropertySetClassChildren"]["PropertySetClasses"]["Elements"]
+      end
+    end
+    []
+  end
+
+  private
+
+    def add_credentials(path)
+      path + (path.include?("?") ? "&" : "?") + "username=#{@username}&password=#{@password}&role=#{@role}"
+    end
+
+    def bl_get(path, options = {})
+      Rest.get("#{@url}/#{add_credentials(path)}", options)
+    end
+
+    def bl_post(path, data, options = {})
+      Rest.post("#{@url}/#{add_credentials(path)}", data, options)
+    end
+
+    def bl_put(path, data, options = {})
+      Rest.put("#{@url}/#{add_credentials(path)}", data, options)
+    end
+
+    def bl_delete(path, options = {})
+      Rest.delete("#{@url}/#{add_credentials(path)}", options)
+    end
+end

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

@@ -0,0 +1,43 @@
+class BlPackage < BsaSoapBase
+  def create_package_from_component(options = {})
+    validate_cli_options_hash([:package_name, :depot_group_id, :component_key], options)
+    integer_result = execute_cli_with_param_list(self.class, "createPackageFromComponent",
+      [
+          options[:package_name],
+          options[:depot_group_id],
+          false, #bSoftLinked
+          false, #bCollectFileAcl
+          false, #bCollectFileAttributes
+          true, #bCopyFileContents
+          false, #bCollectRegistryAcl
+          options[:component_key]
+      ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+
+  def delete_blpackage_by_group_and_name(options = {})
+    validate_cli_options_hash([:parent_group, :package_name], options)
+    integer_result = execute_cli_with_param_list(self.class, "deleteBlPackageByGroupAndName",
+                                                              [
+                                                                  options[:parent_group],
+                                                                  options[:package_name],
+                                                              ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+
+  def get_dbkey_by_group_and_name(options = {})
+    validate_cli_options_hash([:parent_group, :depot_group_path], options)
+    integer_result = execute_cli_with_param_list(self.class, "getDBKeyByGroupAndName",
+                                                              [
+                                                                  options[:parent_group],
+                                                                  options[:depot_group_path],
+                                                              ])
+    integer_value = get_cli_return_value(integer_result)
+  rescue => exception
+    raise "Exception executing #{self.class} function: #{exception.to_s}"
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'savon'
+
+class BsaSoapBase
+  # Filter out password data when logging enabled
+  HTTPI.log = false
+  Savon.configure do |config|
+    config._logger.filter << :password
+    config.log = false
+  end
+
+  # Module Constants
+  HTTP_READ_TIMEOUT = 300
+  DEFAULT_AUTH_TYPE = "SRP"
+  LOGIN_WSDL        = "/services/BSALoginService.wsdl"
+  ROLE_WSDL         = "/services/BSAAssumeRoleService.wsdl"
+  CLI_WSDL          = "/services/BSACLITunnelService.wsdl"
+  LOGIN_SERVICE     = "/services/LoginService"
+  ROLE_SERVICE      = "/services/AssumeRoleService"
+  CLI_SERVICE       = "/services/CLITunnelService"
+
+  def initialize(url, session_id)
+    @url = url
+    @session_id = session_id
+  end
+
+  def validate_cli_options_hash(required_keys, options)
+    required_keys.each { |key| raise "Invalid options hash(missing #{key}) for command, cannot continue" unless options.has_key?(key) }
+  end
+
+  def validate_cli_option_hash_string_values(supported_values, options_key)
+    supported_values.any? {
+      |value| raise "options key value(#{options_value}) not supported" unless options_key.eql?(value)
+    }
+  end
+
+  def get_all_servers(server_group)
+    result = execute_cli_with_param_list("Server", "listServersInGroup", [server_group])
+    servers = get_cli_return_value(result)
+  rescue => exception
+    raise "Failed to get all servers for #{server_group}: #{exception.to_s}"
+  end
+
+  def validate_servers(servers = [])
+    error = {}
+    servers.each do |server|
+      result = execute_cli_with_param_list("Server", "printPropertyValue", [server, "AGENT_STATUS"])
+      if result[:success] == false || result[:return_value] != "agent is alive"
+        error[:"#{server}"] = "cannot validate server status"
+      end
+    end
+    if error.length > 0
+      raise "Problem validating server: #{error}"
+    end
+  rescue => exception
+    raise "Failed to validate server: #{exception.to_s}"
+  end
+
+  def validate_cli_result(result)
+      if result && (result.is_a? Hash)
+        if result[:success] == false
+          raise "Command execution failed: #{result[:error]}, #{result[:comments]}"
+        end
+        return result
+      else
+        raise "Command execution did not return a valid response: #{result.inspect}"
+      end
+      nil
+    end
+
+  def get_cli_return_value(result)
+    if result && result.is_a?(Hash) && result.has_key?(:success) && result[:success]
+      return result[:return_value]
+    end
+    nil
+  end
+
+  def execute_cli_with_attachments(namespace, command, args, payload)
+    BrpmAuto.log("blcli #{namespace} #{command} #{args.join(" ")}")
+
+    client = Savon.client("#{@url}#{CLI_WSDL}") do |wsdl, http|
+      http.auth.ssl.verify_mode = :none
+    end
+    client.http.read_timeout = HTTP_READ_TIMEOUT
+    response = client.request(:execute_command_using_attachments) do |soap|
+      soap.endpoint = "#{@url}#{CLI_SERVICE}"
+      soap.header = {"ins1:sessionId" => @session_id}
+      body_details = { :nameSpace => namespace, :commandName => command, :commandArguments => args }
+      body_details.merge!({:payload => payload}) if payload
+      soap.body = body_details
+    end
+    result = response.body[:execute_command_using_attachments_response][:return]
+    return validate_cli_result(result)
+  rescue Savon::Error => error
+    raise "Error while executing CLI command over SOAP protocol: #{error.to_s}"
+  rescue => exception
+    raise "Error processing CLI(#{namespace}:#{command}) result: #{exception.to_s}"
+  end
+
+  def execute_cli_with_param_list(namespace, command, args = [])
+    BrpmAuto.log("blcli #{namespace} #{command} #{args.join(" ")}")
+
+    client = Savon.client("#{@url}#{CLI_WSDL}") do |wsdl, http|
+      http.auth.ssl.verify_mode = :none
+    end
+    client.http.read_timeout = HTTP_READ_TIMEOUT
+    response = client.request(:execute_command_by_param_list) do |soap|
+      soap.endpoint = "#{@url}#{CLI_SERVICE}"
+      soap.header = {"ins1:sessionId" => @session_id}
+      soap.body = { :nameSpace => namespace, :commandName => command, :commandArguments => args }
+    end
+    result = response.body[:execute_command_by_param_list_response][:return]
+    return validate_cli_result(result)
+  rescue Savon::Error => error
+    raise "Error while executing CLI command over SOAP protocol: #{error.to_s}"
+  rescue Exception => exception
+    raise "Error processing CLI(#{namespace}:#{command}) results: #{exception.to_s}"
+  end
+end

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

@@ -0,0 +1,34 @@
+class BsaSoapClient < BsaSoapBase
+  def initialize(integration_settings = BrpmAuto.integration_settings)
+    @url = integration_settings.dns
+    @session_id = Login.new(integration_settings).login
+  end
+
+  def blpackage
+    @blpackage ||= BlPackage.new(@url, @session_id)
+  end
+
+  def job
+    @job ||= Job.new(@url, @session_id)
+  end
+
+  def job_run
+    @job_run ||= JobRun.new(@url, @session_id)
+  end
+
+  def deploy_job
+    @deploy_job ||= DeployJob.new(@url, @session_id)
+  end
+
+  def job_group
+    @job_group ||= JobGroup.new(@url, @session_id)
+  end
+
+  def depot_group
+    @depot_group ||= DepotGroup.new(@url, @session_id)
+  end
+
+  def utility
+    @utility ||= Utility.new(@url, @session_id)
+  end
+end

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

@@ -0,0 +1,155 @@
+class ComplianceJob < BsaSoapBase
+	def add_component_to_job_by_job_db_key(options = {})
+		validate_cli_options_hash([:compliance_key, :component_key], options)
+		db_key_result = execute_cli_with_param_list(self.class, "addComponentToJobByJobDBKey",
+			[
+				options[:compliance_key],	# Handle to compliance Job
+				options[:component_key]		# Handle to component to be added
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def add_named_server_to_job_by_job_db_key(options = {})
+		validate_cli_options_hash([:db_key, :server_name], options)
+		db_key_result = execute_cli_with_param_list(self.class, "addNamedServerToJobByJobDBKey",
+			[
+				options[:db_key],		# Handle to the Compliance Job
+				options[:server_name]	# Name of the server to be added
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def create_component_based_compliance_job(options = {})
+		validate_cli_options_hash([:job_name, :group_id, :template_key, :server_name], options)
+		db_key_result = execute_cli_with_param_list(self.class, "createComponentBasedComplianceJob",
+			[
+				options[:job_name],				# Name of the job to be created
+				options[:group_id],				# Id of the parent job group for the compliance job
+				options[:template_key],			# Handle to template describing the assets to be included in compliance
+				options[:server_name],			# Target server for compliance job
+				options[:component_index] || 0	# Index of component on target server (typically 0)
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def create_remediation_job_from_compliance_result_by_rule(options = {})
+		validate_cli_options_hash(
+			[:remediation_name, :job_group_name, :depot_group_name, :comp_job_key, :comp_job_run_id, :template_group_name, :template_name, :rule_grp_name, :rule_name, :target_component],
+			options)
+		db_key_result = execute_cli_with_param_list(self.class, "createRemediationJobFromComplianceResultByRule",
+			[
+				options[:remediation_name],							# Name of the package
+				options[:job_group_name],							# Name of a group that should contain the new remediation job(s)
+				options[:depot_group_name],							# Name of a group that should contain the new package(s)
+				options[:comp_job_key],								# Handle to compliance job whose job run result you want to package
+				options[:comp_job_run_id],							# ID of the compliance job run whose result you want to package
+				options[:template_group_name],						# Group name of the template used in the compliance job run
+				options[:template_name],							# Name of the template used in the compliance job run
+				options[:rule_grp_name],							# Name of the template rule group used in the compliance job run
+				options[:rule_name],								# Name of the template rule used in the compliance job run
+				options[:target_component],							# Name of the target component
+				options[:use_component_device_for_targets] || true,	# Use the device of a component as the target of the remediation (defualt = true) devices are targets
+				options[:keep_unique_package_props] || true			# Indicates if the package should uniquely save each local property for the compliance rule packages that are used
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def create_remediation_job_from_compliance_result_by_server(options = {})
+		validate_cli_options_hash(
+			[:remediation_name, :job_group_name, :depot_group_name, :comp_job_key, :comp_job_run_id, :target_server, :template_group_name, :template_name, :target_component, :rule_grp_name, :rule_name],
+			options)
+		db_key_result = execute_cli_with_param_list(self.class, "createRemediationJobFromComplianceResultByServer",
+			[
+				options[:remediation_name],							# Name of the package
+				options[:job_group_name],							# Name of a group that should contain the new remediation job(s)
+				options[:depot_group_name],							# Name of a group that should contain the new package(s)
+				options[:comp_job_key],								# Handle to compliance job whose job run result you want to package
+				options[:comp_job_run_id],							# ID of the compliance job run whose result you want to package
+				options[:target_server],							# Name of the target server
+				options[:template_group_name],						# Group name of the template used in the compliance job run
+				options[:template_name],							# Name of the template used in the compliance job run
+				options[:target_component],							# Name of the target component
+				options[:rule_grp_name],							# Name of the template rule group used in the compliance job run
+				options[:rule_name],								# Name of the template rule used in the compliance job run
+				options[:use_component_device_for_targets] || true,	# Use the device of a component as the target of the remediation (defualt = true) devices are targets
+				options[:keep_unique_package_props] || true			# Indicates if the package should uniquely save each local property for the compliance rule packages that are used
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def create_template_fltered_compliance_job(options = {})
+		validate_cli_options_hash([:job_name, :group_id, :template_key, :server_name], options)
+		db_key_result = execute_cli_with_param_list(self.class, "createTemplateFilteredComplianceJob",
+			[
+				options[:job_name],		# Name of the job to be created
+				options[:group_id],		# Id of the parent job group for the compliance job
+				options[:template_key],	# Handle to the template describing the assets to be including in the compliance job
+				options[:server_name]	# Target server for the compliance job
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def execute_job_and_wait(options = {})
+		validate_cli_options_hash([:job_key], options)
+		job_key_result = execute_cli_with_param_list(self.class, "executeJobAndWait",
+			[
+				options[:job_key]	# Handle to the compliance job to be executed
+			])
+		job_key = get_cli_return_value(job_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	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
+
+	def set_auto_remediation(options = {})
+		validate_cli_options_hash([:job_key, :job_name, :depot_group, :job_group], options)
+		db_key_result = execute_cli_with_param_list(self.class, "setAutoRemediation",
+			[
+				options[:job_key],									# Handle to compliance job
+				options[:job_name],									# Name for auto-remediation job
+				options[:depot_group],								# Name of the depot group to store files in
+				options[:job_group],								# Name of the job group to store the remediation job in
+				options[:is_auto_remediate] || true,				# Auto-remediation state for the job - true = set
+				options[:use_component_device_for_targets] || true,	# Use the device of a component as the target of the remediation (defualt = true) devices are targets
+				options[:keep_unique_package_props] || true			# Indicates if the package should uniquely save each local property for the compliance rule packages that are used
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+
+	def set_description(options = {})
+		validate_cli_options_hash([:job_key, :desc], options)
+		db_key_result = execute_cli_with_param_list(self.class, "setDescription",
+			[
+				options[:job_key],	# handle to compliance job
+				options[:desc]		# description of job
+			])
+		db_key = get_cli_return_value(db_key_result)
+	rescue => exception
+		raise "Exception executing #{self.class} function: #{exception.to_s}"
+	end
+end