kinetic_sdk 0.1.1

data/lib/kinetic_sdk/task/lib/groups.rb

@@ -0,0 +1,112 @@
+module KineticSdk
+  class Task
+
+    # Add a group
+    #
+    # @param name [String] name of the group
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_group(name, headers=default_headers)
+      info("Adding group \"#{name}\"")
+      post("#{@api_url}/groups", { "name" => name }, headers)
+    end
+
+    # Delete a Group
+    #
+    # @param name [String] name of the group
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_group(name, headers=header_basic_auth)
+      info("Deleting Group \"#{name}\"")
+      delete("#{@api_url}/groups/#{encode(name)}", headers)
+    end
+
+    # Delete all Groups
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_groups(headers=header_basic_auth)
+      info("Deleting all groups")
+      (find_groups(headers).content['groups'] || []).each do |group|
+        delete("#{@api_url}/groups/#{encode(group['name'])}", headers)
+      end
+    end
+
+    # Export a Group
+    #
+    # @param group [String] name of the group
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_group(group, headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export a group." if @options[:export_directory].nil?
+      if group.is_a? String
+        response = find_group(group, {}, headers)
+        group = response.content
+      end
+      info("Exporting group \"#{group['name']}\" to #{@options[:export_directory]}.")
+      # Create the groups directory if it doesn't yet exist
+      group_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "groups"))
+      group_file = File.join(group_dir, "#{group['name'].slugify}.json")
+      # write the file
+      responseObj = get("#{@api_url}/groups/#{encode(group['name'])}", {}, headers)
+      File.write(group_file, JSON.pretty_generate(responseObj.content))
+      info("Exported group: #{group['name']} to #{group_file}")
+    end
+
+    # Export Groups
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_groups(headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export groups." if @options[:export_directory].nil?
+      (find_groups.content["groups"] || []).each do |group|
+        export_group(group)
+      end
+    end
+
+    # Find all groups
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_groups(params={}, headers=header_basic_auth)
+      info("Finding all groups")
+      get("#{@api_url}/groups", params, headers)
+    end
+
+    # Find Group
+    #
+    # @param name [String] name of the group
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_group(name, params={}, headers=header_basic_auth)
+      info("Finding the #{name} group")
+      get("#{@api_url}/groups/#{encode(name)}", params, headers)
+    end
+
+    # Add user to group
+    #
+    # @param login_id [String] login id of the user
+    # @param group_name [String] name of the group
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_user_to_group(login_id, group_name, headers=default_headers)
+      body = { "loginId" => login_id }
+      info("Adding user \"#{login_id}\" to group \"#{group_name}\"")
+      post("#{@api_url}/groups/#{encode(group_name)}/users", body, headers)
+    end
+
+    # Remove user from group
+    #
+    # @param login_id [String] login id of the user
+    # @param group_name [String] name of the group
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def remove_user_from_group(login_id, group_name, headers=default_headers)
+      info("Removing user \"#{login_id}\" from group \"#{group_name}\"")
+      post("#{@api_url}/groups/#{encode(group_name)}/users/#{encode(login_id)}", headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/handlers.rb

@@ -0,0 +1,105 @@
+module KineticSdk
+  class Task
+
+    # Delete a Handler
+    #
+    # @param definition_id [String] the handler definition id
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_handler(definition_id, headers=header_basic_auth)
+      info("Deleting Handler \"#{definition_id}\"")
+      delete("#{@api_url}/handlers/#{definition_id}", headers)
+    end
+
+    # Delete all Handlers
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_handlers(headers=header_basic_auth)
+      info("Deleting all handlers")
+      (find_handlers(headers).content['handlers'] || []).each do |handler|
+        delete("#{@api_url}/handlers/#{handler['definition_id']}", headers)
+      end
+    end
+
+    # Find all handlers
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_handlers(params={}, headers=header_basic_auth)
+      info("Find all handlers")
+      get("#{@api_url}/handlers", params, headers)
+    end
+
+    # Find a handler
+    #
+    # @param definition_id [String] the definition id of the handler
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_handler(definition_id, params={}, headers=header_basic_auth)
+      info("Finding handler \"#{definition_id}\"")
+      get("#{@api_url}/handlers/#{definition_id}", params, headers)
+    end
+
+    # Import a handler file
+    #
+    # If the handler already exists on the server, this will fail unless forced to overwrite.
+    #
+    # @param handler [File] handler zip package file
+    # @param force_overwrite [Boolean] whether to overwrite a handler if it exists, default is false
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def import_handler(handler, force_overwrite=false, headers=header_basic_auth)
+      body = { "package" => handler }
+      info("Importing Handler #{File.basename(handler)}")
+      post_multipart("#{@api_url}/handlers?force=#{force_overwrite}", body, headers)
+    end
+
+    # Modifies the properties and info values for a handler
+    #
+    # @param definition_id [String] the definition id of the handler
+    # @param body [Hash] the properties to update
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_handler(definition_id, body, headers=default_headers)
+      info("Updating handler #{definition_id}")
+      put("#{@api_url}/handlers/#{definition_id}", body, headers)
+    end
+
+    # Export a single handler
+    #
+    # @param definition_id [String] the definition id of the handler
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_handler(definition_id, headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export a handler." if @options[:export_directory].nil?
+      info("Exporting handler \"#{definition_id}\" to #{@options[:export_directory]}.")
+      # Create the handler directory if it doesn't yet exist
+      handler_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "handlers"))
+      handler_file = File.join(handler_dir, "#{definition_id}.zip")
+      # write the file
+      File.open(handler_file, "wb") do |file|
+        file.write get("#{@api_url}/handlers/#{definition_id}/zip", {}, headers).content_string
+      end
+      info("Exported handler: #{definition_id} to #{handler_file}")
+    end
+
+    # Export all handlers
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_handlers(headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export handlers." if @options[:export_directory].nil?
+      info("Exporting handlers to #{@options[:export_directory]}.")
+      # Get the handler metadata to geta all handler_ids
+      response = find_handlers(headers)
+      # Parse the response and export each handler
+      (response.content["handlers"] || []).each do |handler|
+        export_handler(handler['definitionId'], headers)
+      end
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/health.rb

@@ -0,0 +1,28 @@
+module KineticSdk
+  class Task
+
+    # Checks if the web application is alive
+    #
+    # @param url [String] the url to query for a 200 response code
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def is_alive?(url, headers=header_basic_auth)
+      response = get(url, {}, headers)
+      response.status == 200
+    end
+
+    # Waits until the web server is alive
+    #
+    # @param url [String] the url to query for a 200 response code
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def wait_until_alive(url, headers=header_basic_auth)
+      url = url[1..-1] if url.start_with?("/")
+      while !is_alive?("#{@api_url}/#{url}", headers) do
+        info("Web server \"#{@api_url}/#{url}\" is not ready, waiting...")
+        sleep 3
+      end
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/license.rb

@@ -0,0 +1,52 @@
+module KineticSdk
+  class Task
+
+    # Delete the license
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_license(headers=header_basic_auth)
+      info("Deleting the license")
+      delete("#{@api_url}/config/license", {}, headers)
+    end
+
+    # Find the license
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_license(params={}, headers=header_basic_auth)
+      info("Finding the license")
+      get("#{@api_url}/config/license", params, headers)
+    end
+
+    # Update the license
+    #
+    # @param license_content [String] the content of the license file
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_license(license_content, headers=default_headers)
+      body = { "licenseContent" => license_content }
+      info("Updating license")
+      post("#{@api_url}/config/license", body, headers)
+    end
+
+    # Imports the license file
+    #
+    # @param license [String|File] Either the license file path (String), or the license file (File)
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def import_license(license, headers=default_headers)
+      if license.is_a? File
+        update_license(license.read, headers)
+      else
+        if File.exists? license
+          update_license(File.read(license), headers)
+        else
+          info("  * License file \"#{license}\" does not exist.")
+        end
+      end
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/policy_rules.rb

@@ -0,0 +1,166 @@
+module KineticSdk
+  class Task
+
+    # Add a policy Rule
+    #
+    # @param policy [Hash] hash of properties for the new policy rule
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    # 
+    # Example
+    #
+    #     add_policy_rule({
+    #       "name" => "Foo",
+    #       "type" => "Console Access | Category Access | API Access | System Default",
+    #       "rule" => "...",
+    #       "message" => "..."
+    #     })
+    #
+    def add_policy_rule(policy, headers=default_headers)
+      info("Adding policy rule \"#{policy['type']} - #{policy['name']}\"")
+      post("#{@api_url}/policyRules/#{encode(policy['type'])}", policy, headers)
+    end
+
+    # Delete a Policy Rule.
+    #
+    # @param policy [Hash] hash of policy type and name
+    #   - +type+ - Policy Rule type ( API Access | Console Access | Category Access | System Default )
+    #   - +name+ - Policy Rule name
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     delete_policy_rule({
+    #       "type" => "API Access",
+    #       "name" => "Company Network"
+    #     })
+    #
+    def delete_policy_rule(policy, headers=header_basic_auth)
+      info("Deleting policy rule \"#{policy['type']} - #{policy['name']}\"")
+      delete("#{@api_url}/policyRules/#{encode(policy['type'])}/#{encode(policy['name'])}", headers)
+    end
+
+    # Delete all Policy Rules.
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_policy_rules(headers=header_basic_auth)
+      info("Deleting all policy rules")
+      (find_policy_rules(headers).content["policyRules"] || []).each do |policy_rule|
+        delete_policy_rule({
+          "type" => policy_rule['type'],
+          "name" => policy_rule['name']
+          }, headers)
+      end
+    end
+
+    # Export a Policy Rule
+    #
+    # @param policy_rule [Hash] Policy Rule properties that must contain at least the name and type
+    #   - +type+ - Policy Rule type ( API Access | Console Access | Category Access | System Default )
+    #   - +name+ - Policy Rule name to export
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_policy_rule(policy_rule, headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export a policy rule." if @options[:export_directory].nil?
+      info("Exporting policy rule \"policy_rule['type']\" : \"#{policy_rule['name']}\" to #{@options[:export_directory]}.")
+      # Create the policy rules directory if it doesn't yet exist
+      dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "policyRules"))
+      file = File.join(dir, "#{policy_rule['type'].slugify}-#{policy_rule['name'].slugify}.json")
+
+      unless policy_rule.has_key?("consolePolicyRules")
+        response = find_policy_rule(
+          { "type" => policy_rule['type'], "name" => policy_rule['name'] },
+          { "include" => "consolePolicyRules" },
+          headers
+        )
+        if response.status != 200
+          info("Failed to export policy rule: #{policy_rule['type']} - #{policy_rule['name']}: #{response.inspect}")
+          policy_rule = nil
+        else
+          policy_rule = response.content
+        end
+      end
+
+      unless policy_rule.nil?
+        # write the file
+        File.write(file, JSON.pretty_generate(policy_rule))
+        info("Exported policy rule: #{policy_rule['type']} - #{policy_rule['name']} to #{file}")
+      end
+    end
+
+    # Export Policy Rules
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_policy_rules(headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export policy rules." if @options[:export_directory].nil?
+      response = find_policy_rules({"include" => "consolePolicyRules"}, headers)
+      (response.content["policyRules"] || []).each do |policy_rule|
+        export_policy_rule(policy_rule, headers)
+      end
+    end
+
+    # Find Policy Rules.
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_policy_rules(params={}, headers=header_basic_auth)
+      info("Finding Policy Rules")
+      policy_rules = []
+      response = nil
+      ["API Access", "Category Access", "Console Access", "System Default"].each do |type|
+        response = get("#{@api_url}/policyRules/#{encode(type)}", params, headers)
+        policy_rules.concat(response.content["policyRules"] || [])
+      end
+      final_content = { "policyRules" => policy_rules }
+      response.content= final_content
+      response.content_string= final_content.to_json
+      response
+    end
+
+
+    # Find a policy rule
+    #
+    # @param policy_rule [Hash] Policy Rule properties that must contain at least the name and type
+    #   - +type+ - Policy Rule type ( API Access | Console Access | Category Access | System Default )
+    #   - +name+ - Policy Rule name to export
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Exammple
+    #
+    #     find_policy_rule({ "type" => "API Access", "name" => "Allow All"})
+    #
+    def find_policy_rule(policy_rule, params={}, headers=header_basic_auth)
+      info("Finding the \"#{policy_rule['type']} - #{policy_rule['name']}\" Policy Rule")
+      get("#{@api_url}/policyRules/#{encode(policy_rule['type'])}/#{encode(policy_rule['name'])}", params, headers)
+    end
+
+
+    # Update a Policy Rule
+    #
+    # @param policy_rule [Hash] Policy Rule properties that must contain the name and type
+    #   - +type+ - Policy Rule type ( API Access | Console Access | Category Access | System Default )
+    #   - +name+ - Policy Rule name to export
+    # @param body [Hash] Policy rule properties to update
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Exammple
+    #
+    #     update_policy_rule(
+    #       { "type" => "API Access", "name" => "Allow All" },
+    #       { "rule" => "false" }
+    #     )
+    #
+    def update_policy_rule(policy_rule, body={}, headers=default_headers)
+      info("Updating the \"#{policy_rule['type']} - #{policy_rule['name']}\" Policy Rule")
+      put("#{@api_url}/policyRules/#{encode(policy_rule['type'])}/#{encode(policy_rule['name'])}", body, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/setup.rb

@@ -0,0 +1,56 @@
+module KineticSdk
+  class Task
+
+    # Test the database connection
+    #
+    # @param db [Hash] Database configuration seettings to send as the request body
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     {
+    #       "type": "PostgreSQL",
+    #       "properties": {
+    #         "host": "mydbserver.company.com",
+    #         "port": "5432",
+    #         "database": "kinetictask",
+    #         "username": "TaskUser",
+    #         "password": "TaskPassword1"
+    #       }
+    #     }
+    #
+    def test_db_connection(db={}, headers=default_headers)
+      info("Testing database connection")
+      response = post("#{@api_url}/setup/db/test", db, headers)
+      response.content
+    end
+
+
+    # Run the database migrations
+    #
+    # @param db [Hash] Database configuration seettings to send as the request body
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    # 
+    #     {
+    #       "type": "PostgreSQL",
+    #       "properties": {
+    #         "host": "mydbserver.company.com",
+    #         "port": "5432",
+    #         "database": "kinetictask",
+    #         "username": "TaskUser",
+    #         "password": "TaskPassword1"
+    #       }
+    #     }
+    #
+    def migrate_db(db={}, headers=default_headers)
+      info("Running database migrations")
+      response = post("#{@api_url}/setup/db/migrate", db, headers)
+      response.content
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/sources.rb

@@ -0,0 +1,134 @@
+module KineticSdk
+  class Task
+
+    # Add a source
+    #
+    # @param source [Hash] Source properties
+    #   - +name+ - name of the source
+    #   - +status+ - initial status of the source (Active | Inactive)
+    #   - +type+ - name of one of the source consumers registered in the task engine
+    #   - +properties+ - hash of properties specific to the source consumer
+    #   - +policyRules+ - array of policy rules to associate with the source
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     add_source({
+    #       "name" => "Source Name",
+    #       "status" => "Active",
+    #       "type" => "Kinetic Request CE",
+    #       "properties" => {
+    #         "Space Slug" => "foo",
+    #         "Web Server" => "http://localhost:8080/kinetic",
+    #         "Proxy Username" => "integration-user",
+    #         "Proxy Password" => "integration-password"
+    #       },
+    #       "policyRules" => []
+    #     })
+    #
+    def add_source(source, headers=default_headers)
+      name = source['name']
+      info("Adding the #{name} source")
+      post("#{@api_url}/sources", source, headers)
+    end
+
+    # Delete a Source
+    #
+    # @param name [String] name of the source
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_source(name, headers=header_basic_auth)
+      info("Deleting Source \"#{name}\"")
+      delete("#{@api_url}/sources/#{encode(name)}", headers)
+    end
+
+    # Delete all Sources
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_sources(headers=header_basic_auth)
+      info("Deleting all sources")
+      (find_sources(headers).content['sources'] || []).each do |source|
+        delete("#{@api_url}/sources/#{encode(source['name'])}", headers)
+      end
+    end
+
+    # Find all sources
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_sources(params={}, headers=header_basic_auth)
+      info("Finding all sources")
+      get("#{@api_url}/sources", params, headers)
+    end
+
+    # Find a source
+    #
+    # @param name [String] name of the source
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_source(name, params={}, headers=header_basic_auth)
+      info("Finding source named \"#{name}\"")
+      get("#{@api_url}/sources/#{encode(name)}", params, headers)
+    end
+
+    # Update a source
+    #
+    # @param source [Hash] hash of existing source properties that must contain 'name'
+    #   - +name+ - name of the source
+    # @param body [Hash] - source properties to update
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Exammple
+    #
+    #     update_source(
+    #       { "name" => "Kinetic Request CE" },
+    #       {
+    #         "name": "Possible New Source Name",
+    #         "status": "Active|Unconfigured",
+    #         "type": "Adhoc|...",
+    #         "properties": {},
+    #         "policyRules": [
+    #           { "type": "API Access", "name": "Super User" },
+    #           { "type": "API Access", "name": "Info User" },
+    #           { "type": "Console Access", "name": "Super User" }
+    #         ]
+    #       }
+    #     )
+    #
+    def update_source(source, body={}, headers=default_headers)
+      info("Updating the \"#{source['name']}\" Source")
+      put("#{@api_url}/sources/#{encode(source['name'])}", body, headers)
+    end
+
+    # Add policy rule to source
+    #
+    # @param policy_rule_type [String] the type of policy rule
+    # @param policy_rule_name [String] the name of the policy rule
+    # @param source_name [String] name of the source to add the policy rule to
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_policy_rule_to_source(policy_rule_type, policy_rule_name, source_name, headers=default_headers)
+      body = { "type" => policy_rule_type, "name" => policy_rule_name }
+      info("Adding policy rule \"#{policy_rule_type} - #{policy_rule_name}\" to source \"#{source_name}\"")
+      post("#{@api_url}/sources/#{encode(source_name)}/policyRules", body, headers)
+    end
+
+    # Remove policy rule from source
+    #
+    # @param policy_rule_type [String] the type of policy rule
+    # @param policy_rule_name [String] the name of the policy rule
+    # @param source_name [String] name of the source to add the policy rule to
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def remove_policy_rule_from_source(policy_rule_type, policy_rule_name, source_name, headers=default_headers)
+      info("Removing policy rule \"#{policy_rule_type} - #{policy_rule_name}\" from source \"#{source_name}\"")
+      delete("#{@api_url}/sources/#{encode(source_name)}/policyRules/#{encode(policy_rule_type)}/#{encode(policy_rule_name)}", headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/tasks.rb

@@ -0,0 +1,17 @@
+module KineticSdk
+  class Task
+
+    # Complete a Deferred Task
+    #
+    # @param source_name [String] - name of the source
+    # @param body [Hash] properties that are sent to update the task
+    #   - +token+ - the token linked to the deferred task
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def complete_deferred_task(source_name, body, headers=default_headers)
+      info("Completing deferred task for the \"#{source_name}\" Source.")
+      post("#{@api_v1_url}/complete-deferred-task/#{encode(source_name)}", body, headers)
+    end
+
+  end
+end