diff --git a/ch05/binTree.go b/ch05/binTree.go new file mode 100644 index 0000000..1d61b03 --- /dev/null +++ b/ch05/binTree.go @@ -0,0 +1,61 @@ +package main + +import ( + "fmt" + "math/rand" + "time" +) + +type Tree struct { + Left *Tree + Value int + Right *Tree +} + +func traverse(t *Tree) { + if t == nil { + return + } + traverse(t.Left) + fmt.Print(t.Value, " ") + traverse(t.Right) +} + +func create(n int) *Tree { + var t *Tree + rand.Seed(time.Now().Unix()) + for i := 0; i < 2*n; i++ { + temp := rand.Intn(n * 2) + t = insert(t, temp) + } + return t +} + +func insert(t *Tree, v int) *Tree { + if t == nil { + return &Tree{nil, v, nil} + } + + if v == t.Value { + return t + } + + if v < t.Value { + t.Left = insert(t.Left, v) + return t + } + t.Right = insert(t.Right, v) + return t +} + +func main() { + tree := create(10) + fmt.Println("The value of the root of the tree is", tree.Value) + traverse(tree) + fmt.Println() + tree = insert(tree, -10) + tree = insert(tree, -2) + traverse(tree) + fmt.Println() + fmt.Println("The value of the root of the tree is", tree.Value) +} diff --git a/ch05/conHeap.go b/ch05/conHeap.go new file mode 100644 index 0000000..6580c12 --- /dev/null +++ b/ch05/conHeap.go @@ -0,0 +1,46 @@ +package main + +import ( + "container/heap" + "fmt" +) + +type heapFloat32 []float32 + +func (n *heapFloat32) Pop() interface{} { + old := *n + x := old[len(old)-1] + new := old[0 : len(old)-1] + *n = new + return x +} + +func (n *heapFloat32) Push(x interface{}) { + *n = append(*n, x.(float32)) +} + +func (n heapFloat32) Len() int { + return len(n) +} + +func (n heapFloat32) Less(a, b int) bool { + return n[a] < n[b] +} + +func (n heapFloat32) Swap(a, b int) { + n[a], n[b] = n[b], n[a] +} + +func main() { + myHeap := &heapFloat32{1.2, 2.1, 3.1, -100.1} + heap.Init(myHeap) + size := len(*myHeap) + fmt.Printf("Heap size: %d\n", size) + fmt.Printf("%v\n", myHeap) + myHeap.Push(float32(-100.2)) + myHeap.Push(float32(0.2)) + fmt.Printf("Heap size: %d\n", len(*myHeap)) + fmt.Printf("%v\n", myHeap) + heap.Init(myHeap) + fmt.Printf("%v\n", myHeap) +} diff --git a/ch05/conList.go b/ch05/conList.go new file mode 100644 index 0000000..97a84fa --- /dev/null +++ b/ch05/conList.go @@ -0,0 +1,46 @@ +package main + +import ( + "container/list" + "fmt" + "strconv" +) + +func printList(l *list.List) { + for t := l.Back(); t != nil; t = t.Prev() { + fmt.Print(t.Value, " ") + } + fmt.Println() + + for t := l.Front(); t != nil; t = t.Next() { + fmt.Print(t.Value, " ") + } + + fmt.Println() +} + +func main() { + + values := list.New() + + e1 := values.PushBack("One") + e2 := values.PushBack("Two") + values.PushFront("Three") + values.InsertBefore("Four", e1) + values.InsertAfter("Five", e2) + values.Remove(e2) + values.Remove(e2) + values.InsertAfter("FiveFive", e2) + values.PushBackList(values) + + printList(values) + + values.Init() + fmt.Printf("After Init(): %v\n", values) + + for i := 0; i < 20; i++ { + values.PushFront(strconv.Itoa(i)) + } + + printList(values) +} diff --git a/ch05/conRing.go b/ch05/conRing.go new file mode 100644 index 0000000..d404778 --- /dev/null +++ b/ch05/conRing.go @@ -0,0 +1,33 @@ +package main + +import ( + "container/ring" + "fmt" +) + +var size int = 10 + +func main() { + myRing := ring.New(size + 1) + fmt.Println("Empty ring:", *myRing) + + for i := 0; i < myRing.Len()-1; i++ { + myRing.Value = i + myRing = myRing.Next() + } + + myRing.Value = 2 + + sum := 0 + myRing.Do(func(x interface{}) { + t := x.(int) + sum = sum + t + }) + fmt.Println("Sum:", sum) + + for i := 0; i < myRing.Len()+2; i++ { + myRing = myRing.Next() + fmt.Print(myRing.Value, " ") + } + fmt.Println() +} diff --git a/ch05/doublyLList.go b/ch05/doublyLList.go new file mode 100644 index 0000000..898ea94 --- /dev/null +++ b/ch05/doublyLList.go @@ -0,0 +1,115 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Previous *Node + Next *Node +} + +func addNode(t *Node, v int) int { + if root == nil { + t = &Node{v, nil, nil} + root = t + return 0 + } + + if v == t.Value { + fmt.Println("Node already exists:", v) + return -1 + } + + if t.Next == nil { + temp := t + t.Next = &Node{v, temp, nil} + return -2 + } + + return addNode(t.Next, v) +} + +func traverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func reverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + temp := t + for t != nil { + temp = t + t = t.Next + } + + for temp.Previous != nil { + fmt.Printf("%d -> ", temp.Value) + temp = temp.Previous + } + fmt.Printf("%d -> ", temp.Value) + fmt.Println() +} + +func size(t *Node) int { + if t == nil { + fmt.Println("-> Empty list!") + return 0 + } + + n := 0 + for t != nil { + n++ + t = t.Next + } + return n +} + +func lookupNode(t *Node, v int) bool { + if root == nil { + return false + } + + if v == t.Value { + return true + } + + if t.Next == nil { + return false + } + + return lookupNode(t.Next, v) +} + +var root = new(Node) + +func main() { + fmt.Println(root) + root = nil + traverse(root) + addNode(root, 1) + addNode(root, 1) + traverse(root) + addNode(root, 10) + addNode(root, 5) + addNode(root, 0) + addNode(root, 0) + traverse(root) + addNode(root, 100) + fmt.Println("Size:", size(root)) + traverse(root) + reverse(root) +} diff --git a/ch05/generatePassword.go b/ch05/generatePassword.go new file mode 100644 index 0000000..251488c --- /dev/null +++ b/ch05/generatePassword.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func main() { + MIN := 0 + MAX := 94 + SEED := time.Now().Unix() + var LENGTH int64 = 8 + + arguments := os.Args + switch len(arguments) { + case 2: + LENGTH, _ = strconv.ParseInt(os.Args[1], 10, 64) + default: + fmt.Println("Using default values!") + } + + rand.Seed(SEED) + + startChar := "!" + var i int64 = 1 + for { + myRand := random(MIN, MAX) + newChar := string(startChar[0] + byte(myRand)) + fmt.Print(newChar) + if i == LENGTH { + break + } + i++ + } + fmt.Println() +} diff --git a/ch05/hashTable.go b/ch05/hashTable.go new file mode 100644 index 0000000..a004036 --- /dev/null +++ b/ch05/hashTable.go @@ -0,0 +1,51 @@ +package main + +import ( + "fmt" +) + +const SIZE = 15 + +type Node struct { + Value int + Next *Node +} + +type HashTable struct { + Table map[int]*Node + Size int +} + +func hashFunction(i, size int) int { + return (i % size) +} + +func insert(hash *HashTable, value int) int { + index := hashFunction(value, hash.Size) + element := Node{Value: value, Next: hash.Table[index]} + hash.Table[index] = &element + return index +} + +func traverse(hash *HashTable) { + for k := range hash.Table { + if hash.Table[k] != nil { + t := hash.Table[k] + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() + } + } +} + +func main() { + table := make(map[int]*Node, SIZE) + hash := &HashTable{Table: table, Size: SIZE} + fmt.Println("Number of spaces:", hash.Size) + for i := 0; i < 120; i++ { + insert(hash, i) + } + traverse(hash) +} diff --git a/ch05/hashTableLookup.go b/ch05/hashTableLookup.go new file mode 100644 index 0000000..944fda2 --- /dev/null +++ b/ch05/hashTableLookup.go @@ -0,0 +1,69 @@ +package main + +import ( + "fmt" +) + +const SIZE = 15 + +type Node struct { + Value int + Next *Node +} + +type HashTable struct { + Table map[int]*Node + Size int +} + +func hashFunction(i, size int) int { + return (i % size) +} + +func insert(hash *HashTable, value int) int { + index := hashFunction(value, hash.Size) + element := Node{Value: value, Next: hash.Table[index]} + hash.Table[index] = &element + return index +} + +func traverse(hash *HashTable) { + for k := range hash.Table { + if hash.Table[k] != nil { + t := hash.Table[k] + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() + } + } +} + +func lookup(hash *HashTable, value int) bool { + index := hashFunction(value, hash.Size) + if hash.Table[index] != nil { + t := hash.Table[index] + for t != nil { + if t.Value == value { + return true + } + t = t.Next + } + } + return false +} + +func main() { + table := make(map[int]*Node, SIZE) + hash := &HashTable{Table: table, Size: SIZE} + for i := 0; i < 120; i++ { + insert(hash, i) + } + + for i := 10; i < 125; i++ { + if !lookup(hash, i) { + fmt.Println(i, "is not in the hash table!") + } + } +} diff --git a/ch05/linkedList.go b/ch05/linkedList.go new file mode 100644 index 0000000..f8a3a19 --- /dev/null +++ b/ch05/linkedList.go @@ -0,0 +1,106 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var root = new(Node) + +func addNode(t *Node, v int) int { + if root == nil { + t = &Node{v, nil} + root = t + return 0 + } + + if v == t.Value { + fmt.Println("Node already exists:", v) + return -1 + } + + if t.Next == nil { + t.Next = &Node{v, nil} + return -2 + } + + return addNode(t.Next, v) +} + +func traverse(t *Node) { + if t == nil { + fmt.Println("-> Empty list!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func lookupNode(t *Node, v int) bool { + if root == nil { + t = &Node{v, nil} + root = t + return false + } + + if v == t.Value { + return true + } + + if t.Next == nil { + return false + } + + return lookupNode(t.Next, v) +} + +func size(t *Node) int { + if t == nil { + fmt.Println("-> Empty list!") + return 0 + } + + i := 0 + for t != nil { + i++ + t = t.Next + } + return i +} + +func main() { + fmt.Println(root) + root = nil + traverse(root) + addNode(root, 1) + addNode(root, -1) + traverse(root) + addNode(root, 10) + addNode(root, 5) + addNode(root, 45) + addNode(root, 5) + addNode(root, 5) + traverse(root) + addNode(root, 100) + traverse(root) + + if lookupNode(root, 100) { + fmt.Println("Node exists!") + } else { + fmt.Println("Node does not exist!") + } + + if lookupNode(root, -100) { + fmt.Println("Node exists!") + } else { + fmt.Println("Node does not exist!") + } +} diff --git a/ch05/queue.go b/ch05/queue.go new file mode 100644 index 0000000..074887f --- /dev/null +++ b/ch05/queue.go @@ -0,0 +1,97 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var size = 0 +var queue = new(Node) + +func Push(t *Node, v int) bool { + if queue == nil { + queue = &Node{v, nil} + size++ + return true + } + + t = &Node{v, nil} + t.Next = queue + queue = t + size++ + + return true +} + +func Pop(t *Node) (int, bool) { + if size == 0 { + return 0, false + } + + if size == 1 { + queue = nil + size-- + return t.Value, true + } + + temp := t + for (t.Next) != nil { + temp = t + t = t.Next + } + + v := (temp.Next).Value + temp.Next = nil + + size-- + return v, true +} + +func traverse(t *Node) { + if size == 0 { + fmt.Println("Empty Queue!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func main() { + queue = nil + Push(queue, 10) + fmt.Println("Size:", size) + traverse(queue) + + v, b := Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + + for i := 0; i < 5; i++ { + Push(queue, i) + } + traverse(queue) + fmt.Println("Size:", size) + + v, b = Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + + v, b = Pop(queue) + if b { + fmt.Println("Pop:", v) + } + fmt.Println("Size:", size) + traverse(queue) +} diff --git a/ch05/randomNumbers.go b/ch05/randomNumbers.go new file mode 100644 index 0000000..0c2d349 --- /dev/null +++ b/ch05/randomNumbers.go @@ -0,0 +1,52 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func main() { + MIN := 0 + MAX := 100 + TOTAL := 100 + SEED := time.Now().Unix() + + arguments := os.Args + switch len(arguments) { + case 2: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX = MIN + 100 + case 3: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + case 4: + fmt.Println("Usage: ./randomNumbers MIN MAX TOTAL SEED") + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + TOTAL, _ = strconv.Atoi(arguments[3]) + case 5: + MIN, _ = strconv.Atoi(arguments[1]) + MAX, _ = strconv.Atoi(arguments[2]) + TOTAL, _ = strconv.Atoi(arguments[3]) + SEED, _ = strconv.ParseInt(arguments[4], 10, 64) + default: + fmt.Println("Using default values!") + } + + rand.Seed(SEED) + for i := 0; i < TOTAL; i++ { + myrand := random(MIN, MAX) + fmt.Print(myrand) + fmt.Print(" ") + } + fmt.Println() +} diff --git a/ch05/stack.go b/ch05/stack.go new file mode 100644 index 0000000..8fa4ae0 --- /dev/null +++ b/ch05/stack.go @@ -0,0 +1,87 @@ +package main + +import ( + "fmt" +) + +type Node struct { + Value int + Next *Node +} + +var size = 0 +var stack = new(Node) + +func Push(v int) bool { + if stack == nil { + stack = &Node{v, nil} + size = 1 + return true + } + + temp := &Node{v, nil} + temp.Next = stack + stack = temp + size++ + return true +} + +func Pop(t *Node) (int, bool) { + if size == 0 { + return 0, false + } + + if size == 1 { + size = 0 + stack = nil + return t.Value, true + } + + stack = stack.Next + size-- + return t.Value, true +} + +func traverse(t *Node) { + if size == 0 { + fmt.Println("Empty Stack!") + return + } + + for t != nil { + fmt.Printf("%d -> ", t.Value) + t = t.Next + } + fmt.Println() +} + +func main() { + + stack = nil + v, b := Pop(stack) + if b { + fmt.Print(v, " ") + } else { + fmt.Println("Pop() failed!") + } + + Push(100) + traverse(stack) + Push(200) + traverse(stack) + + for i := 0; i < 10; i++ { + Push(i) + } + + for i := 0; i < 15; i++ { + v, b := Pop(stack) + if b { + fmt.Print(v, " ") + } else { + break + } + } + fmt.Println() + traverse(stack) +} diff --git a/ch06/a.go b/ch06/a.go new file mode 100644 index 0000000..5022e56 --- /dev/null +++ b/ch06/a.go @@ -0,0 +1,13 @@ +package a + +import ( + "fmt" +) + +func init() { + fmt.Println("init() a") +} + +func FromA() { + fmt.Println("fromA()") +} diff --git a/ch06/aPackage.go b/ch06/aPackage.go new file mode 100644 index 0000000..74de426 --- /dev/null +++ b/ch06/aPackage.go @@ -0,0 +1,16 @@ +package aPackage + +import ( + "fmt" +) + +func A() { + fmt.Println("This is function A!") +} + +func B() { + fmt.Println("privateConstant:", privateConstant) +} + +const MyConstant = 123 +const privateConstant = 21 diff --git a/ch06/b.go b/ch06/b.go new file mode 100644 index 0000000..37f2b9a --- /dev/null +++ b/ch06/b.go @@ -0,0 +1,15 @@ +package b + +import ( + "a" + "fmt" +) + +func init() { + fmt.Println("init() b") +} + +func FromB() { + fmt.Println("fromB()") + a.FromA() +} diff --git a/ch06/funFun.go b/ch06/funFun.go new file mode 100644 index 0000000..9db0558 --- /dev/null +++ b/ch06/funFun.go @@ -0,0 +1,21 @@ +package main + +import "fmt" + +func function1(i int) int { + return i + i +} + +func function2(i int) int { + return i * i +} + +func funFun(f func(int) int, v int) int { + return f(v) +} + +func main() { + fmt.Println("function1:", funFun(function1, 123)) + fmt.Println("function2:", funFun(function2, 123)) + fmt.Println("Inline", funFun(func(i int) int { return i * i * i }, 123)) +} diff --git a/ch06/functions.go b/ch06/functions.go new file mode 100644 index 0000000..9465377 --- /dev/null +++ b/ch06/functions.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "os" + "strconv" +) + +func doubleSquare(x int) (int, int) { + return x * 2, x * x +} + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("The program needs 1 argument!") + return + } + + y, err := strconv.Atoi(arguments[1]) + if err != nil { + fmt.Println(err) + return + } + + square := func(s int) int { + return s * s + } + fmt.Println("The square of", y, "is", square(y)) + + double := func(s int) int { + return s + s + } + fmt.Println("The double of", y, "is", double(y)) + + fmt.Println(doubleSquare(y)) + d, s := doubleSquare(y) + fmt.Println(d, s) +} diff --git a/ch06/html.gohtml b/ch06/html.gohtml new file mode 100644 index 0000000..048018b --- /dev/null +++ b/ch06/html.gohtml @@ -0,0 +1,38 @@ + + + + + Doing Maths in Go! + + + + + + + + + + + + + + +{{ range . }} + + + + + +{{ end }} + +
NumberDoubleSquare
{{ .Number }} {{ .Double }} {{ .Square }}
+ + + diff --git a/ch06/htmlT.db b/ch06/htmlT.db new file mode 100644 index 0000000..1ff8878 Binary files /dev/null and b/ch06/htmlT.db differ diff --git a/ch06/htmlT.go b/ch06/htmlT.go new file mode 100644 index 0000000..2b00789 --- /dev/null +++ b/ch06/htmlT.go @@ -0,0 +1,77 @@ +package main + +import ( + "database/sql" + "fmt" + _ "github.com/mattn/go-sqlite3" + "html/template" + "net/http" + "os" +) + +type Entry struct { + Number int + Double int + Square int +} + +var DATA []Entry +var tFile string + +func myHandler(w http.ResponseWriter, r *http.Request) { + fmt.Printf("Host: %s Path: %s\n", r.Host, r.URL.Path) + myT := template.Must(template.ParseGlob(tFile)) + myT.ExecuteTemplate(w, tFile, DATA) +} + +func main() { + arguments := os.Args + if len(arguments) != 3 { + fmt.Println("Need Database File + Template File!") + return + } + + database := arguments[1] + tFile = arguments[2] + + db, err := sql.Open("sqlite3", database) + if err != nil { + fmt.Println(nil) + return + } + + fmt.Println("Emptying database table.") + _, err = db.Exec("DELETE FROM data") + if err != nil { + fmt.Println(nil) + return + } + + fmt.Println("Populating", database) + stmt, _ := db.Prepare("INSERT INTO data(number, double, square) values(?,?,?)") + for i := 20; i < 50; i++ { + _, _ = stmt.Exec(i, 2*i, i*i) + } + + rows, err := db.Query("SELECT * FROM data") + if err != nil { + fmt.Println(nil) + return + } + + var n int + var d int + var s int + for rows.Next() { + err = rows.Scan(&n, &d, &s) + temp := Entry{Number: n, Double: d, Square: s} + DATA = append(DATA, temp) + } + + http.HandleFunc("/", myHandler) + err = http.ListenAndServe(":8080", nil) + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch06/manyInit.go b/ch06/manyInit.go new file mode 100644 index 0000000..940641c --- /dev/null +++ b/ch06/manyInit.go @@ -0,0 +1,16 @@ +package main + +import ( + "a" + "b" + "fmt" +) + +func init() { + fmt.Println("init() manyInit") +} + +func main() { + a.FromA() + b.FromB() +} diff --git a/ch06/ptrFun.go b/ch06/ptrFun.go new file mode 100644 index 0000000..93a90ee --- /dev/null +++ b/ch06/ptrFun.go @@ -0,0 +1,16 @@ +package main + +import ( + "fmt" +) + +func getPtr(v *float64) float64 { + return *v * *v +} + +func main() { + x := 12.2 + fmt.Println(getPtr(&x)) + x = 12 + fmt.Println(getPtr(&x)) +} diff --git a/ch06/returnFunction.go b/ch06/returnFunction.go new file mode 100644 index 0000000..dcf5a02 --- /dev/null +++ b/ch06/returnFunction.go @@ -0,0 +1,24 @@ +package main + +import ( + "fmt" +) + +func funReturnFun() func() int { + i := 0 + return func() int { + i++ + return i * i + } +} + +func main() { + i := funReturnFun() + j := funReturnFun() + + fmt.Println("1:", i()) + fmt.Println("2:", i()) + fmt.Println("j1:", j()) + fmt.Println("j2:", j()) + fmt.Println("3:", i()) +} diff --git a/ch06/returnNames.go b/ch06/returnNames.go new file mode 100644 index 0000000..d894593 --- /dev/null +++ b/ch06/returnNames.go @@ -0,0 +1,48 @@ +package main + +import ( + "fmt" + "os" + "strconv" +) + +func namedMinMax(x, y int) (min, max int) { + if x > y { + min = y + max = x + } else { + min = x + max = y + } + return +} + +func minMax(x, y int) (min, max int) { + if x > y { + min = y + max = x + } else { + min = x + max = y + } + return min, max +} + +func main() { + arguments := os.Args + if len(arguments) < 3 { + fmt.Println("The program needs at least 2 arguments!") + return + } + + a1, _ := strconv.Atoi(arguments[1]) + a2, _ := strconv.Atoi(arguments[2]) + + fmt.Println(minMax(a1, a2)) + min, max := minMax(a1, a2) + fmt.Println(min, max) + + fmt.Println(namedMinMax(a1, a2)) + min, max = namedMinMax(a1, a2) + fmt.Println(min, max) +} diff --git a/ch06/returnPtr.go b/ch06/returnPtr.go new file mode 100644 index 0000000..ce676be --- /dev/null +++ b/ch06/returnPtr.go @@ -0,0 +1,17 @@ +package main + +import ( + "fmt" +) + +func returnPtr(x int) *int { + y := x * x + return &y +} + +func main() { + sq := returnPtr(10) + fmt.Println("sq:", *sq) + + fmt.Println("sq:", sq) +} diff --git a/ch06/text.gotext b/ch06/text.gotext new file mode 100644 index 0000000..2977dac --- /dev/null +++ b/ch06/text.gotext @@ -0,0 +1,4 @@ +Calculating the squares of some integers + +{{ range . }} The square of {{ printf "%d" .Number}} is {{ printf "%d" .Square}} +{{ end }} diff --git a/ch06/textT.go b/ch06/textT.go new file mode 100644 index 0000000..4622b51 --- /dev/null +++ b/ch06/textT.go @@ -0,0 +1,34 @@ +package main + +import ( + "fmt" + "os" + "text/template" +) + +type Entry struct { + Number int + Square int +} + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("Need the template file!") + return + } + + tFile := arguments[1] + DATA := [][]int{{-1, 1}, {-2, 4}, {-3, 9}, {-4, 16}} + var Entries []Entry + + for _, i := range DATA { + if len(i) == 2 { + temp := Entry{Number: i[0], Square: i[1]} + Entries = append(Entries, temp) + } + } + + t := template.Must(template.ParseGlob(tFile)) + t.Execute(os.Stdout, Entries) +} diff --git a/ch06/useAPackage.go b/ch06/useAPackage.go new file mode 100644 index 0000000..f21815e --- /dev/null +++ b/ch06/useAPackage.go @@ -0,0 +1,13 @@ +package main + +import ( + "aPackage" + "fmt" +) + +func main() { + fmt.Println("Using aPackage!") + aPackage.A() + aPackage.B() + fmt.Println(aPackage.MyConstant) +} diff --git a/ch06/useSyscall.go b/ch06/useSyscall.go new file mode 100644 index 0000000..f631982 --- /dev/null +++ b/ch06/useSyscall.go @@ -0,0 +1,23 @@ +package main + +import ( + "fmt" + "os" + "syscall" +) + +func main() { + pid, _, _ := syscall.Syscall(39, 0, 0, 0) + fmt.Println("My pid is", pid) + uid, _, _ := syscall.Syscall(24, 0, 0, 0) + fmt.Println("User ID:", uid) + + message := []byte{'H', 'e', 'l', 'l', 'o', '!', '\n'} + fd := 1 + syscall.Write(fd, message) + + fmt.Println("Using syscall.Exec()") + command := "/bin/ls" + env := os.Environ() + syscall.Exec(command, []string{"ls", "-a", "-x"}, env) +} diff --git a/ch07/advRefl.go b/ch07/advRefl.go new file mode 100644 index 0000000..40a8cfb --- /dev/null +++ b/ch07/advRefl.go @@ -0,0 +1,64 @@ +package main + +import ( + "fmt" + "os" + "reflect" +) + +type t1 int +type t2 int + +type a struct { + X int + Y float64 + Text string +} + +func (a1 a) compareStruct(a2 a) bool { + r1 := reflect.ValueOf(&a1).Elem() + r2 := reflect.ValueOf(&a2).Elem() + + for i := 0; i < r1.NumField(); i++ { + if r1.Field(i).Interface() != r2.Field(i).Interface() { + return false + } + } + return true +} + +func printMethods(i interface{}) { + r := reflect.ValueOf(i) + t := r.Type() + fmt.Printf("Type to examine: %s\n", t) + + for j := 0; j < r.NumMethod(); j++ { + m := r.Method(j).Type() + fmt.Println(t.Method(j).Name, "-->", m) + } +} + +func main() { + x1 := t1(100) + x2 := t2(100) + fmt.Printf("The type of x1 is %s\n", reflect.TypeOf(x1)) + fmt.Printf("The type of x2 is %s\n", reflect.TypeOf(x2)) + + var p struct{} + r := reflect.New(reflect.ValueOf(&p).Type()).Elem() + fmt.Printf("The type of r is %s\n", reflect.TypeOf(r)) + + a1 := a{1, 2.1, "A1"} + a2 := a{1, -2, "A2"} + + if a1.compareStruct(a1) { + fmt.Println("Equal!") + } + + if !a1.compareStruct(a2) { + fmt.Println("Not Equal!") + } + + var f *os.File + printMethods(f) +} diff --git a/ch07/assertion.go b/ch07/assertion.go new file mode 100644 index 0000000..f0b453d --- /dev/null +++ b/ch07/assertion.go @@ -0,0 +1,27 @@ +package main + +import ( + "fmt" +) + +func main() { + var myInt interface{} = 123 + + k, ok := myInt.(int) + if ok { + fmt.Println("Success:", k) + } + + v, ok := myInt.(float64) + if ok { + fmt.Println(v) + } else { + fmt.Println("Failed without panicking!") + } + + i := myInt.(int) + fmt.Println("No cheking:", i) + + j := myInt.(bool) + fmt.Println(j) +} diff --git a/ch07/goCoIn.go b/ch07/goCoIn.go new file mode 100644 index 0000000..486ee8a --- /dev/null +++ b/ch07/goCoIn.go @@ -0,0 +1,33 @@ +package main + +import ( + "fmt" +) + +type first struct{} + +func (a first) F() { + a.shared() +} + +func (a first) shared() { + fmt.Println("This is shared() from first!") +} + +type second struct { + first +} + +func (a second) shared() { + fmt.Println("This is shared() from second!") +} + +func main() { + first{}.F() + second{}.shared() + i := second{} + j := i.first + j.F() + // (i.first).F() + // (second{}.first).F() +} diff --git a/ch07/methods.go b/ch07/methods.go new file mode 100644 index 0000000..a0b6dc3 --- /dev/null +++ b/ch07/methods.go @@ -0,0 +1,27 @@ +package main + +import ( + "fmt" +) + +type twoInts struct { + X int64 + Y int64 +} + +func regularFunction(a, b twoInts) twoInts { + temp := twoInts{X: a.X + b.X, Y: a.Y + b.Y} + return temp +} + +func (a twoInts) method(b twoInts) twoInts { + temp := twoInts{X: a.X + b.X, Y: a.Y + b.Y} + return temp +} + +func main() { + i := twoInts{X: 1, Y: 2} + j := twoInts{X: -5, Y: -2} + fmt.Println(regularFunction(i, j)) + fmt.Println(i.method(j)) +} diff --git a/ch07/myInterface.go b/ch07/myInterface.go new file mode 100644 index 0000000..3aabc92 --- /dev/null +++ b/ch07/myInterface.go @@ -0,0 +1,6 @@ +package myInterface + +type Shape interface { + Area() float64 + Perimeter() float64 +} diff --git a/ch07/ooo.go b/ch07/ooo.go new file mode 100644 index 0000000..f774517 --- /dev/null +++ b/ch07/ooo.go @@ -0,0 +1,34 @@ +package main + +import ( + "fmt" +) + +type a struct { + XX int + YY int +} + +type b struct { + AA string + XX int +} + +type c struct { + A a + B b +} + +func (A a) A() { + fmt.Println("Function A() for A") +} + +func (B b) A() { + fmt.Println("Function A() for B") +} + +func main() { + var i c + i.A.A() + i.B.A() +} diff --git a/ch07/reflection.go b/ch07/reflection.go new file mode 100644 index 0000000..fc71634 --- /dev/null +++ b/ch07/reflection.go @@ -0,0 +1,49 @@ +package main + +import ( + "fmt" + "os" + "reflect" +) + +type a struct { + X int + Y float64 + Z string +} + +type b struct { + F int + G int + H string + I float64 +} + +func main() { + x := 100 + xRefl := reflect.ValueOf(&x).Elem() + xType := xRefl.Type() + fmt.Printf("The type of x is %s.\n", xType) + // fmt.Printf("The type of x is %s.\n", reflect.TypeOf(x)) + + A := a{100, 200.12, "Struct a"} + B := b{1, 2, "Struct b", -1.2} + var r reflect.Value + + arguments := os.Args + if len(arguments) == 1 { + r = reflect.ValueOf(&A).Elem() + } else { + r = reflect.ValueOf(&B).Elem() + } + + iType := r.Type() + fmt.Printf("i Type: %s\n", iType) + fmt.Printf("The %d fields of %s are:\n", r.NumField(), iType) + + for i := 0; i < r.NumField(); i++ { + fmt.Printf("Field name: %s ", iType.Field(i).Name) + fmt.Printf("with type: %s ", r.Field(i).Type()) + fmt.Printf("and value %v\n", r.Field(i).Interface()) + } +} diff --git a/ch07/switch.go b/ch07/switch.go new file mode 100644 index 0000000..a8fde96 --- /dev/null +++ b/ch07/switch.go @@ -0,0 +1,41 @@ +package main + +import ( + "fmt" +) + +type square struct { + X float64 +} + +type circle struct { + R float64 +} + +type rectangle struct { + X float64 + Y float64 +} + +func tellInterface(x interface{}) { + switch v := x.(type) { + case square: + fmt.Println("This is a square!") + case circle: + fmt.Printf("%v is a circle!\n", v) + case rectangle: + fmt.Println("This is a rectangle!") + default: + fmt.Printf("Unknown type %T!\n", v) + } +} + +func main() { + x := circle{R: 10} + tellInterface(x) + y := rectangle{X: 4, Y: 1} + tellInterface(y) + z := square{X: 4} + tellInterface(z) + tellInterface(10) +} diff --git a/ch07/useInterface.go b/ch07/useInterface.go new file mode 100644 index 0000000..d2a1677 --- /dev/null +++ b/ch07/useInterface.go @@ -0,0 +1,54 @@ +package main + +import ( + "fmt" + "math" + "myInterface" +) + +type square struct { + X float64 +} + +type circle struct { + R float64 +} + +func (s square) Area() float64 { + return s.X * s.X +} + +func (s square) Perimeter() float64 { + return 4 * s.X +} + +func (s circle) Area() float64 { + return s.R * s.R * math.Pi +} + +func (s circle) Perimeter() float64 { + return 2 * s.R * math.Pi +} + +func Calculate(x myInterface.Shape) { + _, ok := x.(circle) + if ok { + fmt.Println("Is a circle!") + } + + v, ok := x.(square) + if ok { + fmt.Println("Is a square:", v) + } + + fmt.Println(x.Area()) + fmt.Println(x.Perimeter()) +} + +func main() { + x := square{X: 10} + fmt.Println("Perimeter:", x.Perimeter()) + Calculate(x) + y := circle{R: 5} + Calculate(y) +} diff --git a/ch08/CSVplot.go b/ch08/CSVplot.go new file mode 100644 index 0000000..cc39106 --- /dev/null +++ b/ch08/CSVplot.go @@ -0,0 +1,65 @@ +package main + +import ( + "encoding/csv" + "fmt" + "github.com/Arafatk/glot" + "os" + "strconv" +) + +func main() { + if len(os.Args) != 2 { + fmt.Println("Need a data file!") + return + } + + file := os.Args[1] + _, err := os.Stat(file) + if err != nil { + fmt.Println("Cannot stat", file) + return + } + + f, err := os.Open(file) + if err != nil { + fmt.Println("Cannot open", file) + fmt.Println(err) + return + } + defer f.Close() + + reader := csv.NewReader(f) + reader.FieldsPerRecord = -1 + allRecords, err := reader.ReadAll() + if err != nil { + fmt.Println(err) + return + } + + xP := []float64{} + yP := []float64{} + for _, rec := range allRecords { + x, _ := strconv.ParseFloat(rec[0], 64) + y, _ := strconv.ParseFloat(rec[1], 64) + xP = append(xP, x) + yP = append(yP, y) + } + + points := [][]float64{} + points = append(points, xP) + points = append(points, yP) + fmt.Println(points) + + dimensions := 2 + persist := true + debug := false + plot, _ := glot.NewPlot(dimensions, persist, debug) + + plot.SetTitle("Using Glot with CSV data") + plot.SetXLabel("X-Axis") + plot.SetYLabel("Y-Axis") + style := "circle" + plot.AddPointGroup("Circle:", style, points) + plot.SavePlot("output.png") +} diff --git a/ch08/SYSCALLS b/ch08/SYSCALLS new file mode 100644 index 0000000..5db7dee --- /dev/null +++ b/ch08/SYSCALLS @@ -0,0 +1,303 @@ + SYS_READ = 0 + SYS_WRITE = 1 + SYS_OPEN = 2 + SYS_CLOSE = 3 + SYS_STAT = 4 + SYS_FSTAT = 5 + SYS_LSTAT = 6 + SYS_POLL = 7 + SYS_LSEEK = 8 + SYS_MMAP = 9 + SYS_MPROTECT = 10 + SYS_MUNMAP = 11 + SYS_BRK = 12 + SYS_RT_SIGACTION = 13 + SYS_RT_SIGPROCMASK = 14 + SYS_RT_SIGRETURN = 15 + SYS_IOCTL = 16 + SYS_PREAD64 = 17 + SYS_PWRITE64 = 18 + SYS_READV = 19 + SYS_WRITEV = 20 + SYS_ACCESS = 21 + SYS_PIPE = 22 + SYS_SELECT = 23 + SYS_SCHED_YIELD = 24 + SYS_MREMAP = 25 + SYS_MSYNC = 26 + SYS_MINCORE = 27 + SYS_MADVISE = 28 + SYS_SHMGET = 29 + SYS_SHMAT = 30 + SYS_SHMCTL = 31 + SYS_DUP = 32 + SYS_DUP2 = 33 + SYS_PAUSE = 34 + SYS_NANOSLEEP = 35 + SYS_GETITIMER = 36 + SYS_ALARM = 37 + SYS_SETITIMER = 38 + SYS_GETPID = 39 + SYS_SENDFILE = 40 + SYS_SOCKET = 41 + SYS_CONNECT = 42 + SYS_ACCEPT = 43 + SYS_SENDTO = 44 + SYS_RECVFROM = 45 + SYS_SENDMSG = 46 + SYS_RECVMSG = 47 + SYS_SHUTDOWN = 48 + SYS_BIND = 49 + SYS_LISTEN = 50 + SYS_GETSOCKNAME = 51 + SYS_GETPEERNAME = 52 + SYS_SOCKETPAIR = 53 + SYS_SETSOCKOPT = 54 + SYS_GETSOCKOPT = 55 + SYS_CLONE = 56 + SYS_FORK = 57 + SYS_VFORK = 58 + SYS_EXECVE = 59 + SYS_EXIT = 60 + SYS_WAIT4 = 61 + SYS_KILL = 62 + SYS_UNAME = 63 + SYS_SEMGET = 64 + SYS_SEMOP = 65 + SYS_SEMCTL = 66 + SYS_SHMDT = 67 + SYS_MSGGET = 68 + SYS_MSGSND = 69 + SYS_MSGRCV = 70 + SYS_MSGCTL = 71 + SYS_FCNTL = 72 + SYS_FLOCK = 73 + SYS_FSYNC = 74 + SYS_FDATASYNC = 75 + SYS_TRUNCATE = 76 + SYS_FTRUNCATE = 77 + SYS_GETDENTS = 78 + SYS_GETCWD = 79 + SYS_CHDIR = 80 + SYS_FCHDIR = 81 + SYS_RENAME = 82 + SYS_MKDIR = 83 + SYS_RMDIR = 84 + SYS_CREAT = 85 + SYS_LINK = 86 + SYS_UNLINK = 87 + SYS_SYMLINK = 88 + SYS_READLINK = 89 + SYS_CHMOD = 90 + SYS_FCHMOD = 91 + SYS_CHOWN = 92 + SYS_FCHOWN = 93 + SYS_LCHOWN = 94 + SYS_UMASK = 95 + SYS_GETTIMEOFDAY = 96 + SYS_GETRLIMIT = 97 + SYS_GETRUSAGE = 98 + SYS_SYSINFO = 99 + SYS_TIMES = 100 + SYS_PTRACE = 101 + SYS_GETUID = 102 + SYS_SYSLOG = 103 + SYS_GETGID = 104 + SYS_SETUID = 105 + SYS_SETGID = 106 + SYS_GETEUID = 107 + SYS_GETEGID = 108 + SYS_SETPGID = 109 + SYS_GETPPID = 110 + SYS_GETPGRP = 111 + SYS_SETSID = 112 + SYS_SETREUID = 113 + SYS_SETREGID = 114 + SYS_GETGROUPS = 115 + SYS_SETGROUPS = 116 + SYS_SETRESUID = 117 + SYS_GETRESUID = 118 + SYS_SETRESGID = 119 + SYS_GETRESGID = 120 + SYS_GETPGID = 121 + SYS_SETFSUID = 122 + SYS_SETFSGID = 123 + SYS_GETSID = 124 + SYS_CAPGET = 125 + SYS_CAPSET = 126 + SYS_RT_SIGPENDING = 127 + SYS_RT_SIGTIMEDWAIT = 128 + SYS_RT_SIGQUEUEINFO = 129 + SYS_RT_SIGSUSPEND = 130 + SYS_SIGALTSTACK = 131 + SYS_UTIME = 132 + SYS_MKNOD = 133 + SYS_USELIB = 134 + SYS_PERSONALITY = 135 + SYS_USTAT = 136 + SYS_STATFS = 137 + SYS_FSTATFS = 138 + SYS_SYSFS = 139 + SYS_GETPRIORITY = 140 + SYS_SETPRIORITY = 141 + SYS_SCHED_SETPARAM = 142 + SYS_SCHED_GETPARAM = 143 + SYS_SCHED_SETSCHEDULER = 144 + SYS_SCHED_GETSCHEDULER = 145 + SYS_SCHED_GET_PRIORITY_MAX = 146 + SYS_SCHED_GET_PRIORITY_MIN = 147 + SYS_SCHED_RR_GET_INTERVAL = 148 + SYS_MLOCK = 149 + SYS_MUNLOCK = 150 + SYS_MLOCKALL = 151 + SYS_MUNLOCKALL = 152 + SYS_VHANGUP = 153 + SYS_MODIFY_LDT = 154 + SYS_PIVOT_ROOT = 155 + SYS__SYSCTL = 156 + SYS_PRCTL = 157 + SYS_ARCH_PRCTL = 158 + SYS_ADJTIMEX = 159 + SYS_SETRLIMIT = 160 + SYS_CHROOT = 161 + SYS_SYNC = 162 + SYS_ACCT = 163 + SYS_SETTIMEOFDAY = 164 + SYS_MOUNT = 165 + SYS_UMOUNT2 = 166 + SYS_SWAPON = 167 + SYS_SWAPOFF = 168 + SYS_REBOOT = 169 + SYS_SETHOSTNAME = 170 + SYS_SETDOMAINNAME = 171 + SYS_IOPL = 172 + SYS_IOPERM = 173 + SYS_CREATE_MODULE = 174 + SYS_INIT_MODULE = 175 + SYS_DELETE_MODULE = 176 + SYS_GET_KERNEL_SYMS = 177 + SYS_QUERY_MODULE = 178 + SYS_QUOTACTL = 179 + SYS_NFSSERVCTL = 180 + SYS_GETPMSG = 181 + SYS_PUTPMSG = 182 + SYS_AFS_SYSCALL = 183 + SYS_TUXCALL = 184 + SYS_SECURITY = 185 + SYS_GETTID = 186 + SYS_READAHEAD = 187 + SYS_SETXATTR = 188 + SYS_LSETXATTR = 189 + SYS_FSETXATTR = 190 + SYS_GETXATTR = 191 + SYS_LGETXATTR = 192 + SYS_FGETXATTR = 193 + SYS_LISTXATTR = 194 + SYS_LLISTXATTR = 195 + SYS_FLISTXATTR = 196 + SYS_REMOVEXATTR = 197 + SYS_LREMOVEXATTR = 198 + SYS_FREMOVEXATTR = 199 + SYS_TKILL = 200 + SYS_TIME = 201 + SYS_FUTEX = 202 + SYS_SCHED_SETAFFINITY = 203 + SYS_SCHED_GETAFFINITY = 204 + SYS_SET_THREAD_AREA = 205 + SYS_IO_SETUP = 206 + SYS_IO_DESTROY = 207 + SYS_IO_GETEVENTS = 208 + SYS_IO_SUBMIT = 209 + SYS_IO_CANCEL = 210 + SYS_GET_THREAD_AREA = 211 + SYS_LOOKUP_DCOOKIE = 212 + SYS_EPOLL_CREATE = 213 + SYS_EPOLL_CTL_OLD = 214 + SYS_EPOLL_WAIT_OLD = 215 + SYS_REMAP_FILE_PAGES = 216 + SYS_GETDENTS64 = 217 + SYS_SET_TID_ADDRESS = 218 + SYS_RESTART_SYSCALL = 219 + SYS_SEMTIMEDOP = 220 + SYS_FADVISE64 = 221 + SYS_TIMER_CREATE = 222 + SYS_TIMER_SETTIME = 223 + SYS_TIMER_GETTIME = 224 + SYS_TIMER_GETOVERRUN = 225 + SYS_TIMER_DELETE = 226 + SYS_CLOCK_SETTIME = 227 + SYS_CLOCK_GETTIME = 228 + SYS_CLOCK_GETRES = 229 + SYS_CLOCK_NANOSLEEP = 230 + SYS_EXIT_GROUP = 231 + SYS_EPOLL_WAIT = 232 + SYS_EPOLL_CTL = 233 + SYS_TGKILL = 234 + SYS_UTIMES = 235 + SYS_VSERVER = 236 + SYS_MBIND = 237 + SYS_SET_MEMPOLICY = 238 + SYS_GET_MEMPOLICY = 239 + SYS_MQ_OPEN = 240 + SYS_MQ_UNLINK = 241 + SYS_MQ_TIMEDSEND = 242 + SYS_MQ_TIMEDRECEIVE = 243 + SYS_MQ_NOTIFY = 244 + SYS_MQ_GETSETATTR = 245 + SYS_KEXEC_LOAD = 246 + SYS_WAITID = 247 + SYS_ADD_KEY = 248 + SYS_REQUEST_KEY = 249 + SYS_KEYCTL = 250 + SYS_IOPRIO_SET = 251 + SYS_IOPRIO_GET = 252 + SYS_INOTIFY_INIT = 253 + SYS_INOTIFY_ADD_WATCH = 254 + SYS_INOTIFY_RM_WATCH = 255 + SYS_MIGRATE_PAGES = 256 + SYS_OPENAT = 257 + SYS_MKDIRAT = 258 + SYS_MKNODAT = 259 + SYS_FCHOWNAT = 260 + SYS_FUTIMESAT = 261 + SYS_NEWFSTATAT = 262 + SYS_UNLINKAT = 263 + SYS_RENAMEAT = 264 + SYS_LINKAT = 265 + SYS_SYMLINKAT = 266 + SYS_READLINKAT = 267 + SYS_FCHMODAT = 268 + SYS_FACCESSAT = 269 + SYS_PSELECT6 = 270 + SYS_PPOLL = 271 + SYS_UNSHARE = 272 + SYS_SET_ROBUST_LIST = 273 + SYS_GET_ROBUST_LIST = 274 + SYS_SPLICE = 275 + SYS_TEE = 276 + SYS_SYNC_FILE_RANGE = 277 + SYS_VMSPLICE = 278 + SYS_MOVE_PAGES = 279 + SYS_UTIMENSAT = 280 + SYS_EPOLL_PWAIT = 281 + SYS_SIGNALFD = 282 + SYS_TIMERFD_CREATE = 283 + SYS_EVENTFD = 284 + SYS_FALLOCATE = 285 + SYS_TIMERFD_SETTIME = 286 + SYS_TIMERFD_GETTIME = 287 + SYS_ACCEPT4 = 288 + SYS_SIGNALFD4 = 289 + SYS_EVENTFD2 = 290 + SYS_EPOLL_CREATE1 = 291 + SYS_DUP3 = 292 + SYS_PIPE2 = 293 + SYS_INOTIFY_INIT1 = 294 + SYS_PREADV = 295 + SYS_PWRITEV = 296 + SYS_RT_TGSIGQUEUEINFO = 297 + SYS_PERF_EVENT_OPEN = 298 + SYS_RECVMMSG = 299 + SYS_FANOTIFY_INIT = 300 + SYS_FANOTIFY_MARK = 301 + SYS_PRLIMIT64 = 302 diff --git a/ch08/byCharacter.go b/ch08/byCharacter.go new file mode 100644 index 0000000..389d02f --- /dev/null +++ b/ch08/byCharacter.go @@ -0,0 +1,49 @@ +package main + +import ( + "bufio" + "flag" + "fmt" + "io" + "os" +) + +func charByChar(file string) error { + var err error + f, err := os.Open(file) + if err != nil { + return err + } + defer f.Close() + + r := bufio.NewReader(f) + for { + line, err := r.ReadString('\n') + if err == io.EOF { + break + } else if err != nil { + fmt.Printf("error reading file %s", err) + return err + } + + for _, x := range line { + fmt.Println(string(x)) + } + } + return nil +} + +func main() { + flag.Parse() + if len(flag.Args()) == 0 { + fmt.Printf("usage: byChar [ ...]\n") + return + } + + for _, file := range flag.Args() { + err := charByChar(file) + if err != nil { + fmt.Println(err) + } + } +} diff --git a/ch08/byLine.go b/ch08/byLine.go new file mode 100644 index 0000000..669f062 --- /dev/null +++ b/ch08/byLine.go @@ -0,0 +1,47 @@ +package main + +import ( + "bufio" + "flag" + "fmt" + "io" + "os" +) + +func lineByLine(file string) error { + var err error + + f, err := os.Open(file) + if err != nil { + return err + } + defer f.Close() + + r := bufio.NewReader(f) + for { + line, err := r.ReadString('\n') + if err == io.EOF { + break + } else if err != nil { + fmt.Printf("error reading file %s", err) + break + } + fmt.Print(line) + } + return nil +} + +func main() { + flag.Parse() + if len(flag.Args()) == 0 { + fmt.Printf("usage: byLine [ ...]\n") + return + } + + for _, file := range flag.Args() { + err := lineByLine(file) + if err != nil { + fmt.Println(err) + } + } +} diff --git a/ch08/byWord.go b/ch08/byWord.go new file mode 100644 index 0000000..ab5eacd --- /dev/null +++ b/ch08/byWord.go @@ -0,0 +1,52 @@ +package main + +import ( + "bufio" + "flag" + "fmt" + "io" + "os" + "regexp" +) + +func wordByWord(file string) error { + var err error + f, err := os.Open(file) + if err != nil { + return err + } + defer f.Close() + + r := bufio.NewReader(f) + for { + line, err := r.ReadString('\n') + if err == io.EOF { + break + } else if err != nil { + fmt.Printf("error reading file %s", err) + return err + } + + r := regexp.MustCompile("[^\\s]+") + words := r.FindAllString(line, -1) + for i := 0; i < len(words); i++ { + fmt.Println(words[i]) + } + } + return nil +} + +func main() { + flag.Parse() + if len(flag.Args()) == 0 { + fmt.Printf("usage: byWord [ ...]\n") + return + } + + for _, file := range flag.Args() { + err := wordByWord(file) + if err != nil { + fmt.Println(err) + } + } +} diff --git a/ch08/bytes.go b/ch08/bytes.go new file mode 100644 index 0000000..35e22ca --- /dev/null +++ b/ch08/bytes.go @@ -0,0 +1,34 @@ +package main + +import ( + "bytes" + "fmt" + "io" + "os" +) + +func main() { + var buffer bytes.Buffer + buffer.Write([]byte("This is")) + fmt.Fprintf(&buffer, " a string!\n") + buffer.WriteTo(os.Stdout) + buffer.WriteTo(os.Stdout) + + buffer.Reset() + buffer.Write([]byte("Mastering Go!")) + r := bytes.NewReader([]byte(buffer.String())) + fmt.Println(buffer.String()) + for { + b := make([]byte, 3) + n, err := r.Read(b) + if err == io.EOF { + break + } + + if err != nil { + fmt.Println(err) + continue + } + fmt.Printf("Read %s Bytes: %d\n", b, n) + } +} diff --git a/ch08/cat.go b/ch08/cat.go new file mode 100644 index 0000000..d8eb67d --- /dev/null +++ b/ch08/cat.go @@ -0,0 +1,39 @@ +package main + +import ( + "bufio" + "fmt" + "io" + "os" +) + +func printFile(filename string) error { + f, err := os.Open(filename) + if err != nil { + return err + } + defer f.Close() + scanner := bufio.NewScanner(f) + for scanner.Scan() { + io.WriteString(os.Stdout, scanner.Text()) + io.WriteString(os.Stdout, "\n") + } + return nil +} + +func main() { + filename := "" + arguments := os.Args + if len(arguments) == 1 { + io.Copy(os.Stdout, os.Stdin) + return + } + + for i := 1; i < len(arguments); i++ { + filename = arguments[i] + err := printFile(filename) + if err != nil { + fmt.Println(err) + } + } +} diff --git a/ch08/dataFile b/ch08/dataFile new file mode 100644 index 0000000..61e3e0a --- /dev/null +++ b/ch08/dataFile @@ -0,0 +1,10 @@ +1,2 +2,3 +3,3 +4,4 +5,8 +6,5 +-1,12 +-2,10 +-3,10 +-4,10 diff --git a/ch08/devRandom.go b/ch08/devRandom.go new file mode 100644 index 0000000..24fb70d --- /dev/null +++ b/ch08/devRandom.go @@ -0,0 +1,21 @@ +package main + +import ( + "encoding/binary" + "fmt" + "os" +) + +func main() { + f, err := os.Open("/dev/random") + defer f.Close() + + if err != nil { + fmt.Println(err) + return + } + + var seed int64 + binary.Read(f, binary.LittleEndian, &seed) + fmt.Println("Seed:", seed) +} diff --git a/ch08/ebpf.go b/ch08/ebpf.go new file mode 100644 index 0000000..56f2206 --- /dev/null +++ b/ch08/ebpf.go @@ -0,0 +1,12 @@ +package main + +import ( + "fmt" + "github.com/iovisor/gobpf" + "os" + "unsafe" +) + +func main() { + +} diff --git a/ch08/funWithFlag.go b/ch08/funWithFlag.go new file mode 100644 index 0000000..216c28d --- /dev/null +++ b/ch08/funWithFlag.go @@ -0,0 +1,51 @@ +package main + +import ( + "flag" + "fmt" + "strings" +) + +type NamesFlag struct { + Names []string +} + +func (s *NamesFlag) GetNames() []string { + return s.Names +} + +func (s *NamesFlag) String() string { + return fmt.Sprint(s.Names) +} + +func (s *NamesFlag) Set(v string) error { + if len(s.Names) > 0 { + return fmt.Errorf("Cannot use names flag more than once!") + } + + names := strings.Split(v, ",") + for _, item := range names { + s.Names = append(s.Names, item) + } + return nil +} + +func main() { + var manyNames NamesFlag + minusK := flag.Int("k", 0, "An int") + minusO := flag.String("o", "Mihalis", "The name") + flag.Var(&manyNames, "names", "Comma-separated list") + + flag.Parse() + fmt.Println("-k:", *minusK) + fmt.Println("-o:", *minusO) + + for i, item := range manyNames.GetNames() { + fmt.Println(i, item) + } + + fmt.Println("Remaining command line arguments:") + for index, val := range flag.Args() { + fmt.Println(index, ":", val) + } +} diff --git a/ch08/goFind.go b/ch08/goFind.go new file mode 100644 index 0000000..55774d6 --- /dev/null +++ b/ch08/goFind.go @@ -0,0 +1,53 @@ +package main + +import ( + "flag" + "fmt" + "os" + "path/filepath" +) + +var minusD bool = false +var minusF bool = false + +func walk(path string, info os.FileInfo, err error) error { + fileInfo, err := os.Stat(path) + if err != nil { + return err + } + + mode := fileInfo.Mode() + if mode.IsRegular() && minusF { + fmt.Println("+", path) + return nil + } + + if mode.IsDir() && minusD { + fmt.Println("*", path) + return nil + } + + fmt.Println(path) + return nil +} + +func main() { + starD := flag.Bool("d", false, "Signify directories") + plusF := flag.Bool("f", false, "Signify regular files") + flag.Parse() + flags := flag.Args() + + Path := "." + if len(flags) == 1 { + Path = flags[0] + } + + minusD = *starD + minusF = *plusF + + err := filepath.Walk(Path, walk) + if err != nil { + fmt.Println(err) + os.Exit(1) + } +} diff --git a/ch08/handleAll.go b/ch08/handleAll.go new file mode 100644 index 0000000..8dffca4 --- /dev/null +++ b/ch08/handleAll.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "os" + "os/signal" + "syscall" + "time" +) + +func handle(signal os.Signal) { + fmt.Println("Received:", signal) +} + +func main() { + sigs := make(chan os.Signal, 1) + signal.Notify(sigs) + go func() { + for { + sig := <-sigs + switch sig { + case os.Interrupt: + handle(sig) + case syscall.SIGTERM: + handle(sig) + os.Exit(0) + case syscall.SIGUSR2: + fmt.Println("Handling syscall.SIGUSR2!") + default: + fmt.Println("Ignoring:", sig) + } + } + }() + + for { + fmt.Printf(".") + time.Sleep(30 * time.Second) + } +} diff --git a/ch08/handleTwo.go b/ch08/handleTwo.go new file mode 100644 index 0000000..a47b6cc --- /dev/null +++ b/ch08/handleTwo.go @@ -0,0 +1,35 @@ +package main + +import ( + "fmt" + "os" + "os/signal" + "syscall" + "time" +) + +func handleSignal(signal os.Signal) { + fmt.Println("handleSignal() Caught:", signal) +} + +func main() { + sigs := make(chan os.Signal, 1) + signal.Notify(sigs, os.Interrupt, syscall.SIGINFO) + go func() { + for { + sig := <-sigs + switch sig { + case os.Interrupt: + fmt.Println("Caught:", sig) + case syscall.SIGINFO: + handleSignal(sig) + return + } + } + }() + + for { + fmt.Printf(".") + time.Sleep(20 * time.Second) + } +} diff --git a/ch08/ids.go b/ch08/ids.go new file mode 100644 index 0000000..075e416 --- /dev/null +++ b/ch08/ids.go @@ -0,0 +1,20 @@ +package main + +import ( + "fmt" + "os" + "os/user" +) + +func main() { + fmt.Println("User id:", os.Getuid()) + + var u *user.User + u, _ = user.Current() + fmt.Print("Group ids: ") + groupIDs, _ := u.GroupIds() + for _, i := range groupIDs { + fmt.Print(i, " ") + } + fmt.Println() +} diff --git a/ch08/kvSaveLoad.go b/ch08/kvSaveLoad.go new file mode 100644 index 0000000..7f70c85 --- /dev/null +++ b/ch08/kvSaveLoad.go @@ -0,0 +1,161 @@ +package main + +import ( + "bufio" + "encoding/gob" + "fmt" + "os" + "strings" +) + +type myElement struct { + Name string + Surname string + Id string +} + +var DATA = make(map[string]myElement) +var DATAFILE = "/tmp/dataFile.gob" + +func save() error { + fmt.Println("Saving", DATAFILE) + err := os.Remove(DATAFILE) + if err != nil { + fmt.Println(err) + } + + saveTo, err := os.Create(DATAFILE) + if err != nil { + fmt.Println("Cannot create", DATAFILE) + return err + } + defer saveTo.Close() + + encoder := gob.NewEncoder(saveTo) + err = encoder.Encode(DATA) + if err != nil { + fmt.Println("Cannot save to", DATAFILE) + return err + } + return nil +} + +func load() error { + fmt.Println("Loading", DATAFILE) + loadFrom, err := os.Open(DATAFILE) + defer loadFrom.Close() + if err != nil { + fmt.Println("Empty key/value store!") + return err + } + + decoder := gob.NewDecoder(loadFrom) + decoder.Decode(&DATA) + return nil +} + +func ADD(k string, n myElement) bool { + if k == "" { + return false + } + + if LOOKUP(k) == nil { + DATA[k] = n + return true + } + return false +} + +func DELETE(k string) bool { + if LOOKUP(k) != nil { + delete(DATA, k) + return true + } + return false +} + +func LOOKUP(k string) *myElement { + _, ok := DATA[k] + if ok { + n := DATA[k] + return &n + } else { + return nil + } +} + +func CHANGE(k string, n myElement) bool { + DATA[k] = n + return true +} + +func PRINT() { + for k, d := range DATA { + fmt.Printf("key: %s value: %v\n", k, d) + } +} + +func main() { + err := load() + if err != nil { + fmt.Println(err) + } + + scanner := bufio.NewScanner(os.Stdin) + for scanner.Scan() { + text := scanner.Text() + text = strings.TrimSpace(text) + tokens := strings.Fields(text) + + switch len(tokens) { + case 0: + continue + case 1: + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + case 2: + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + case 3: + tokens = append(tokens, "") + tokens = append(tokens, "") + case 4: + tokens = append(tokens, "") + } + + switch tokens[0] { + case "PRINT": + PRINT() + case "STOP": + err = save() + if err != nil { + fmt.Println(err) + } + return + case "DELETE": + if !DELETE(tokens[1]) { + fmt.Println("Delete operation failed!") + } + case "ADD": + n := myElement{tokens[2], tokens[3], tokens[4]} + if !ADD(tokens[1], n) { + fmt.Println("Add operation failed!") + } + case "LOOKUP": + n := LOOKUP(tokens[1]) + if n != nil { + fmt.Printf("%v\n", *n) + } + case "CHANGE": + n := myElement{tokens[2], tokens[3], tokens[4]} + if !CHANGE(tokens[1], n) { + fmt.Println("Update operation failed!") + } + default: + fmt.Println("Unknown command – please try again!") + } + } +} diff --git a/ch08/permissions.go b/ch08/permissions.go new file mode 100644 index 0000000..2c2dcec --- /dev/null +++ b/ch08/permissions.go @@ -0,0 +1,19 @@ +package main + +import ( + "fmt" + "os" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Printf("usage: permissions filename\n") + return + } + + filename := arguments[1] + info, _ := os.Stat(filename) + mode := info.Mode() + fmt.Println(filename, "mode is", mode.String()[1:10]) +} diff --git a/ch08/ptraceRegs.go b/ch08/ptraceRegs.go new file mode 100644 index 0000000..3d557ec --- /dev/null +++ b/ch08/ptraceRegs.go @@ -0,0 +1,38 @@ +package main + +import ( + "fmt" + "os" + "os/exec" + "syscall" + "time" +) + +func main() { + var r syscall.PtraceRegs + cmd := exec.Command(os.Args[1], os.Args[2:]...) + + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + + cmd.SysProcAttr = &syscall.SysProcAttr{Ptrace: true} + err := cmd.Start() + if err != nil { + fmt.Println("Start:", err) + return + } + + err = cmd.Wait() + fmt.Printf("State: %v\n", err) + wpid := cmd.Process.Pid + + err = syscall.PtraceGetRegs(wpid, &r) + if err != nil { + fmt.Println("PtraceGetRegs:", err) + return + } + fmt.Printf("Registers: %#v\n", r) + fmt.Printf("R15=%d, Gs=%d\n", r.R15, r.Gs) + + time.Sleep(2 * time.Second) +} diff --git a/ch08/readSize.go b/ch08/readSize.go new file mode 100644 index 0000000..51659c4 --- /dev/null +++ b/ch08/readSize.go @@ -0,0 +1,55 @@ +package main + +import ( + "fmt" + "io" + "os" + "strconv" +) + +func readSize(f *os.File, size int) []byte { + buffer := make([]byte, size) + + n, err := f.Read(buffer) + if err == io.EOF { + return nil + } + + if err != nil { + fmt.Println(err) + return nil + } + + return buffer[0:n] +} + +func main() { + arguments := os.Args + if len(arguments) != 3 { + fmt.Println(" ") + return + } + + bufferSize, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + + file := os.Args[2] + f, err := os.Open(file) + if err != nil { + fmt.Println(err) + return + } + defer f.Close() + + for { + readData := readSize(f, bufferSize) + if readData != nil { + fmt.Print(string(readData)) + } else { + break + } + } +} diff --git a/ch08/save.go b/ch08/save.go new file mode 100644 index 0000000..9b66d08 --- /dev/null +++ b/ch08/save.go @@ -0,0 +1,59 @@ +package main + +import ( + "bufio" + "fmt" + "io" + "io/ioutil" + "os" +) + +func main() { + s := []byte("Data to write\n") + + f1, err := os.Create("f1.txt") + if err != nil { + fmt.Println("Cannot create file", err) + return + } + defer f1.Close() + fmt.Fprintf(f1, string(s)) + + f2, err := os.Create("f2.txt") + if err != nil { + fmt.Println("Cannot create file", err) + return + } + defer f2.Close() + n, err := f2.WriteString(string(s)) + fmt.Printf("wrote %d bytes\n", n) + + f3, err := os.Create("f3.txt") + if err != nil { + fmt.Println(err) + return + } + w := bufio.NewWriter(f3) + n, err = w.WriteString(string(s)) + fmt.Printf("wrote %d bytes\n", n) + w.Flush() + + f4 := "f4.txt" + err = ioutil.WriteFile(f4, s, 0644) + if err != nil { + fmt.Println(err) + return + } + + f5, err := os.Create("f5.txt") + if err != nil { + fmt.Println(err) + return + } + n, err = io.WriteString(f5, string(s)) + if err != nil { + fmt.Println(err) + return + } + fmt.Printf("wrote %d bytes\n", n) +} diff --git a/ch08/simpleFlag.go b/ch08/simpleFlag.go new file mode 100644 index 0000000..8d607e7 --- /dev/null +++ b/ch08/simpleFlag.go @@ -0,0 +1,18 @@ +package main + +import ( + "flag" + "fmt" +) + +func main() { + minusK := flag.Bool("k", true, "k") + minusO := flag.Int("O", 1, "O") + flag.Parse() + + valueK := *minusK + valueO := *minusO + valueO++ + fmt.Println("-k:", valueK) + fmt.Println("-O:", valueO) +} diff --git a/ch08/str.go b/ch08/str.go new file mode 100644 index 0000000..4d16404 --- /dev/null +++ b/ch08/str.go @@ -0,0 +1,38 @@ +package main + +import ( + "fmt" + "io" + "os" + "strings" +) + +func main() { + + r := strings.NewReader("test") + fmt.Println("r length:", r.Len()) + + b := make([]byte, 1) + for { + n, err := r.Read(b) + if err == io.EOF { + break + } + + if err != nil { + fmt.Println(err) + continue + } + fmt.Printf("Read %s Bytes: %d\n", b, n) + } + + s := strings.NewReader("This is an error!\n") + fmt.Println("r length:", s.Len()) + n, err := s.WriteTo(os.Stderr) + + if err != nil { + fmt.Println(err) + return + } + fmt.Printf("Wrote %d bytes to os.Stderr\n", n) +} diff --git a/ch08/traceSyscall.go b/ch08/traceSyscall.go new file mode 100644 index 0000000..892e2ab --- /dev/null +++ b/ch08/traceSyscall.go @@ -0,0 +1,90 @@ +package main + +import ( + "bufio" + "fmt" + "os" + "os/exec" + "strings" + "syscall" +) + +var maxSyscalls = 0 + +const SYSCALLFILE = "SYSCALLS" + +func main() { + var SYSTEMCALLS []string + f, err := os.Open(SYSCALLFILE) + defer f.Close() + if err != nil { + fmt.Println(err) + return + } + + scanner := bufio.NewScanner(f) + for scanner.Scan() { + line := scanner.Text() + line = strings.Replace(line, " ", "", -1) + line = strings.Replace(line, "SYS_", "", -1) + temp := strings.ToLower(strings.Split(line, "=")[0]) + SYSTEMCALLS = append(SYSTEMCALLS, temp) + maxSyscalls++ + } + + COUNTER := make([]int, maxSyscalls) + var regs syscall.PtraceRegs + cmd := exec.Command(os.Args[1], os.Args[2:]...) + + cmd.Stdin = os.Stdin + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.SysProcAttr = &syscall.SysProcAttr{Ptrace: true} + + err = cmd.Start() + err = cmd.Wait() + if err != nil { + fmt.Println("Wait:", err) + } + + pid := cmd.Process.Pid + fmt.Println("Process ID:", pid) + + before := true + forCount := 0 + for { + if before { + err := syscall.PtraceGetRegs(pid, ®s) + if err != nil { + break + } + if regs.Orig_rax > uint64(maxSyscalls) { + fmt.Println("Unknown:", regs.Orig_rax) + return + } + + COUNTER[regs.Orig_rax]++ + forCount++ + } + + err = syscall.PtraceSyscall(pid, 0) + if err != nil { + fmt.Println("PtraceSyscall:", err) + return + } + + _, err = syscall.Wait4(pid, nil, 0, nil) + if err != nil { + fmt.Println("Wait4:", err) + return + } + before = !before + } + + for i, x := range COUNTER { + if x != 0 { + fmt.Println(SYSTEMCALLS[i], "->", x) + } + } + fmt.Println("Total System Calls:", forCount) +} diff --git a/ch09/create.go b/ch09/create.go new file mode 100644 index 0000000..b3cb98f --- /dev/null +++ b/ch09/create.go @@ -0,0 +1,23 @@ +package main + +import ( + "flag" + "fmt" + "time" +) + +func main() { + n := flag.Int("n", 10, "Number of goroutines") + flag.Parse() + + count := *n + fmt.Printf("Going to create %d goroutines.\n", count) + for i := 0; i < count; i++ { + go func(x int) { + fmt.Printf("%d ", x) + }(i) + } + + time.Sleep(time.Second) + fmt.Println("\nExiting...") +} diff --git a/ch09/pipeline.go b/ch09/pipeline.go new file mode 100644 index 0000000..a684a39 --- /dev/null +++ b/ch09/pipeline.go @@ -0,0 +1,74 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +var CLOSEA = false + +var DATA = make(map[int]bool) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func first(min, max int, out chan<- int) { + for { + if CLOSEA { + close(out) + return + } + out <- random(min, max) + } +} + +func second(out chan<- int, in <-chan int) { + for x := range in { + fmt.Print(x, " ") + _, ok := DATA[x] + if ok { + CLOSEA = true + } else { + DATA[x] = true + out <- x + } + } + fmt.Println() + close(out) +} + +func third(in <-chan int) { + var sum int + sum = 0 + for x2 := range in { + sum = sum + x2 + } + fmt.Printf("The sum of the random numbers is %d\n", sum) +} + +func main() { + if len(os.Args) != 3 { + fmt.Println("Need two integer parameters!") + os.Exit(1) + } + + n1, _ := strconv.Atoi(os.Args[1]) + n2, _ := strconv.Atoi(os.Args[2]) + + if n1 > n2 { + fmt.Printf("%d should be smaller than %d\n", n1, n2) + return + } + + rand.Seed(time.Now().UnixNano()) + A := make(chan int) + B := make(chan int) + + go first(n1, n2, A) + go second(B, A) + third(B) +} diff --git a/ch09/readCh.go b/ch09/readCh.go new file mode 100644 index 0000000..526f356 --- /dev/null +++ b/ch09/readCh.go @@ -0,0 +1,28 @@ +package main + +import ( + "fmt" + "time" +) + +func writeToChannel(c chan int, x int) { + fmt.Println("1", x) + c <- x + close(c) + fmt.Println("2", x) +} + +func main() { + c := make(chan int) + go writeToChannel(c, 10) + time.Sleep(1 * time.Second) + fmt.Println("Read:", <-c) + time.Sleep(1 * time.Second) + + _, ok := <-c + if ok { + fmt.Println("Channel is open!") + } else { + fmt.Println("Channel is closed!") + } +} diff --git a/ch09/simple.go b/ch09/simple.go new file mode 100644 index 0000000..2e620d6 --- /dev/null +++ b/ch09/simple.go @@ -0,0 +1,25 @@ +package main + +import ( + "fmt" + "time" +) + +func function() { + for i := 0; i < 10; i++ { + fmt.Print(i) + } + fmt.Println() +} + +func main() { + go function() + + go func() { + for i := 10; i < 20; i++ { + fmt.Print(i, " ") + } + }() + + time.Sleep(1 * time.Second) +} diff --git a/ch09/syncGo.go b/ch09/syncGo.go new file mode 100644 index 0000000..85bc5a3 --- /dev/null +++ b/ch09/syncGo.go @@ -0,0 +1,28 @@ +package main + +import ( + "flag" + "fmt" + "sync" +) + +func main() { + n := flag.Int("n", 20, "Number of goroutines") + flag.Parse() + count := *n + fmt.Printf("Going to create %d goroutines.\n", count) + + var waitGroup sync.WaitGroup + fmt.Printf("%#v\n", waitGroup) + for i := 0; i < count; i++ { + waitGroup.Add(1) + go func(x int) { + defer waitGroup.Done() + fmt.Printf("%d ", x) + }(i) + } + + fmt.Printf("%#v\n", waitGroup) + waitGroup.Wait() + fmt.Println("\nExiting...") +} diff --git a/ch09/writeCh.go b/ch09/writeCh.go new file mode 100644 index 0000000..98f72b7 --- /dev/null +++ b/ch09/writeCh.go @@ -0,0 +1,19 @@ +package main + +import ( + "fmt" + "time" +) + +func writeToChannel(c chan int, x int) { + fmt.Println(x) + c <- x + close(c) + fmt.Println(x) +} + +func main() { + c := make(chan int) + go writeToChannel(c, 10) + time.Sleep(1 * time.Second) +} diff --git a/ch10/bufChannel.go b/ch10/bufChannel.go new file mode 100644 index 0000000..585c96d --- /dev/null +++ b/ch10/bufChannel.go @@ -0,0 +1,28 @@ +package main + +import ( + "fmt" +) + +func main() { + numbers := make(chan int, 5) + counter := 10 + + for i := 0; i < counter; i++ { + select { + case numbers <- i: + default: + fmt.Println("Not enough space for", i) + } + } + + for i := 0; i < counter+5; i++ { + select { + case num := <-numbers: + fmt.Println(num) + default: + fmt.Println("Nothing more to be done!") + break + } + } +} diff --git a/ch10/chSquare.go b/ch10/chSquare.go new file mode 100644 index 0000000..b0bb958 --- /dev/null +++ b/ch10/chSquare.go @@ -0,0 +1,56 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "time" +) + +var times int + +func f1(cc chan chan int, f chan bool) { + c := make(chan int) + cc <- c + defer close(c) + + sum := 0 + select { + case x := <-c: + for i := 0; i <= x; i++ { + sum = sum + i + } + c <- sum + case <-f: + return + } +} + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("Need just one integer argument!") + return + } + + times, err := strconv.Atoi(arguments[1]) + if err != nil { + fmt.Println(err) + return + } + + cc := make(chan chan int) + + for i := 1; i < times+1; i++ { + f := make(chan bool) + go f1(cc, f) + ch := <-cc + ch <- i + for sum := range ch { + fmt.Print("Sum(", i, ")=", sum) + } + fmt.Println() + time.Sleep(time.Second) + close(f) + } +} diff --git a/ch10/closeNilChannel.go b/ch10/closeNilChannel.go new file mode 100644 index 0000000..89f2957 --- /dev/null +++ b/ch10/closeNilChannel.go @@ -0,0 +1,6 @@ +package main + +func main() { + var c chan string + close(c) +} diff --git a/ch10/defineOrder.go b/ch10/defineOrder.go new file mode 100644 index 0000000..8e5bbad --- /dev/null +++ b/ch10/defineOrder.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "time" +) + +func A(a, b chan struct{}) { + <-a + fmt.Println("A()!") + time.Sleep(time.Second) + close(b) +} + +func B(a, b chan struct{}) { + <-a + fmt.Println("B()!") + close(b) +} + +func C(a chan struct{}) { + <-a + fmt.Println("C()!") +} + +func main() { + x := make(chan struct{}) + y := make(chan struct{}) + z := make(chan struct{}) + + go C(z) + go A(x, y) + go C(z) + go B(y, z) + go C(z) + + close(x) + time.Sleep(3 * time.Second) +} diff --git a/ch10/forgetMutex.go b/ch10/forgetMutex.go new file mode 100644 index 0000000..3515a44 --- /dev/null +++ b/ch10/forgetMutex.go @@ -0,0 +1,31 @@ +package main + +import ( + "fmt" + "sync" +) + +var m sync.Mutex + +func function() { + m.Lock() + fmt.Println("Locked!") +} + +func main() { + var w sync.WaitGroup + + go func() { + defer w.Done() + function() + }() + w.Add(1) + + go func() { + defer w.Done() + function() + }() + w.Add(1) + + w.Wait() +} diff --git a/ch10/maxprocs.go b/ch10/maxprocs.go new file mode 100644 index 0000000..8ea1dd8 --- /dev/null +++ b/ch10/maxprocs.go @@ -0,0 +1,14 @@ +package main + +import ( + "fmt" + "runtime" +) + +func getGOMAXPROCS() int { + return runtime.GOMAXPROCS(0) +} + +func main() { + fmt.Printf("GOMAXPROCS: %d\n", getGOMAXPROCS()) +} diff --git a/ch10/monitor.go b/ch10/monitor.go new file mode 100644 index 0000000..32f55b5 --- /dev/null +++ b/ch10/monitor.go @@ -0,0 +1,60 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "sync" + "time" +) + +var readValue = make(chan int) +var writeValue = make(chan int) + +func set(newValue int) { + writeValue <- newValue +} + +func read() int { + return <-readValue +} + +func monitor() { + var value int + for { + select { + case newValue := <-writeValue: + value = newValue + fmt.Printf("%d ", value) + case readValue <- value: + } + } +} + +func main() { + if len(os.Args) != 2 { + fmt.Println("Please give an integer!") + return + } + n, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + + fmt.Printf("Going to create %d random numbers.\n", n) + rand.Seed(time.Now().Unix()) + go monitor() + var w sync.WaitGroup + + for r := 0; r < n; r++ { + w.Add(1) + go func() { + defer w.Done() + set(rand.Intn(10 * n)) + }() + } + w.Wait() + fmt.Printf("\nLast value: %d\n", read()) +} diff --git a/ch10/mutex.go b/ch10/mutex.go new file mode 100644 index 0000000..0b87666 --- /dev/null +++ b/ch10/mutex.go @@ -0,0 +1,58 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "sync" + "time" +) + +var ( + m sync.Mutex + v1 int +) + +func change(i int) { + m.Lock() + time.Sleep(time.Second) + v1 = v1 + 1 + if v1%10 == 0 { + v1 = v1 - 10*i + } + m.Unlock() +} + +func read() int { + m.Lock() + a := v1 + m.Unlock() + return a +} + +func main() { + if len(os.Args) != 2 { + fmt.Println("Please give me an integer!") + return + } + + numGR, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + var waitGroup sync.WaitGroup + + fmt.Printf("%d ", read()) + for i := 0; i < numGR; i++ { + waitGroup.Add(1) + go func(i int) { + defer waitGroup.Done() + change(i) + fmt.Printf("-> %d", read()) + }(i) + } + + waitGroup.Wait() + fmt.Printf("-> %d\n", read()) +} diff --git a/ch10/nilChannel.go b/ch10/nilChannel.go new file mode 100644 index 0000000..8cd509d --- /dev/null +++ b/ch10/nilChannel.go @@ -0,0 +1,36 @@ +package main + +import ( + "fmt" + "math/rand" + "time" +) + +func add(c chan int) { + sum := 0 + t := time.NewTimer(time.Second) + + for { + select { + case input := <-c: + sum = sum + input + case <-t.C: + c = nil + fmt.Println(sum) + } + } +} + +func send(c chan int) { + for { + c <- rand.Intn(10) + } +} + +func main() { + c := make(chan int) + go add(c) + go send(c) + + time.Sleep(3 * time.Second) +} diff --git a/ch10/noRaceC.go b/ch10/noRaceC.go new file mode 100644 index 0000000..1371b38 --- /dev/null +++ b/ch10/noRaceC.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "sync" +) + +var aMutex sync.Mutex + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("Give me a natural number!") + os.Exit(1) + } + numGR, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + + var waitGroup sync.WaitGroup + var i int + + k := make(map[int]int) + k[1] = 12 + + for i = 0; i < numGR; i++ { + waitGroup.Add(1) + go func(j int) { + defer waitGroup.Done() + aMutex.Lock() + k[j] = j + aMutex.Unlock() + }(i) + } + + waitGroup.Wait() + k[2] = 10 + fmt.Printf("k = %#v\n", k) +} diff --git a/ch10/raceC.go b/ch10/raceC.go new file mode 100644 index 0000000..1f5d236 --- /dev/null +++ b/ch10/raceC.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "sync" +) + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("Give me a natural number!") + os.Exit(1) + } + numGR, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + + var waitGroup sync.WaitGroup + var i int + + k := make(map[int]int) + k[1] = 12 + + for i = 0; i < numGR; i++ { + waitGroup.Add(1) + go func() { + defer waitGroup.Done() + k[i] = i + }() + } + + k[2] = 10 + waitGroup.Wait() + fmt.Printf("k = %#v\n", k) +} diff --git a/ch10/rwMutex.go b/ch10/rwMutex.go new file mode 100644 index 0000000..d5f3349 --- /dev/null +++ b/ch10/rwMutex.go @@ -0,0 +1,70 @@ +package main + +import ( + "fmt" + "os" + "sync" + "time" +) + +var Password = secret{password: "myPassword"} + +type secret struct { + RWM sync.RWMutex + password string +} + +func Change(c *secret, pass string) { + c.RWM.Lock() + fmt.Println("LChange") + time.Sleep(10 * time.Second) + c.password = pass + c.RWM.Unlock() +} + +func show(c *secret) string { + c.RWM.RLock() + fmt.Print("show") + time.Sleep(3 * time.Second) + defer c.RWM.RUnlock() + return c.password +} + +func showWithLock(c *secret) string { + c.RWM.Lock() + fmt.Println("showWithLock") + time.Sleep(3 * time.Second) + defer c.RWM.Unlock() + return c.password +} + +func main() { + var showFunction = func(c *secret) string { return "" } + if len(os.Args) != 2 { + fmt.Println("Using sync.RWMutex!") + showFunction = show + } else { + fmt.Println("Using sync.Mutex!") + showFunction = showWithLock + } + + var waitGroup sync.WaitGroup + + fmt.Println("Pass:", showFunction(&Password)) + for i := 0; i < 15; i++ { + waitGroup.Add(1) + go func() { + defer waitGroup.Done() + fmt.Println("Go Pass:", showFunction(&Password)) + }() + } + + go func() { + waitGroup.Add(1) + defer waitGroup.Done() + Change(&Password, "123456") + }() + + waitGroup.Wait() + fmt.Println("Pass:", showFunction(&Password)) +} diff --git a/ch10/select.go b/ch10/select.go new file mode 100644 index 0000000..a1cf053 --- /dev/null +++ b/ch10/select.go @@ -0,0 +1,45 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" + "time" +) + +func gen(min, max int, createNumber chan int, end chan bool) { + for { + select { + case createNumber <- rand.Intn(max-min) + min: + case <-end: + close(end) + return + case <-time.After(4 * time.Second): + fmt.Println("\ntime.After()!") + } + } +} + +func main() { + rand.Seed(time.Now().Unix()) + createNumber := make(chan int) + end := make(chan bool) + + if len(os.Args) != 2 { + fmt.Println("Please give me an integer!") + return + } + + n, _ := strconv.Atoi(os.Args[1]) + fmt.Printf("Going to create %d random numbers.\n", n) + go gen(0, 2*n, createNumber, end) + + for i := 0; i < n; i++ { + fmt.Printf("%d ", <-createNumber) + } + + time.Sleep(5 * time.Second) + fmt.Println("Exiting...") + end <- true +} diff --git a/ch10/simpleContext.go b/ch10/simpleContext.go new file mode 100644 index 0000000..d992d05 --- /dev/null +++ b/ch10/simpleContext.go @@ -0,0 +1,88 @@ +package main + +import ( + "context" + "fmt" + "os" + "strconv" + "time" +) + +func f1(t int) { + c1 := context.Background() + c1, cancel := context.WithCancel(c1) + defer cancel() + + go func() { + time.Sleep(4 * time.Second) + cancel() + }() + + select { + case <-c1.Done(): + fmt.Println("f1():", c1.Err()) + return + case r := <-time.After(time.Duration(t) * time.Second): + fmt.Println("f1():", r) + } + return +} + +func f2(t int) { + c2 := context.Background() + c2, cancel := context.WithTimeout(c2, time.Duration(t)*time.Second) + defer cancel() + + go func() { + time.Sleep(4 * time.Second) + cancel() + }() + + select { + case <-c2.Done(): + fmt.Println("f2():", c2.Err()) + return + case r := <-time.After(time.Duration(t) * time.Second): + fmt.Println("f2():", r) + } + return +} + +func f3(t int) { + c3 := context.Background() + deadline := time.Now().Add(time.Duration(2*t) * time.Second) + c3, cancel := context.WithDeadline(c3, deadline) + defer cancel() + + go func() { + time.Sleep(4 * time.Second) + cancel() + }() + + select { + case <-c3.Done(): + fmt.Println("f3():", c3.Err()) + return + case r := <-time.After(time.Duration(t) * time.Second): + fmt.Println("f3():", r) + } + return +} + +func main() { + if len(os.Args) != 2 { + fmt.Println("Need a delay!") + return + } + + delay, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("Delay:", delay) + + f1(delay) + f2(delay) + f3(delay) +} diff --git a/ch10/slowWWW.go b/ch10/slowWWW.go new file mode 100644 index 0000000..252abe5 --- /dev/null +++ b/ch10/slowWWW.go @@ -0,0 +1,42 @@ +package main + +import ( + "fmt" + "math/rand" + "net/http" + "os" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func myHandler(w http.ResponseWriter, r *http.Request) { + delay := random(0, 15) + time.Sleep(time.Duration(delay) * time.Second) + + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Fprintf(w, "Delay: %d\n", delay) + fmt.Printf("Served: %s\n", r.Host) +} + +func main() { + seed := time.Now().Unix() + rand.Seed(seed) + + PORT := ":8001" + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Using default port number: ", PORT) + } else { + PORT = ":" + arguments[1] + } + + http.HandleFunc("/", myHandler) + err := http.ListenAndServe(PORT, nil) + if err != nil { + fmt.Println(err) + os.Exit(10) + } +} diff --git a/ch10/timeOut1.go b/ch10/timeOut1.go new file mode 100644 index 0000000..e0f75de --- /dev/null +++ b/ch10/timeOut1.go @@ -0,0 +1,34 @@ +package main + +import ( + "fmt" + "time" +) + +func main() { + c1 := make(chan string) + go func() { + time.Sleep(time.Second * 3) + c1 <- "c1 OK" + }() + + select { + case res := <-c1: + fmt.Println(res) + case <-time.After(time.Second * 1): + fmt.Println("timeout c1") + } + + c2 := make(chan string) + go func() { + time.Sleep(3 * time.Second) + c2 <- "c2 OK" + }() + + select { + case res := <-c2: + fmt.Println(res) + case <-time.After(4 * time.Second): + fmt.Println("timeout c2") + } +} diff --git a/ch10/timeOut2.go b/ch10/timeOut2.go new file mode 100644 index 0000000..f068c34 --- /dev/null +++ b/ch10/timeOut2.go @@ -0,0 +1,58 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "sync" + "time" +) + +func timeout(w *sync.WaitGroup, t time.Duration) bool { + temp := make(chan int) + go func() { + time.Sleep(5 * time.Second) + defer close(temp) + w.Wait() + }() + + select { + case <-temp: + return false + case <-time.After(t): + return true + } +} + +func main() { + arguments := os.Args + if len(arguments) != 2 { + fmt.Println("Need a time duration!") + return + } + + var w sync.WaitGroup + w.Add(1) + + t, err := strconv.Atoi(arguments[1]) + if err != nil { + fmt.Println(err) + return + } + + duration := time.Duration(int32(t)) * time.Millisecond + fmt.Printf("Timeout period is %s\n", duration) + + if timeout(&w, duration) { + fmt.Println("Timed out!") + } else { + fmt.Println("OK!") + } + + w.Done() + if timeout(&w, duration) { + fmt.Println("Timed out!") + } else { + fmt.Println("OK!") + } +} diff --git a/ch10/useContext.go b/ch10/useContext.go new file mode 100644 index 0000000..7ac52cf --- /dev/null +++ b/ch10/useContext.go @@ -0,0 +1,98 @@ +package main + +import ( + "context" + "fmt" + "io/ioutil" + "net/http" + "os" + "strconv" + "sync" + "time" +) + +var ( + myUrl string + delay int = 5 + w sync.WaitGroup +) + +type myData struct { + r *http.Response + err error +} + +func connect(c context.Context) error { + defer w.Done() + data := make(chan myData, 1) + + tr := &http.Transport{} + httpClient := &http.Client{Transport: tr} + + req, _ := http.NewRequest("GET", myUrl, nil) + + go func() { + response, err := httpClient.Do(req) + if err != nil { + fmt.Println(err) + data <- myData{nil, err} + return + } else { + pack := myData{response, err} + data <- pack + } + }() + + select { + case <-c.Done(): + tr.CancelRequest(req) + <-data + fmt.Println("The request was cancelled!") + return c.Err() + case ok := <-data: + err := ok.err + resp := ok.r + if err != nil { + fmt.Println("Error select:", err) + return err + } + defer resp.Body.Close() + + realHTTPData, err := ioutil.ReadAll(resp.Body) + if err != nil { + fmt.Println("Error select:", err) + return err + } + fmt.Printf("Server Response: %s\n", realHTTPData) + + } + return nil +} + +func main() { + if len(os.Args) == 1 { + fmt.Println("Need a URL and a delay!") + return + } + + myUrl = os.Args[1] + if len(os.Args) == 3 { + t, err := strconv.Atoi(os.Args[2]) + if err != nil { + fmt.Println(err) + return + } + delay = t + } + + fmt.Println("Delay:", delay) + c := context.Background() + c, cancel := context.WithTimeout(c, time.Duration(delay)*time.Second) + defer cancel() + + fmt.Printf("Connecting to %s \n", myUrl) + w.Add(1) + go connect(c) + w.Wait() + fmt.Println("Exiting...") +} diff --git a/ch10/workerPool.go b/ch10/workerPool.go new file mode 100644 index 0000000..21ca2ea --- /dev/null +++ b/ch10/workerPool.go @@ -0,0 +1,88 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "sync" + "time" +) + +type Client struct { + id int + integer int +} + +type Data struct { + job Client + square int +} + +var ( + size = 10 + clients = make(chan Client, size) + data = make(chan Data, size) +) + +func worker(w *sync.WaitGroup) { + for c := range clients { + square := c.integer * c.integer + output := Data{c, square} + data <- output + time.Sleep(time.Second) + } + w.Done() +} + +func makeWP(n int) { + var w sync.WaitGroup + for i := 0; i < n; i++ { + w.Add(1) + go worker(&w) + } + w.Wait() + close(data) +} + +func create(n int) { + for i := 0; i < n; i++ { + c := Client{i, i} + clients <- c + } + close(clients) +} + +func main() { + fmt.Println("Capacity of clients:", cap(clients)) + fmt.Println("Capacity of data:", cap(data)) + + if len(os.Args) != 3 { + fmt.Println("Need #jobs and #workers!") + os.Exit(1) + } + + nJobs, err := strconv.Atoi(os.Args[1]) + if err != nil { + fmt.Println(err) + return + } + + nWorkers, err := strconv.Atoi(os.Args[2]) + if err != nil { + fmt.Println(err) + return + } + + go create(nJobs) + finished := make(chan interface{}) + go func() { + for d := range data { + fmt.Printf("Client ID: %d\tint: ", d.job.id) + fmt.Printf("%d\tsquare: %d\n", d.job.integer, d.square) + } + finished <- true + }() + + makeWP(nWorkers) + fmt.Printf(": %v\n", <-finished) +} diff --git a/ch11/benchmarkMe.go b/ch11/benchmarkMe.go new file mode 100644 index 0000000..a9524a2 --- /dev/null +++ b/ch11/benchmarkMe.go @@ -0,0 +1,42 @@ +package main + +import ( + "fmt" +) + +func fibo1(n int) int { + if n == 0 { + return 0 + } else if n == 1 { + return 1 + } else { + return fibo1(n-1) + fibo1(n-2) + } +} + +func fibo2(n int) int { + if n == 0 || n == 1 { + return n + } + return fibo2(n-1) + fibo2(n-2) +} + +func fibo3(n int) int { + fn := make(map[int]int) + for i := 0; i <= n; i++ { + var f int + if i <= 2 { + f = 1 + } else { + f = fn[i-1] + fn[i-2] + } + fn[i] = f + } + return fn[n] +} + +func main() { + fmt.Println(fibo1(40)) + fmt.Println(fibo2(40)) + fmt.Println(fibo3(40)) +} diff --git a/ch11/benchmarkMe_test.go b/ch11/benchmarkMe_test.go new file mode 100644 index 0000000..92c4ac2 --- /dev/null +++ b/ch11/benchmarkMe_test.go @@ -0,0 +1,81 @@ +package main + +import ( + "testing" +) + +var result int + +func benchmarkfibo1(b *testing.B, n int) { + var r int + for i := 0; i < b.N; i++ { + r = fibo1(n) + } + result = r +} + +func benchmarkfibo2(b *testing.B, n int) { + var r int + for i := 0; i < b.N; i++ { + r = fibo2(n) + } + result = r +} + +func benchmarkfibo3(b *testing.B, n int) { + var r int + for i := 0; i < b.N; i++ { + r = fibo3(n) + } + result = r +} + +func Benchmark30fibo1(b *testing.B) { + benchmarkfibo1(b, 30) +} + +func Benchmark30fibo2(b *testing.B) { + benchmarkfibo2(b, 30) +} + +func Benchmark30fibo3(b *testing.B) { + benchmarkfibo3(b, 30) +} + +func Benchmark50fibo1(b *testing.B) { + benchmarkfibo1(b, 50) +} + +func Benchmark50fibo2(b *testing.B) { + benchmarkfibo2(b, 50) +} + +func Benchmark50fibo3(b *testing.B) { + benchmarkfibo3(b, 50) +} + +// This is a correct benchmark function +func BenchmarkFiboIV(b *testing.B) { + for i := 0; i < b.N; i++ { + _ = fibo3(10) + } +} + +// This is also a correct benchmark function +func BenchmarkFiboIII(b *testing.B) { + _ = fibo3(b.N) +} + +// This benchmark function never converges +// func BenchmarkFiboI(b *testing.B) { +// for i := 0; i < b.N; i++ { +// _ = fibo1(i) +// } +// } + +// This benchmark function never converges +// func BenchmarkFiboII(b *testing.B) { +// for i := 0; i < b.N; i++ { +// _ = fibo2(b.N) +// } +// } diff --git a/ch11/betterProfile.go b/ch11/betterProfile.go new file mode 100644 index 0000000..6253ed7 --- /dev/null +++ b/ch11/betterProfile.go @@ -0,0 +1,53 @@ +package main + +import ( + "fmt" + "github.com/pkg/profile" +) + +var VARIABLE int + +func N1(n int) bool { + for i := 2; i < n; i++ { + if (n % i) == 0 { + return false + } + } + return true +} + +func Multiply(a, b int) int { + if a == 1 { + return b + } + if a == 0 || b == 0 { + return 0 + } + if a < 0 { + return -Multiply(-a, b) + } + return b + Multiply(a-1, b) +} + +func main() { + defer profile.Start(profile.ProfilePath("/tmp")).Stop() + + total := 0 + for i := 2; i < 200000; i++ { + n := N1(i) + if n { + total++ + } + } + fmt.Println("Total: ", total) + + total = 0 + for i := 0; i < 5000; i++ { + for j := 0; j < 400; j++ { + k := Multiply(i, j) + VARIABLE = k + total++ + } + } + fmt.Println("Total: ", total) +} diff --git a/ch11/cannotReach.go b/ch11/cannotReach.go new file mode 100644 index 0000000..9af3153 --- /dev/null +++ b/ch11/cannotReach.go @@ -0,0 +1,25 @@ +package main + +import ( + "fmt" +) + +func f1() int { + fmt.Println("Entering f1()") + // return -10 + fmt.Println("Exiting f1()") + return -1 +} + +func f2() int { + if true { + return 10 + } + fmt.Println("Exiting f2()") + return 0 +} + +func main() { + fmt.Println(f1()) + fmt.Println("Exiting program...") +} diff --git a/ch11/documentMe.go b/ch11/documentMe.go new file mode 100644 index 0000000..30cebed --- /dev/null +++ b/ch11/documentMe.go @@ -0,0 +1,26 @@ +// This package is for showcasing the documentation capabilities of Go +// It is a naive package! +package documentMe + +// Pie is a global variable +// This is a silly comment! +const Pie = 3.1415912 + +// The S1() function finds the length of a string +// It iterates over the string using range +func S1(s string) int { + if s == "" { + return 0 + } + n := 0 + for range s { + n++ + } + return n +} + +// The F1() function returns the double value of its input integer +// A better function name would have been Double()! +func F1(n int) int { + return 2 * n +} diff --git a/ch11/documentMe_test.go b/ch11/documentMe_test.go new file mode 100644 index 0000000..aed1265 --- /dev/null +++ b/ch11/documentMe_test.go @@ -0,0 +1,21 @@ +package documentMe + +import ( + "fmt" +) + +func ExampleS1() { + fmt.Println(S1("123456789")) + fmt.Println(S1("")) + // Output: + // 9 + // 0 +} + +func ExampleF1() { + fmt.Println(F1(10)) + fmt.Println(F1(2)) + // Output: + // 1 + // 55 +} diff --git a/ch11/ex.go b/ch11/ex.go new file mode 100644 index 0000000..4d937c9 --- /dev/null +++ b/ch11/ex.go @@ -0,0 +1,15 @@ +package ex + +func F1(n int) int { + if n == 0 { + return 0 + } + if n == 1 || n == 2 { + return 1 + } + return F1(n-1) + F1(n-2) +} + +func S1(s string) int { + return len(s) +} diff --git a/ch11/ex_test.go b/ch11/ex_test.go new file mode 100644 index 0000000..7c3f5e7 --- /dev/null +++ b/ch11/ex_test.go @@ -0,0 +1,21 @@ +package ex + +import ( + "fmt" +) + +func ExampleF1() { + fmt.Println(F1(10)) + fmt.Println(F1(2)) + // Output: + // 55 + // 1 +} + +func ExampleS1() { + fmt.Println(S1("123456789")) + fmt.Println(S1("")) + // Output: + // 8 + // 0 +} diff --git a/ch11/goGC.go b/ch11/goGC.go new file mode 100644 index 0000000..8858d2f --- /dev/null +++ b/ch11/goGC.go @@ -0,0 +1,53 @@ +package main + +import ( + "fmt" + "os" + "runtime" + "runtime/trace" + "time" +) + +func printStats(mem runtime.MemStats) { + runtime.ReadMemStats(&mem) + fmt.Println("mem.Alloc:", mem.Alloc) + fmt.Println("mem.TotalAlloc:", mem.TotalAlloc) + fmt.Println("mem.HeapAlloc:", mem.HeapAlloc) + fmt.Println("mem.NumGC:", mem.NumGC) + fmt.Println("-----") +} + +func main() { + f, err := os.Create("/tmp/traceFile.out") + if err != nil { + panic(err) + } + defer f.Close() + + err = trace.Start(f) + if err != nil { + fmt.Println(err) + return + } + defer trace.Stop() + + var mem runtime.MemStats + printStats(mem) + + for i := 0; i < 3; i++ { + s := make([]byte, 50000000) + if s == nil { + fmt.Println("Operation failed!") + } + } + printStats(mem) + + for i := 0; i < 5; i++ { + s := make([]byte, 100000000) + if s == nil { + fmt.Println("Operation failed!") + } + time.Sleep(time.Millisecond) + } + printStats(mem) +} diff --git a/ch11/graph.dot b/ch11/graph.dot new file mode 100644 index 0000000..09143cf --- /dev/null +++ b/ch11/graph.dot @@ -0,0 +1,24 @@ +digraph G +{ + graph [dpi = 300, bgcolor = "gray"]; + rankdir = LR; + node [shape=record, width=.2, height=.2, color="white" ]; + + node0 [label = " | | | | | | ", height = 3]; + node[ width=2 ]; + node1 [label = "{ r0 | 123 |

}", color="gray" ]; + node2 [label = "{ r10 | 13 |

}" ]; + node3 [label = "{ r11 | 23 |

}" ]; + node4 [label = "{ r12 | 326 |

}" ]; + node5 [label = "{ r13 | 1f3 |

}" ]; + node6 [label = "{ r20 | 143 |

}" ]; + node7 [label = "{ r40 | b23 |

}" ]; + + node0:p0 -> node1:e [dir=both color="red:blue"]; + node0:p1 -> node2:e [dir=back arrowhead=diamond]; + node2:p -> node3:e; + node3:p -> node4:e [dir=both arrowtail=box color="red"]; + node4:p -> node5:e [dir=forward]; + node0:p2 -> node6:e [dir=none color="orange"]; + node0:p4 -> node7:e; +} diff --git a/ch11/profileMe.go b/ch11/profileMe.go new file mode 100644 index 0000000..ee4c55f --- /dev/null +++ b/ch11/profileMe.go @@ -0,0 +1,116 @@ +package main + +import ( + "fmt" + "math" + "os" + "runtime" + "runtime/pprof" + "time" +) + +func fibo1(n int) int64 { + if n == 0 || n == 1 { + return int64(n) + } + time.Sleep(time.Millisecond) + return int64(fibo2(n-1)) + int64(fibo2(n-2)) +} + +func fibo2(n int) int { + fn := make(map[int]int) + for i := 0; i <= n; i++ { + var f int + if i <= 2 { + f = 1 + } else { + f = fn[i-1] + fn[i-2] + } + fn[i] = f + } + time.Sleep(50 * time.Millisecond) + return fn[n] +} + +func N1(n int) bool { + k := math.Floor(float64(n/2 + 1)) + for i := 2; i < int(k); i++ { + if (n % i) == 0 { + return false + } + } + return true +} + +func N2(n int) bool { + for i := 2; i < n; i++ { + if (n % i) == 0 { + return false + } + } + return true +} + +func main() { + cpuFile, err := os.Create("/tmp/cpuProfile.out") + if err != nil { + fmt.Println(err) + return + } + pprof.StartCPUProfile(cpuFile) + defer pprof.StopCPUProfile() + + total := 0 + for i := 2; i < 100000; i++ { + n := N1(i) + if n { + total = total + 1 + } + } + fmt.Println("Total primes:", total) + + total = 0 + for i := 2; i < 100000; i++ { + n := N2(i) + if n { + total = total + 1 + } + } + fmt.Println("Total primes:", total) + + for i := 1; i < 90; i++ { + n := fibo1(i) + fmt.Print(n, " ") + } + fmt.Println() + + for i := 1; i < 90; i++ { + n := fibo2(i) + fmt.Print(n, " ") + } + fmt.Println() + + runtime.GC() + + // Memory profiling! + memory, err := os.Create("/tmp/memoryProfile.out") + if err != nil { + fmt.Println(err) + return + } + defer memory.Close() + + for i := 0; i < 10; i++ { + s := make([]byte, 50000000) + if s == nil { + fmt.Println("Operation failed!") + } + time.Sleep(50 * time.Millisecond) + } + + err = pprof.WriteHeapProfile(memory) + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch11/testMe.go b/ch11/testMe.go new file mode 100644 index 0000000..f9d73df --- /dev/null +++ b/ch11/testMe.go @@ -0,0 +1,37 @@ +package testMe + +func f1(n int) int { + if n == 0 { + return 0 + } + if n == 1 { + return 1 + } + return f1(n-1) + f1(n-2) +} + +func f2(n int) int { + if n == 0 { + return 0 + } + if n == 1 { + return 2 + } + + return f2(n-1) + f2(n-2) +} + +func s1(s string) int { + if s == "" { + return 0 + } + n := 1 + for range s { + n++ + } + return n +} + +func s2(s string) int { + return len(s) +} diff --git a/ch11/testMe_test.go b/ch11/testMe_test.go new file mode 100644 index 0000000..04c1772 --- /dev/null +++ b/ch11/testMe_test.go @@ -0,0 +1,60 @@ +package testMe + +import "testing" + +func TestS1(t *testing.T) { + if s1("123456789") != 9 { + t.Error(`s1("123456789") != 9`) + } + + if s1("") != 0 { + t.Error(`s1("") != 0`) + } +} + +func TestS2(t *testing.T) { + if s2("123456789") != 9 { + t.Error(`s2("123456789") != 9`) + } + + if s2("") != 0 { + t.Error(`s2("") != 0`) + } +} + +func TestF1(t *testing.T) { + if f1(0) != 0 { + t.Error(`f1(0) != 0`) + } + + if f1(1) != 1 { + t.Error(`f1(1) != 1`) + } + + if f1(2) != 1 { + t.Error(`f1(2) != 1`) + } + + if f1(10) != 55 { + t.Error(`f1(10) != 55`) + } + +} + +func TestF2(t *testing.T) { + if f2(0) != 0 { + t.Error(`f2(0) != 0`) + } + + if f2(1) != 1 { + t.Error(`f2(1) != 1`) + } + + if f2(2) != 1 { + t.Error(`f2(2) != 1`) + } + + if f2(10) != 55 { + t.Error(`f2(10) != 55`) + } +} diff --git a/ch11/writingBU.go b/ch11/writingBU.go new file mode 100644 index 0000000..4d20a5d --- /dev/null +++ b/ch11/writingBU.go @@ -0,0 +1,82 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "strconv" +) + +var BUFFERSIZE int +var FILESIZE int + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func createBuffer(buf *[]byte, count int) { + *buf = make([]byte, count) + if count == 0 { + return + } + + for i := 0; i < count; i++ { + intByte := byte(random(0, 100)) + if len(*buf) > count { + return + } + *buf = append(*buf, intByte) + } +} + +func Create(dst string, b, f int) error { + _, err := os.Stat(dst) + if err == nil { + return fmt.Errorf("File %s already exists.", dst) + } + + destination, err := os.Create(dst) + if err != nil { + return err + } + defer destination.Close() + + if err != nil { + panic(err) + } + + buf := make([]byte, 0) + for { + createBuffer(&buf, b) + buf = buf[:b] + if _, err := destination.Write(buf); err != nil { + return err + } + + if f < 0 { + break + } + f = f - len(buf) + } + return err +} + +func main() { + if len(os.Args) != 3 { + fmt.Println("Need BUFFERSIZE FILESIZE!") + return + } + + output := "/tmp/randomFile" + BUFFERSIZE, _ = strconv.Atoi(os.Args[1]) + FILESIZE, _ = strconv.Atoi(os.Args[2]) + err := Create(output, BUFFERSIZE, FILESIZE) + if err != nil { + fmt.Println(err) + } + + err = os.Remove(output) + if err != nil { + fmt.Println(err) + } +} diff --git a/ch11/writingBU_test.go b/ch11/writingBU_test.go new file mode 100644 index 0000000..531fe50 --- /dev/null +++ b/ch11/writingBU_test.go @@ -0,0 +1,42 @@ +package main + +import ( + "fmt" + "os" + "testing" +) + +var ERR error + +func benchmarkCreate(b *testing.B, buffer, filesize int) { + var err error + for i := 0; i < b.N; i++ { + err = Create("/tmp/random", buffer, filesize) + } + ERR = err + + err = os.Remove("/tmp/random") + if err != nil { + fmt.Println(err) + } +} + +func Benchmark1Create(b *testing.B) { + benchmarkCreate(b, 1, 1000000) +} + +func Benchmark2Create(b *testing.B) { + benchmarkCreate(b, 2, 1000000) +} + +func Benchmark4Create(b *testing.B) { + benchmarkCreate(b, 4, 1000000) +} + +func Benchmark10Create(b *testing.B) { + benchmarkCreate(b, 10, 1000000) +} + +func Benchmark1000Create(b *testing.B) { + benchmarkCreate(b, 1000, 1000000) +} diff --git a/ch11/xCompile.go b/ch11/xCompile.go new file mode 100644 index 0000000..9f3a913 --- /dev/null +++ b/ch11/xCompile.go @@ -0,0 +1,12 @@ +package main + +import ( + "fmt" + "runtime" +) + +func main() { + fmt.Print("You are using ", runtime.Compiler, " ") + fmt.Println("on a", runtime.GOARCH, "machine") + fmt.Println("with Go version", runtime.Version()) +} diff --git a/ch12/DNS.go b/ch12/DNS.go new file mode 100644 index 0000000..e5f439f --- /dev/null +++ b/ch12/DNS.go @@ -0,0 +1,50 @@ +package main + +import ( + "fmt" + "net" + "os" +) + +func lookIP(address string) ([]string, error) { + hosts, err := net.LookupAddr(address) + if err != nil { + return nil, err + } + return hosts, nil +} + +func lookHostname(hostname string) ([]string, error) { + IPs, err := net.LookupHost(hostname) + if err != nil { + return nil, err + } + return IPs, nil +} + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide an argument!") + return + } + + input := arguments[1] + IPaddress := net.ParseIP(input) + + if IPaddress == nil { + IPs, err := lookHostname(input) + if err == nil { + for _, singleIP := range IPs { + fmt.Println(singleIP) + } + } + } else { + hosts, err := lookIP(input) + if err == nil { + for _, hostname := range hosts { + fmt.Println(hostname) + } + } + } +} diff --git a/ch12/MXrecords.go b/ch12/MXrecords.go new file mode 100644 index 0000000..74d4070 --- /dev/null +++ b/ch12/MXrecords.go @@ -0,0 +1,26 @@ +package main + +import ( + "fmt" + "net" + "os" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Need a domain name!") + return + } + + domain := arguments[1] + MXs, err := net.LookupMX(domain) + if err != nil { + fmt.Println(err) + return + } + + for _, MX := range MXs { + fmt.Println(MX.Host) + } +} diff --git a/ch12/NSrecords.go b/ch12/NSrecords.go new file mode 100644 index 0000000..543c36c --- /dev/null +++ b/ch12/NSrecords.go @@ -0,0 +1,26 @@ +package main + +import ( + "fmt" + "net" + "os" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Need a domain name!") + return + } + + domain := arguments[1] + NSs, err := net.LookupNS(domain) + if err != nil { + fmt.Println(err) + return + } + + for _, NS := range NSs { + fmt.Println(NS.Host) + } +} diff --git a/ch12/advancedWebClient.go b/ch12/advancedWebClient.go new file mode 100644 index 0000000..9a7d113 --- /dev/null +++ b/ch12/advancedWebClient.go @@ -0,0 +1,69 @@ +package main + +import ( + "fmt" + "net/http" + "net/http/httputil" + "net/url" + "os" + "path/filepath" + "strings" + "time" +) + +func main() { + if len(os.Args) != 2 { + fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0])) + return + } + + URL, err := url.Parse(os.Args[1]) + if err != nil { + fmt.Println("Error in parsing:", err) + return + } + + c := &http.Client{ + Timeout: 15 * time.Second, + } + request, err := http.NewRequest("GET", URL.String(), nil) + if err != nil { + fmt.Println("Get:", err) + return + } + + httpData, err := c.Do(request) + if err != nil { + fmt.Println("Error in Do():", err) + return + } + + fmt.Println("Status code:", httpData.Status) + header, _ := httputil.DumpResponse(httpData, false) + fmt.Print(string(header)) + + contentType := httpData.Header.Get("Content-Type") + characterSet := strings.SplitAfter(contentType, "charset=") + if len(characterSet) > 1 { + fmt.Println("Character Set:", characterSet[1]) + } + + if httpData.ContentLength == -1 { + fmt.Println("ContentLength is unknown!") + } else { + fmt.Println("ContentLength:", httpData.ContentLength) + } + + length := 0 + var buffer [1024]byte + r := httpData.Body + for { + n, err := r.Read(buffer[0:]) + if err != nil { + fmt.Println(err) + break + } + length = length + n + } + fmt.Println("Calculated response data length:", length) +} diff --git a/ch12/anotherTimeOut.go b/ch12/anotherTimeOut.go new file mode 100644 index 0000000..beccb1c --- /dev/null +++ b/ch12/anotherTimeOut.go @@ -0,0 +1,48 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "os" + "strconv" + "time" +) + +var timeout = time.Duration(time.Second) + +func main() { + if len(os.Args) == 1 { + fmt.Println("Please provide a URL") + return + } + + if len(os.Args) == 3 { + temp, err := strconv.Atoi(os.Args[2]) + if err != nil { + fmt.Println("Using Default Timeout!") + } else { + timeout = time.Duration(time.Duration(temp) * time.Second) + } + } + + URL := os.Args[1] + + client := http.Client{ + Timeout: timeout, + } + client.Get(URL) + + data, err := client.Get(URL) + if err != nil { + fmt.Println(err) + return + } else { + defer data.Body.Close() + _, err := io.Copy(os.Stdout, data.Body) + if err != nil { + fmt.Println(err) + return + } + } +} diff --git a/ch12/clientTimeOut.go b/ch12/clientTimeOut.go new file mode 100644 index 0000000..8c1af06 --- /dev/null +++ b/ch12/clientTimeOut.go @@ -0,0 +1,61 @@ +package main + +import ( + "fmt" + "io" + "net" + "net/http" + "os" + "path/filepath" + "strconv" + "time" +) + +var timeout = time.Duration(time.Second) + +func Timeout(network, host string) (net.Conn, error) { + conn, err := net.DialTimeout(network, host, timeout) + if err != nil { + return nil, err + } + conn.SetDeadline(time.Now().Add(timeout)) + return conn, nil +} + +func main() { + if len(os.Args) == 1 { + fmt.Printf("Usage: %s URL TIMEOUT\n", filepath.Base(os.Args[0])) + return + } + + if len(os.Args) == 3 { + temp, err := strconv.Atoi(os.Args[2]) + if err != nil { + fmt.Println("Using Default Timeout!") + } else { + timeout = time.Duration(time.Duration(temp) * time.Second) + } + } + + URL := os.Args[1] + t := http.Transport{ + Dial: Timeout, + } + + client := http.Client{ + Transport: &t, + } + + data, err := client.Get(URL) + if err != nil { + fmt.Println(err) + return + } else { + defer data.Body.Close() + _, err := io.Copy(os.Stdout, data.Body) + if err != nil { + fmt.Println(err) + return + } + } +} diff --git a/ch12/home.gohtml b/ch12/home.gohtml new file mode 100644 index 0000000..052e2d4 --- /dev/null +++ b/ch12/home.gohtml @@ -0,0 +1,17 @@ + + + + + A Key Value Store! + + + +Home sweet home! +List all elements! +Change an element! +Insert new element! + +

