cloudfs 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0922a7cd038e8bf4db5460e34f07946828a1561
+  data.tar.gz: cf488972f0f1b095944c665799ffb57806435971
+SHA512:
+  metadata.gz: a675b40f92dbb67f390a1a8ba1168f73677248732be245f8eb2d31a95b9d5e6362eabc2064a677b7fe6f8e5bceb6894df242049b1a1f8749ed936558946a6685
+  data.tar.gz: d435d4a6265c4c304dda9cea5b3974d543151eb8036a2908ca6a2a01592a59335b29b72905993508458c6dc28e984e1a0dc5ce8d1accce7e7964889f22840b8e

data/.yardopts

@@ -0,0 +1,13 @@
+--markup           markdown
+--template-path    yard
+--title 					'Bitcasa SDK for Ruby'
+--no-private
+--no-highlight
+--tag optimize:"OPTIMIZE" #--hide-tag optimize
+--tag review:"REVIEW" #--hide-tag review
+#--hide-tag todo
+#--hide-api private
+#--hide-void-return
+--hide-tag author
+'lib/**/*.rb' - '*.md'
+-

data/lib/cloudfs.rb

@@ -0,0 +1,18 @@
+require_relative 'cloudfs/version'
+require_relative 'cloudfs/rest_adapter'
+require_relative 'cloudfs/user'
+require_relative 'cloudfs/account'
+require_relative 'cloudfs/session'
+require_relative 'cloudfs/item'
+require_relative 'cloudfs/filesystem'
+require_relative 'cloudfs/file'
+require_relative 'cloudfs/container'
+require_relative 'cloudfs/folder'
+require_relative 'cloudfs/share'
+require_relative 'cloudfs/media'
+
+# This module enables application to consume Bitcasa CloudFS storage service 
+#	by creating authenticated RESTful interfaces to filesystem objects 
+#	in end-user's CloudFS account.
+module CloudFS
+end

data/lib/cloudfs/account.rb

@@ -0,0 +1,95 @@
+require_relative 'user'
+module CloudFS
+
+  # Account class defines properties of the end-user's CloudFS paid account
+  #
+  # @author Mrinal Dhillon
+  class Account
+
+    #	@!attribute [r] id
+    # @return [String] id of this user's account
+    def id
+      @properties[:id]
+    end
+
+    #	@!attribute [r] storage_usage
+    #	@return [Fixnum] current storage usage of account in bytes
+    def storage_usage
+      @properties[:storage][:usage]
+    end
+
+    #	@!attribute [r] storage_limit
+    #	@return [Fixnum] storage limit of account in bytes
+    def storage_limit
+      @properties[:storage][:limit]
+    end
+
+    #	@!attribute [r] over_storage_limit
+    #	@return [Boolean] whether user is currently over its storage quota
+    def over_storage_limit
+      @properties[:storage][:otl]
+    end
+
+    #	@!attribute [r]	state_id
+    #	@return [String] id of current account state
+    def state_id
+      @properties[:account_state][:id]
+    end
+
+    #	@!attribute [r] state_display_name
+    #	@return [String] Human readable name of account's CloudFS state
+    def state_display_name
+      @properties[:account_state][:display_name]
+    end
+
+    #	@!attribute [r] plan_display_name
+    #	@return [String] Human readable name of account's CloudFS plan
+    def plan_display_name
+      @properties[:account_plan][:display_name]
+    end
+
+    #	@!attribute [r] plan_id
+    #	@return [String] id of CloudFS plan
+    def plan_id
+      @properties[:account_plan][:id]
+    end
+
+    #	@!attribute [r] session_locale
+    #	@return [String] locale of current session
+    def session_locale
+      @properties[:session][:locale]
+    end
+
+    #	@!attribute [r] account_locale
+    #	@return [String] locale of the entire account
+    def account_locale
+      @properties[:locale]
+    end
+
+    # @param rest_adapter [RestAdapter] cloudfs RESTful api object
+    # @param [Hash] properties metadata of account
+    def initialize(rest_adapter, ** properties)
+      fail RestAdapter::Errors::ArgumentError,
+           "invalid RestAdapter type #{rest_adapter.class}, expected CloudFS::RestAdapter" unless rest_adapter.is_a?(CloudFS::RestAdapter)
+
+      @rest_adapter = rest_adapter
+      set_account_info(** properties)
+    end
+
+    # @see #initialize
+    # @review required parameters
+    def set_account_info(** properties)
+      @properties = properties
+    end
+
+    # Refresh this user's account metadata from server
+    #	@return [Account] returns self
+    def refresh
+      response = @rest_adapter.get_profile
+      set_account_info(** response)
+      self
+    end
+
+    private :set_account_info
+  end
+end

