nexpose 7.0.1 → 7.3.0

data/lib/eso/step.rb

@@ -0,0 +1,166 @@
+module Eso
+  # Object representation of a step, which are attributes of Workflows and Integration Options
+  #
+  class Step
+    # UUID of this step. This is generated on creation on the server.
+    attr_accessor :uuid
+
+    # Type of this step. Should be one of Eso::ServiceNames
+    attr_accessor :serviceName
+
+    # The configuration for this step.
+    attr_accessor :stepConfiguration
+
+    # Constructor for Step.
+    #
+    # @param [String] uuid UUID of this Step. This is created on the server side upon creation through the API.
+    # @param [String] service_name The name of step this is.
+    # @param [Workflow] workflow The workflow this step belongs to.
+    # @param [Hash] configuration_params Hash of the parameters for this step.
+    #
+    def initialize(uuid: nil, service_name:, workflow: nil, type_name:, previous_type_name: StepNames::EMPTY, configuration_params: nil)
+      @uuid = uuid if uuid
+      @serviceName = service_name
+      @stepConfiguration = StepConfiguration.new(type_name, previous_type_name)
+      @stepConfiguration.configurationParams = configuration_params if configuration_params
+      @stepConfiguration.workflowID = workflow.id if workflow
+    end
+
+    # Return the configuration parameters for this step.
+    #
+    # @return [Hash] Hash of the configuration parameters for this step.
+    #
+    def configuration_params
+      @stepConfiguration.configurationParams
+    end
+
+    # Set the the configuration parameters for this step.
+    #
+    # @param [Hash] config_params of the new configuration parameters you would like to set.
+    # @return [Hash] Hash of the updated configuration parameters for this step.
+    #
+    def configuration_params=(config_params)
+      @stepConfiguration.configurationParams = config_params
+    end
+
+    # Return the type name for this step.
+    #
+    # @return [String] The currently configured type name.
+    #
+    def type_name
+      @stepConfiguration.typeName
+    end
+
+    # Set the type name for this step.
+    #
+    # @param [String] The new type_name that you would like to set this to. See Eso::StepNames for valid names.
+    # @return [String] The newly set type name.
+    #
+    def type_name=(wf_action_name)
+      @stepConfiguration.typeName = wf_action_name
+    end
+
+    # Return the previous type name for this step.
+    #
+    # @return [String] The previous type name for this step.
+    #
+    def previous_type_name
+      @stepConfiguration.previousTypeName
+    end
+
+    # Set the previous type name for this step.
+    #
+    # @param [String] The new previous type name that you would like to set. See Eso::StepNames for valid names.
+    # @return [String] Hash of the configuration parameters for this step.
+    #
+    def previous_type_name=(action_name)
+      @stepConfiguration.previousTypeName = action_name
+    end
+
+    # Return the properties of this step.
+    #
+    # @return [Hash{}] Hash of the properties for this step.
+    #
+    def properties
+      @stepConfiguration.configurationParams[:properties]
+    end
+
+    # Set the properties of this step.
+    #
+    # @param [Hash] The new properties to set for this step.
+    # @return [Hash] Hash of the newly configured properties for this step.
+    #
+    def properties=(new_properties)
+      @stepConfiguration.configurationParams[:properties] = new_properties
+    end
+
+    # Determine the siteID of this step, if it exists
+    #
+    # @return [String|nil] The String siteID value or nil if no siteID
+    def site_id
+      if @stepConfiguration.configurationParams[:properties][:siteID]
+        @stepConfiguration.configurationParams[:properties][:siteID][:value]
+      end
+    end
+
+    # Returns all configured filters for this step.
+    #
+    # @return [Array] An array of the currently configured filters for this step, each represented as a hash.
+    #
+    def filters
+      rv = {}
+      self.properties.each_pair do |key, value|
+        if value[:properties]
+          rv[key] = value if value[:properties].has_key?(:operators)
+        end
+      end
+      rv
+    end
+
+    # Convenience method which calls the #add_property method of the @stepConfiguration, but returns the Step
+    #
+    # @return [Step] Returns this Step for chaining
+    def add_property(name, value)
+      @stepConfiguration.add_property(name, value)
+      self
+    end
+
+    # Convenience method which calls the #add_property method of the @stepConfiguration, but returns the Step
+    #
+    # @return [Step] Returns this Step for chaining
+    def update_property(name, value)
+      @stepConfiguration.add_property(name, value)
+      self
+    end
+
+    # Add the specified filter to this step. The filter is converted to a hash and saved as such instead of being saved as a ESO::Filter object.
+    #
+    # @param [Filter] filter The filter to add to this step.
+    #
+    def add_filter(filter)
+      @stepConfiguration.configurationParams[:properties].merge! filter.to_hash
+    end
+
+    # Return this step in a JSON digestible format.
+    #
+    # @return [String] JSON interpretation of this step.
+    #
+    def to_json
+      self.to_hash.to_json
+    end
+
+    # Return this step as a hash.
+    #
+    # @return [Hash] Hash interpretation of this step.
+    #
+    def to_hash
+      hash = {}
+      instance_variables.each do |var|
+        value = instance_variable_get(var)
+        value = value.to_h if value.respond_to?('to_h')
+        hash[var.to_s.delete('@')] = value
+      end
+      hash
+    end
+  end
+end

