di-dao / sonr Goto Github PK

• Add information into metadata
• Replace CompletedMessage with relevant Protobuf information

Inbound

• Post Authentication receiver StateMachine updated to allow incoming streams
• Pending -> InProgress

Outbound

• Post Peer response Sender initializes a new stream for SessionPID to remote peer
• Pending -> InProgress

1. Remove Circle Integration
2. Create SonrPeer Struct
3. Update Notification Message
4. Create Lobby dictionary for peers
5. Remove All Status References

• Pub/Sub Peer manager w/ all active nodes in OLC
• Messages sent/received returned as callback and handled in dart frontend

Implement

• Checks size of each item in request
• New Reader created with cap bytes for EOF.

┆Issue is synchronized with this Asana task by Unito

• Expose Endpoints for grpc container in image for Dockerfile
• Deploy on Digital Ocean Kubernettes
• Point Sonr Domain to Cluster

• Create Contact Card Service and Implement same RPC Auth/Reply Structure as Authentication, except Card is Passed instead of Requesting

• User handles card in frontend to save or dismiss

• Pass PeerID, don't cache PeerInfo in PeerConnection

• Utilize both websockets/quic transports
• Struct with host, multiaddr, peerinfo, autonat, auto_relay, and circuit
• Switch transport from Websockets to QUIC and Back

https://developer.chrome.com/docs/extensions/reference/contextMenus/

References:

• https://berty.tech/newsletter/news-48
• https://github.com/berty/berty

1. Identify when Peer direction/status has been changed by reading the message in the lobby
2. Check if the user is in Searching state
   i. Update graph edge/node with new calculated difference
   ii. CallBack to OnPeersUpdate

Implement

• FastCDC Chunking Algorithm
• Reads Path and uses writer interface to Write Chunks to Stream
• Rolling Hash of 10,000 random unsigned integers

Fix

• Null Item Reference from List/Queue

Implement

• Push Bytes into buffer List until delimiter
• Emit progress every mod(10%Total)

Fix Bugs:

• Null pointer reference for Item path off queue/list

https://blog.filippo.io/shrink-your-go-binaries-with-this-one-weird-trick/

Handling Queued File

• Process File before Invite Event
• Add to badgerDB in new memory store with metadata and thumbnail
• OnInvite wait for Thumbnail to process if it hasn't already
• Retrieve data items and send request

Additional Event(s)

• Queue Event queues the file in memory store and initiates thumbnail processing

Additional Callback(s)

• OnQueued informs the frontend that the file has finished processing

• Automatically Upload Created Premium Cards to IPFS
• https://towardsdatascience.com/decentralizing-your-website-f5bca765f9ed
• https://labs.eleks.com/2019/03/ipfs-network-data-replication.html

• Handle Invited/Accepted/Declined as callbacks

• Handle Exit/Close/Busy/Leave Events

• OnRequested message the peer for authentication

  • Return result to peer then begin transfer sequence if accepted

• Invite User has invited peer to transfer

• Accept User has accepted transfer request

• Decline User has declined transfer request

• Identify FileType prior to request invitation

CodeFactor found an issue: Duplicate Code

It's currently on:
internalhosthost.go:84-102
internalhosthost.go:144-162

Implementation

• Create Channels for Progress Events
• Create Channels for Item-Written events

Item-Written

• Update Path to item with new File path
• Replace File in Payload Object

https://medium.com/learning-the-go-programming-language/encoding-data-with-the-go-binary-package-42c7c0eb3e73

Code Example

   // encode a slice of packet
    buf := new(bytes.Buffer)
    err := binary.Write(buf, binary.LittleEndian, dataOut)
    if err != nil {
        fmt.Println(err)
        return
    }
    // decode all items from slice
    dataIn := make([]packet, 3)
    err := binary.Read(buf, binary.LittleEndian, dataIn)
    if err != nil {
        fmt.Println("failed to Read:", err)
        return
    }

• Attempt Go Library to have uniform SDK for Devices
• If failed implement platform specific solution

References:
https://berty.tech/blog/bluetooth-low-energy/

https://github.com/libp2p/go-libp2p-gorpc/tree/master/examples/ping

• Replace Struct Type w/ Protobuf Message and Implement
• Reference Documentation
• LibP2P Documentation

Example Syntax:

syntax = "proto2";
package main;

message Request {
  enum Type {
    SEND_MESSAGE = 0;
    UPDATE_PEER = 1;
  }

  required Type type = 1;
  optional SendMessage sendMessage = 2;
  optional UpdatePeer updatePeer = 3;
}

