refactoring naming conventions
Siraj Ravel committed
Sep 10, 2014 at 12:31 UTC
4f7856a4149110c4e0c8d1afe3da8ad85cd4be65
2 files changed
+38
-34
daemon/daemon.go
+28
-28
@@ -21,25 +21,25 @@ type DaemonListener struct {
21
closed bool
22
}
23
24
-func NewDaemonListener(node *core.IpfsNode, addr string) (*DaemonListener, error) {
24
+type Command struct {
25
+ Command string
26
+ Args []string
27
+ Opts map[string]interface{}
28
+}
29
+
30
+func NewDaemonListener(Ipfsnode *core.IpfsNode, addr string) (*DaemonListener, error) {
31
list, err := net.Listen("tcp", addr)
32
if err != nil {
33
return nil, err
34
}
29
- fmt.Println("new daemon listener.")
35
+ fmt.Println("New daemon listener initialized.")
36
37
return &DaemonListener{
32
- node: node,
38
+ node: Ipfsnode,
39
list: list,
40
}, nil
41
}
42
37
-type Command struct {
38
- Command string
39
- Args []string
40
- Opts map[string]interface{}
41
-}
42
-
43
func NewCommand() *Command {
44
return &Command{
45
Opts: make(map[string]interface{}),
@@ -49,7 +49,7 @@ func NewCommand() *Command {
49
func (dl *DaemonListener) Listen() {
50
fmt.Println("listen.")
51
for {
52
- c, err := dl.list.Accept()
52
+ conn, err := dl.list.Accept()
53
fmt.Println("Loop!")
54
if err != nil {
55
if !dl.closed {
@@ -57,27 +57,27 @@ func (dl *DaemonListener) Listen() {
57
}
58
return
59
}
60
- go dl.handleConnection(c)
60
+ go dl.handleConnection(conn)
61
}
62
}
63
64
-func (dl *DaemonListener) handleConnection(c net.Conn) {
65
- defer c.Close()
64
+func (dl *DaemonListener) handleConnection(conn net.Conn) {
65
+ defer conn.Close()
66
67
- dec := json.NewDecoder(c)
67
+ dec := json.NewDecoder(conn)
68
69
- var com Command
70
- err := dec.Decode(&com)
69
+ var command Command
70
+ err := dec.Decode(&command)
71
if err != nil {
72
- fmt.Fprintln(c, err)
72
+ fmt.Fprintln(conn, err)
73
return
74
}
75
76
- u.DOut("Got command: %v\n", com)
77
- ExecuteCommand(&com, dl.node, c)
76
+ u.DOut("Got command: %v\n", command)
77
+ ExecuteCommand(&command, dl.node, conn)
78
}
79
80
-func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
80
+func ExecuteCommand(com *Command, Ipfsnode *core.IpfsNode, out io.Writer) {
81
u.DOut("executing command: %s\n", com.Command)
82
switch com.Command {
83
case "add":
@@ -86,7 +86,7 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
86
depth = -1
87
}
88
for _, path := range com.Args {
89
- _, err := commands.AddPath(n, path, depth)
89
+ _, err := commands.AddPath(Ipfsnode, path, depth)
90
if err != nil {
91
fmt.Fprintf(out, "addFile error: %v\n", err)
92
continue
@@ -94,13 +94,13 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
94
}
95
case "cat":
96
for _, fn := range com.Args {
97
- nd, err := n.Resolver.ResolvePath(fn)
97
+ DAGnode, err := Ipfsnode.Resolver.ResolvePath(fn)
98
if err != nil {
99
fmt.Fprintf(out, "catFile error: %v\n", err)
100
return
101
}
102
103
- read, err := dag.NewDagReader(nd, n.DAG)
103
+ read, err := dag.NewDagReader(nd, Ipfsnode.DAG)
104
if err != nil {
105
fmt.Fprintln(out, err)
106
continue
@@ -114,9 +114,9 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
114
}
115
case "ls":
116
for _, fn := range com.Args {
117
- nd, err := n.Resolver.ResolvePath(fn)
117
+ DAGnode, err := n.Resolver.ResolvePath(fn)
118
if err != nil {
119
- fmt.Fprintf(out, "ls: %v\n", err)
119
+ fmt.Fprintf(out, "ls error: %v\n", err)
120
return
121
}
122
@@ -126,13 +126,13 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
126
}
127
case "pin":
128
for _, fn := range com.Args {
129
- nd, err := n.Resolver.ResolvePath(fn)
129
+ DAGnode, err := Ipfsnode.Resolver.ResolvePath(fn)
130
if err != nil {
131
- fmt.Fprintf(out, "pin: %v\n", err)
131
+ fmt.Fprintf(out, "pin error: %v\n", err)
132
return
133
}
134
135
- err = n.PinDagNode(nd)
135
+ err = Ipfsnode.PinDagNode(nd)
136
if err != nil {
137
fmt.Fprintf(out, "pin: %v\n", err)
138
return
daemon/daemon_client.go
+10
-6
@@ -5,22 +5,26 @@ import (
5
"io"
6
"net"
7
"os"
8
- "time"
8
+ "time"
9
)
10
11
-func SendCommand(com *Command, server string) error {
12
- con, err := net.DialTimeout("tcp", server, time.Millisecond*300)
11
+
12
+//connects to the address on the network with a timeout and encodes the connection into JSON
13
+func SendCommand(command *Command, server string) error {
14
+
15
+ conn, err := net.DialTimeout("tcp", server, time.Millisecond*300)
16
+
17
if err != nil {
18
return err
19
}
20
17
- enc := json.NewEncoder(con)
18
- err = enc.Encode(com)
21
+ enc := json.NewEncoder(conn)
22
+ err = enc.Encode(command)
23
if err != nil {
24
return err
25
}
26
23
- io.Copy(os.Stdout, con)
27
+ io.Copy(os.Stdout, conn)
28
29
return nil
30
}