Welcome to the Go KV store!

+ + + diff --git a/ch12/httpTrace.go b/ch12/httpTrace.go new file mode 100644 index 0000000..014335f --- /dev/null +++ b/ch12/httpTrace.go @@ -0,0 +1,57 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "net/http/httptrace" + "os" +) + +func main() { + if len(os.Args) != 2 { + fmt.Printf("Usage: URL\n") + return + } + + URL := os.Args[1] + client := http.Client{} + + req, _ := http.NewRequest("GET", URL, nil) + trace := &httptrace.ClientTrace{ + GotFirstResponseByte: func() { + fmt.Println("First response byte!") + }, + GotConn: func(connInfo httptrace.GotConnInfo) { + fmt.Printf("Got Conn: %+v\n", connInfo) + }, + DNSDone: func(dnsInfo httptrace.DNSDoneInfo) { + fmt.Printf("DNS Info: %+v\n", dnsInfo) + }, + ConnectStart: func(network, addr string) { + fmt.Println("Dial start") + }, + ConnectDone: func(network, addr string, err error) { + fmt.Println("Dial done") + }, + WroteHeaders: func() { + fmt.Println("Wrote headers") + }, + } + + req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) + fmt.Println("Requesting data from server!") + _, err := http.DefaultTransport.RoundTrip(req) + if err != nil { + fmt.Println(err) + return + } + + response, err := client.Do(req) + if err != nil { + fmt.Println(err) + return + } + + io.Copy(os.Stdout, response.Body) +} diff --git a/ch12/insert.gohtml b/ch12/insert.gohtml new file mode 100644 index 0000000..3148701 --- /dev/null +++ b/ch12/insert.gohtml @@ -0,0 +1,32 @@ + + + + + A Key Value Store! + + + +Home sweet home! +List all elements! +Change an element! +Insert new element! + +{{if .Success}} +

