kinetic_sdk 0.1.1

data/lib/kinetic_sdk/discussions/lib/messages.rb

@@ -0,0 +1,190 @@
+module KineticSdk
+  class Discussions
+
+    # Add a Message without attachments
+    #
+    # If message parameter is a Hash, it assumes the message contains the
+    # `content` property set to an array of the expected tokens (`type` 
+    # and `value` properties).
+    #
+    # If message parameter is an Array, it assumes the message contains
+    # the array of expected tokens (`type` and `value` properties).
+    #
+    # If message parameter is a string, it builds up the message `content`
+    # property as a single `text` token with the value of the message
+    # parameter.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message [String | Hash | Array] message
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_message(discussion_id, message, headers=default_jwt_headers)
+      payload = message_content(message)
+      info("Adding a message to the #{discussion_id} Discussion")
+      post("#{@api_url}/discussions/#{discussion_id}/messages", payload, headers)
+    end
+
+    # Add a Message with attachments
+    #
+    # If properties['message'] parameter is a Hash, it assumes the message
+    # contains the `content` property set to an array of the expected tokens
+    # (`type` and `value` properties).
+    #
+    # If properties['message'] parameter is an Array, it assumes the message
+    # contains the array of expected tokens (`type` and `value` properties).
+    #
+    # If properties['message'] parameter is a string, it builds up the message
+    # `content` property as a single `text` token with the value of the
+    # properties['message'] parameter.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param properties [Hash] message properties
+    #   - +message+ [String | Hash | Array] message
+    #   - +attachments+ [File[]]
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_message_with_attachments(discussion_id, properties={}, headers=default_jwt_headers)
+      payload = message_content(properties['message'])
+      payload["attachments"] = properties['attachments']
+      info("Adding a message to the #{discussion_id} Discussion")
+      post_multipart("#{@api_url}/discussions/#{discussion_id}/messages", payload, headers)
+    end
+
+    # Find Messages in a Discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_messages(discussion_id, params={}, headers=default_jwt_headers)
+      info("Finding messages in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/messages", params, headers)
+    end
+
+    # Find a Message in a Discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message_id [String] id of the message
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_message(discussion_id, message_id, params={}, headers=default_jwt_headers)
+      info("Finding the #{message_id} message in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/messages/#{message_id}", params, headers)
+    end
+
+    # Update a Message without new attachments
+    #
+    # If message parameter is a Hash, it assumes the message contains the
+    # `content` property set to an array of the expected tokens (`type` 
+    # and `value` properties).
+    #
+    # If message parameter is an Array, it assumes the message contains
+    # the array of expected tokens (`type` and `value` properties).
+    #
+    # If message parameter is a string, it builds up the message `content`
+    # property as a single `text` token with the value of the message
+    # parameter.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message_id [String] id of the message
+    # @param message [String | Hash | Array] updated content of the message
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_message(discussion_id, message_id, message, headers=default_jwt_headers)
+      payload = message_content(message)
+      info("Updating the #{message_id} message in the #{discussion_id} Discussion")
+      put("#{@api_url}/discussions/#{discussion_id}/messages/#{message_id}", payload, headers)
+    end
+
+    # Update a Message with new attachments
+    #
+    # If message parameter is a Hash, it assumes the message contains the
+    # `content` property set to an array of the expected tokens (`type` 
+    # and `value` properties).
+    #
+    # If message parameter is an Array, it assumes the message contains
+    # the array of expected tokens (`type` and `value` properties).
+    #
+    # If message parameter is a string, it builds up the message `content`
+    # property as a single `text` token with the value of the message
+    # parameter.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message_id [String] id of the message
+    # @param message [String | Hash | Array] updated content of the message
+    # @param attachments [File[]] new attachments to add to the message
+    # @param headers [Hash] hash of headers to send, default is bearer authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_message_with_attachments(discussion_id, message_id, message, attachments=[], headers=header_bearer_auth)
+      payload = { "message" => message_content(message).to_json, "attachments" => attachments }
+      info("Updating the #{message_id} message in the #{discussion_id} Discussion")
+      post_multipart("#{@api_url}/discussions/#{discussion_id}/messages/#{message_id}", payload, headers)
+    end
+
+    # Download a message attachment
+    #
+    # **WARNING** This method downloads the entire attachment into memory. This
+    # may cause problems with large files. To stream the attachment in chunks to
+    # avoid consuming large amounts of memory, see the 
+    # {export_message_attachment} method.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message_id [String] id of the message
+    # @param document_id [String] id of the document in the filestore
+    # @param filename [String] default name to use for the downloaded file
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def download_message_attachment(discussion_id, message_id, document_id, filename, params={}, headers=header_bearer_auth)
+      info("Downloading the #{filename} file attachment in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/messages/#{message_id}/files/#{document_id}/#{filename}", params, headers)
+    end
+
+    # Export a message attachment
+    #
+    # This method streams the attachment in chunks to avoid consuming large
+    # amounts of memory.
+    #
+    # The message attachment will be saved to the 
+    # `{export_directory}/{discussion_id}/files/{message_id}` directory, where:
+    #
+    #   * +export_directory+: the directory specified in the SDK configuration
+    #   * +discussion_id+: the id of the discussion
+    #   * +message_id+: the id of the message that contains the attachment
+    #
+    # If you want to work with the attachment in code rather than automatically
+    # save it to a file, see the {download_message_attachment} method.
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param message_id [String] id of the message
+    # @param document_id [String] id of the document in the filestore
+    # @param filename [String] default name to use for the downloaded file
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication
+    def export_message_attachment(discussion_id, message_id, document_id, filename, params={}, headers=header_bearer_auth)
+      raise StandardError.new "An export directory must be defined to export a file attachment." if @options[:export_directory].nil?
+      info("Exporting the #{filename} file attachment in the #{discussion_id} Discussion")
+      # Create the export directory if it doesn't yet exist
+      export_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], discussion_id, "files", message_id))
+      export_file = File.join(export_dir, filename)
+      url = "#{@api_url}/discussions/#{discussion_id}/messages/#{message_id}/files/#{document_id}/#{filename}"
+      stream_download_to_file(export_file, url, params, headers)
+    end
+
+
+    private
+
+    def message_content(message)
+      case message.class.name
+      when 'Hash'
+        message
+      when 'Array'
+        { "content" => message }
+      else
+        { "content" => [{ "type": "text", "value": message }] }
+      end
+    end
+
+  end
+end