data/lib/eso/step_configuration.rb

@@ -0,0 +1,73 @@
+module Eso
+  class StepConfiguration
+    attr_accessor :typeName, :previousTypeName, :configurationParams, :workflowID
+
+    module ConfigParamProperties
+      DISCOVERY_CONFIG_ID = 'discoveryConfigID'
+      EXCLUDE_ASSETS_WITH_TAGS= 'excludeAssetsWithTags'
+      IMPORT_TAGS = 'importTags'
+      ONLY_IMPORT_THESE_TAGS = 'onlyImportTheseTags'
+      SITE_ID = 'siteID'
+      TAG_ID = 'tagID'
+    end
+
+    module ConfigParamPropertyTypes
+      BOOLEAN = [ConfigParamProperties::IMPORT_TAGS]
+      INTEGER = [ConfigParamProperties::DISCOVERY_CONFIG_ID,
+                 ConfigParamProperties::SITE_ID,
+                 ConfigParamProperties::TAG_ID]
+      STRING = [ConfigParamProperties::EXCLUDE_ASSETS_WITH_TAGS,
+                ConfigParamProperties::ONLY_IMPORT_THESE_TAGS]
+    end
+
+    def initialize (typeName, previousTypeName, configurationParams=nil, workflowID=nil)
+      @typeName = typeName
+      @previousTypeName = previousTypeName
+      @configurationParams = configurationParams ? configurationParams : {
+          :valueClass => Values::OBJECT,
+          :objectType => 'params',
+          :properties => {}}
+      @workflowID = workflowID if workflowID
+    end
+
+    # This adds the specified property to this StepConfiguration.configurationParams.properties Hash
+    #
+    # @param [String] name The name of the property to add, which should be one of ConfigParamProperties
+    # @param [Object] value The value of the property to add, which should already be in the appropriate format (Eso::Values)
+    # @return [StepConfiguration] Returns this object for chaining.
+    def add_property(name, value)
+      @configurationParams[:properties][name] =
+          case name
+            when *ConfigParamPropertyTypes::BOOLEAN
+              {
+                  valueClass: Values::BOOLEAN,
+                  value: value
+              }
+            when *ConfigParamPropertyTypes::INTEGER
+              {
+                  valueClass: Values::INTEGER,
+                  value: value
+              }
+            when *ConfigParamPropertyTypes::STRING
+              {
+                  valueClass: Values::STRING,
+                  value: value
+              }
+            else
+              raise ArgumentError, "Invalid StepConfiguration ConfigurationParameter Property name: #{name}. " +
+                  'Should be one of StepConfiguration::ConfigParamProperties'
+          end
+      self
+    end
+
+    def to_h
+      hash = {
+          :typeName => @typeName,
+          :previousTypeName => @previousTypeName,
+          :configurationParams => @configurationParams
+      }
+      hash['workflowID'] = @workflowID if @workflowID
+      hash
+    end
+  end
+end

data/lib/eso/workflow.rb

