michaelmure / arbore-qt Goto Github PK

We use QNetworkAccessManager to access the daemon via the http API.

QNetworkAccessManager has a hardcoded limit at 6 concurrent access (https://github.com/qtproject/qtbase/blob/dev/src/network/access/qhttpnetworkconnection.cpp#L63)

It seems to slow down things (more test needed here to be sure).

A solution might be to use multiple instance of QNetworkAccessManager and load balance between them.

UI Mockup

• login screen: profile selection
  
• login screen: profile selected
  

Inspiration & user familiar concept

• Gnome login screen
  
  

Profile management is a key problem to avoid the user to deal with cryptographic primitive and notions. The idea here is to map the public/private cryptographic key that define the user identity to the concept of "profile".

• generating a new keypair is mapped to creating a new profile.
• keypair unlock is mapped to the login process
• identity/keypair transfer is mapped to profile export/import

To avoid the user to deal with keypair, profile import/export can use more user-friendly concept:

• a single file containing both keys and user-data
• a QR code (more practical for transfer on a mobile device)
• the profile picture with both keys and user-data padded inside

Things left to be thinkered:

• keypair revocation

We need to persist at least Share details for now, probably contact information in the future.

We can use a SqLite database to do that.

I have this code laying around:

QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
QString path = QStandardPaths::writableLocation(QStandardPaths::DataLocation) +
        QDir::separator() + "test.db3";

qDebug() << path;

db.setDatabaseName(path);
db.open();

db.close();

WIP -- The actual UI is to be defined.

The user should be able to:

• organize its contacts in groups
• manually add a contact from different sources
• remove contacts/groups

To avoid the user from manually adding every contact he might know, contacts data could be propagated from known user, like a trust chain. To do that, users could share (with optout) on their IPNS space their collection of contact, encrypted for each of their contact. Arbore can then automatically retrieve those collection and suggest contact for addition.

For the WebUI share, I get (progress 58 / 59) in the logs, even if everything is local.

We need to be able to:

• create a new share from the GUI using a root hash
• trigger the download in IPFS

We should find a way to stop/kill the daemon when the main app crash or is killed.

Step to reproduce:

• attach a debugger and run
• kill the app

Currently there is a race condition when arbore start, as the Share try to build their graph of object when the daemon might not be reachable yet.

We have nothing to deal with that yet, nor to deal with the daemon crashing or else. This is a problem also because the daemon might not even be local, thus more unreachability problem.

23:26 <BatO> is there a way to trigger the download of a hash without hanging ? 23:27 <BatO> ipfs pin add hang and only add the pin when everything is local
23:27 <Bat`O> so it block a http request as well
23:27 actually, i was thinking of adding a command to do just that
23:28 right now, you can do 'ipfs block get ' and cancel the request
23:28 and it will continue to fetch it

Note that we still need to use ipfs pin add to keep the Share in the datastore.

Some notes here: ipfs/notes#33

To avoid data corruption, we should update the database record each time the Share change.

We need to add a filter class on top of the ShareModel to filter the list based on a research string, a status ....

Inspiration & user familiar concept:

• Social network timeline
• P2P client (Transmission-bt)
  

When a user share something with another user, it appears on his share timeline, in a way similar to a social network collection of post. The actual download can then be triggered on demand.
The aspect and what can be done on a share notification change depending on its status.

The user can also manually add a public share by using the Magnet link.

Shares are presented in two timeline (incoming/downloaded and outgoing).

when an Object is shared by multiple Share or even inside the same Share (for instance, the webui share have two times the same folder), we instanciate mutliple times an Object instance and do multiple time the API request to fetch details.

We can create a pool/cache of Object where we will look into to see if an Object already exist with the same hash and use it.

• check if a directory with the same childs but different name for this childs have a different hash (I think it does)
• functions to compute the number of blocks, size, progress should still work without change, even with the deduplication.

implement Share::trigger_download()

We need to separate this two download to be able to show share file names and size, but without triggering the actual download.

Bat`O: you could just do 'ipfs object stat QmHash'
10:22 pm
also, 'ipfs file ls QmHash'
10:23 pm
the file ls one doesnt actually show it in the commands output, but it shows size through the API i think

We should find a method to package Arbore+IPFS for the various target OS.

Windows:

• installer

Linux:

• http://doc.qt.io/qt-5/appicon.html

I have been playing around with the ShareDetails.qml

The textual_arborescence is convenient for our current tests purposes. Yet it seems a TreeView would be a user friendly display since shares contains folders and files

WIP -- The actual UI is to be defined

When launching Arbore, the only window available is the profile window (see #3). When a profile is choosen and unlocked, the main window appear.

Content:

• a list of incoming/downloaded share (see #4)
• a list of outgoing share (see #4)
• a contact management UI (see #5)
• an about popup

Inspiration & user familiar concept

• Google+ sharing
  

Public sharing produce a Magnet link containing the root ipfs hash to share with people. This magnet could be available for private sharing as well. How this magnet will be made available to the user is still to be thinkered.

Private sharing produce a notification for all the recipient (more details on the future "Download" issue).

Optional:

• Shell integration (select a list of files/folder, right clic, "Share with Arbore...")

Original link: ipfs/kubo#961

I would really like to see happen a friend-to-friend filesharing app with the following caracteristics:

• targeted for private/low diffusion data between people that know each-others. Main use case: friends want to share between each-others their holidays pictures.
• low friction: it should be as easy as possible
• encryption should be used to maintain privacy and control the diffusion of the data

The underlying goal is to reduce the need to use solution like Facebook, Dropbox, Drive... for file/pictures exchange that should be kept private. Also this.

IPFS seems to be the perfect backend for this project. What I envision is a thin GUI layer that provide the low-friction caracteristics. Most of the actual feature would be in IPFS. Here is the issues that needs to be resolved for this project to happen:

• ipfs/kubo/issues/875 : avoid duplicating files added to ipfs, ie having ipfs track and share files that are directly on disk, not copied in the datastore
• ipfs/kubo/issues/930 : API access to current download
• ipfs/specs/issues/3 : keystore, encryption, signing and key sharing support
• jbenet/ipfs/issues/45 : having a node keypair and an identity keypair
• pub/sub system : @cryptix mentionned this system as a way for user to notify the receiver that somethng was shared to them, need more details

Optional:

• ipfs/kubo/issues/920 Need statistics on what content is being uploaded
• ipfs/kubo/issues/826 Private keys should be encrypted

On a side note, a problem that arise with low-diffusion filesharing is that sender and receivers need to be online at the same time. The future Filecoin seems to be a good solution to mitigate this problem as the sender could incentive other nodes to replicate and hold the encrypted blob online while he is offline.

That is, replace the use of ipfs refs local.

See also #33

Each Ipfs command binds on a QNetworkReply::finished SIGNAL to get its results.

Each command then has to deal with the possible network failures.

It would be better if Ipfs would make sur the connection goes well (possibly re issuing the request) and would guaranty the command to get its result.

23:32 <Bat`O> i don't have much hope for this one, but is there a way to have the bandwidth usage relative to a hash ?
23:34 nothing in the api
23:34 but!
23:34 i think you could still get that info
23:34 ipfs log tail returns a json stream of events
23:34 you could parse that stream for 'send block X'
23:35 and use that to estimate bandwidth for a given block
23:35 actually, that would be a really cool app to write
23:35 print out bandwidth for every outgoing block

We need to find a way to tell IPFS to stop downloading something to be able to implement Share::pause()

https://github.com/MichaelMure/Arbore-qt/blob/master/src/file.cpp#L33

The real size of the block is missing, we need to get that from IPFS

Current mockup:

For the user interaction, I would say:

• left click: hide/show the main window
• right click: hide/show the information popup

It would be nice to have a graphical logo in addition to the textual logo we already have.

It needs to fit well inside a square/circle.

It might be the 'ae' stylized letters, but it could also be something more graphical, maybe something derived from a tree (arbore mean tree in latin).