Element inserted!

+{{else}} +

Please fill in the fields:

+
+
+
+
+
+
+
+
+
+ +
+{{end}} + + + diff --git a/ch12/kvWeb.go b/ch12/kvWeb.go new file mode 100644 index 0000000..9992368 --- /dev/null +++ b/ch12/kvWeb.go @@ -0,0 +1,198 @@ +package main + +import ( + "encoding/gob" + "fmt" + "html/template" + "net/http" + "os" +) + +type myElement struct { + Name string + Surname string + Id string +} + +var DATA = make(map[string]myElement) +var DATAFILE = "/tmp/dataFile.gob" + +func save() error { + fmt.Println("Saving", DATAFILE) + err := os.Remove(DATAFILE) + if err != nil { + fmt.Println(err) + } + + saveTo, err := os.Create(DATAFILE) + if err != nil { + fmt.Println("Cannot create", DATAFILE) + return err + } + defer saveTo.Close() + + encoder := gob.NewEncoder(saveTo) + err = encoder.Encode(DATA) + if err != nil { + fmt.Println("Cannot save to", DATAFILE) + return err + } + return nil +} + +func load() error { + fmt.Println("Loading", DATAFILE) + loadFrom, err := os.Open(DATAFILE) + defer loadFrom.Close() + if err != nil { + fmt.Println("Empty key/value store!") + return err + } + + decoder := gob.NewDecoder(loadFrom) + decoder.Decode(&DATA) + return nil +} + +func ADD(k string, n myElement) bool { + if k == "" { + return false + } + + if LOOKUP(k) == nil { + DATA[k] = n + return true + } + return false +} + +func DELETE(k string) bool { + if LOOKUP(k) != nil { + delete(DATA, k) + return true + } + return false +} + +func LOOKUP(k string) *myElement { + _, ok := DATA[k] + if ok { + n := DATA[k] + return &n + } else { + return nil + } +} + +func CHANGE(k string, n myElement) bool { + DATA[k] = n + return true +} + +func PRINT() { + for k, d := range DATA { + fmt.Printf("key: %s value: %v\n", k, d) + } +} + +func homePage(w http.ResponseWriter, r *http.Request) { + fmt.Println("Serving", r.Host, "for", r.URL.Path) + myT := template.Must(template.ParseGlob("home.gohtml")) + myT.ExecuteTemplate(w, "home.gohtml", nil) +} + +func listAll(w http.ResponseWriter, r *http.Request) { + fmt.Println("Listing the contents of the KV store!") + + fmt.Fprintf(w, "Home sweet home!") + fmt.Fprintf(w, "List all elements!") + fmt.Fprintf(w, "Change an element!") + fmt.Fprintf(w, "Insert new element!") + + fmt.Fprintf(w, "

The contents of the KV store are:

") + fmt.Fprintf(w, "
    ") + for k, v := range DATA { + fmt.Fprintf(w, "
  • ") + fmt.Fprintf(w, "%s with value: %v\n", k, v) + fmt.Fprintf(w, "
  • ") + } + + fmt.Fprintf(w, "
") +} + +func changeElement(w http.ResponseWriter, r *http.Request) { + fmt.Println("Changing an element of the KV store!") + tmpl := template.Must(template.ParseFiles("update.gohtml")) + if r.Method != http.MethodPost { + tmpl.Execute(w, nil) + return + } + + key := r.FormValue("key") + n := myElement{ + Name: r.FormValue("name"), + Surname: r.FormValue("surname"), + Id: r.FormValue("id"), + } + + if !CHANGE(key, n) { + fmt.Println("Update operation failed!") + } else { + err := save() + if err != nil { + fmt.Println(err) + return + } + tmpl.Execute(w, struct{ Success bool }{true}) + } +} + +func insertElement(w http.ResponseWriter, r *http.Request) { + fmt.Println("Inserting an element to the KV store!") + tmpl := template.Must(template.ParseFiles("insert.gohtml")) + if r.Method != http.MethodPost { + tmpl.Execute(w, nil) + return + } + + key := r.FormValue("key") + n := myElement{ + Name: r.FormValue("name"), + Surname: r.FormValue("surname"), + Id: r.FormValue("id"), + } + + if !ADD(key, n) { + fmt.Println("Add operation failed!") + } else { + err := save() + if err != nil { + fmt.Println(err) + return + } + tmpl.Execute(w, struct{ Success bool }{true}) + } +} + +func main() { + err := load() + if err != nil { + fmt.Println(err) + } + + PORT := ":8001" + arguments := os.Args + if len(arguments) != 1 { + PORT = ":" + arguments[1] + } + fmt.Println("Using port number: ", PORT) + + http.HandleFunc("/", homePage) + http.HandleFunc("/change", changeElement) + http.HandleFunc("/list", listAll) + http.HandleFunc("/insert", insertElement) + err = http.ListenAndServe(PORT, nil) + if err != nil { + fmt.Println(err) + } +} diff --git a/ch12/netCapabilities.go b/ch12/netCapabilities.go new file mode 100644 index 0000000..be6cffe --- /dev/null +++ b/ch12/netCapabilities.go @@ -0,0 +1,24 @@ +package main + +import ( + "fmt" + "net" +) + +func main() { + interfaces, err := net.Interfaces() + + if err != nil { + fmt.Print(err) + return + } + + for _, i := range interfaces { + fmt.Printf("Name : %v\n", i.Name) + fmt.Println("Interface Flags:", i.Flags.String()) + fmt.Println("Interface MTU:", i.MTU) + fmt.Println("Interface Hardware Address:", i.HardwareAddr) + + fmt.Println() + } +} diff --git a/ch12/netConfig.go b/ch12/netConfig.go new file mode 100644 index 0000000..fe8f7c5 --- /dev/null +++ b/ch12/netConfig.go @@ -0,0 +1,28 @@ +package main + +import ( + "fmt" + "net" +) + +func main() { + interfaces, err := net.Interfaces() + if err != nil { + fmt.Println(err) + return + } + + for _, i := range interfaces { + fmt.Printf("Interface: %v\n", i.Name) + byName, err := net.InterfaceByName(i.Name) + if err != nil { + fmt.Println(err) + } + + addresses, err := byName.Addrs() + for k, v := range addresses { + fmt.Printf("Interface Address #%v : %v\n", k, v.String()) + } + fmt.Println() + } +} diff --git a/ch12/serverTimeOut.go b/ch12/serverTimeOut.go new file mode 100644 index 0000000..d913099 --- /dev/null +++ b/ch12/serverTimeOut.go @@ -0,0 +1,48 @@ +package main + +import ( + "fmt" + "net/http" + "os" + "time" +) + +func myHandler(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served: %s\n", r.Host) +} + +func timeHandler(w http.ResponseWriter, r *http.Request) { + t := time.Now().Format(time.RFC1123) + Body := "The current time is:" + fmt.Fprintf(w, "

%s

", Body) + fmt.Fprintf(w, "

%s

\n", t) + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served time for: %s\n", r.Host) +} + +func main() { + PORT := ":8001" + arguments := os.Args + if len(arguments) != 1 { + PORT = ":" + arguments[1] + } + fmt.Println("Using port number: ", PORT) + + m := http.NewServeMux() + srv := &http.Server{ + Addr: PORT, + Handler: m, + ReadTimeout: 3 * time.Second, + WriteTimeout: 3 * time.Second, + } + + m.HandleFunc("/time", timeHandler) + m.HandleFunc("/", myHandler) + + err := srv.ListenAndServe() + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch12/testWWW.go b/ch12/testWWW.go new file mode 100644 index 0000000..6db25f4 --- /dev/null +++ b/ch12/testWWW.go @@ -0,0 +1,41 @@ +package main + +import ( + "fmt" + "net/http" + "os" +) + +func CheckStatusOK(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + fmt.Fprintf(w, `Fine!`) +} + +func StatusNotFound(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) +} + +func MyHandler(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served: %s\n", r.Host) +} + +func main() { + PORT := ":8001" + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Using default port number: ", PORT) + } else { + PORT = ":" + arguments[1] + } + + http.HandleFunc("/CheckStatusOK", CheckStatusOK) + http.HandleFunc("/StatusNotFound", StatusNotFound) + http.HandleFunc("/", MyHandler) + + err := http.ListenAndServe(PORT, nil) + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch12/testWWW_test.go b/ch12/testWWW_test.go new file mode 100644 index 0000000..6fa8cd4 --- /dev/null +++ b/ch12/testWWW_test.go @@ -0,0 +1,47 @@ +package main + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" +) + +func TestCheckStatusOK(t *testing.T) { + req, err := http.NewRequest("GET", "/CheckStatusOK", nil) + if err != nil { + fmt.Println(err) + return + } + + rr := httptest.NewRecorder() + handler := http.HandlerFunc(CheckStatusOK) + handler.ServeHTTP(rr, req) + + status := rr.Code + if status != http.StatusOK { + t.Errorf("handler returned %v", status) + } + + expect := `Fine!` + if rr.Body.String() != expect { + t.Errorf("handler returned %v", rr.Body.String()) + } +} + +func TestStatusNotFound(t *testing.T) { + req, err := http.NewRequest("GET", "/StatusNotFound", nil) + if err != nil { + fmt.Println(err) + return + } + + rr := httptest.NewRecorder() + handler := http.HandlerFunc(StatusNotFound) + handler.ServeHTTP(rr, req) + + status := rr.Code + if status != http.StatusNotFound { + t.Errorf("handler returned %v", status) + } +} diff --git a/ch12/update.gohtml b/ch12/update.gohtml new file mode 100644 index 0000000..89af750 --- /dev/null +++ b/ch12/update.gohtml @@ -0,0 +1,32 @@ + + + + + A Key Value Store! + + + +Home sweet home! +List all elements! +Change an element! +Insert new element! + +{{if .Success}} +