@@ -0,0 +1,149 @@
+module Eso
+
+  # The following classes have mixed casing (snake and camel) to accommodate for the API.
+  # I guess a TODO would be to write a helper to automatically convert them.
+  class Workflow
+    # The id of the workflow. This will be created upon saving to the server upon creation.
+    attr_accessor :id
+
+    # The name of the workflow. This is required.
+    attr_accessor :name
+
+    # An array of the steps this workflow takes action on.
+    attr_accessor :steps
+
+    # The time the workflow was created in milliseconds since epoch
+    attr_accessor :timeCreated
+
+    # Constructor for the workflow
+    #
+    # @param [String] id ID of the workflow.
+    # @param [String] name Name of the workflow.
+    # @param [Array] steps Array of the steps that this workflow takes.
+    # @param [Fixnum] time_created The time the workflow was created in millis since epoch
+    #
+    def initialize(id: nil, name:, steps: [], time_created: (Time.now.strftime('%s').to_i * 1000))
+      @id = id
+      @name = name
+      @steps = steps
+      @timeCreated = time_created
+    end
+
+    # Load an existing workflow from the API.
+    #
+    # @param [Conductor] conductor The Conductor object governing the workflows
+    # @param [String] id ID of the workflow to load
+    # @return [Workflow] Workflow object that was loaded.
+    #
+    def self.load(conductor, id)
+      uri = "#{conductor.url}workflows/#{id}"
+      resp = conductor.get(url: uri)
+      workflow = self.new(id: resp[:id], name: resp[:name])
+      steps = resp[:steps]
+      steps.each do |step|
+        workflow_step = Step.new(uuid: step[:uuid],
+                                 service_name: step[:serviceName],
+                                 workflow: workflow,
+                                 type_name: step[:stepConfiguration][:typeName],
+                                 previous_type_name: step[:stepConfiguration][:previousTypeName],
+                                 configuration_params: step[:stepConfiguration][:configurationParams])
+        workflow.steps << workflow_step
+      end
+      workflow
+    end
+
+    # Return the relevant step based on the given service name.
+    # For example, if you want the step related to the scan service you would pass 'nexpose-scan-service'.
+    #
+    # @param [String] service_name Service name to be returned.
+    # @return [Step] Step object corresponding to the given service.
+    #
+    def get_step(type_name)
+      @steps.find do |step|
+        step.type_name == type_name
+      end
+    end
+
+    # Return the trigger step of a workflow. The trigger step is defined as a step that monitors for events
+    # that will cause the action to fire.
+    #
+    # Currently triggers do not have a previous-action so that is what this is returning. This behavior could change in ESO's future.
+    #
+    # @return [Step] Step object representation of the trigger step.
+    #
+    def trigger
+      @steps.find do |step|
+        step.stepConfiguration.previousTypeName.nil?
+      end
+    end
+
+    # Return this object and the associated steps in a digestible JSON format.
+    #
+    # @return [String] JSON interpretation of this workflow.
+    #
+    def to_json
+      hash = self.to_hash
+      steps = hash['steps']
+      hashified_steps = []
+      steps.each { |step| hashified_steps << step.to_hash }
+      hash['steps'] = hashified_steps
+      hash.to_json
+    end
+
+    # Return this object as a hash.
+    # The corresponding steps will still be objects.
+    #
+    # @return [Hash{}] Hash interpretation of this workflow.
+    def to_hash
+      hash = {}
+      instance_variables.each { |var| hash[var.to_s.delete('@')] = instance_variable_get(var) }
+      hash
+    end
+
+    # Representation of state of a workflow or integration option. Taken from service-orchestration State.java
+    module State
+      # Workflow or an integration option is configured and ready to accept events
+      READY = 'ready'
+
+      # Workflow or an integration option is processing or has processed events
+      RUNNING = 'running'
+
+      # The workflow or an integration option is running, but is temporarily unsuccessful processing events
+      RETRY = 'retry'
+
+      # Workflow or an integration option is stopped by the user
+      STOPPED = 'stopped'
+
+      # Workflow or an integration option has experienced an error that caused it to stop
+      ERROR = 'error'
+    end
+
+    StateHistory = Struct.new(:message, :state, :startTime)
+
+    class History < Workflow
+      # The current state of the workflow
+      attr_accessor :state
+
+      # The most recent message
+      attr_accessor :message
+
+      # An array of Eso::Workflow::StateHistory
+      attr_accessor :state_histories
+
+      # Constructor for the WorkflowHistory
+      #
+      # @param [String] id ID of the workflow.
+      # @param [String] name Name of the workflow.
+      # @param [Array] steps Array of the steps that this workflow takes.
+      # @param [Fixnum] time_created The time the workflow was created in millis since epoch
+      # @param [Eso::Workflow::State] state The current state of the workflow
+      # @param [String] message The most recent message
+      def initialize(id:, name:, time_created:, steps:, state:, message:, history:)
+        super(id: id, name: name, timeCreated: time_created, steps: steps)
+        @state = state
+        @message = message
+        @state_histories = history
+      end
+    end
+  end
+end