data/lib/cloudfs/client/connection.rb

@@ -0,0 +1,154 @@
+require 'httpclient'
+require_relative 'utils'
+require_relative 'error'
+require_relative 'constants'
+
+module CloudFS
+  class RestAdapter
+    # Provides RESTful interface
+    #
+    # @author Mrinal Dhillon
+    # Maintains a persistent instance of class HTTPClient,
+    #		since HTTPClient instance is MT-safe and can be called from
+    #		several threads without synchronization after setting up an instance,
+    #		same behaviour is expected from Connection class.
+    #
+    # @see http://www.rubydoc.info/gems/httpclient
+    #
+    # @example
+    #		conn = Connection.new
+    # 	response = conn.request('GET', "https://www.example.com",
+    #			:query => { :a => "b", :c => "d" })
+    # 	response = conn.request('POST', "https://www.example.com", :body => "a=b&c=d")
+    # 	response = conn.request('POST', "https://www.example.com",
+    #			:body => { :a => "b", :c => "d"} )
+    class Connection
+      # Creates Connection instance
+      #
+      # @param params [Hash] connection configurations
+      # @option params [Fixnum] :connect_timeout (60) for server handshake,
+      #			defualts to 60 as per httpclient documentation
+      # @option params [Fixnum] :send_timeout (120) for send request,
+      #			defaults to 120 sec as per httpclient documentation, set 0 for no timeout
+      # @option params [Fixnum] :receive_timeout (60) timeout for read per block,
+      #			defaults to 60 sec as per httpclient documentation, set 0 for no timeout
+      # @option params [Fixnum] :max_retry (0) for http 500 level errors
+      #	@option params [String] :agent_name (HTTPClient)
+      # @option params [#<<] :debug_dev (nil) provide http wire information
+      #		from httpclient
+      def initialize(** params)
+        @persistent_conn = HTTPClient.new
+        @persistent_conn.cookie_manager = nil
+
+        connect_timeout, send_timeout, receive_timeout,
+            max_retries, debug_dev, agent_name =
+            params.values_at(:connect_timeout, :send_timeout, :receive_timeout,
+                             :max_retries, :debug_dev, :agent_name)
+        @persistent_conn.connect_timeout = connect_timeout if connect_timeout
+        @persistent_conn.send_timeout = send_timeout if send_timeout
+        @persistent_conn.receive_timeout = receive_timeout if receive_timeout
+        @persistent_conn.debug_dev = debug_dev if debug_dev.respond_to?(:<<)
+        @persistent_conn.agent_name = agent_name
+        @max_retries = max_retries ? max_retries : 0
+      end
+
+      # Disconnects all keep alive connections and intenal sessions
+      def unlink
+        @persistent_conn.reset_all
+      end
+
+      # Sends request to specified url,
+      #		calls HTTPClient#request, retries http 500 level errors with
+      #			exponential delay upto max retries
+      #
+      # @param method [Symbol] (:get, :put, :post, :delete) http verb
+      # @param uri [String, URI] represents complete url to web resource
+      #	@param params [Hash] http request parameters i.e. :headers, :query, :body
+      # @option params [Hash] :header http request headers
+      # @option params [Hash] :query part of url -
+      #		"https://host/path?key=value&key1=value1"
+      # @option params [Array<Hash>, Hash, String] :body {} to post multipart forms,
+      #			key:value forms, string
+      #
+      # @return [Hash] response hash containing content, content_type and http code
+      #			{ :content => String, :content_type => String, :code => Fixnum }
+      # @raise [Errors::ClientError, Errors::ServerError]
+      # 		ClientError wraps httpclient exceptions
+      #				i.e. timeout, connection failed etc.
+      #			ServerError contains error message and code from server
+      # @optimize async request support
+      #
+      # @review Behaviour in case of error with follow_redirect set to true
+      #		with callback block for get: observed is that if server return
+      #		message as response body in case of error, message is discarded
+      #		and unable to fetch it. Opened issue#234 on nahi/httpclient github.
+      #		Currently fetching HTTP::Message#reason if HTTP::Message#content
+      #			is not available in such case
+      # @review exceptions raised by HTTPClient should not be handled
+      def request(method, uri, ** params, &block)
+        method = method.to_s.downcase.to_sym
+        req_params = params.reject { |_, v| Utils.is_blank?(v) }
+
+        if method == :get && !params[:header].has_key?(Constants::HEADER_REDIRECT)
+          req_params = req_params.merge({follow_redirect: true})
+        end
+
+        resp = request_with_retry(method, uri, req_params, &block)
+
+        status = resp.status.to_i
+        response = {code: status}
+        response[:content] = resp.content
+        response[:content_type] = resp.header['Content-Type'].first
+        if status < 200 || status >=400 || (resp.redirect? && status != 302)
+          message = Utils.is_blank?(resp.content) ? resp.reason : resp.content
+          request = set_error_request_context(method, uri, req_params)
+          fail Errors::ServerError.new(message, status, response, request)
+        end
+        response
+
+      rescue HTTPClient::TimeoutError
+        request = set_error_request_context(method, uri, req_params)
+        raise Errors::TimeoutError.new($!, request)
+      rescue HTTPClient::BadResponseError
+        request = set_error_request_context(method, uri, req_params)
+        raise Errors::ClientError.new($!, request)
+      rescue Errno::ECONNREFUSED, EOFError, SocketError
+        request = set_error_request_context(method, uri, req_params)
+        raise Errors::ConnectionFailed.new($!, request)
+      end
+
+      # Retries HTTP 500 error upto max retries
+      # @see request for request and response parameters
+      def request_with_retry(method, uri, req_params, &block)
+        retry_count = 0
+        loop do
+          response = @persistent_conn.request(method, uri, req_params, &block)
+          retry_count += 1
+          break response unless (response.status.to_i >= 500) && do_retry?(retry_count)
+        end
+      end
+
+      # Check if retry count is less that max retries and exponentially sleep
+      # @param retry_count [Fixnum] current count of retry
+      # @return [Boolean]
+      def do_retry?(retry_count)
+        # max retries + 1 to accommodate try
+        retry_count < @max_retries + 1 ? sleep(2**retry_count*0.3) : false
+      end
+
+      # Set request context
+      # @see #request
+      def set_error_request_context(method, uri, request_params)
+        request = {uri: uri.to_s}
+        request[:method] = method.to_s
+        # @optimize copying params as string makes exception only informative,
+        #		should instead return deep copy of request params so that
+        #		applications can evaluate error.
+        request[:params] = request_params.to_s
+        request
+      end
+
+      private :set_error_request_context, :request_with_retry, :do_retry?
+    end
+  end
+end

