interface for go-ipfs clients

[jbenet]

Would be great to setup a very simple interface for programmatic go-ipfs clients.

Let's use this issue to outline what the interface below should look like

package ipfs

// maybe rebind things clients will need, so they dont have to import
// a ton of packages.
type Key u.Key
type Block blocks.Block
type Object mdag.Node
...

// Node is an IPFS Node
type Node interface {

   // blocks
   GetBlock(Key) (Block, error)
   PutBlock(Key, Block) error

   // objects
   GetObject(Key) (Object, error)
   PutObject(Object) error

   // etc.
}

And some nice functions that can setup a node for you, given certain specific types of workflows:

// when you have a directory locally
func NewNodeWithConfigDir(string) (ipfs.Node, error) { ... }

// when you create your own config
func NewNodeWithConfig(cfg config.Config) (ipfs.Node, error) { ... }

// creates new keys, memory only ds, etc...
func NewEphemeralNode() (ipfs.Node, error) { ... }

// etc.

[whyrusleeping]

Huh, dhtHell would love to have this

[ehmry]

How about a convience Writer?

type ObjectWriter interface {
    // Object that represents everything written thus far
    Root() Object

    Write([]byte) (int, error) {

    // Flush the last chunk in the internal splitter and prevent further writes.
    Close() error
}

[whyrusleeping]

ehmry, thats called the DagWriter, its in unixfs/io

[ehmry]

heh, so it is.

[ehmry]

Turns out if you make DAGService an interface, you can swap out the blockservice with RPC calls and reuse DagWriter/DagReader in a simple client.

https://github.com/ehmry/go-ipfs/compare/client

[whyrusleeping]

i like that

[btc]

hey @ehmry would you like to submit a PR for DAGService as an interface?

[ehmry]

@briantigerchow Let me look and see what I got.

[ehmry]

This is what I had https://github.com/ehmry/go-ipfs/blob/client/merkledag/merkledag.go

[ehmry]

I'm confused, DAGService is an interface at master, and I know longer remember what I was working on.

[whyrusleeping]

I think it was the distinction between mutable and immutable dag nodes. But i could be wrong

[whyrusleeping]

i have a common interface here: https://github.com/whyrusleeping/fallback-ipfs-shell

that lets us have the same 'object' be either an http client or an embedded node. It needs some documentation work, but it's the direction I want to go with this.

[daviddias]

Let's transform this issue into a documentation effort on how to use IPFS programatically in go, using:

• HTTP API
• Core (for embedding IPFS directly)

There is currently one example available at https://ipfs.io/ipfs/QmTkzDwWqPbnAh5YiV5VwcTLnGdwSNsNTn2aDxdXBFca7D/example#/ipfs/QmQwAP9vFjbCtKvD8RkJdCvPHqLQjZfW7Mqbbqx18zd8j7/api/service/readme.md (would be good to verify that it still follows the current API)

@RichardLitt this would fit nicely into the API documentation efforts

[novocodev]

I'd like to use IPFS embedded in my golang App, has the convenience API described at the top of this ticket been implemented or are there any further examples of how to access the current IPFS implementation programatically.

[ghost]

@novocodev go-ipfs-api might get you some of what you need: https://github.com/ipfs/go-ipfs-api

[ghost]

Eh nevermind sorry -- I misread that you want to embed go-ipfs.

[whyrusleeping]

@lgierth can this be closed in favor of core api discussions?

[ghost]

Yes, closing this.

The follow up on this is that there's now a Core API (ipfs/interface-ipfs-core) which all IPFS implementations should implement. The go-ipfs implementation of this has only just started and currently lives in the core/coreapi package.