/
jsoninterface.go
106 lines (97 loc) · 2.72 KB
/
jsoninterface.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package dht
import "net"
import "fmt"
import "json"
import "os"
//I'm not implementing this part as JSON-RPC because of some limitations it has.
type JSONRequest struct {
Action string
Parameters map[string]interface{}
}
func NewJSONRequest() *JSONRequest {
j := new(JSONRequest)
j.Parameters = make(map[string]interface{})
return j
}
type JSONInterface struct {
Node *Node
Conn net.Conn
}
func NewJSONInterface(node *Node, c net.Conn) *JSONInterface {
j := new(JSONInterface)
j.Node = node
j.Conn = c
return j
}
func (this *JSONInterface) Start() {
for {
d := json.NewDecoder(this.Conn)
req := NewJSONRequest()
err := d.Decode(req)
if err != nil {
fmt.Printf("%s\n", err)
break
}
switch req.Action {
case "stream":
fmt.Printf("It's a stream request\n")
port := int32(req.Parameters["port"].(float64))
nodeid_string := req.Parameters["nodeid"].(string)
nodeid := make([]byte, 20)
_,err := fmt.Sscanf(nodeid_string, "%x", &nodeid)
if err != nil { fmt.Printf("%s\n", err ); break }
fmt.Printf("nodeid: %x\n", nodeid)
this.PipeStream(nodeid, port)
case "store":
}
}
}
func (this *JSONInterface) PipeStream(nodeid Key, port int32) {
in := make(chan []byte)
out := make( chan []byte)
fmt.Printf("before StreamConnect\n")
streamhandler := this.Node.StreamConnect(nodeid, port)
fmt.Printf("after StreamConnect\n")
if streamhandler == nil { return }
go func () {
for {
b,err := streamhandler.Read()
if err != nil { in <- nil; return }
in <- b
}
}()
go func () {
b := make ([]byte,3000)
for {
n,err := this.Conn.Read(b)
if err != nil { out <- nil; return }
bn := make([]byte, n)
copy (bn, b)
out <- bn
}
}()
for {
select {
case b := <- in:
if b == nil {return}
this.Conn.Write(b)
case b := <- out:
if b == nil {return}
streamhandler.Write(b,true)
}
}
}
func ListenJSON(node *Node,port int) os.Error {
laddr,err := net.ResolveTCPAddr(fmt.Sprintf("127.0.0.1:%d", port))
if err != nil { return err }
l,err := net.ListenTCP("tcp", laddr)
if err != nil { return err }
fmt.Printf("JSON interface is listening\n")
for {
c, _ := l.Accept()
fmt.Printf("Accepted one\n")
j := NewJSONInterface(node,c)
go j.Start()
}
return nil
}