selfsdk 0.0.209 → 0.0.210

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4adb1d39e345e27532a012a26dcd8711fc245b2e93baa81890c6539cd8cf5424
-  data.tar.gz: d2e725fb3ab955237186ba7c5d9eca6e2083e4a4144b4a1f7d59b96f92e7ee59
+  metadata.gz: 97a576e450b5c015dd14fdac839bdffa8de9a3f6d5fdcda6f9c09970a9a11e63
+  data.tar.gz: 02eb35df5ad3fb4609ad5b91704c8085b74532434ca94c458d88fa1f35e62aa9
 SHA512:
-  metadata.gz: a916f8c596495f580ee4b29c8e253325be6409133bb5eafb7df398b8848aef5148acc44cee6302d3ad25a1136c9e2344add606290ad49f2bc0be7a081b83b939
-  data.tar.gz: 51790af7cb7fb53f911c7484584deb733f4d55b9d151b23a4086cab356946cf95c066449a307dd20be755ea33a0db0d287596bb247414446de89f2d3b8866e9e
+  metadata.gz: 01335ef6d7e1afcc0abcd3e74d3ff15073ba24b13442475374e28263c02e7a5ba3c2face85ac3140aa8dee54bedb54f81ae0d0a1acfc28c40cb24177e5021456
+  data.tar.gz: 344a4b3becca938ff1c23dbe9b29216c7e04d2c31d3bfc986a8bdec3421b94c5ae434bbbec18a3abd071ec17d95cf4a22c841ec3607ce7e979df69c7cb644ca6

data/lib/acl.rb

@@ -25,30 +25,43 @@ module SelfSDK
     def allow(id)
       @acl_rules << id
       SelfSDK.logger.info "Allowing connections from #{id}"
-      @messaging.add_acl_rule(@jwt.prepare(jti: SecureRandom.uuid,
-                                           cid: SecureRandom.uuid,
-                                           typ: 'acl.permit',
-                                           iss: @jwt.id,
-                                           sub: @jwt.id,
-                                           iat: (SelfSDK::Time.now - 5).strftime('%FT%TZ'),
-                                           exp: (SelfSDK::Time.now + 60).strftime('%FT%TZ'),
-                                           acl_source: id,
-                                           acl_exp: (SelfSDK::Time.now + 360_000).to_datetime.rfc3339))
+      payload = @jwt.prepare(jti: SecureRandom.uuid,
+                             cid: SecureRandom.uuid,
+                             typ: 'acl.permit',
+                             iss: @jwt.id,
+                             sub: @jwt.id,
+                             iat: (SelfSDK::Time.now - 5).strftime('%FT%TZ'),
+                             exp: (SelfSDK::Time.now + 60).strftime('%FT%TZ'),
+                             acl_source: id,
+                             acl_exp: (SelfSDK::Time.now + 360_000).to_datetime.rfc3339)
+
+      a = SelfMsg::Acl.new
+      a.id = SecureRandom.uuid
+      a.command = SelfMsg::AclCommandPERMIT
+      a.payload = payload
+
+      @messaging.send_message a
     end
 
     # Deny incomming messages from the given identity.
     def deny(id)
       @acl_rules.delete(id)
       SelfSDK.logger.info "Denying connections from #{id}"
-      @messaging.remove_acl_rule(@jwt.prepare(jti: SecureRandom.uuid,
-                                               cid: SecureRandom.uuid,
-                                               typ: 'acl.revoke',
-                                               iss: @jwt.id,
-                                               sub: @jwt.id,
-                                               iat: (SelfSDK::Time.now - 5).strftime('%FT%TZ'),
-                                               exp: (SelfSDK::Time.now + 60).strftime('%FT%TZ'),
-                                               acl_source: id,
-                                               acl_exp: (SelfSDK::Time.now + 360_000).to_datetime.rfc3339))
+      payload = @jwt.prepare(jti: SecureRandom.uuid,
+                             cid: SecureRandom.uuid,
+                             typ: 'acl.revoke',
+                             iss: @jwt.id,
+                             sub: @jwt.id,
+                             iat: (SelfSDK::Time.now - 5).strftime('%FT%TZ'),
+                             exp: (SelfSDK::Time.now + 60).strftime('%FT%TZ'),
+                             acl_source: id,
+                             acl_exp: (SelfSDK::Time.now + 360_000).to_datetime.rfc3339)
+
+      a = SelfMsg::Acl.new
+      a.id = SecureRandom.uuid
+      a.command = SelfMsg::AclCommandREVOKE
+      a.payload = payload
+      @messaging.send_message a
     end
   end
 end

data/lib/client.rb

@@ -52,7 +52,7 @@ module SelfSDK
       res = get "/v1/identities/#{id}/devices"
       body = JSON.parse(res.body, symbolize_names: true)
       if res.code != 200