data/lib/nexpose/ajax.rb

@@ -149,6 +149,7 @@ module Nexpose
     def headers(nsc, request)
       request.add_field('nexposeCCSessionID', nsc.session_id)
       request.add_field('Cookie', "nexposeCCSessionID=#{nsc.session_id}")
+      request.add_field('X-Requested-With', 'XMLHttpRequest')
     end
 
     def request(nsc, request, timeout = nil)

data/lib/nexpose/connection.rb

@@ -57,11 +57,11 @@ module Nexpose
     attr_reader :response_xml
     # The trust store to validate connections against if any
     attr_reader :trust_store
-    # The main HTTP read_timeout value
+    # The main HTTP read_timeout value, in seconds
     # For more information visit the link below:
     # https://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html#read_timeout-attribute-method
     attr_accessor :timeout
-    # The optional HTTP open_timeout value
+    # The optional HTTP open_timeout value, in seconds
     # For more information visit the link below:
     # http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html#open_timeout-attribute-method
     attr_accessor :open_timeout
@@ -143,11 +143,15 @@ module Nexpose
         http.cert_store = @trust_store
       end
       headers = { 'Cookie' => "nexposeCCSessionID=#{@session_id}" }
-      resp    = http.get(uri.to_s, headers)
 
       if file_name
-        ::File.open(file_name, 'wb') { |file| file.write(resp.body) }
+        http.request_get(uri.to_s, headers) do |resp|
+          ::File.open(file_name, 'wb') do |file|
+            resp.read_body { |chunk| file.write(chunk) }
+          end
+        end
       else
+        resp = http.get(uri.to_s, headers)
         resp.body
       end
     end

data/lib/nexpose/group.rb

@@ -159,7 +159,7 @@ module Nexpose
     #
     def self.load(connection, id)
       xml = %(<AssetGroupConfigRequest session-id="#{connection.session_id}" group-id="#{id}"/>)
-      r   = APIRequest.execute(connection.url, xml)
+      r   = APIRequest.execute(connection.url, xml, '1.1', { timeout: connection.timeout, open_timeout: connection.open_timeout })
       parse(r.res)
     end
 

data/lib/nexpose/maint.rb

@@ -96,12 +96,15 @@ module Nexpose
     # It will restart the console after acknowledging receiving the request.
     #
     # @param [Connection] nsc An active connection to a Nexpose console.
+    # @param [String] (Optional) The password to use when restoring the backup.
     # @return [Boolean] Whether the request was received.
     #
-    def restore(nsc)
+    def restore(nsc, password = nil)
+      raise 'Supplied Password is incorrect for restoring this Backup.' if invalid_backup_password?(nsc, password)
       parameters = { 'backupid' => @name,
                      'cmd' => 'restore',
-                     'targetTask' => 'backupRestore' }
+                     'targetTask' => 'backupRestore',
+                     'password' => password }
       xml = AJAX.form_post(nsc, '/admin/global/maintenance/maintCmd.txml', parameters)
       if !!(xml =~ /succeded="true"/)
         nsc._maintenance_restart
@@ -129,5 +132,23 @@ module Nexpose
           hash['Platform-Independent'],
           hash['Size'])
     end
+
+    private
+
+    def invalid_backup_password?(nsc, password)
+      !correct_backup_password?(nsc, password) if backup_need_password?(nsc)
+    end
+
+    def backup_need_password?(nsc)
+      resp = Nexpose::AJAX.get(nsc, '/data/admin/backups/password', Nexpose::AJAX::CONTENT_TYPE::JSON, 'backupID' => name)
+      resp == 'true'
+    end
+
+    def correct_backup_password?(nsc, password)
+      raise 'This Backup file requires a Password. Please include a password during the restore command.' if password.nil?
+      resp = Nexpose::AJAX.post(nsc, "/data/admin/backups/password?backupID=#{name}&password=#{password}", nil, Nexpose::AJAX::CONTENT_TYPE::JSON)
+      resp == 'true'
+    end
+
   end
 end