message SendMessage {
  required bytes data = 1;
  required int64 created = 2;
  required bytes id = 3;
}

message UpdatePeer {
  optional bytes userHandle = 1;
}

• Utilize either yamux or muxado

• Use GoMobile: https://divan.dev/talks/2019/gdgbcn/FlutterGomobile.pdf
• Handle Signalling with Libp2p pubsub
• Handle Peers with Libp2p-DHT
• Handle Nat traversal with Libp2p-NAT

• Have public card be a subscription, upload as site on IPFS
• https://tarunbatra.com/blog/decentralization/Deploy-your-website-on-IPFS-Why-and-How/
• Figure out Business Model Later can utilize ads too

Create better discovery structure that implements a goroutine similar to the lobby layout, then provide a callback to show updated peers in frontend.

• https://godoc.org/github.com/libp2p/go-libp2p-discovery#Advertise

https://golang.org/doc/effective\_go.html#channels

Less Resourceful:
https://jbrandhorst.com/post/grpc-binary-blob-stream/

https://www.devdungeon.com/content/working-images-go

• Utilize PubSub Listener opposed to Lobby Message Update

Utilize this tutorial in order to return the uploaded data hashes back from IPFS.

┆Issue is synchronized with this Asana task by Unito

Inbound

• Net.Stream interface is wrapped into PID handler function for Inbound Streams

Outbound

• Direction is set for outbound rest is same in terms of implementation.

• Reading Files in Go Reference
• Passing Bytes Reference
• Protobuf in Go

TODO

• Assign chunk size by detected transport to maximize speed

Stream Handling

Case 1: Register before connect.

In this case, both peers will send the known supported protocols on connect using the identify protocol. When that happens, we use something called "lazy" stream negotiation.

1. When we call NewStream, we find a protocol (out of the list specified by the user) that we know the peer speaks.
2. We then create a special stream that negotiates this protocol lazily. We can do this because we know the negotiation will succeed.
3. Finally, when the user actually tries to use the stream (call read/write), we negotiate the protocol.

We do this because:

• Not waiting for the protocol negotiation saves us a round trip.
• If we're going to write immediately after creating the stream, negotiating lazily allows us to send one big packet instead of two small packets (i.e., we don't have to send the protocol in one packet, then the message).

Case 2: Register after connect.

In this case, the identify handshake didn't tell our peer about this protocol. We don't know if they speak the protocol so we negotiate up-front.

Data ProtoBuf

Potential Fields in Transfer ProtoBuf TransferBlock

  const { info } = this.files.outgoing[connection.peer];
  const chunkSize = WebRTC.CHUNK_MTU;
  const chunksPerAck = WebRTC.CHUNKS_PER_ACK;
  const remainingChunks = info.chunksTotal - beginChunkNum;
  const chunksToSend = Math.min(remainingChunks, chunksPerAck);
  const endChunkNum = beginChunkNum + chunksToSend - 1;
  const blockBegin = beginChunkNum * chunkSize;
  const blockEnd = endChunkNum * chunkSize + chunkSize;

• Utilize as in-memory key/value store to handle peers

• Pass Contexts to Allow User to Cancel Action at any time

• https://github.com/uber-go/zap: 👍🏼 For Logging

Implement

• Looping over all items in Array set with ReadWriter created per each element

To-Do

• Extend service did document to define channels as fragment
• Utilize service public key to setup channel roles

┆Issue is synchronized with this Asana task by Unito

https://github.com/libp2p/go-libp2p-examples/blob/master/libp2p-host/host.go

┆Issue is synchronized with this Asana task by Unito

• Utilize a channel initiated by a goroutine on PeerConnection creation to listen to auth events
• Have method be for type PeerConnection, await reply from peer for roughly 10 seconds before calling denied and reseting GRPC

Receiver Side

• Await user to handle invite request
• Set reply as done after authentication

• Create two stream structs for node to implement in its own struct for both streams
• Create MsgIO Stream for Authentication

• Utilize Wav encoding/decoding to integrate user PeerID into sound metadata
• Have Plugin be listening for events to add peers and provide user PeerID

Utilize OrbitDB

• Create a Dart callback to use in Swift callback implementation
• Create Data Model for universally handling Networking messages (Signaling, Pairing, Transfering)
• Handle all data in JSON Format where keys are parsed in both Dart and Go into models