data/lib/kinetic_sdk/discussions/lib/meta.rb

@@ -0,0 +1,14 @@
+module KineticSdk
+  class Discussions
+
+    # Retrieve Discussions application version
+    #
+    # @param headers [Hash] hash of headers to send, default is accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def app_version(headers=header_accept_json)
+      info("Retrieving Discussions application version.")
+      get("#{@api_url}/version", {}, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/discussions/lib/participants.rb

@@ -0,0 +1,64 @@
+module KineticSdk
+  class Discussions
+
+    # Create a participant for an existing user
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param username [String] username of the user
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_participant(discussion_id, username, headers=default_jwt_headers)
+      payload = { "username" => username }
+      info("Participant #{username} joining the #{discussion_id} Discussion")
+      post("#{@api_url}/discussions/#{discussion_id}/participants", payload, headers)
+    end
+
+    # Delete a participant
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param username [String] username of the participant
+    # @param headers [Hash] hash of headers to send, default is bearer authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_participant(discussion_id, username, headers=header_bearer_auth)
+      info("Participant #{username} is leaving the #{discussion_id} Discussion")
+      delete("#{@api_url}/discussions/#{discussion_id}/participants/#{encode(username)}", headers)
+    end
+
+    # Find participants in a discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_participants(discussion_id, params={}, headers=default_jwt_headers)
+      info("Finding Participants in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/participants", params, headers)
+    end
+
+    # Find a participant in a discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param username [String] username of the participant
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_participant(discussion_id, username, params={}, headers=default_jwt_headers)
+      info("Finding the #{username} Participant in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/participants/#{encode(username)}", params, headers)
+    end
+
+    # Update a participant in a discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param username [String] username of the participant
+    # @param properties [Hash] participant properties to update
+    #   - +isMuted+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_participant(discussion_id, username, properties={}, headers=default_jwt_headers)
+      info("Updating the #{username} Participant in the #{discussion_id} Discussion")
+      put("#{@api_url}/discussions/#{discussion_id}/participants/#{encode(username)}", properties, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/discussions/lib/related_items.rb

@@ -0,0 +1,54 @@
+module KineticSdk
+  class Discussions
+
+    # Add a Related Item to a discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param type [String] type of related item
+    # @param key [String] key that identifies the related item
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def add_related_item(discussion_id, type, key, headers=default_jwt_headers)
+      payload = {"type": type, "key": key}
+      info("Adding a related item of type #{type} and key #{key} to the #{discussion_id} Discussion")
+      post("#{@api_url}/discussions/#{discussion_id}/relatedItems", payload, headers)
+    end
+
+    # Delete a Related Item from a discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param type [String] type of related item
+    # @param key [String] key that identifies the related item
+    # @param headers [Hash] hash of headers to send, default is bearer authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_related_item(discussion_id, type, key, headers=header_bearer_auth)
+      info("Deleting related item of type #{type} and key #{key} from the #{discussion_id} Discussion")
+      delete("#{@api_url}/discussions/#{discussion_id}/relatedItems/#{encode(type)}/#{encode(key)}", payload, headers)
+    end
+
+    # Find Related Items in a Discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_related_items(discussion_id, params={}, headers=default_jwt_headers)
+      info("Finding related items in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/relatedItems", params, headers)
+    end
+
+    # Find a Related Item in a Discussion
+    #
+    # @param discussion_id [String] id of the discussion
+    # @param type [String] type of the related item
+    # @param key [String] key that identifies the related item
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is bearer authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_related_item(discussion_id, type, key, params={}, headers=default_jwt_headers)
+      info("Finding the related item of type #{type} and key #{key} in the #{discussion_id} Discussion")
+      get("#{@api_url}/discussions/#{discussion_id}/relatedItems/#{encode(type)}/#{encode(key)}", params, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/discussions/lib/websockets.rb

@@ -0,0 +1,96 @@
+require 'kontena-websocket-client'
+
+################################################################################
+#
+# NOTE: All of the Discussion Web Socket methods are experimental.
+#
+# Websocket status codes
+# https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+# 
+################################################################################
+
+module KineticSdk
+  class Discussions
+
+    # Subscribes an existing user or invited user to the specified discussion.
+    #
+    # @param discussion_id [String] id of the discussion to subscribe the person to
+    # @param invitation_token [String] UUID of the invitation user token, 
+    #     nil for an existing user
+    def subscribe(discussion_id, invitation_token=nil)
+      ws_client(join_msg(discussion_id, invitation_token))
+    end
+
+
+    private
+
+    def identify_msg
+      {
+        "action": "identify",
+        "payload": { "token": @jwt },
+        "ref": "identify-ref",
+        "topic": "topichub"
+      }.to_json
+    end
+
+    def join_msg(discussion_id, invitation_token)
+      {
+        "action": "subscribe",
+        "payload": {
+          "topic": "discussions/discussion/#{discussion_id}",
+          "userInvitationToken": invitation_token
+        },
+        "ref": "subscription-ref",
+        "topic": "topichub"
+      }.to_json
+    end
+
+
+    def ws_writer(ws, msg)
+      info("Websocket send message: #{msg}")
+      ws.send(msg)
+    end
+
+    def ws_reader(ws, send_msg=nil)
+      ws.read do |msg|
+        info("Websocket read: #{msg}")
+        o = JSON.parse(msg)
+        if ("error$".match(o['event']))
+          info("Websocket failure: #{o['payload']}")
+        elsif (o['event'] == "participant:updated")
+          info("Websocket close: EOF")
+          ws.close(1000, "EOF")
+          break
+        else
+          unless send_msg.nil?
+            ws_writer(ws, send_msg)
+            send_msg = nil
+          end
+        end
+      end
+    end
+
+    def ws_client(message)
+      write_thread = nil
+      info("Websocket connecting to #{@topics_ws_server}")
+      Kontena::Websocket::Client.connect(@topics_ws_server) do |ws|
+        info("Websocket connected to #{ws.url}")
+        write_thread = Thread.new {
+          ws_writer(ws, identify_msg())
+        }
+        ws_reader(ws, message)
+        info("Websocket client closed connection with code #{ws.close_code}: #{ws.close_reason}")
+      end
+    rescue Kontena::Websocket::CloseError => e
+      info(e)
+    rescue Kontena::Websocket::Error => e
+      info(e)
+    ensure
+      if write_thread
+        write_thread.kill
+        write_thread.join
+      end
+    end
+
+  end
+end

data/lib/kinetic_sdk/filehub/filehub-sdk.rb

@@ -0,0 +1,80 @@
+Dir[File.join(File.dirname(File.expand_path(__FILE__)), "lib", "**", "*.rb")].each {|file| require file }
+
+module KineticSdk
+
+  # Filehub is a Ruby class that acts as a wrapper for the Kinetic FileHub REST API
+  # without having to make explicit HTTP requests.
+  #
+  class Filehub
+
+    # Include the KineticHttpUtils module
+    include KineticSdk::Utils::KineticHttpUtils
+
+    attr_reader :api_url, :username, :options, :password, :server, :version
+
+    # Initalize the FileHub SDK with the web server URL and configuration user
+    # credentials, along with any custom option values.
+    #
+    # @param opts [Hash] Kinetic FileHub properties
+    # @option opts [String] :config_file optional - path to the YAML configuration file
+    #
+    #   * Ex: /opt/config/filehub-configuration1.yaml
+    #
+    # @option opts [String] :app_server_url the URL to the Kinetic Filehub web application.
+    #
+    #   * Ex: <http://192.168.0.1:8080/kinetic-filehub>
+    #
+    # @option opts [String] :username the username for the user
+    # @option opts [String] :password the password for the user
+    # @option opts [Hash<Symbol, Object>] :options ({}) optional settings
+    #
+    #   * :log_level (String) (_defaults to: off_) level of logging - off | info | debug | trace
+    #   * :max_redirects (Fixnum) (_defaults to: 10_) maximum number of redirects to follow
+    #   * :ssl_ca_file (String) full path to PEM certificate used to verify the server
+    #   * :ssl_verify_mode (String) (_defaults to: none_) - none | peer
+    #
+    # Example: using a configuration file
+    #
+    #     KineticSdk::Filehub.new({
+    #       config_file: "/opt/config1.yaml"
+    #     })
+    #
+    # Example: using a properties hash
+    #
+    #     KineticSdk::Filehub.new({
+    #       app_server_url: "http://localhost:8080/kinetic-filehub",
+    #       username: "admin",
+    #       password: "admin",
+    #       options: {
+    #         log_level: "debug",
+    #         ssl_verify_mode: "peer",
+    #         ssl_ca_file: "/usr/local/self_signing_ca.pem"
+    #       }
+    #     })
+    #
+    # If the +config_file+ option is present, it will be loaded first, and any additional
+    # options will overwrite any values in the config file
+    #
+    def initialize(opts={})
+      # initialize any variables
+      options = {}
+
+      # process the configuration file if it was provided
+      unless opts[:config_file].nil?
+        options.merge!(YAML::load_file opts[:config_file])
+      end
+
+      # process the configuration hash if it was provided
+      options.merge!(opts)
+
+      # process any individual options
+      @options = options.delete(:options) || {}
+      @username = options[:username]
+      @password = options[:password]
+      @server = options[:app_server_url].chomp('/')
+      @api_url = "#{@server}/app/api/v1"
+      @version = 1
+    end
+
+  end
+end

data/lib/kinetic_sdk/filehub/lib/access_keys.rb

@@ -0,0 +1,67 @@
+module KineticSdk
+  class Filehub
+
+    # Add an Access Key for a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @param payload [Hash] properties for the access key
+    #   - +description+
+    #   - +id+
+    #   - +secret+
+    # @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_access_key(slug, payload, headers=default_headers)
+      info("Adding Access Key for Filestore \"#{slug}\"")
+      post("#{@api_url}/filestores/#{slug}/access-keys", payload, headers)
+    end
+
+    # Delete an Access Key for a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @param id [String] id (key) of the access key
+    # @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 delete_access_key(slug, id, headers=default_headers)
+      info("Deleting Access Key #{id} for Filestore \"#{slug}\"")
+      delete("#{@api_url}/filestores/#{slug}/access-keys/#{id}", headers)
+    end
+
+    # Find Access Keys for a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @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 and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_access_keys(slug, params={}, headers=default_headers)
+      info("Finding Access Keys for Filestore \"#{slug}\"")
+      get("#{@api_url}/filestores/#{slug}/access-keys", params, headers)
+    end
+
+    # Find an Access Key for a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @param id [String] id (key) of the access key
+    # @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 and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_access_key(slug, id, params={}, headers=default_headers)
+      info("Finding Access Key \"#{id}\" for Filestore \"#{slug}\"")
+      get("#{@api_url}/filestores/#{slug}/access-keys/#{id}", params, headers)
+    end
+
+    # Update a Filestore Access Key
+    #
+    # @param slug [String] slug of the filestore
+    # @param id [String] id (key) of the access key
+    # @param payload [Hash] properties for the access key
+    #   - +description+
+    #   - +secret+
+    # @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_access_key(slug, id, payload, headers=default_headers)
+      info("Updating Access Key \"#{id}\" for Filestore \"#{slug}\"")
+      put("#{@api_url}/filestores/#{slug}/access-keys/#{id}", payload, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/filehub/lib/filestores.rb

@@ -0,0 +1,67 @@
+module KineticSdk
+  class Filehub
+
+    # Add a Filestore
+    #
+    # @param payload [Hash] properties for the bridge
+    #   - +accessKeys+
+    #   - +adapterClass+
+    #   - +name+
+    #   - +properties+
+    #   - +slug+
+    # @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_filestore(payload, headers=default_headers)
+      info("Adding Filestore \"#{payload['name']}\" with slug \"#{payload['slug']}\"")
+      post("#{@api_url}/filestores", payload, headers)
+    end
+
+    # Delete a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @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 delete_filestore(slug, headers=default_headers)
+      info("Deleting Filestore \"#{slug}\"")
+      delete("#{@api_url}/filestores/#{slug}", headers)
+    end
+
+    # Find Filestore
+    #
+    # @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 and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_filestores(params={}, headers=default_headers)
+      info("Find Filestores")
+      get("#{@api_url}/filestores", params, headers)
+    end
+
+    # Find a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @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 and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_filestore(slug, params={}, headers=default_headers)
+      info("Finding Filestore \"#{slug}\"")
+      get("#{@api_url}/filestores/#{slug}", params, headers)
+    end
+
+    # Update a Filestore
+    #
+    # @param slug [String] slug of the filestore
+    # @param payload [Hash] properties for the bridge
+    #   - +accessKeys+
+    #   - +adapterClass+
+    #   - +name+
+    #   - +properties+
+    #   - +slug+
+    # @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_filestore(slug, payload, headers=default_headers)
+      info("Updating Filestore \"#{slug}\"")
+      put("#{@api_url}/filestores/#{slug}", payload, headers)
+    end
+
+  end
+end