data/lib/cloudfs/client/constants.rb

@@ -0,0 +1,80 @@
+module CloudFS
+  class RestAdapter
+    #	@private
+    # Declares cloudfs constants
+    module Constants
+      HTTP_AGENT_NAME = 'BCSClient'
+      REQUEST_KEY_METHOD = 'method'
+      REQUEST_KEY_URI = 'uri'
+      HTTP_METHOD_KEY = 'method'
+      HTTP_METHOD_POST = 'POST'
+      HTTP_METHOD_GET = 'GET'
+
+      URI_PREFIX_HTTPS = 'https://'
+      #  DATE_FORMAT define date format
+      DATE_FORMAT = '%a, %e %b %Y %H:%M:%S %Z'
+      # HEADER_DATE constant string
+      HEADER_DATE = 'Date'
+      # HEADER_CONTENT_TYP content-type string
+      HEADER_CONTENT_TYPE = 'Content-Type'
+      # HEADER_AUTHORIZATION authorization
+      HEADER_AUTH_PREFIX_BCS = 'BCS'
+      # HEADER_AUTHORIZATION authorization
+      HEADER_AUTHORIZATION = 'Authorization'
+      # HEADER_REDIRECT follow_redirect
+      HEADER_REDIRECT = 'follow_redirect'
+      # CONTENT_TYPE_APP_URLENCODED url for application
+      CONTENT_TYPE_APP_URLENCODED = 'application/x-www-form-urlencoded;charset=utf-8'
+      # CONTENT_TYPE_MULTI content type for multipart
+      CONTENT_TYPE_MULTI = 'multipart/form-data'
+      # HEADER_CONTENT_TYPE_APP_URLENCODED
+      HEADER_CONTENT_TYPE_APP_URLENCODED = {"#{HEADER_CONTENT_TYPE}" =>
+                                                "#{CONTENT_TYPE_APP_URLENCODED}"}
+
+      PARAM_EMAIL = 'email'
+      PARAM_FIRST_NAME = 'first_name'
+      PARAM_LAST_NAME = 'last_name'
+      # PARAM_GRANT_TYPE grant_type
+      PARAM_GRANT_TYPE = 'grant_type'
+      # PARAM_USER for username
+      PARAM_USER = 'username'
+      # PARAM_PASSWORD for password
+      PARAM_PASSWORD = 'password'
+      KEY_ENDPOINT = 'endpoint'
+      # ENDPOINT_OAUTH for oauth2 token
+      ENDPOINT_OAUTH = '/v2/oauth2/token'
+      # ENDPOINT_PING for ping
+      ENDPOINT_PING = '/v2/ping'
+      # ENDPOINT_CUSTOMERS defines admin cloudfs customers
+      ENDPOINT_CUSTOMERS = '/v2/admin/cloudfs/customers/'
+      # ENDPOINT_USER_PROFILE for user profile
+      ENDPOINT_USER_PROFILE = '/v2/user/profile/'
+      # ENDPOINT_FOLDERS for folders
+      ENDPOINT_FOLDERS = '/v2/folders/'
+      # ENDPOINT_FILES for files
+      ENDPOINT_FILES = '/v2/files/'
+      # ENDPOINT_FILES for files
+      ENDPOINT_ITEM = '/v2/files/' # TODO should change this path to /v2/filesystem/root/<path>/meta after REST fix
+      # ENDPOINT_SHARES for share folder
+      ENDPOINT_SHARES = '/v2/shares/'
+      # ENDPOINT_HISTORY for history
+      ENDPOINT_HISTORY = '/v2/history'
+      # ENDPOINT_TRASH for trash
+      ENDPOINT_TRASH = '/v2/trash/'
+      # QUERY_OPS_CREATE creates query ops
+      QUERY_OPS_CREATE = 'create'
+      # QUERY_OPS_COPY for copying query ops
+      QUERY_OPS_COPY = 'copy'
+      # QUERY_OPS_MOVE for move
+      QUERY_OPS_MOVE = 'move'
+      # QUERY_OPS_PROMOTE for promote
+      QUERY_OPS_PROMOTE = 'promote'
+      # EXISTS for fail, overwrite, rename & reuse actions
+      EXISTS = {FAIL: 'fail', OVERWRITE: 'overwrite', RENAME: 'rename'}
+      # VERSION_CONFLICT for fail or ignore.
+      VERSION_EXISTS = {FAIL: 'fail', IGNORE: 'ignore'}
+      # RESTORE fail, rescue & recreate action
+      RESTORE_METHOD = {FAIL: 'fail', RESCUE: 'rescue', RECREATE: 'recreate'}
+    end
+  end
+end