Element updated!

+{{else}} +

Please fill in the fields:

+
+
+
+
+
+
+
+
+
+ +
+{{end}} + + + diff --git a/ch12/webClient.go b/ch12/webClient.go new file mode 100644 index 0000000..4032134 --- /dev/null +++ b/ch12/webClient.go @@ -0,0 +1,31 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "os" + "path/filepath" +) + +func main() { + if len(os.Args) != 2 { + fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0])) + return + } + + URL := os.Args[1] + data, err := http.Get(URL) + + if err != nil { + fmt.Println(err) + return + } else { + defer data.Body.Close() + _, err := io.Copy(os.Stdout, data.Body) + if err != nil { + fmt.Println(err) + return + } + } +} diff --git a/ch12/www.go b/ch12/www.go new file mode 100644 index 0000000..7e0e443 --- /dev/null +++ b/ch12/www.go @@ -0,0 +1,40 @@ +package main + +import ( + "fmt" + "net/http" + "os" + "time" +) + +func myHandler(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served: %s\n", r.Host) +} + +func timeHandler(w http.ResponseWriter, r *http.Request) { + t := time.Now().Format(time.RFC1123) + Body := "The current time is:" + fmt.Fprintf(w, "

%s

", Body) + fmt.Fprintf(w, "

%s

\n", t) + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served time for: %s\n", r.Host) +} + +func main() { + PORT := ":8001" + arguments := os.Args + if len(arguments) != 1 { + PORT = ":" + arguments[1] + } + fmt.Println("Using port number: ", PORT) + + http.HandleFunc("/time", timeHandler) + http.HandleFunc("/", myHandler) + + err := http.ListenAndServe(PORT, nil) + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch12/wwwProfile.go b/ch12/wwwProfile.go new file mode 100644 index 0000000..0cd49b2 --- /dev/null +++ b/ch12/wwwProfile.go @@ -0,0 +1,50 @@ +package main + +import ( + "fmt" + "net/http" + "net/http/pprof" + "os" + "time" +) + +func myHandler(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served: %s\n", r.Host) +} + +func timeHandler(w http.ResponseWriter, r *http.Request) { + t := time.Now().Format(time.RFC1123) + Body := "The current time is:" + fmt.Fprintf(w, "

%s

", Body) + fmt.Fprintf(w, "

%s

\n", t) + fmt.Fprintf(w, "Serving: %s\n", r.URL.Path) + fmt.Printf("Served time for: %s\n", r.Host) +} + +func main() { + PORT := ":8001" + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Using default port number: ", PORT) + } else { + PORT = ":" + arguments[1] + fmt.Println("Using port number: ", PORT) + } + + r := http.NewServeMux() + r.HandleFunc("/time", timeHandler) + r.HandleFunc("/", myHandler) + + r.HandleFunc("/debug/pprof/", pprof.Index) + r.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline) + r.HandleFunc("/debug/pprof/profile", pprof.Profile) + r.HandleFunc("/debug/pprof/symbol", pprof.Symbol) + r.HandleFunc("/debug/pprof/trace", pprof.Trace) + + err := http.ListenAndServe(PORT, r) + if err != nil { + fmt.Println(err) + return + } +} diff --git a/ch13/RPCclient.go b/ch13/RPCclient.go new file mode 100644 index 0000000..00ab960 --- /dev/null +++ b/ch13/RPCclient.go @@ -0,0 +1,40 @@ +package main + +import ( + "fmt" + "net/rpc" + "os" + "sharedRPC" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a host:port string!") + return + } + + CONNECT := arguments[1] + c, err := rpc.Dial("tcp", CONNECT) + if err != nil { + fmt.Println(err) + return + } + + args := sharedRPC.MyFloats{16, -0.5} + var reply float64 + + err = c.Call("MyInterface.Multiply", args, &reply) + if err != nil { + fmt.Println(err) + return + } + fmt.Printf("Reply (Multiply): %f\n", reply) + + err = c.Call("MyInterface.Power", args, &reply) + if err != nil { + fmt.Println(err) + return + } + fmt.Printf("Reply (Power): %f\n", reply) +} diff --git a/ch13/RPCserver.go b/ch13/RPCserver.go new file mode 100644 index 0000000..4133bbc --- /dev/null +++ b/ch13/RPCserver.go @@ -0,0 +1,56 @@ +package main + +import ( + "fmt" + "math" + "net" + "net/rpc" + "os" + "sharedRPC" +) + +type MyInterface struct{} + +func Power(x, y float64) float64 { + return math.Pow(x, y) +} + +func (t *MyInterface) Multiply(arguments *sharedRPC.MyFloats, reply *float64) error { + *reply = arguments.A1 * arguments.A2 + return nil +} + +func (t *MyInterface) Power(arguments *sharedRPC.MyFloats, reply *float64) error { + *reply = Power(arguments.A1, arguments.A2) + return nil +} + +func main() { + PORT := ":1234" + arguments := os.Args + if len(arguments) != 1 { + PORT = ":" + arguments[1] + } + + myInterface := new(MyInterface) + rpc.Register(myInterface) + t, err := net.ResolveTCPAddr("tcp4", PORT) + if err != nil { + fmt.Println(err) + return + } + l, err := net.ListenTCP("tcp4", t) + if err != nil { + fmt.Println(err) + return + } + + for { + c, err := l.Accept() + if err != nil { + continue + } + fmt.Printf("%s\n", c.RemoteAddr()) + rpc.ServeConn(c) + } +} diff --git a/ch13/TCPclient.go b/ch13/TCPclient.go new file mode 100644 index 0000000..c04804b --- /dev/null +++ b/ch13/TCPclient.go @@ -0,0 +1,38 @@ +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strings" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide host:port.") + return + } + + CONNECT := arguments[1] + c, err := net.Dial("tcp", CONNECT) + if err != nil { + fmt.Println(err) + return + } + + for { + reader := bufio.NewReader(os.Stdin) + fmt.Print(">> ") + text, _ := reader.ReadString('\n') + fmt.Fprintf(c, text+"\n") + + message, _ := bufio.NewReader(c).ReadString('\n') + fmt.Print("->: " + message) + if strings.TrimSpace(string(text)) == "STOP" { + fmt.Println("TCP client exiting...") + return + } + } +} diff --git a/ch13/TCPserver.go b/ch13/TCPserver.go new file mode 100644 index 0000000..d0dbcb9 --- /dev/null +++ b/ch13/TCPserver.go @@ -0,0 +1,49 @@ +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strings" + "time" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide port number") + return + } + + PORT := ":" + arguments[1] + l, err := net.Listen("tcp", PORT) + if err != nil { + fmt.Println(err) + return + } + defer l.Close() + + c, err := l.Accept() + if err != nil { + fmt.Println(err) + return + } + + for { + netData, err := bufio.NewReader(c).ReadString('\n') + if err != nil { + fmt.Println(err) + return + } + if strings.TrimSpace(string(netData)) == "STOP" { + fmt.Println("Exiting TCP server!") + return + } + + fmt.Print("-> ", string(netData)) + t := time.Now() + myTime := t.Format(time.RFC3339) + "\n" + c.Write([]byte(myTime)) + } +} diff --git a/ch13/UDPclient.go b/ch13/UDPclient.go new file mode 100644 index 0000000..0465c7d --- /dev/null +++ b/ch13/UDPclient.go @@ -0,0 +1,54 @@ +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strings" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a host:port string") + return + } + CONNECT := arguments[1] + + s, err := net.ResolveUDPAddr("udp4", CONNECT) + c, err := net.DialUDP("udp4", nil, s) + + if err != nil { + fmt.Println(err) + return + } + + fmt.Printf("The UDP server is %s\n", c.RemoteAddr().String()) + defer c.Close() + + for { + reader := bufio.NewReader(os.Stdin) + fmt.Print(">> ") + text, _ := reader.ReadString('\n') + data := []byte(text + "\n") + _, err = c.Write(data) + if strings.TrimSpace(string(data)) == "STOP" { + fmt.Println("Exiting UDP client!") + return + } + + if err != nil { + fmt.Println(err) + return + } + + buffer := make([]byte, 1024) + n, _, err := c.ReadFromUDP(buffer) + if err != nil { + fmt.Println(err) + return + } + fmt.Printf("Reply: %s\n", string(buffer[0:n])) + } +} diff --git a/ch13/UDPserver.go b/ch13/UDPserver.go new file mode 100644 index 0000000..68007fa --- /dev/null +++ b/ch13/UDPserver.go @@ -0,0 +1,58 @@ +package main + +import ( + "fmt" + "math/rand" + "net" + "os" + "strconv" + "strings" + "time" +) + +func random(min, max int) int { + return rand.Intn(max-min) + min +} + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a port number!") + return + } + PORT := ":" + arguments[1] + + s, err := net.ResolveUDPAddr("udp4", PORT) + if err != nil { + fmt.Println(err) + return + } + + connection, err := net.ListenUDP("udp4", s) + if err != nil { + fmt.Println(err) + return + } + + defer connection.Close() + buffer := make([]byte, 1024) + rand.Seed(time.Now().Unix()) + + for { + n, addr, err := connection.ReadFromUDP(buffer) + fmt.Print("-> ", string(buffer[0:n-1])) + + if strings.TrimSpace(string(buffer[0:n])) == "STOP" { + fmt.Println("Exiting UDP server!") + return + } + + data := []byte(strconv.Itoa(random(1, 1001))) + fmt.Printf("data: %s\n", string(data)) + _, err = connection.WriteToUDP(data, addr) + if err != nil { + fmt.Println(err) + return + } + } +} diff --git a/ch13/fiboTCP.go b/ch13/fiboTCP.go new file mode 100644 index 0000000..12ddd29 --- /dev/null +++ b/ch13/fiboTCP.go @@ -0,0 +1,74 @@ +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strconv" + "strings" + "time" +) + +func f(n int) int { + fn := make(map[int]int) + for i := 0; i <= n; i++ { + var f int + if i <= 2 { + f = 1 + } else { + f = fn[i-1] + fn[i-2] + } + fn[i] = f + } + return fn[n] +} + +func handleConnection(c net.Conn) { + for { + netData, err := bufio.NewReader(c).ReadString('\n') + if err != nil { + fmt.Println(err) + os.Exit(100) + } + + temp := strings.TrimSpace(string(netData)) + if temp == "STOP" { + break + } + + fibo := "-1\n" + n, err := strconv.Atoi(temp) + if err == nil { + fibo = strconv.Itoa(f(n)) + "\n" + } + c.Write([]byte(string(fibo))) + } + time.Sleep(5 * time.Second) + c.Close() +} + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a port number!") + return + } + + PORT := ":" + arguments[1] + l, err := net.Listen("tcp4", PORT) + if err != nil { + fmt.Println(err) + return + } + defer l.Close() + + for { + c, err := l.Accept() + if err != nil { + fmt.Println(err) + return + } + go handleConnection(c) + } +} diff --git a/ch13/kvTCP.go b/ch13/kvTCP.go new file mode 100644 index 0000000..417a403 --- /dev/null +++ b/ch13/kvTCP.go @@ -0,0 +1,220 @@ +package main + +import ( + "bufio" + "encoding/gob" + "fmt" + "net" + "os" + "strings" +) + +type myElement struct { + Name string + Surname string + Id string +} + +const welcome = "Welcome to the Key Value store!\n" + +var DATA = make(map[string]myElement) +var DATAFILE = "/tmp/dataFile.gob" + +func handleConnection(c net.Conn) { + c.Write([]byte(welcome)) + for { + netData, err := bufio.NewReader(c).ReadString('\n') + if err != nil { + fmt.Println(err) + return + } + + command := strings.TrimSpace(string(netData)) + tokens := strings.Fields(command) + switch len(tokens) { + case 0: + continue + case 1: + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + case 2: + tokens = append(tokens, "") + tokens = append(tokens, "") + tokens = append(tokens, "") + case 3: + tokens = append(tokens, "") + tokens = append(tokens, "") + case 4: + tokens = append(tokens, "") + } + + switch tokens[0] { + case "STOP": + err = save() + if err != nil { + fmt.Println(err) + } + c.Close() + return + case "PRINT": + PRINT(c) + case "DELETE": + if !DELETE(tokens[1]) { + netData := "Delete operation failed!\n" + c.Write([]byte(netData)) + } else { + netData := "Delete operation successful!\n" + c.Write([]byte(netData)) + } + case "ADD": + n := myElement{tokens[2], tokens[3], tokens[4]} + if !ADD(tokens[1], n) { + netData := "Add operation failed!\n" + c.Write([]byte(netData)) + } else { + netData := "Add operation successful!\n" + c.Write([]byte(netData)) + } + err = save() + if err != nil { + fmt.Println(err) + } + case "LOOKUP": + n := LOOKUP(tokens[1]) + if n != nil { + netData := fmt.Sprintf("%v\n", *n) + c.Write([]byte(netData)) + } else { + netData := "Did not find key!\n" + c.Write([]byte(netData)) + } + case "CHANGE": + n := myElement{tokens[2], tokens[3], tokens[4]} + if !CHANGE(tokens[1], n) { + netData := "Update operation failed!\n" + c.Write([]byte(netData)) + } else { + netData := "Update operation successful!\n" + c.Write([]byte(netData)) + } + err = save() + if err != nil { + fmt.Println(err) + } + default: + netData := "Unknown command – please try again!\n" + c.Write([]byte(netData)) + } + } +} + +func save() error { + fmt.Println("Saving", DATAFILE) + err := os.Remove(DATAFILE) + if err != nil { + fmt.Println(err) + } + + saveTo, err := os.Create(DATAFILE) + if err != nil { + fmt.Println("Cannot create", DATAFILE) + return err + } + defer saveTo.Close() + + encoder := gob.NewEncoder(saveTo) + err = encoder.Encode(DATA) + if err != nil { + fmt.Println("Cannot save to", DATAFILE) + return err + } + return nil +} + +func load() error { + fmt.Println("Loading", DATAFILE) + loadFrom, err := os.Open(DATAFILE) + defer loadFrom.Close() + if err != nil { + fmt.Println("Empty key/value store!") + return err + } + + decoder := gob.NewDecoder(loadFrom) + decoder.Decode(&DATA) + return nil +} + +func ADD(k string, n myElement) bool { + if k == "" { + return false + } + + if LOOKUP(k) == nil { + DATA[k] = n + return true + } + return false +} + +func DELETE(k string) bool { + if LOOKUP(k) != nil { + delete(DATA, k) + return true + } + return false +} + +func LOOKUP(k string) *myElement { + _, ok := DATA[k] + if ok { + n := DATA[k] + return &n + } else { + return nil + } +} + +func CHANGE(k string, n myElement) bool { + DATA[k] = n + return true +} + +func PRINT(c net.Conn) { + for k, d := range DATA { + netData := fmt.Sprintf("key: %s value: %v\n", k, d) + c.Write([]byte(netData)) + } +} + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a port number!") + return + } + + PORT := ":" + arguments[1] + l, err := net.Listen("tcp", PORT) + if err != nil { + fmt.Println(err) + return + } + defer l.Close() + + err = load() + if err != nil { + fmt.Println(err) + } + + for { + c, err := l.Accept() + if err != nil { + fmt.Println(err) + os.Exit(100) + } + go handleConnection(c) + } +} diff --git a/ch13/lowLevel.go b/ch13/lowLevel.go new file mode 100644 index 0000000..341b7a3 --- /dev/null +++ b/ch13/lowLevel.go @@ -0,0 +1,28 @@ +package main + +import ( + "fmt" + "net" +) + +func main() { + netaddr, err := net.ResolveIPAddr("ip4", "127.0.0.1") + if err != nil { + fmt.Println(err) + return + } + conn, err := net.ListenIP("ip4:icmp", netaddr) + if err != nil { + fmt.Println(err) + return + } + + buffer := make([]byte, 1024) + n, _, err := conn.ReadFrom(buffer) + if err != nil { + fmt.Println(err) + return + } + + fmt.Printf("% X\n", buffer[0:n]) +} diff --git a/ch13/otherTCPclient.go b/ch13/otherTCPclient.go new file mode 100644 index 0000000..57dcd6d --- /dev/null +++ b/ch13/otherTCPclient.go @@ -0,0 +1,46 @@ +package main + +import ( + "bufio" + "fmt" + "net" + "os" + "strings" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a server:port string!") + return + } + + CONNECT := arguments[1] + + tcpAddr, err := net.ResolveTCPAddr("tcp4", CONNECT) + if err != nil { + fmt.Println("ResolveTCPAddr:", err.Error()) + return + } + + conn, err := net.DialTCP("tcp4", nil, tcpAddr) + if err != nil { + fmt.Println("DialTCP:", err.Error()) + return + } + + for { + reader := bufio.NewReader(os.Stdin) + fmt.Print(">> ") + text, _ := reader.ReadString('\n') + fmt.Fprintf(conn, text+"\n") + + message, _ := bufio.NewReader(conn).ReadString('\n') + fmt.Print("->: " + message) + if strings.TrimSpace(string(text)) == "STOP" { + fmt.Println("TCP client exiting...") + conn.Close() + return + } + } +} diff --git a/ch13/otherTCPserver.go b/ch13/otherTCPserver.go new file mode 100644 index 0000000..cd5dc4f --- /dev/null +++ b/ch13/otherTCPserver.go @@ -0,0 +1,58 @@ +package main + +import ( + "fmt" + "net" + "os" + "strings" +) + +func main() { + arguments := os.Args + if len(arguments) == 1 { + fmt.Println("Please provide a port number!") + return + } + + SERVER := "localhost" + ":" + arguments[1] + + s, err := net.ResolveTCPAddr("tcp", SERVER) + if err != nil { + fmt.Println(err) + return + } + + l, err := net.ListenTCP("tcp", s) + if err != nil { + fmt.Println(err) + return + } + + buffer := make([]byte, 1024) + conn, err := l.Accept() + if err != nil { + fmt.Println(err) + return + } + + for { + n, err := conn.Read(buffer) + if err != nil { + fmt.Println(err) + return + } + + if strings.TrimSpace(string(buffer[0:n])) == "STOP" { + fmt.Println("Exiting TCP server!") + conn.Close() + return + } + + fmt.Print("> ", string(buffer[0:n-1])) + _, err = conn.Write(buffer) + if err != nil { + fmt.Println(err) + return + } + } +} diff --git a/ch13/sharedRPC.go b/ch13/sharedRPC.go new file mode 100644 index 0000000..32a300c --- /dev/null +++ b/ch13/sharedRPC.go @@ -0,0 +1,10 @@ +package sharedRPC + +type MyFloats struct { + A1, A2 float64 +} + +type MyInterface interface { + Multiply(arguments *MyFloats, reply *float64) error + Power(arguments *MyFloats, reply *float64) error +} diff --git a/ch13/syscallNet.go b/ch13/syscallNet.go new file mode 100644 index 0000000..1d9d0f7 --- /dev/null +++ b/ch13/syscallNet.go @@ -0,0 +1,36 @@ +package main + +import ( + "fmt" + "os" + "syscall" +) + +func main() { + fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP) + if err != nil { + fmt.Println("Error in syscall.Socket:", err) + return + } + + f := os.NewFile(uintptr(fd), "captureICMP") + if f == nil { + fmt.Println("Error in os.NewFile:", err) + return + } + + err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, 256) + if err != nil { + fmt.Println("Error in syscall.Socket:", err) + return + } + + for { + buf := make([]byte, 1024) + numRead, err := f.Read(buf) + if err != nil { + fmt.Println(err) + } + fmt.Printf("% X\n", buf[:numRead]) + } +}