From 3b570d3f82d2334dc9d8696acb0a8253eb9ce4e3 Mon Sep 17 00:00:00 2001
From: Juan Batiz-Benet <juan@benet.ai>
Date: Thu, 26 Jun 2014 01:14:26 -0700
Subject: [PATCH] skeleton.

---
 README.md            | 10 +++++
 bitswap/bitswap.go   | 17 ++++++++
 block/block.go       | 10 +++++
 blocks/blocks.go     | 14 +++++++
 core/core.go         | 33 +++++++++++++++
 dht/dht.go           |  7 ++++
 msgproto/msgproto.go |  0
 netmux/interface.go  | 96 ++++++++++++++++++++++++++++++++++++++++++++
 netmux/netmux.go     | 51 +++++++++++++++++++++++
 object/object.go     |  0
 path/path.go         |  0
 peer/peer.go         |  0
 routing/routing.go   |  4 ++
 storage/storage.go   |  0
 14 files changed, 242 insertions(+)
 create mode 100644 README.md
 create mode 100644 bitswap/bitswap.go
 create mode 100644 block/block.go
 create mode 100644 blocks/blocks.go
 create mode 100644 core/core.go
 create mode 100644 dht/dht.go
 create mode 100644 msgproto/msgproto.go
 create mode 100644 netmux/interface.go
 create mode 100644 netmux/netmux.go
 create mode 100644 object/object.go
 create mode 100644 path/path.go
 create mode 100644 peer/peer.go
 create mode 100644 routing/routing.go
 create mode 100644 storage/storage.go

