util/file_reader: remove errChan

cmd/info/main.go

@@ -30,7 +30,7 @@ var Cmd = &cobra.Command{
 			return err
 		}
 		for row := range res {
-			fmt.Printf("Vertex Count: %s\n", row)
+			fmt.Printf("Vertex Count: %v\n", row.GetCount())
 		}
 
 		q = aql.E().Count()
@@ -39,7 +39,7 @@ var Cmd = &cobra.Command{
 			return err
 		}
 		for row := range res {
-			fmt.Printf("Edge Count: %s\n", row)
+			fmt.Printf("Edge Count: %v\n", row.GetCount())
 		}
 		return nil
 	},

cmd/load/main.go

@@ -91,44 +91,29 @@ var Cmd = &cobra.Command{
 
 		if vertexFile != "" {
 			log.Printf("Loading %s", vertexFile)
-			verts, errs := util.StreamVerticesFromFile(vertexFile)
-			go func(verts chan *aql.Vertex) {
-				count := 0
-				for v := range verts {
-					count++
-					if count%1000 == 0 {
-						log.Printf("Loaded %d vertices", count)
-					}
-					elemChan <- &aql.GraphElement{Graph: graph, Vertex: v}
+			count := 0
+			for v := range util.StreamVerticesFromFile(vertexFile) {
+				count++
+				if count%1000 == 0 {
+					log.Printf("Loaded %d vertices", count)
 				}
-				log.Printf("Loaded %d vertices", count)
-			}(verts)
-			go func(errs chan error) {
-				for e := range errs {
-					log.Printf("Error loading vertices: %v", e)
-				}
-			}(errs)
+				elemChan <- &aql.GraphElement{Graph: graph, Vertex: v}
+			}
+			log.Printf("Loaded %d vertices", count)
+
 		}
 
 		if edgeFile != "" {
 			log.Printf("Loading %s", edgeFile)
-			edges, errs := util.StreamEdgesFromFile(edgeFile)
-			go func(edges chan *aql.Edge) {
-				count := 0
-				for e := range edges {
-					count++
-					if count%1000 == 0 {
-						log.Printf("Loaded %d edges", count)
-					}
-					elemChan <- &aql.GraphElement{Graph: graph, Edge: e}
+			count := 0
+			for e := range util.StreamEdgesFromFile(edgeFile) {
+				count++
+				if count%1000 == 0 {
+					log.Printf("Loaded %d edges", count)
 				}
-				log.Printf("Loaded %d edges", count)
-			}(edges)
-			go func(errs chan error) {
-				for e := range errs {
-					log.Printf("Error loading vertices: %v", e)
-				}
-			}(errs)
+				elemChan <- &aql.GraphElement{Graph: graph, Edge: e}
+			}
+			log.Printf("Loaded %d edges", count)
 		}
 
 		m := jsonpb.Unmarshaler{AllowUnknownFields: true}

test/main_test.go

@@ -33,11 +33,11 @@ var edges = []*aql.Edge{}
 func init() {
 	flag.StringVar(&configFile, "config", configFile, "config file to use for tests")
 	flag.Parse()
-	vertChan, _ := util.StreamVerticesFromFile("./resources/smtest_vertices.txt")
+	vertChan := util.StreamVerticesFromFile("./resources/smtest_vertices.txt")
 	for v := range vertChan {
 		vertices = append(vertices, v)
 	}
-	edgeChan, _ := util.StreamEdgesFromFile("./resources/smtest_edges.txt")
+	edgeChan := util.StreamEdgesFromFile("./resources/smtest_edges.txt")
 	for e := range edgeChan {
 		edges = append(edges, e)
 	}

util/file_reader.go

@@ -2,27 +2,26 @@ package util
 
 import (
 	"bytes"
-	"fmt"
 	"io"
+	"log"
 
 	"github.com/bmeg/arachne/aql"
 	"github.com/bmeg/golib"
 	"github.com/golang/protobuf/jsonpb"
 )
 
 // StreamVerticesFromFile reads a file containing a vertex per line and
-// streams *aql.Vertex objects and errors out on channels
-func StreamVerticesFromFile(file string) (chan *aql.Vertex, chan error) {
-	vertChan := make(chan *aql.Vertex)
-	errChan := make(chan error)
+// streams *aql.Vertex objects out on a channel
+func StreamVerticesFromFile(file string) chan *aql.Vertex {
+	vertChan := make(chan *aql.Vertex, 100)
 
 	go func() {
 		defer close(vertChan)
-		defer close(errChan)
 
 		reader, err := golib.ReadFileLines(file)
 		if err != nil {
-			errChan <- fmt.Errorf("reading file: %v", err)
+			log.Printf("Error: reading file: %v", err)
+			return
 		}
 
 		m := jsonpb.Unmarshaler{AllowUnknownFields: true}
@@ -33,29 +32,28 @@ func StreamVerticesFromFile(file string) (chan *aql.Vertex, chan error) {
 				break
 			}
 			if err != nil {
-				errChan <- fmt.Errorf("unmarshaling vertex: %v", err)
-				continue
+				log.Printf("Error: unmarshaling vertex: %v", err)
+				return
 			}
 			vertChan <- v
 		}
 	}()
 
-	return vertChan, errChan
+	return vertChan
 }
 
 // StreamEdgesFromFile reads a file containing an edge per line and
-// streams aql.Edge objects and errors out on channels
-func StreamEdgesFromFile(file string) (chan *aql.Edge, chan error) {
-	edgeChan := make(chan *aql.Edge)
-	errChan := make(chan error)
+// streams aql.Edge objects on a channel
+func StreamEdgesFromFile(file string) chan *aql.Edge {
+	edgeChan := make(chan *aql.Edge, 100)
 
 	go func() {
 		defer close(edgeChan)
-		defer close(errChan)
 
 		reader, err := golib.ReadFileLines(file)
 		if err != nil {
-			errChan <- fmt.Errorf("reading file: %v", err)
+			log.Printf("Error: reading file: %v", err)
+			return
 		}
 
 		m := jsonpb.Unmarshaler{AllowUnknownFields: true}
@@ -66,12 +64,12 @@ func StreamEdgesFromFile(file string) (chan *aql.Edge, chan error) {
 				break
 			}
 			if err != nil {
-				errChan <- fmt.Errorf("unmarshaling edge: %v", err)
-				continue
+				log.Printf("Error: unmarshaling edge: %v", err)
+				return
 			}
 			edgeChan <- e
 		}
 	}()
 
-	return edgeChan, errChan
+	return edgeChan
 }