From 4f7856a4149110c4e0c8d1afe3da8ad85cd4be65 Mon Sep 17 00:00:00 2001
From: Siraj Ravel <jason.ravel@cbsinteractive.com>
Date: Wed, 10 Sep 2014 12:31:19 -0700
Subject: [PATCH] refactoring naming conventions
---
daemon/daemon.go | 56 ++++++++++++++++++++---------------------
daemon/daemon_client.go | 16 +++++++-----
2 files changed, 38 insertions(+), 34 deletions(-)
diff --git a/daemon/daemon.go b/daemon/daemon.go
index 94e519c16..0ee155ae0 100644
--- a/daemon/daemon.go
+++ b/daemon/daemon.go
@@ -21,25 +21,25 @@ type DaemonListener struct {
closed bool
}
-func NewDaemonListener(node *core.IpfsNode, addr string) (*DaemonListener, error) {
+type Command struct {
+ Command string
+ Args []string
+ Opts map[string]interface{}
+}
+
+func NewDaemonListener(Ipfsnode *core.IpfsNode, addr string) (*DaemonListener, error) {
list, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
- fmt.Println("new daemon listener.")
+ fmt.Println("New daemon listener initialized.")
return &DaemonListener{
- node: node,
+ node: Ipfsnode,
list: list,
}, nil
}
-type Command struct {
- Command string
- Args []string
- Opts map[string]interface{}
-}
-
func NewCommand() *Command {
return &Command{
Opts: make(map[string]interface{}),
@@ -49,7 +49,7 @@ func NewCommand() *Command {
func (dl *DaemonListener) Listen() {
fmt.Println("listen.")
for {
- c, err := dl.list.Accept()
+ conn, err := dl.list.Accept()
fmt.Println("Loop!")
if err != nil {
if !dl.closed {
@@ -57,27 +57,27 @@ func (dl *DaemonListener) Listen() {
}
return
}
- go dl.handleConnection(c)
+ go dl.handleConnection(conn)
}
}
-func (dl *DaemonListener) handleConnection(c net.Conn) {
- defer c.Close()
+func (dl *DaemonListener) handleConnection(conn net.Conn) {
+ defer conn.Close()
- dec := json.NewDecoder(c)
+ dec := json.NewDecoder(conn)
- var com Command
- err := dec.Decode(&com)
+ var command Command
+ err := dec.Decode(&command)
if err != nil {
- fmt.Fprintln(c, err)
+ fmt.Fprintln(conn, err)
return
}
- u.DOut("Got command: %v\n", com)
- ExecuteCommand(&com, dl.node, c)
+ u.DOut("Got command: %v\n", command)
+ ExecuteCommand(&command, dl.node, conn)
}
-func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
+func ExecuteCommand(com *Command, Ipfsnode *core.IpfsNode, out io.Writer) {
u.DOut("executing command: %s\n", com.Command)
switch com.Command {
case "add":
@@ -86,7 +86,7 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
depth = -1
}
for _, path := range com.Args {
- _, err := commands.AddPath(n, path, depth)
+ _, err := commands.AddPath(Ipfsnode, path, depth)
if err != nil {
fmt.Fprintf(out, "addFile error: %v\n", err)
continue
@@ -94,13 +94,13 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
}
case "cat":
for _, fn := range com.Args {
- nd, err := n.Resolver.ResolvePath(fn)
+ DAGnode, err := Ipfsnode.Resolver.ResolvePath(fn)
if err != nil {
fmt.Fprintf(out, "catFile error: %v\n", err)
return
}
- read, err := dag.NewDagReader(nd, n.DAG)
+ read, err := dag.NewDagReader(nd, Ipfsnode.DAG)
if err != nil {
fmt.Fprintln(out, err)
continue
@@ -114,9 +114,9 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
}
case "ls":
for _, fn := range com.Args {
- nd, err := n.Resolver.ResolvePath(fn)
+ DAGnode, err := n.Resolver.ResolvePath(fn)
if err != nil {
- fmt.Fprintf(out, "ls: %v\n", err)
+ fmt.Fprintf(out, "ls error: %v\n", err)
return
}
@@ -126,13 +126,13 @@ func ExecuteCommand(com *Command, n *core.IpfsNode, out io.Writer) {
}
case "pin":
for _, fn := range com.Args {
- nd, err := n.Resolver.ResolvePath(fn)
+ DAGnode, err := Ipfsnode.Resolver.ResolvePath(fn)
if err != nil {
- fmt.Fprintf(out, "pin: %v\n", err)
+ fmt.Fprintf(out, "pin error: %v\n", err)
return
}
- err = n.PinDagNode(nd)
+ err = Ipfsnode.PinDagNode(nd)
if err != nil {
fmt.Fprintf(out, "pin: %v\n", err)
return
diff --git a/daemon/daemon_client.go b/daemon/daemon_client.go
index 623336a99..83174076a 100644
--- a/daemon/daemon_client.go
+++ b/daemon/daemon_client.go
@@ -5,22 +5,26 @@ import (
"io"
"net"
"os"
- "time"
+ "time"
)
-func SendCommand(com *Command, server string) error {
- con, err := net.DialTimeout("tcp", server, time.Millisecond*300)
+
+//connects to the address on the network with a timeout and encodes the connection into JSON
+func SendCommand(command *Command, server string) error {
+
+ conn, err := net.DialTimeout("tcp", server, time.Millisecond*300)
+
if err != nil {
return err
}
- enc := json.NewEncoder(con)
- err = enc.Encode(com)
+ enc := json.NewEncoder(conn)
+ err = enc.Encode(command)
if err != nil {
return err
}
- io.Copy(os.Stdout, con)
+ io.Copy(os.Stdout, conn)
return nil
}
--
GitLab