diff --git a/README.md b/README.md
new file mode 100644
index 000000000..24228258e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,10 @@
+# ipfs implementation in go.
+
+See: https://github.com/jbenet/ipfs
+
+Please put all issues regarding IPFS _design_ in the
+[ipfs repo issues](https://github.com/jbenet/ipfs/issues).
+
+Please put all issues regarding go IPFS _implementation_ in [this repo](https://github.com/jbenet/go-ipfs/issues).
+
+The [node implementation](https://github.com/jbenet/node-ipfs) is much farther along. This one is just a skeleton.
diff --git a/bitswap/bitswap.go b/bitswap/bitswap.go
new file mode 100644
index 000000000..fc236936c
--- /dev/null
+++ b/bitswap/bitswap.go
@@ -0,0 +1,17 @@
+package bitswap
+
+import (
+  "github.com/jbenet/go-ipfs/peer"
+)
+
+// aliases
+
+type Ledger struct {
+  // todo
+}
+
+type BitSwap struct {
+  Ledgers map[peer.PeerId]*Ledger
+  HaveList map[multihash.Multihash]*block.Block
+  WantList []*multihash.Multihash
+}
diff --git a/block/block.go b/block/block.go
new file mode 100644
index 000000000..da3e73d2b
--- /dev/null
+++ b/block/block.go
@@ -0,0 +1,10 @@
+package block
+
+import (
+  "github.com/jbenet/go-multihash"
+)
+
+type Block struct {
+  Multihash []byte
+  Data []byte
+}
diff --git a/blocks/blocks.go b/blocks/blocks.go
new file mode 100644
index 000000000..fd7124651
--- /dev/null
+++ b/blocks/blocks.go
@@ -0,0 +1,14 @@
+package blocks
+
+import (
+  "github.com/jbenet/go-ipfs/bitswap"
+  "github.com/jbenet/go-ipfs/storage"
+)
+
+// Blocks is the ipfs blocks service. It is the way
+// to retrieve blocks by the higher level ipfs modules
+
+type BlockService struct {
+  Local *storage.Storage
+  Remote *bitswap.BitSwap
+}
diff --git a/core/core.go b/core/core.go
new file mode 100644
index 000000000..d74e37b9e
--- /dev/null
+++ b/core/core.go
@@ -0,0 +1,33 @@
+package core
+
+// IPFS Core module. It represents an IPFS instance.
+
+type IPFSNode struct {
+
+  // the local node's identity (a Peer instance)
+  Identity *peer.Peer
+
+  // the book of other nodes (a hashtable of Peer instances)
+  PeerBook *peerbook.PeerBook
+
+  // the local database (uses datastore)
+  Storage *storage.Storage
+
+  // the network message stream
+  Network *netmux.Netux
+
+  // the routing system. recommend ipfs-dht
+  Routing *routing.Routing
+
+  // the block exchange + strategy (bitswap)
+  BitSwap *bitswap.BitSwap
+
+  // the block service, get/add blocks.
+  Blocks *blocks.BlockService
+
+  // the path resolution system
+  Resolver *resolver.PathResolver
+
+  // the name system, resolves paths to hashes
+  Namesys *namesys.Namesys
+}
diff --git a/dht/dht.go b/dht/dht.go
new file mode 100644
index 000000000..f553e9c24
--- /dev/null
+++ b/dht/dht.go
@@ -0,0 +1,7 @@
+package dht
+
+// The IPFS DHT is an implementation of Kademlia with
+// Coral and S/Kademlia modifications. It is used to
+// implement the base IPFS Routing module.
+
+TODO. SEE https://github.com/jbenet/node-ipfs/blob/master/submodules/ipfs-dht/index.js
diff --git a/msgproto/msgproto.go b/msgproto/msgproto.go
new file mode 100644
index 000000000..e69de29bb
diff --git a/netmux/interface.go b/netmux/interface.go
new file mode 100644
index 000000000..68819a930
--- /dev/null
+++ b/netmux/interface.go
@@ -0,0 +1,96 @@
+package netmux
+
+import (
+  "net"
+)
+
+// An interface is the module connecting netmux
+// to various networks (tcp, udp, webrtc, etc).
+// It keeps the relevant connections open.
+type Interface struct {
+
+  // Interface network (e.g. udp4, tcp6)
+  Network string
+
+  // Own network address
+  Address string
+  ResolvedAddress string
+
+  // Connection
+  conn *net.Conn
+
+  // next packets + close control channels
+  Input chan *Packet
+  Output chan *Packet
+  Closed chan bool
+  Errors chan error
+}
+
+func NewUDPInterface(net, addr string) (*Interface, error) {
+  raddr, err := net.ResolveUDPAddr(net, addr)
+  if err != nil {
+    return nil, err
+  }
+
+  conn, err := net.ListenUDP(net, addr)
+  if err != nil {
+    return nil, err
+  }
+
+  i := &Interface{
+    Network: net,
+    Address: addr,
+    ResolvedAddress: raddr,
+    conn: conn,
+  }
+
+  go i.processInput()
+  go i.processOutput()
+  return i, nil
+}
+
+func (i *Interface) processOutput() {
+  for {
+    select {
+    case <-i.Closed:
+      break;
+
+    case buffer := <-i.Output:
+      i.conn.Write([]byte(buffer))
+    }
+  }
+}
+
+func (i *Interface) processUDPInput() {
+  for {
+    select {
+    case <- i.Closed:
+      break;
+
+    }
+  }
+}
+
+func (i *Interface) Read(buffer []byte) bool {
+  n, err := i.Conn.Read(buffer)
+  if err != nil {
+    i.Errors <- err
+    i.Close()
+    return false
+  }
+  return true
+}
+
+func (i *Interface) Close() {
+  // closing net connection
+  err := i.conn.Close()
+  if err != nil {
+    i.Errors <- err
+  }
+
+  // closing channels
+  close(i.Input)
+  close(i.Output)
+  close(i.Closed)
+  close(i.Errors)
+}
diff --git a/netmux/netmux.go b/netmux/netmux.go
new file mode 100644
index 000000000..eb71e2190
--- /dev/null
+++ b/netmux/netmux.go
@@ -0,0 +1,51 @@
+package netmux
+
+import (
+  "net"
+)
+
+// The netmux module provides a "network multiplexer".
+// The core idea is to have the client be able to connect to
+// many different networks (potentially over different transports)
+// and multiplex everything over one interface.
+
+type Netmux struct {
+  // the list of NetMux interfaces
+  Interfaces []*Interface
+
+  // The channels to send/recv from
+  Incoming <-chan *Packet
+  Outgoing chan<- *Packet
+
+  // internally managed other side of channels
+  incomingSrc chan<- *Packet
+  outgoingSrc <-chan *Packet
+}
+
+
+// Warning: will probably change to adopt multiaddr format
+type Packet {
+  // the network addresses to send to
+  // e.g. tcp4://127.0.0.1:12345
+  NetAddrTo string
+
+  // the network addresses to recv from
+  // e.g. tcp4://127.0.0.1:12345
+  // may be left blank to select one automatically.
+  NetAddrFrom string
+
+  // the data to send.
+  Data []byte
+}
+
+func NewNetmux() *Netmux {
+  n := &Netmux{}
+
+  // setup channels
+  och := make(chan *Packet)
+  ich := make(chan *Packet)
+  n.Incoming, n.incomingSrc := ich, ich
+  n.Outgoing, n.outgoingSrc := och, och
+
+  return n
+}
diff --git a/object/object.go b/object/object.go
new file mode 100644
index 000000000..e69de29bb
diff --git a/path/path.go b/path/path.go
new file mode 100644
index 000000000..e69de29bb
diff --git a/peer/peer.go b/peer/peer.go
new file mode 100644
index 000000000..e69de29bb
diff --git a/routing/routing.go b/routing/routing.go
new file mode 100644
index 000000000..2ab572c9a
--- /dev/null
+++ b/routing/routing.go
@@ -0,0 +1,4 @@
+package routing
+
+
+TODO SEE https://github.com/jbenet/node-ipfs/blob/master/submodules/ipfs-routing/index.js
diff --git a/storage/storage.go b/storage/storage.go
new file mode 100644
index 000000000..e69de29bb