-        SelfSDK.logger.error "identity response : #{body[:message]}"
+        SelfSDK.logger.debug "getting devices response : #{body[:message]}"
         raise "you need connection permissions"
       end
       body
@@ -68,31 +68,43 @@ module SelfSDK
     end
 
     def post(endpoint, body)
-      res = nil
-      loop do
-        res = HTTParty.post("#{@self_url}#{endpoint}",
+      safe_request do
+        HTTParty.post("#{@self_url}#{endpoint}",
                       headers: {
-                          'Content-Type' => 'application/json',
-                          'Authorization' => "Bearer #{@jwt.auth_token}"
+                        'Content-Type' => 'application/json',
+                        'Authorization' => "Bearer #{@jwt.auth_token}"
                       },
                       body: body)
-        break if res.code != 503
-        sleep 2
       end
-      return res
     end
 
     def get(endpoint)
+      safe_request do
+        HTTParty.get("#{@self_url}#{endpoint}", 
+                     headers: {
+                        'Content-Type'  => 'application/json',
+                        'Authorization' => "Bearer #{@jwt.auth_token}"
+                      })
+      end
+    end
+
+    def safe_request(&block)
       res = nil
       loop do
-        res = HTTParty.get("#{@self_url}#{endpoint}", headers: {
-          'Content-Type' => 'application/json',
-          'Authorization' => "Bearer #{@jwt.auth_token}"
-        })
-        break if res.code != 503
+        begin
+          res = block.call
+
+          break if res.code == 200
+          next if res.code == 503
+          next if body[:error_id] == 'token_expired'
+
+          break
+        rescue StandardError => e
+          # retry if the server is down
+        end
         sleep 2
       end
-      return res
+      res
     end
 
     # Lists all public keys stored on self for the given ID

data/lib/crypto.rb

@@ -9,6 +9,8 @@ module SelfSDK
       @device = device
       @storage_key = storage_key
       @storage_folder = "#{storage_folder}/#{@client.jwt.key_id}"
+      @lock_strategy = true
+      @mode = "r+"
 
       if File.exist?(account_path)
         # 1a) if alice's account file exists load the pickle from the file
@@ -33,68 +35,111 @@ module SelfSDK
     end
 
     def encrypt(message, recipients)
-      ::SelfSDK.logger.debug('encrypting a message')
+      ::SelfSDK.logger.debug('- [crypto] encrypting a message')
 
       # create a group session and set the identity of the account youre using
-      ::SelfSDK.logger.debug('create a group session and set the identity of the account youre using')
+      ::SelfSDK.logger.debug('- [crypto] create a group session and set the identity of the account youre using')
       gs = SelfCrypto::GroupSession.new("#{@client.jwt.id}:#{@device}")
 
       sessions = {}
-      ::SelfSDK.logger.debug('managing sessions with all recipients')
+      locks = {}
+      ::SelfSDK.logger.debug('- [crypto] managing sessions with all recipients')
+
       recipients.each do |r|
+        f = nil
+        next if r[:id] == @client.jwt.id && r[:device_id] == @device
+
         session_file_name = session_path(r[:id], r[:device_id])
         session_with_bob = nil
 
         begin
-          session_with_bob = get_outbound_session_with_bob(r[:id], r[:device_id], session_file_name)
+          if File.exist?(session_file_name)
+            # Lock the session file
+            locks[session_file_name] = File.open(session_file_name, @mode)
+            locks[session_file_name].flock(File::LOCK_EX)
+          end
+          session_with_bob = get_outbound_session_with_bob(locks[session_file_name], r[:id], r[:device_id])
         rescue => e
-          ::SelfSDK.logger.warn("  there is a problem adding group participant #{r[:id]}:#{r[:device_id]}, skipping...")
-          ::SelfSDK.logger.warn(e)
+          ::SelfSDK.logger.warn("- [crypto]   there is a problem adding group participant #{r[:id]}:#{r[:device_id]}, skipping...")
+          ::SelfSDK.logger.warn("- [crypto] #{e}")
           next
         end
 
-        ::SelfSDK.logger.debug("  adding group participant #{r[:id]}:#{r[:device_id]}")
+        ::SelfSDK.logger.debug("- [crypto]   adding group participant #{r[:id]}:#{r[:device_id]}")
         gs.add_participant("#{r[:id]}:#{r[:device_id]}", session_with_bob)
         sessions[session_file_name] = session_with_bob
       end
 
       # 5) encrypt a message
-      ::SelfSDK.logger.debug("group encrypting message")
+      ::SelfSDK.logger.debug("- [crypto] group encrypting message")
       ct = gs.encrypt(message).to_s
 
       # 6) store the session to a file
-      ::SelfSDK.logger.debug("storing sessions")
+      ::SelfSDK.logger.debug("- [crypto] storing sessions")
       sessions.each do |session_file_name, session_with_bob|
-        File.write(session_file_name, session_with_bob.to_pickle(@storage_key))
+        pickle = session_with_bob.to_pickle(@storage_key)
+        if locks[session_file_name]
+          locks[session_file_name].rewind
+          locks[session_file_name].write(pickle)
+          locks[session_file_name].truncate(locks[session_file_name].pos)
+        else
+          File.write(session_file_name, pickle)
+        end
       end
 
       ct
+    ensure
+      locks.each do |session_file_name, lock|
+        # Unlock the file
+        if lock
+          lock.flock(File::LOCK_UN)
+        end
+      end
     end
 
     def decrypt(message, sender, sender_device)
-      ::SelfSDK.logger.debug("decrypting a message")
+      f = nil
+      ::SelfSDK.logger.debug("- [crypto] decrypting a message")
       session_file_name = session_path(sender, sender_device)
 
-      ::SelfSDK.logger.debug("loading sessions")
-      session_with_bob = get_inbound_session_with_bob(message, session_file_name)
+      if File.exist?(session_file_name)
+        # Lock the session file
+        f = File.open(session_file_name, @mode)
+        f.flock(File::LOCK_EX)
+      end
+
+      ::SelfSDK.logger.debug("- [crypto] loading sessions")
+      session_with_bob = get_inbound_session_with_bob(f, message)
 
       # 8) create a group session and set the identity of the account you're using
-      ::SelfSDK.logger.debug("create a group session and set the identity of the account #{@client.jwt.id}:#{@device}")
+      ::SelfSDK.logger.debug("- [crypto] create a group session and set the identity of the account #{@client.jwt.id}:#{@device}")
       gs = SelfCrypto::GroupSession.new("#{@client.jwt.id}:#{@device}")
 
       # 9) add all recipients and their sessions
-      ::SelfSDK.logger.debug("add all recipients and their sessions #{@sender}:#{@sender_device}")
+      ::SelfSDK.logger.debug("- [crypto] add all recipients and their sessions #{@sender}:#{@sender_device}")
       gs.add_participant("#{sender}:#{sender_device}", session_with_bob)
 
       # 10) decrypt the message ciphertext
-      ::SelfSDK.logger.debug("decrypt the message ciphertext")
+      ::SelfSDK.logger.debug("- [crypto] decrypt the message ciphertext")
       pt = gs.decrypt("#{sender}:#{sender_device}", message).to_s
 
       # 11) store the session to a file
-      ::SelfSDK.logger.debug("store the session to a file")
-      File.write(session_file_name, session_with_bob.to_pickle(@storage_key))
+      ::SelfSDK.logger.debug("- [crypto] store the session to a file")
+
+      pickle = session_with_bob.to_pickle(@storage_key)
+      if !f.nil?
+        f.rewind
+        f.write(pickle)
+        f.truncate(f.pos)
+      else
+        File.write(session_file_name, pickle)
+      end
 
       pt
+    ensure
+      # Unlock the session file
+      f&.flock(File::LOCK_UN)
+      f&.close
     end
 
     private
@@ -107,10 +152,11 @@ module SelfSDK
       "#{@storage_folder}/#{selfid}:#{device}-session.pickle"
     end
 
-    def get_outbound_session_with_bob(recipient, recipient_device, session_file_name)
-      if File.exist?(session_file_name)
+    def get_outbound_session_with_bob(f, recipient, recipient_device)
+      if !f.nil?
+        pickle = f.read
         # 2a) if bob's session file exists load the pickle from the file
-        session_with_bob = SelfCrypto::Session.from_pickle(File.read(session_file_name), @storage_key)
+        session_with_bob = SelfCrypto::Session.from_pickle(pickle, @storage_key)
       else
         # 2b-i) if you have not previously sent or recevied a message to/from bob,
         #       you must get his identity key from GET /v1/identities/bob/
@@ -121,7 +167,7 @@ module SelfSDK
 
         if res.code != 200
           b = JSON.parse(res.body)
-          ::SelfSDK.logger.error "identity response : #{b['message']}"
+          ::SelfSDK.logger.error "- [crypto] identity response : #{b['message']}"
           raise "could not get identity pre_keys"
         end
 
@@ -137,10 +183,11 @@ module SelfSDK
       session_with_bob
     end
 
-    def get_inbound_session_with_bob(message, session_file_name)
-      if File.exist?(session_file_name)
+    def get_inbound_session_with_bob(f, message)
+      if !f.nil?
+        pickle = f.read
         # 7a) if carol's session file exists load the pickle from the file
-        session_with_bob = SelfCrypto::Session.from_pickle(File.read(session_file_name), @storage_key)
+        session_with_bob = SelfCrypto::Session.from_pickle(pickle, @storage_key)
       end
 
       # 7b-i) if you have not previously sent or received a message to/from bob,

data/lib/messages/base.rb

@@ -79,7 +79,7 @@ module SelfSDK
           end
         end
         raise ::StandardError.new("expired message") if @expires < SelfSDK::Time.now
-        raise ::StandardError.new("issued too soon") if @issued > SelfSDK::Time.now
+        raise ::StandardError.new("issued too soon") if @issued.round > (SelfSDK::Time.now + 1).round
       end
 
       protected

data/lib/messages/message.rb

@@ -21,6 +21,9 @@ require_relative "connection_response"
 
 module SelfSDK
   module Messages
+    class UnmappedMessage < StandardError
+    end
+    
     def self.parse(input, messaging, original=nil)
       envelope = nil
       body = if input.is_a? String
@@ -84,7 +87,7 @@ module SelfSDK
         m = VoiceSummary.new(messaging)
         m.parse(body, envelope)
       else
-        raise StandardError.new("Invalid message type #{payload[:typ]}.")
+        raise UnmappedMessage.new("Invalid message type #{payload[:typ]}.")
       end
       return m
     end

data/lib/messaging.rb

@@ -11,28 +11,91 @@ require_relative 'crypto'
 require_relative 'messages/message'
 
 module SelfSDK
+  class WebsocketClient
+    ON_DEMAND_CLOSE_CODE=3999
+
+    attr_accessor :ws
+
+    def initialize(url, auto_reconnect, authentication_hook, process_message_hook)
+      @url = url
+      @reconnection_delay = nil
+      @auto_reconnect = auto_reconnect
+      @authentication_hook = authentication_hook
+      @process_message_hook = process_message_hook
+    end
+
+    # Creates a websocket connection and sets up its callbacks.
+    def start
+      SelfSDK.logger.debug "starting listener"
+      @ws = Faye::WebSocket::Client.new(@url)
+      SelfSDK.logger.debug "initialized"
+
+      @ws.on :open do |_event|
+        SelfSDK.logger.debug "websocket connection established"
+        @authentication_hook.call
+      end
+
+      @ws.on :message do |event|
+        @process_message_hook.call(event)
+      end
+
+      @ws.on :close do |event|
+        SelfSDK.logger.debug "connection closed detected : #{event.code} #{event.reason}"
+
+        if event.code != ON_DEMAND_CLOSE_CODE
+          raise StandardError('websocket connection closed') if !@auto_reconnect
+
+          if !@reconnection_delay.nil?
+            SelfSDK.logger.debug "websocket connection closed (#{event.code}) #{event.reason}"
+            sleep @reconnection_delay
+            SelfSDK.logger.debug "reconnecting..."
+          end
+
+          @reconnection_delay = 3
+          start
+        end
+      end
+    end
+
+    # Sends a closing message to the websocket client.
+    def close
+      @ws.close(ON_DEMAND_CLOSE_CODE, "connection closed by the client")
+    end
+
+    # Sends a ping message to the websocket server, but does 
+    # not expect response.
+    # This is kind of a hack to catch some corner cases where
+    # the websocket client is not aware it has been disconnected.
+    def ping
+      SelfSDK.logger.debug "ping"
+      @ws.ping 'ping'
+    end
+
+    def send(message)
+      @ws.send(message.to_fb.bytes)
+    end
+  end
+
   class MessagingClient
     DEFAULT_DEVICE="1"
     DEFAULT_AUTO_RECONNECT=true
     DEFAULT_STORAGE_DIR="./.self_storage"
-    ON_DEMAND_CLOSE_CODE=3999
 
-    PRIORITIES = {
-      "chat.invite":                 SelfSDK::Messages::PRIORITY_VISIBLE,
-      "chat.join":                   SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "chat.message":                SelfSDK::Messages::PRIORITY_VISIBLE,
-      "chat.message.delete":         SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "chat.message.delivered":      SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "chat.message.edit":           SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "chat.message.read":           SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "chat.remove":                 SelfSDK::Messages::PRIORITY_INVISIBLE,
-      "document.sign.req":           SelfSDK::Messages::PRIORITY_VISIBLE,
-      "identities.authenticate.req": SelfSDK::Messages::PRIORITY_VISIBLE,
-      "identities.connections.req":  SelfSDK::Messages::PRIORITY_VISIBLE,
-      "identities.facts.query.req":  SelfSDK::Messages::PRIORITY_VISIBLE,
-      "identities.facts.issue":      SelfSDK::Messages::PRIORITY_VISIBLE,
-      "identities.notify":           SelfSDK::Messages::PRIORITY_VISIBLE
-    }
+    PRIORITIES = { 
+      'chat.invite':                 SelfSDK::Messages::PRIORITY_VISIBLE,
+      'chat.join':                   SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'chat.message':                SelfSDK::Messages::PRIORITY_VISIBLE,
+      'chat.message.delete':         SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'chat.message.delivered':      SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'chat.message.edit':           SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'chat.message.read':           SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'chat.remove':                 SelfSDK::Messages::PRIORITY_INVISIBLE,
+      'document.sign.req':           SelfSDK::Messages::PRIORITY_VISIBLE,
+      'identities.authenticate.req': SelfSDK::Messages::PRIORITY_VISIBLE,
+      'identities.connections.req':  SelfSDK::Messages::PRIORITY_VISIBLE,
+      'identities.facts.query.req':  SelfSDK::Messages::PRIORITY_VISIBLE,
+      'identities.facts.issue':      SelfSDK::Messages::PRIORITY_VISIBLE,
+      'identities.notify':           SelfSDK::Messages::PRIORITY_VISIBLE }.freeze
 
     attr_accessor :client, :jwt, :device_id, :ack_timeout, :timeout, :type_observer, :uuid_observer, :encryption_client, :source
 
@@ -47,7 +110,6 @@ module SelfSDK
     # @option opts [String] :device_id The device id to be used by the app defaults to "1".
     def initialize(url, client, storage_key, options = {})
       @mon = Monitor.new
-      @url = url
       @messages = {}
       @acks = {}
       @type_observer = {}
@@ -58,14 +120,12 @@ module SelfSDK
       @timeout = 120 # seconds
       @auth_id = SecureRandom.uuid
       @device_id = options.fetch(:device_id, DEFAULT_DEVICE)
-      @auto_reconnect = options.fetch(:auto_reconnect, DEFAULT_AUTO_RECONNECT)
       @raw_storage_dir = options.fetch(:storage_dir, DEFAULT_STORAGE_DIR)
       @storage_dir = "#{@raw_storage_dir}/apps/#{@jwt.id}/devices/#{@device_id}"
       FileUtils.mkdir_p @storage_dir unless File.exist? @storage_dir
       @offset_file = "#{@storage_dir}/#{@jwt.id}:#{@device_id}.offset"
       @offset = read_offset
       @source = SelfSDK::Sources.new("#{__dir__}/sources.json")
-      migrate_old_storage_format
 
       unless options.include? :no_crypto
         crypto_path = "#{@storage_dir}/keys"
@@ -73,13 +133,55 @@ module SelfSDK
         @encryption_client = Crypto.new(@client, @device_id, crypto_path, storage_key)
       end
 
-      if options.include? :ws
-        @ws = options[:ws]
-      else
-        start
+      @ws = if options.include? :ws
+              options[:ws]
+            else
+              WebsocketClient.new(url,
+                                  options.fetch(:auto_reconnect, DEFAULT_AUTO_RECONNECT),
+                                  -> { authenticate },
+                                  ->(event) { on_message(event) })
+            end
+    end
+
+    # Starts the underlying websocket connection.
+    def start
+      SelfSDK.logger.debug "starting"
+      auth_id = @auth_id.dup
+
+      @mon.synchronize do
+        @acks[auth_id] = { waiting_cond: @mon.new_cond,
+                           waiting: true,
+                           timeout: SelfSDK::Time.now + @ack_timeout }
+      end
+
+      Thread.new do
+        EM.run start_connection
       end
+
+      Thread.new do
+        loop do
+          sleep 10
+          clean_timeouts
+          @ws.ping
+        end
+      end
+
+      @mon.synchronize do
+        @acks[auth_id][:waiting_cond].wait_while { @acks[auth_id][:waiting] }
+        @acks.delete(auth_id)
+      end
+
+      return unless @acks.include? auth_id
+
+      # In case this does not succeed start the process again.
+      if @acks[auth_id][:waiting]
+        close
+        start_connection
+      end
+      @acks.delete(auth_id)
     end
 
+    # Stops the underlying websocket connection.
     def stop
       @acks.each do |k, _v|
         mark_as_acknowledged(k)
@@ -90,27 +192,7 @@ module SelfSDK
       end
     end
 
-    def close
-      @ws.close(ON_DEMAND_CLOSE_CODE, "connection closed by the client")
-    end
-
-    # Responds a request information request
-    #
-    # @param recipient [string] selfID to be requested
-    # @param recipient_device [string] device id for the selfID to be requested
-    # @param request [string] original message requesing information
-    def share_information(recipient, recipient_device, request)
-      m = SelfMsg::Message.new
-      m.id = SecureRandom.uuid 
-      m.sender = "#{@jwt.id}:#{@device_id}"
-      m.recipient = "#{recipient}:#{recipient_device}"
-      m.message_type = "identities.facts.query.resp"
-      m.priority = select_priority(m.message_type)
-      m.ciphertext = @jwt.prepare(request)
-
-      send_message m
-    end
-
+    # Checks if the session with a specified identity / device is already created.
     def session?(identifier, device)
       path = @encryption_client.session_path(identifier, device)
       File.file?(path)
@@ -136,7 +218,7 @@ module SelfSDK
         end
       end
 
-      SelfSDK.logger.info "sending custom message #{request_body.to_json}"
+      SelfSDK.logger.debug "sending custom message #{request_body.to_json}"
       current_device = "#{@jwt.id}:#{@device_id}"
 
       recs.each do |r|
@@ -154,43 +236,19 @@ module SelfSDK
         m.message_type = r[:typ]
         m.priority = select_priority(r[:typ])
 
-        SelfSDK.logger.info " -> to #{m.recipient}"
+        SelfSDK.logger.debug "[#{m.id}] -> to #{m.recipient}"
         send_message m
       end
     end
 
-    # Allows incomming messages from the given identity
-    #
-    # @params payload [string] base64 encoded payload to be sent
-    def add_acl_rule(payload)
-      a = SelfMsg::Acl.new
-      a.id = SecureRandom.uuid
-      a.command = SelfMsg::AclCommandPERMIT
-      a.payload = payload
-
-      send_message a
-    end
-
-    # Blocks incoming messages from specified identities
-    #
-    # @params payload [string] base64 encoded payload to be sent
-    def remove_acl_rule(payload)
-      a = SelfMsg::Acl.new
-      a.id = SecureRandom.uuid
-      a.command = SelfMsg::AclCommandREVOKE
-      a.payload = payload
-
-      send_message a
-    end
-
-    # Lists acl rules
+    # Sends a command to list ACL rules.
     def list_acl_rules
       wait_for 'acl_list' do
         a = SelfMsg::Acl.new
         a.id = SecureRandom.uuid
         a.command = SelfMsg::AclCommandLIST
 
-        send_raw a
+        @ws.send a
       end
     end
 
@@ -198,7 +256,7 @@ module SelfSDK
     #
     # @params msg [SelfMsg::Message] message object to be sent
     def send_and_wait_for_response(msgs, original)
-      SelfSDK.logger.info "sending/wait for #{msgs.first.id}"
+      SelfSDK.logger.debug "sending/wait for #{msgs.first.id}"
       wait_for msgs.first.id, original do
         msgs.each do |msg|
           send_message msg
@@ -211,7 +269,7 @@ module SelfSDK
     #
     # @params uuid [string] unique identifier for a conversation
     def wait_for(uuid, msg = nil)
-      SelfSDK.logger.info "sending #{uuid}"
+      SelfSDK.logger.debug "sending #{uuid}"
       @mon.synchronize do
         @messages[uuid] = {
           waiting_cond: @mon.new_cond,
@@ -223,14 +281,14 @@ module SelfSDK
 
       yield
 
-      SelfSDK.logger.info "waiting for client to respond #{uuid}"
+      SelfSDK.logger.debug "waiting for client to respond #{uuid}"
       @mon.synchronize do
         @messages[uuid][:waiting_cond].wait_while do
           @messages[uuid][:waiting]
         end
       end
 
-      SelfSDK.logger.info "response received for #{uuid}"
+      SelfSDK.logger.debug "response received for #{uuid}"
       @messages[uuid][:response]
     ensure
       @messages.delete(uuid)
@@ -248,14 +306,21 @@ module SelfSDK
           timeout: SelfSDK::Time.now + @ack_timeout,
         }
       end
-      send_raw(msg)
-      SelfSDK.logger.info "waiting for acknowledgement #{uuid}"
+      @ws.send msg
+      SelfSDK.logger.debug "waiting for acknowledgement #{uuid}"
       @mon.synchronize do
         @acks[uuid][:waiting_cond].wait_while do
           @acks[uuid][:waiting]
         end
       end
-      SelfSDK.logger.info "acknowledged #{uuid}"
+
+      # response has timed out
+      if @acks[uuid][:timed_out]
+        SelfSDK.logger.debug "acknowledgement response timed out re-sending message #{uuid}"
+        return send_message(msg)
+      end
+
+      SelfSDK.logger.debug "acknowledged #{uuid}"
       true
     ensure
       @acks.delete(uuid)
@@ -281,6 +346,7 @@ module SelfSDK
     # Notify the type observer for the given message
     def notify_observer(message)
       if @uuid_observer.include? message.id
+        SelfSDK.logger.debug " - notifying by id"
         observer = @uuid_observer[message.id]
         message.validate!(observer[:original_message]) if observer.include?(:original_message)
         Thread.new do
@@ -290,9 +356,15 @@ module SelfSDK
         return
       end
 
+      SelfSDK.logger.debug " - notifying by type"
+      SelfSDK.logger.debug " - #{message.typ}"
+      SelfSDK.logger.debug " - #{message}"
+      SelfSDK.logger.debug " - #{@type_observer.keys.join(',')}"
+
       # Return if there is no observer setup for this kind of message
       return unless @type_observer.include? message.typ
 
+      SelfSDK.logger.debug " - notifying by type (Y)"
       Thread.new do
         @type_observer[message.typ][:block].call(message)
       end
@@ -310,38 +382,6 @@ module SelfSDK
 
     private
 
-    # Start sthe websocket listener
-    def start
-      SelfSDK.logger.info "starting"
-      auth_id = @auth_id.dup
-
-      @mon.synchronize do
-        @acks[auth_id] = { waiting_cond: @mon.new_cond,
-                                    waiting: true,
-                                    timeout: SelfSDK::Time.now + @ack_timeout }
-      end
-
-      Thread.new do
-        EM.run start_connection
-      end
-
-      Thread.new do
-        loop { sleep 10; clean_timeouts }
-      end
-
-      @mon.synchronize do
-        @acks[auth_id][:waiting_cond].wait_while { @acks[auth_id][:waiting] }
-        @acks.delete(auth_id)
-      end
-      # In case this does not succeed start the process again.
-      if @acks.include? auth_id
-        if @acks[auth_id][:waiting]
-          close
-          start_connection
-        end
-        @acks.delete(auth_id)
-      end
-    end
 
     # Cleans expired messages
     def clean_timeouts
@@ -355,44 +395,17 @@ module SelfSDK
         next unless list[uuid][:timeout] < SelfSDK::Time.now
 
         @mon.synchronize do
-          SelfSDK.logger.info "message response timed out #{uuid}"
+          SelfSDK.logger.debug "[#{uuid}] message response timed out"
           list[uuid][:waiting] = false
           list[uuid][:waiting_cond].broadcast
+          list[uuid][:timed_out] = true
         end
       end
     end
 
     # Creates a websocket connection and sets up its callbacks.
     def start_connection
-      SelfSDK.logger.info "starting listener"
-      @ws = Faye::WebSocket::Client.new(@url)
-      SelfSDK.logger.info "initialized"
-
-      @ws.on :open do |_event|
-        SelfSDK.logger.info "websocket connection established"
-        authenticate
-      end
-
-      @ws.on :message do |event|
-        on_message(event)
-      end
-
-      @ws.on :close do |event|
-        if event.code == ON_DEMAND_CLOSE_CODE
-          puts "client closed connection"
-        else
-          if !@auto_reconnect
-            raise StandardError "websocket connection closed"
-          end
-          if !@reconnection_delay.nil?
-            SelfSDK.logger.info "websocket connection closed (#{event.code}) #{event.reason}"
-            sleep @reconnection_delay
-            SelfSDK.logger.info "reconnecting..."
-          end
-          @reconnection_delay = 3
-          start_connection
-        end
-      end
+      @ws.start
     end
 
 
@@ -401,29 +414,32 @@ module SelfSDK
       data = event.data.pack('c*')
       hdr = SelfMsg::Header.new(data: data)
 
-      SelfSDK.logger.info " - received #{hdr.id} (#{hdr.type})"
+      SelfSDK.logger.debug " - received #{hdr.id} (#{hdr.type})"
       case hdr.type
       when SelfMsg::MsgTypeMSG
-        SelfSDK.logger.info "Message #{hdr.id} received"
+        SelfSDK.logger.debug "[#{hdr.id}] message received"
         m = SelfMsg::Message.new(data: data)
         process_incomming_message m
       when SelfMsg::MsgTypeACK
-        SelfSDK.logger.info "#{hdr.id} acknowledged"
+        SelfSDK.logger.debug "[#{hdr.id}] acknowledged"
         mark_as_acknowledged hdr.id
       when SelfMsg::MsgTypeERR
         SelfSDK.logger.warn "error on #{hdr.id}"
         e = SelfMsg::Notification.new(data: data)
         SelfSDK.logger.warn "#{e.error}"
+        # TODO control @messages[hdr.id] being nil
+        raise "ERROR : #{e.error}" if @messages[hdr.id].nil?
+
         @messages[hdr.id][:response] = {error: e.error}
         mark_as_acknowledged(hdr.id)
         mark_as_arrived(hdr.id)
       when SelfMsg::MsgTypeACL
-        SelfSDK.logger.info "ACL received"
+        SelfSDK.logger.debug "#{hdr.id} ACL received"
         a = SelfMsg::Acl.new(data: data)
         process_incomming_acl a
       end
     rescue TypeError
-      SelfSDK.logger.info "invalid array message"
+      SelfSDK.logger.debug "invalid array message"
     end
 
     def process_incomming_acl(input)
@@ -433,8 +449,8 @@ module SelfSDK
       mark_as_arrived 'acl_list'
     rescue StandardError => e
       p "Error processing incoming ACL #{input.id} #{input.payload}"
-      SelfSDK.logger.info e
-      SelfSDK.logger.info e.backtrace
+      SelfSDK.logger.debug e
+      SelfSDK.logger.debug e.backtrace
       nil
     end
 
@@ -446,28 +462,35 @@ module SelfSDK
         @messages[message.id][:response] = message
         mark_as_arrived message.id
       else
-        SelfSDK.logger.info "Received async message #{input.id}"
+        SelfSDK.logger.debug "Received async message #{input.id}"
         message.validate! @uuid_observer[message.id][:original_message] if @uuid_observer.include? message.id
+        SelfSDK.logger.debug "[#{input.id}] is valid, notifying observer"
         notify_observer(message)
       end
     rescue StandardError => e
       p "Error processing incoming message #{e.message}"
-      SelfSDK.logger.info e
+      SelfSDK.logger.debug e
       # p e.backtrace
       nil
     end
 
     def parse_and_write_offset(input)
-      SelfSDK::Messages.parse(input, self)
-    ensure
+      msg = SelfSDK::Messages.parse(input, self)
       write_offset(input.offset)
+      # Avoid catching any other decryption errors.
+      msg
+    rescue SelfSDK::Messages::UnmappedMessage => e
+      # this is an ummapped message, let's ignore it but write the offset.
+      write_offset(input.offset)
+      nil
     end
 
     # Authenticates current client on the websocket server.
     def authenticate
       @auth_id = SecureRandom.uuid if @auth_id.nil?
+      @offset = read_offset
 
-      SelfSDK.logger.info "authenticating"
+      SelfSDK.logger.debug "authenticating with offset (#{@offset})"
 
       a = SelfMsg::Auth.new
       a.id = @auth_id
@@ -475,15 +498,11 @@ module SelfSDK
       a.device = @device_id
       a.offset = @offset
 
-      send_raw a
+      @ws.send a
 
       @auth_id = nil
     end
 
-    def send_raw(msg)
-      @ws.send(msg.to_fb.bytes)
-    end
-
     # Marks a message as arrived.
     def mark_as_arrived(id)
       # Return if no one is waiting for this message
@@ -518,27 +537,8 @@ module SelfSDK
         f.flock(File::LOCK_EX)
         f.write(offset.to_s.rjust(19, "0"))
       end
-    end
-
-    def migrate_old_storage_format
-      # Move the offset file
-      old_offset_file = "#{@raw_storage_dir}/#{@jwt.id}:#{@device_id}.offset"
-      if File.file?(old_offset_file)
-        File.open(old_offset_file, 'rb') do |f|
-          offset = f.read.unpack('q')[0]
-          write_offset(offset)
-        end
-        File.delete(old_offset_file)
-      end
-      
-      # Move all pickle files
-      crypto_path = "#{@storage_dir}/keys/#{@jwt.key_id}"
-      FileUtils.mkdir_p crypto_path unless File.exist? crypto_path
-      Dir[File.join(@raw_storage_dir, "*.pickle")].each do |file|
-        filename = File.basename(file, ".pickle")
-        File.rename file, "#{crypto_path}/#{filename}.pickle"
-      end
-        
+      SelfSDK.logger.debug "offset written #{offset}"
+      @offset = offset
     end
 
     def select_priority(mtype)

data/lib/selfsdk.rb

@@ -36,7 +36,7 @@ module SelfSDK
     BASE_URL = "https://api.joinself.com".freeze
     MESSAGING_URL = "wss://messaging.joinself.com/v2/messaging".freeze
 
-    attr_reader :client
+    attr_reader :client, :started
     attr_accessor :messaging_client
 
     # Initializes a SelfSDK App
@@ -59,6 +59,7 @@ module SelfSDK
 
       @client = RestClient.new(base_url(opts), app_id, app_key, env)
       messaging_url = messaging_url(opts)
+      @started = false
       unless messaging_url.nil?
         @messaging_client = MessagingClient.new(messaging_url,
                                                 @client,
@@ -69,6 +70,17 @@ module SelfSDK
       end
     end
 
+    # Starts the websockets connection and processes incoming messages in case the client
+    # is initialized with auto_start set to false.
+    def start
+      return self if @started
+
+      @messaging_client.start
+      @started = true
+
+      self
+    end
+
     # Provides access to SelfSDK::Services::Facts service
     def facts
       @facts ||= SelfSDK::Services::Facts.new(requester)

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: selfsdk
 version: !ruby/object:Gem::Version
-  version: 0.0.209
+  version: 0.0.210
 platform: ruby
 authors:
-- Aldgate Ventures
+- Self Group Ltd.
 autorequire: 
 bindir: bin
 cert_chain: []