data/lib/cloudfs/client/error.rb

@@ -0,0 +1,452 @@
+require_relative 'utils'
+
+module CloudFS
+  class RestAdapter
+    # Defines exceptional behavior.
+    # {Error} is base class of all exceptions raised by CloudFS SDK.
+    # {Errors::ServiceError} is base class of all errors returned by CloudFS service.
+    # Other exceptions are {Errors::ArgumentError}, {Errors::ClientError},
+    #		{Errors::InvalidItemError}, {Errors::InvalidShareError},
+    #		{Errors::OperationNotAllowedError}, {Errors::SessionNotLinked}
+    #
+    #	@example
+    #		begin
+    #			rest_adapter.ping
+    #		rescue RestAdapter::Errors::SessionNotLinked
+    #			rest_adapter.authenticate(username, password)
+    #			retry
+    #		rescue RestAdapter::Errors::ServiceError => error
+    #			puts error.message
+    #			puts error.request
+    #			puts error.response
+    #			puts error.code
+    #		rescue RestAdapter::Errors::Error => error
+    #			puts error.message
+    #			puts error.backtrace
+    #		end
+    #
+    # @author Mrinal Dhillon
+    module Errors
+
+      # Maps exception classes to error codes returned by CloudFS Service
+      BITCASA_ERRORS = {
+          9999 => 'GeneralPanicError',
+          9000 => 'APIError',
+          9006 => 'APICallLimitReached',
+
+          # FileSystem errors
+          8001 => 'InvalidVersion',
+          8002 => 'VersionMismatchIgnored',
+          8004 => 'OrigionalPathNoLongerExists',
+
+          # Shares errors
+          6001 => 'SharePathRequired',
+          6002 => 'SharePathDoesNotExist',
+          6003 => 'WouldExceedQuota',
+          6004 => 'ShareDoesNotExist',
+
+          # Folder errors
+          2002 => 'FolderDoesNotExist',
+          2003 => 'FolderNotFound',
+          2004 => 'UploadToReadOnlyDestinationFailed',
+          2005 => 'MoveToReadOnlyDestinationFailed',
+          2006 => 'CopyToReadOnlyDestinationFailed',
+          2007 => 'RenameOnReadOnlyLocationFailed',
+          2008 => 'DeleteOnReadOnlyLocationFailed',
+          2009 => 'CreateFolderOnReadOnlyLocationFailed',
+          2010 => 'FailedToReadFilesystem',
+          2011 => 'FailedToReadFilesystem',
+          2012 => 'FailedToReadFilesystem',
+          2013 => 'FailedToReadFilesystem',
+          2014 => 'NameConflictCreatingFolder',
+          2015 => 'NameConflictOnUpload',
+          2016 => 'NameConflictOnRename',
+          2017 => 'NameConflictOnMove',
+          2018 => 'NameConflictOnCopy',
+          2019 => 'FailedToSaveChanges',
+          2020 => 'FailedToSaveChanges',
+          2021 => 'FailedToSaveChanges',
+          2022 => 'FailedToBroadcastUpdate',
+          2023 => 'FailedToBroadcastUpdate',
+          2024 => 'FailedToSaveChanges',
+          2025 => 'FailedToSaveChanges',
+          2026 => 'CannotDeleteTheInfiniteDrive',
+          2028 => 'MissingToParameter"',
+          2033 => 'ExistsParameterInvalid',
+          2034 => 'MissingPathParameter',
+          2036 => 'SpecifiedLocationIsReadOnly',
+          2037 => 'SpecifiedSourceIsReadOnly',
+          2038 => 'SpecifiedDestinationIsReadOnly',
+          2039 => 'FolderPathDoesNotExist',
+          2040 => 'PermissionDenied',
+          2041 => 'RenamePermissionDenied',
+          2042 => 'NameConflictInOperation',
+          2043 => 'InvalidOperation',
+          2044 => 'VersionMissingOrIncorrect',
+          2045 => 'InvalidDepth',
+          2046 => 'VersionDoesNotExist',
+          2047 => 'FolderNameRequired',
+          2048 => 'InvalidName',
+          2049 => 'TreeRequired',
+          2050 => 'InvalidVerbose',
+          2052 => 'DirectoryNotEmpty',
+
+          # File errors
+          3001 => 'NotFound',
+          3007 => 'InvalidOperation',
+          3008 => 'InvalidName',
+          3009 => 'InvalidExists',
+          3010 => 'ExtensionTooLong',
+          3011 => 'InvalidDateCreated',
+          3012 => 'InvalidDateMetaLastModified',
+          3013 => 'InvalidDateContentLastModified',
+          3014 => 'MIMETooLong',
+          3015 => 'SizeMustBePositive',
+          3018 => 'NameRequired',
+          3019 => 'SizeRequired',
+          3020 => 'ToPathRequired',
+          3021 => 'VersionMissingOrIncorrect',
+
+          # Endpoint Entry Errors
+          10000 => 'InvalidPath',
+          10001 => 'AlreadyExists',
+          10002 => 'NotAllowed'
+      }
+
+      # All errors can be rescued by Errors::Error
+      #	Top most error class, all cloudfs exceptions can be rescued by this class
+      class Error < StandardError;
+      end
+
+      # Item does not exists anymore, this is possible when item has been deleted
+      class InvalidItemError < Error;
+      end
+
+      # Share does not exists anymore, this is possible when share has been deleted
+      class InvalidShareError < Error;
+      end
+
+      # Operation not allowed error
+      class OperationNotAllowedError < Error;
+      end
+
+      # Invalid Argument error
+      class ArgumentError < Error;
+      end
+
+      # Session not linked error points out that either session
+      #		is not authenticated or has been unlinked
+      class SessionNotLinked < Error
+        def initialize
+          super('session is not linked, please authenticate')
+        end
+      end
+
+      # All HTTP errors can be rescued by Errors::HttpError
+      class HttpError < Error;
+      end
+
+      # Base class of Client side errors - {ConnectionFailed}, {TimeoutError}
+      class ClientError < HttpError
+        # @return [Fixnum] http status
+        attr_reader :code
+        # @return [ { :content => "HTTPClient Error",
+        #				:content_type => "application/text", :code => -1 } ] response
+        # Is not informative, see backtrace for more info
+        attr_reader :response
+        #	@return [Hash]
+        #	{ :uri => String, :method => String, :params => String }
+        attr_reader :request
+
+        # @param error [Exception, String]
+        # @param request [Hash] request context
+        def initialize(error, request={})
+          if error.respond_to?(:backtrace)
+            super(error.message)
+            @original = error
+            @code = -1
+            @request = request
+            # nothing informative to provide here
+            @response = {:content => 'HTTPClient Error',
+                         :content_type => 'application/text', :code => -1}
+          else
+            super(error.to_s)
+          end
+        end
+
+        # @return [String] backtrace of original exception
+        def backtrace
+          @original.backtrace if @original && @original.respond_to?(:backtrace)
+        end
+      end
+
+      # Client side error when host is not reachable
+      class ConnectionFailed < ClientError;
+      end
+
+      # Client side error when excution is expired due to send and receive time out
+      class TimeoutError < ClientError;
+      end
+
+      # Exception for errors returned by remote service
+      class ServerError < HttpError
+        # @return [Fixnum] http status
+        attr_reader :code
+        # @return [Hash] response
+        #		{ :content => String, :content_type => String, :code => Fixnum }
+        attr_reader :response
+        #	@return [Hash] request context
+        #	{ :uri => String, :method => String, :params => String }
+        attr_reader :request
+
+        # @param message [String] error message
+        # @param code [Fixnum] error code
+        # @param response [Hash] service response body
+        # @param request [Hash] service request body
+        def initialize(message, code, response={}, request={})
+          super(message)
+          @code = code
+          @response = response
+          @request = request
+        end
+      end
+
+      # Base class of all errors returned by cloudfs service
+      class ServiceError < Error
+        # @param message [String] error message
+        # @param original [Exception] original exception
+        def initialize(message, original=nil)
+          super(message)
+          @original = original
+        end
+
+        # @attribute [r] request
+        # @return [Hash] request context
+        def request
+          if @original.respond_to?(:request)
+            @original.request
+          else
+            {}
+          end
+        end
+
+        # @attribute [r] response
+        # @return [Hash] response context
+        def response
+          if @original.respond_to?(:response)
+            @original.response
+          else
+            {}
+          end
+        end
+
+        # @attribute [r] code
+        # @return [Fixnum] http status
+        def code
+          if @original.respond_to?(:code)
+            @original.code
+          else
+            -1
+          end
+        end
+
+        # @return [String] backtrace of original exception
+        def backtrace
+          @original.backtrace if @original && @original.respond_to?(:backtrace)
+        end
+      end
+
+      class GeneralPanicError < ServiceError;
+      end
+      class APIError < ServiceError;
+      end
+      class APICallLimitReached < ServiceError;
+      end
+
+      # Base class for filesystem errors returned by cloudfs service.
+      class FileSystemError < ServiceError;
+      end
+
+      # Base class for share errors returned by cloudfs service.
+      class ShareError < ServiceError;
+      end
+
+      # Base class for folder errors returned by cloudfs service.
+      class FolderError < ServiceError;
+      end
+
+      # Base class for file errors returned by cloudfs service.
+      class FileError < ServiceError;
+      end
+
+      # Base class for endpoint errors returned by cloudfs service.
+      class EndpointError < ServiceError;
+      end
+
+      # FileSystem Errors
+
+      class InvalidVersion < FileSystemError;
+      end
+      class VersionMismatchIgnored < FileSystemError;
+      end
+      class OrigionalPathNoLongerExists < FileSystemError;
+      end
+
+      # Share Errors
+
+      class SharePathRequired < ShareError;
+      end
+      class SharePathDoesNotExist < ShareError;
+      end
+      class WouldExceedQuota < ShareError;
+      end
+      class ShareDoesNotExist < ShareError;
+      end
+
+      # Folder Errors
+
+      class FolderDoesNotExist < FolderError;
+      end
+      class FolderNotFound < FolderError;
+      end
+      class UploadToReadOnlyDestinationFailed < FolderError;
+      end
+      class MoveToReadOnlyDestinationFailed < FolderError;
+      end
+      class CopyToReadOnlyDestinationFailed < FolderError;
+      end
+      class RenameOnReadOnlyLocationFailed < FolderError;
+      end
+      class DeleteOnReadOnlyLocationFailed < FolderError;
+      end
+      class CreateFolderOnReadOnlyLocationFailed < FolderError;
+      end
+      class FailedToReadFilesystem < FolderError;
+      end
+      class NameConflictCreatingFolder < FolderError;
+      end
+      class NameConflictOnUpload < FolderError;
+      end
+      class NameConflictOnRename < FolderError;
+      end
+      class NameConflictOnMove < FolderError;
+      end
+      class NameConflictOnCopy < FolderError;
+      end
+      class FailedToSaveChanges < FolderError;
+      end
+      class FailedToBroadcastUpdate < FolderError;
+      end
+      class CannotDeleteTheInfiniteDrive < FolderError;
+      end
+      class FolderMissingToParameter < FolderError;
+      end
+      class ExistsParameterInvalid < FolderError;
+      end
+      class MissingPathParameter < FolderError;
+      end
+      class SpecifiedLocationIsReadOnly < FolderError;
+      end
+      class SpecifiedSourceIsReadOnly < FolderError;
+      end
+      class SpecifiedDestinationIsReadOnly < FolderError;
+      end
+      class FolderPathDoesNotExist < FolderError;
+      end
+      class PermissionDenied < FolderError;
+      end
+      class RenamePermissionDenied < FolderError;
+      end
+      class NameConflictInOperation < FolderError;
+      end
+      class InvalidOperation < FolderError;
+      end
+      class VersionMissingOrIncorrect < FolderError;
+      end
+      class InvalidDepth < FolderError;
+      end
+      class VersionMissingOrIncorrect < FolderError;
+      end
+      class VersionDoesNotExist < FolderError;
+      end
+      class FolderNameRequired < FolderError;
+      end
+      class InvalidName < FolderError;
+      end
+      class TreeRequired < FolderError;
+      end
+      class InvalidVerbose < FolderError;
+      end
+      class DirectoryNotEmpty < FolderError;
+      end
+
+      # FileErrors
+
+      class SizeRequired < FileError;
+      end
+      class NotFound < FileError;
+      end
+      class FileInvalidOperation < FileError;
+      end
+      class FileInvalidName < FileError;
+      end
+      class InvalidExists < FileError;
+      end
+      class ExtensionTooLong < FileError;
+      end
+      class InvalidDateCreated < FileError;
+      end
+      class InvalidDateMetaLastModified < FileError;
+      end
+      class InvalidDateContentLastModified < FileError;
+      end
+      class MIMETooLong < FileError;
+      end
+      class SizeMustBePositive < FileError;
+      end
+      class NameRequired < FileError;
+      end
+      class SizeRequired < FileError;
+      end
+      class ToPathRequired < FileError;
+      end
+      class FileVersionMissingOrIncorrect < FileError;
+      end
+
+      # Enpoint Errors
+
+      class InvalidPath < EndpointError;
+      end
+      class AlreadyExists < EndpointError;
+      end
+      class NotAllowed < EndpointError;
+      end
+
+      # Raises specific exception mapped by CloudFS error code in json message
+      #
+      # @param error [ServerError] contains message, request, response context
+      #			and http code returned by cloudfs service
+      #
+      # @raise [ServiceError] mapped by code in message parameter in {ServerError}
+      def self.raise_service_error(error)
+        begin
+          hash = Utils.json_to_hash(error.message)
+        rescue StandardError
+          raise ServiceError.new(error.message, error)
+        end
+        raise ServiceError.new(error.message, error) unless hash.key?(:error)
+
+        if hash[:error].is_a?(Hash)
+          code, message = Utils.hash_to_arguments(hash[:error],
+                                                  :code, :message)
+        else
+          message = hash.fetch(:message) { hash[:error] }
+          code = hash.fetch(:error_code, nil)
+        end
+        raise ServiceError.new(message, error) unless code && BITCASA_ERRORS.key?(code)
+        raise const_get(BITCASA_ERRORS[code]).new(message, error)
+      end
+
+    end
+  end
+end