make vendor
Juan Batiz-Benet committed
Dec 16, 2014 at 14:53 UTC
ba323c3e48778b676ad64baf523622600ef7b122
22 files changed
+28
-540
Godeps/Godeps.json
+17
-4
@@ -34,6 +34,15 @@
34
"Comment": "null-144",
35
"Rev": "ad01a6fcc8a19d3a4478c836895ffe883bd2ceab"
36
},
37
+ {
38
+ "ImportPath": "code.google.com/p/go.net/spdy",
39
+ "Comment": "null-144",
40
+ "Rev": "ad01a6fcc8a19d3a4478c836895ffe883bd2ceab"
41
+ },
42
+ {
43
+ "ImportPath": "code.google.com/p/gogoprotobuf/io",
44
+ "Rev": "6c980277330804e94257ac7ef70a3adbe1641059"
45
+ },
46
{
47
"ImportPath": "code.google.com/p/gogoprotobuf/proto",
48
"Rev": "6c980277330804e94257ac7ef70a3adbe1641059"
@@ -60,6 +69,10 @@
69
"ImportPath": "github.com/coreos/go-semver/semver",
70
"Rev": "6fe83ccda8fb9b7549c9ab4ba47f47858bc950aa"
71
},
72
+ {
73
+ "ImportPath": "github.com/docker/spdystream",
74
+ "Rev": "e9d52d77345028f700deb3799ec0b77d5df56dcd"
75
+ },
76
{
77
"ImportPath": "github.com/facebookgo/stack",
78
"Rev": "4da6d991fc3c389efa512151354d643eb5fae4e2"
@@ -127,12 +140,12 @@
140
"Rev": "1976046c2b0db0b668791b3e541d76a38b7c1af7"
141
},
142
{
130
- "ImportPath": "github.com/jbenet/go-random",
131
- "Rev": "2e83344e7dc7898f94501665af34edd4aa95a013"
143
+ "ImportPath": "github.com/jbenet/go-peerstream",
144
+ "Rev": "5023d0d6b3efeb50c2c30535d011bdcb2351e212"
145
},
146
{
134
- "ImportPath": "github.com/jbenet/go-router",
135
- "Rev": "7a4053217b7bfe3a14cc79541557d47d0c4ad85f"
147
+ "ImportPath": "github.com/jbenet/go-random",
148
+ "Rev": "2e83344e7dc7898f94501665af34edd4aa95a013"
149
},
150
{
151
"ImportPath": "github.com/kr/binarydist",
Godeps/_workspace/src/github.com/jbenet/go-msgio/chan.go
+1
-1
@@ -3,7 +3,7 @@ package msgio
3
import (
4
"io"
5
6
- mpool "github.com/jbenet/go-msgio/mpool"
6
+ mpool "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio/mpool"
7
)
8
9
// Chan is a msgio duplex channel. It is used to have a channel interface
Godeps/_workspace/src/github.com/jbenet/go-msgio/msgio.go
+1
-1
@@ -5,7 +5,7 @@ import (
5
"io"
6
"sync"
7
8
- mpool "github.com/jbenet/go-msgio/mpool"
8
+ mpool "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio/mpool"
9
)
10
11
// NBO is NetworkByteOrder
Godeps/_workspace/src/github.com/jbenet/go-router/LICENSE
deleted
-21
@@ -1,21 +0,0 @@
1
-The MIT License (MIT)
2
-
3
-Copyright (c) 2014 Juan Batiz-Benet
4
-
5
-Permission is hereby granted, free of charge, to any person obtaining a copy
6
-of this software and associated documentation files (the "Software"), to deal
7
-in the Software without restriction, including without limitation the rights
8
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
-copies of the Software, and to permit persons to whom the Software is
10
-furnished to do so, subject to the following conditions:
11
-
12
-The above copyright notice and this permission notice shall be included in
13
-all copies or substantial portions of the Software.
14
-
15
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21
-THE SOFTWARE.
Godeps/_workspace/src/github.com/jbenet/go-router/README.md
deleted
-8
@@ -1,8 +0,0 @@
1
-# go-router - networking inspired muxing
2
-
3
-This is a networking-inspired model. It's useful for muxing and lots of other
4
-things. It enables you to construct your abstractions as you would compose
5
-computer networks (endpoints, switches, routing tables). These could represent
6
-processing workers, entire subsystems, or even real computers ;).
7
-
8
-See https://godoc.org/github.com/jbenet/go-router
Godeps/_workspace/src/github.com/jbenet/go-router/distance.go
deleted
-33
@@ -1,33 +0,0 @@
1
-package router
2
-
3
-// HammingDistance is a DistanceFunc that interprets Addresses as strings
4
-// and uses their Hamming distance.
5
-// Return -1 if the Addresses are not strings, or strings length don't match.
6
-func HammingDistance(a1, a2 Address) int {
7
- s1, ok := a1.(string)
8
- if !ok {
9
- return -1
10
- }
11
-
12
- s2, ok := a2.(string)
13
- if !ok {
14
- return -1
15
- }
16
-
17
- // runes not code points
18
- r1 := []rune(s1)
19
- r2 := []rune(s2)
20
-
21
- // hamming distance requires equal length strings
22
- if len(r1) != len(r2) {
23
- return -1
24
- }
25
-
26
- d := 0
27
- for i := range r1 {
28
- if r1[i] != r2[i] {
29
- d++
30
- }
31
- }
32
- return d
33
-}
Godeps/_workspace/src/github.com/jbenet/go-router/impl.go
deleted
-81
@@ -1,81 +0,0 @@
1
-package router
2
-
3
-import (
4
- "errors"
5
-)
6
-
7
-type packet struct {
8
- a Address
9
- p interface{}
10
-}
11
-
12
-// ErrNoRoute signals when there is no Route to a destination
13
-var ErrNoRoute = errors.New("routing error: no route")
14
-
15
-// NewPacket constructs a trivial packet linking a destination Address to
16
-// an interface{} payload.
17
-func NewPacket(destination Address, payload interface{}) Packet {
18
- return &packet{destination, payload}
19
-}
20
-
21
-func (p *packet) Destination() Address {
22
- return p.a
23
-}
24
-
25
-func (p *packet) Payload() interface{} {
26
- return p.p
27
-}
28
-
29
-// QueueNode is a trivial node, which accepts packets into a queue
30
-type QueueNode struct {
31
- a Address
32
- q chan Packet
33
-}
34
-
35
-// NewQueueNode constructs a node with an internal chan Packet queue
36
-func NewQueueNode(addr Address, q chan Packet) *QueueNode {
37
- return &QueueNode{addr, q}
38
-}
39
-
40
-// Queue returns the chan Packet queue
41
-func (n *QueueNode) Queue() <-chan Packet {
42
- return n.q
43
-}
44
-
45
-// Address returns the QueueNode's Address
46
-func (n *QueueNode) Address() Address {
47
- return n.a
48
-}
49
-
50
-// HandlePacket consumes the incomng packet and adds it to the queue.
51
-func (n *QueueNode) HandlePacket(p Packet, s Node) error {
52
- n.q <- p
53
- return nil
54
-}
55
-
56
-type switchh struct {
57
- addr Address
58
- router Router
59
- nodes []Node
60
-}
61
-
62
-// NewSwitch constructs a switch with given Router and list of adjacent Nodes.
63
-func NewSwitch(a Address, r Router, adj []Node) Switch {
64
- return &switchh{a, r, adj}
65
-}
66
-
67
-func (s *switchh) Address() Address {
68
- return s.addr
69
-}
70
-
71
-func (s *switchh) Router() Router {
72
- return s.router
73
-}
74
-
75
-func (s *switchh) HandlePacket(p Packet, n Node) error {
76
- next := s.router.Route(p)
77
- if next != nil {
78
- return next.HandlePacket(p, s)
79
- }
80
- return ErrNoRoute
81
-}
Godeps/_workspace/src/github.com/jbenet/go-router/interface.go
deleted
-81
@@ -1,81 +0,0 @@
1
-// Package router is a networking-inspired routing model. It's useful for
2
-// muxing and lots of other things. It enables you to construct your
3
-// abstractions as you would compose computer networks (endpoints, switches,
4
-// routing tables). These could represent processing workers, entire
5
-// subsystems, or even real computers ;).
6
-package router
7
-
8
-// Address is our way of knowing where we're headed. Traditionally, addresses
9
-// are things like IP Addresses, or email addresses. But filepaths, or URLs
10
-// can be seen as addresses too. We really leave it up to you. Our routing
11
-// is general, and forces you to pick an addressing scheme, and some logic to
12
-// discriminate addresses that you'll plug into Routers (Address DistanceFunc).
13
-type Address interface{}
14
-
15
-// Packet is the unit of moving things in our network. Anything can be routed
16
-// in our network, as long as it has a Destination.
17
-type Packet interface {
18
-
19
- // Destination is the Address of the endpoint this Packet is headed to.
20
- // They could use the same Addressing throughout (recommended) like the
21
- // internet, or face the pain of translating addresses at inter-network
22
- // gateways.
23
- Destination() Address
24
-
25
- // Payload is here for completeness. This can be the Packet itself, but this
26
- // function encourages the client to think through their packet design.
27
- Payload() interface{}
28
-}
29
-
30
-// Node is an object which has interfaces to connect to networks. This
31
-// is an "endpoint" object.
32
-type Node interface {
33
-
34
- // Address returns the node's address.
35
- Address() Address
36
-
37
- // HandlePacket receives a packet sent by another node.
38
- HandlePacket(Packet, Node) error
39
-}
40
-
41
-// Switch is the basic forwarding device. It listens to all its interfaces (it
42
-// is a Node in our network) and Forwards all Packets received by any interface
43
-// out another interface, according to its ForwardingTable.
44
-type Switch interface {
45
- Node
46
-
47
- // Router returns the Router used to decide where to forward packets.
48
- Router() Router
49
-}
50
-
51
-// Router is an object that decides how a Packet should be Routed. This should
52
-// be as close to a static table lookup as possible, meaning it would be best
53
-// to prepare a forwarding table in parallel, instead of blocking.
54
-//
55
-// Our Router captures the entire Control Plane, meaning that we can implement:
56
-// - Static Routing - forwarding table only
57
-// - Dynamic Routing - routing table computed with an algorithm or protocol
58
-// - "SDN" Routing - Control Plane separated from Data Plane
59
-// And even:
60
-// - URL Routers (like gorilla.Muxer)
61
-// - Protocol Muxers
62
-// entirely within different Router implementations.
63
-//
64
-// Note that this is a break from traditional networking systems. Instead of
65
-// having the abstractions of FIB, RIB, Routing/Forwarding Tables, Routers,
66
-// and Switches, we only have the last two:
67
-// - Router -- the things that "route" (decide where things go)
68
-// - Switch -- connecting Nodes, "switch" Packets according to a Router.
69
-type Router interface {
70
-
71
- // Route decides how to route a Packet.
72
- // It returns the next hop Node chosen to send the Packet to.
73
- // Route may return nil, if no route is suitable at all (equivalent of drop).
74
- Route(Packet) Node
75
-}
76
-
77
-// DistanceFunc returns a measure of distance between two Addresses.
78
-// Examples:
79
-// - masked longest prefix match (IP, CIDR)
80
-// - XOR distance (Kademlia)
81
-type DistanceFunc func(a, b Address) int
Godeps/_workspace/src/github.com/jbenet/go-router/ip/ip.go
deleted
-6
@@ -1,6 +0,0 @@
1
-// Package ip provides a Table for ip matching
2
-package ip
3
-
4
-// import (
5
-// ipaddr "github.com/mikioh/ipaddr"
6
-// )
Godeps/_workspace/src/github.com/jbenet/go-router/ip/ip_test.go
deleted
-1
@@ -1 +0,0 @@
1
-package ip
Godeps/_workspace/src/github.com/jbenet/go-router/pkt_test.go
deleted
-77
@@ -1,77 +0,0 @@
1
-package router
2
-
3
-import (
4
- "testing"
5
-)
6
-
7
-type mockNode struct {
8
- addr string
9
- pkts []Packet
10
-}
11
-
12
-func (m *mockNode) Address() Address {
13
- return m.addr
14
-}
15
-
16
-func (m *mockNode) HandlePacket(p Packet, n Node) error {
17
- m.pkts = append(m.pkts, p)
18
- return nil
19
-}
20
-
21
-type mockPacket struct {
22
- a string
23
-}
24
-
25
-func (m *mockPacket) Destination() Address {
26
- return m.a
27
-}
28
-
29
-func (m *mockPacket) Payload() interface{} {
30
- return m
31
-}
32
-
33
-func TestAddrs(t *testing.T) {
34
-
35
- ta := func(a, b Address, expect int) {
36
- actual := HammingDistance(a, b)
37
- if actual != expect {
38
- t.Error("address distance error:", a, b, expect, actual)
39
- }
40
- }
41
-
42
- a := "abc"
43
- b := "abc"
44
- c := "abd"
45
- d := "add"
46
- e := "ddd"
47
-
48
- ta(a, a, 0)
49
- ta(a, b, 0)
50
- ta(a, c, 1)
51
- ta(a, d, 2)
52
- ta(a, e, 3)
53
-}
54
-
55
-func TestNodes(t *testing.T) {
56
-
57
- a := &mockPacket{"abc"}
58
- b := &mockPacket{"abc"}
59
- c := &mockPacket{"abd"}
60
- d := &mockPacket{"add"}
61
- e := &mockPacket{"ddd"}
62
-
63
- n := &mockNode{addr: "abc"}
64
- n2 := &mockNode{addr: "ddd"}
65
- n.HandlePacket(a, n2)
66
- n.HandlePacket(b, n2)
67
- n.HandlePacket(c, n2)
68
- n.HandlePacket(d, n2)
69
- n.HandlePacket(e, n2)
70
-
71
- pkts := []Packet{a, b, c, d, e}
72
- for i, p := range pkts {
73
- if n.pkts[i] != p {
74
- t.Error("pkts not handled in order.")
75
- }
76
- }
77
-}
Godeps/_workspace/src/github.com/jbenet/go-router/table.go
deleted
-137
@@ -1,137 +0,0 @@
1
-package router
2
-
3
-import (
4
- "sync"
5
-)
6
-
7
-// TableEntry is an (Address, Node) pair for a routing Table
8
-type TableEntry interface {
9
- Address() Address
10
- NextHop() Node
11
-}
12
-
13
-func NewTableEntry(addr Address, nexthop Node) TableEntry {
14
- return &tableEntry{addr, nexthop}
15
-}
16
-
17
-type tableEntry struct {
18
- addr Address
19
- next Node
20
-}
21
-
22
-func (te *tableEntry) Address() Address {
23
- return te.addr
24
-}
25
-
26
-func (te *tableEntry) NextHop() Node {
27
- return te.next
28
-}
29
-
30
-// Table is a Router (Routing Table, really) based on a distance criterion.
31
-//
32
-// For example:
33
-//
34
-// n1 := NewQueueNode("aaa", make(chan Packet, 10))
35
-// n2 := NewQueueNode("aba", make(chan Packet, 10))
36
-// n3 := NewQueueNode("abc", make(chan Packet, 10))
37
-//
38
-// var t router.Table
39
-// t.Distance = router.HammingDistance
40
-// t.AddNodes(n1, n2)
41
-//
42
-// p1 := NewPacket("aaa", "hello1")
43
-// p2 := NewPacket("aba", "hello2")
44
-// p3 := NewPacket("abc", "hello3")
45
-//
46
-// t.Route(p1) // n1
47
-// t.Route(p2) // n2
48
-// t.Route(p3) // n2, because we don't have n3 and n2 is closet
49
-//
50
-// t.AddNode(n3)
51
-// t.Route(p3) // n3
52
-type Table interface {
53
- Router
54
-
55
- // Entries are the entries in this routing table
56
- Entries() []TableEntry
57
-
58
- // Distance returns a measure of distance between two Addresses
59
- Distance() DistanceFunc
60
-}
61
-
62
-type SimpleTable struct {
63
- entries []TableEntry
64
- distance DistanceFunc
65
- sync.RWMutex
66
-}
67
-
68
-// Entries are the entries in this routing table
69
-func (t *SimpleTable) Entries() []TableEntry {
70
- return t.entries
71
-}
72
-
73
-// Distance returns a measure of distance between two Addresses.
74
-func (t *SimpleTable) Distance() DistanceFunc {
75
- return t.distance
76
-}
77
-
78
-// AddEntry adds an (Address, NextHop) entry to the Table
79
-func (t *SimpleTable) AddEntry(addr Address, nextHop Node) {
80
- t.Lock()
81
- defer t.Unlock()
82
- t.entries = append(t.entries, NewTableEntry(addr, nextHop))
83
-}
84
-
85
-// AddNode calls AddTableEntry for the given Node
86
-func (t *SimpleTable) AddNode(n Node) {
87
- t.AddEntry(n.Address(), n)
88
-}
89
-
90
-// AddNodes calls AddTableEntry for the given Node
91
-func (t *SimpleTable) AddNodes(ns ...Node) {
92
- t.Lock()
93
- defer t.Unlock()
94
- for _, n := range ns {
95
- t.entries = append(t.entries, NewTableEntry(n.Address(), n))
96
- }
97
-}
98
-
99
-// Route decides how to route a Packet out of a list of Nodes.
100
-// It returns the Node chosen to send the Packet to.
101
-// Route may return nil, if no route is suitable at all (equivalent of drop).
102
-func (t *SimpleTable) Route(p Packet) Node {
103
- if t.entries == nil {
104
- return nil
105
- }
106
-
107
- t.RLock()
108
- defer t.RUnlock()
109
-
110
- dist := t.Distance()
111
- if dist == nil {
112
- dist = equalDistance
113
- }
114
-
115
- var best Node
116
- var bestDist int
117
- var addr = p.Destination()
118
-
119
- for _, e := range t.entries {
120
- d := dist(e.Address(), addr)
121
- if d < 0 {
122
- continue
123
- }
124
- if best == nil || d < bestDist {
125
- bestDist = d
126
- best = e.NextHop()
127
- }
128
- }
129
- return best
130
-}
131
-
132
-func equalDistance(a, b Address) int {
133
- if a == b {
134
- return 0
135
- }
136
- return -1
137
-}
Godeps/_workspace/src/github.com/jbenet/go-router/table_test.go
deleted
-80
@@ -1,80 +0,0 @@
1
-package router
2
-
3
-import (
4
- "testing"
5
-)
6
-
7
-func TestTable(t *testing.T) {
8
-
9
- na := &mockNode{addr: "abc"}
10
- nc := &mockNode{addr: "abd"}
11
- nd := &mockNode{addr: "add"}
12
- ne := &mockNode{addr: "ddd"}
13
-
14
- pa := &mockPacket{"abc"}
15
- pb := &mockPacket{"abc"}
16
- pc := &mockPacket{"abd"}
17
- pd := &mockPacket{"add"}
18
- pe := &mockPacket{"ddd"}
19
-
20
- table := &SimpleTable{
21
- entries: []TableEntry{
22
- &tableEntry{na.Address(), na},
23
- &tableEntry{nc.Address(), nc},
24
- &tableEntry{nd.Address(), nd},
25
- &tableEntry{ne.Address(), ne},
26
- },
27
- }
28
-
29
- s := NewSwitch("sss", table, []Node{na, nc, nd, ne})
30
- s.HandlePacket(pa, na)
31
- s.HandlePacket(pb, na)
32
- s.HandlePacket(pc, na)
33
- s.HandlePacket(pd, na)
34
- s.HandlePacket(pe, na)
35
-
36
- tt := func(n *mockNode, pkts []Packet) {
37
- for i, p := range pkts {
38
- if len(n.pkts) <= i {
39
- t.Error("pkts not handled in order.", n, pkts)
40
- return
41
- }
42
- if n.pkts[i] != p {
43
- t.Error("pkts not handled in order.", n, pkts)
44
- }
45
- }
46
- }
47
-
48
- tt(na, []Packet{pa, pb})
49
- tt(nc, []Packet{pc})
50
- tt(nd, []Packet{pd})
51
- tt(ne, []Packet{pe})
52
-}
53
-
54
-func TestTable2(t *testing.T) {
55
-
56
- n1 := NewQueueNode("aaa", make(chan Packet, 1))
57
- n2 := NewQueueNode("aba", make(chan Packet, 1))
58
- n3 := NewQueueNode("abc", make(chan Packet, 1))
59
-
60
- var tb SimpleTable
61
- tb.distance = HammingDistance
62
- tb.AddNodes(n1, n2)
63
-
64
- p1 := NewPacket("aaa", "hello1")
65
- p2 := NewPacket("aba", "hello2")
66
- p3 := NewPacket("abc", "hello3")
67
-
68
- testRoute := func(p Packet, expect Node) {
69
- if tb.Route(p) != expect {
70
- t.Error(p, "route should be", expect)
71
- }
72
- }
73
-
74
- testRoute(p1, n1)
75
- testRoute(p2, n2)
76
- testRoute(p3, n2) // n2 because we don't have n3 and n2 is closet
77
-
78
- tb.AddNode(n3)
79
- testRoute(p3, n3)
80
-}
diagnostics/diag.go
+1
-1
@@ -13,7 +13,7 @@ import (
13
14
"crypto/rand"
15
16
- ggio "code.google.com/p/gogoprotobuf/io"
16
+ ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
17
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
18
"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto"
19
exchange/bitswap/message/message.go
+1
-1
@@ -8,7 +8,7 @@ import (
8
inet "github.com/jbenet/go-ipfs/net"
9
u "github.com/jbenet/go-ipfs/util"
10
11
- ggio "code.google.com/p/gogoprotobuf/io"
11
+ ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
12
)
13
14
// TODO move message.go into the bitswap package
net/conn/handshake.go
+1
-1
@@ -7,7 +7,7 @@ import (
7
handshake "github.com/jbenet/go-ipfs/net/handshake"
8
hspb "github.com/jbenet/go-ipfs/net/handshake/pb"
9
10
- ggprotoio "code.google.com/p/gogoprotobuf/io"
10
+ ggprotoio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
11
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
12
)
13
net/swarm2/swarm.go
+1
-1
@@ -9,7 +9,7 @@ import (
9
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
10
ctxgroup "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-ctxgroup"
11
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
12
- ps "github.com/jbenet/go-peerstream"
12
+ ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
13
)
14
15
var log = eventlog.Logger("swarm2")
net/swarm2/swarm_conn.go
+1
-1
@@ -8,7 +8,7 @@ import (
8
9
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
10
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
11
- ps "github.com/jbenet/go-peerstream"
11
+ ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
12
)
13
14
// a Conn is a simple wrapper around a ps.Conn that also exposes
net/swarm2/swarm_listen.go
+1
-1
@@ -7,7 +7,7 @@ import (
7
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
8
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
9
multierr "github.com/jbenet/go-ipfs/util/multierr"
10
- ps "github.com/jbenet/go-peerstream"
10
+ ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
11
)
12
13
// Open listeners for each network the swarm should listen on
net/swarm2/swarm_stream.go
+1
-1
@@ -1,7 +1,7 @@
1
package swarm
2
3
import (
4
- ps "github.com/jbenet/go-peerstream"
4
+ ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
5
)
6
7
// a Stream is a wrapper around a ps.Stream that exposes a way to get
routing/dht/dht_net.go
+1
-1
@@ -8,7 +8,7 @@ import (
8
peer "github.com/jbenet/go-ipfs/peer"
9
pb "github.com/jbenet/go-ipfs/routing/dht/pb"
10
11
- ggio "code.google.com/p/gogoprotobuf/io"
11
+ ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
12
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
13
)
14
routing/dht/ext_test.go
+1
-1
@@ -14,7 +14,7 @@ import (
14
u "github.com/jbenet/go-ipfs/util"
15
testutil "github.com/jbenet/go-ipfs/util/testutil"
16
17
- ggio "code.google.com/p/gogoprotobuf/io"
17
+ ggio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/io"
18
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
19
ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
20