Use modularity / up to Exercise 1-12
authorwatkinsr <ryanwatkins54@gmail.com>
Tue, 2 Jun 2020 00:52:52 +0000 (01:52 +0100)
committerwatkinsr <ryanwatkins54@gmail.com>
Tue, 2 Jun 2020 00:52:52 +0000 (01:52 +0100)
fetch/fetch.go
fetchall/fetchall.go [new file with mode: 0644]
go.mod [new file with mode: 0644]
httpserve/httpserve.go [new file with mode: 0644]
lissajous/lissajous.go
lissajous/test.go [deleted file]
main.go [new file with mode: 0644]

index 07125533a36298d5415c3403782fa9b0b49d64e1..2f215686d261edc1aa6ac90603c26789580a77d8 100644 (file)
@@ -1,24 +1,29 @@
 // Fetch prints the content found at a URL.
-package main
+package fetch
 import (
   "fmt"
-  "io/ioutil"
+  "io"
   "net/http"
   "os"
+  "strings"
 )
 func main() {
   for _, url := range os.Args[1:] {
+    if !(strings.HasPrefix(url, "http://")) {
+      url = "http://" + url
+    }
     resp, err := http.Get(url)
     if err != nil {
       fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
       os.Exit(1)
     }
-    b, err := ioutil.ReadAll(resp.Body)
-    resp.Body.Close()
+    _, err = io.Copy(os.Stdout, resp.Body)
+    fmt.Println("\nstatus: " + resp.Status)
     if err != nil {
-      fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err)
+      fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
       os.Exit(1)
     }
-    fmt.Printf("%s", b)
+    // b, err := ioutil.ReadAll(resp.Body)
+    resp.Body.Close()
   }
 }
diff --git a/fetchall/fetchall.go b/fetchall/fetchall.go
new file mode 100644 (file)
index 0000000..1e46c65
--- /dev/null
@@ -0,0 +1,44 @@
+package fetchall
+
+import (
+  "fmt"
+  "io"
+  // "io/ioutil"
+  "net/http"
+  "net/url"
+  "os"
+  "time"
+)
+
+func main() {
+  start := time.Now()
+  ch := make(chan string)
+  for _, url := range os.Args[1:] {
+    go fetch(url, ch) // start a goroutine
+  }
+  for range os.Args[1:] {
+    fmt.Println(<-ch) // receive from channel ch
+  }
+  fmt.Printf("%2.fs elapsed\n", time.Since(start).Seconds())
+}
+func fetch(uri string, ch chan<- string) {
+  start := time.Now()
+  resp, err := http.Get(uri)
+  if err != nil {
+    ch <- fmt.Sprint(err) // send to channel ch
+    return
+  }
+  f, err := os.Create(url.QueryEscape(uri))
+  if err != nil {
+    ch <- fmt.Sprintf("error creating file: %v", err)
+    return
+  }
+  nbytes, err := io.Copy(f, resp.Body)
+  resp.Body.Close() // dont leak resources
+  if err != nil {
+    ch <- fmt.Sprintf("while reading %s: %v", uri, err)
+    return
+  }
+  secs := time.Since(start).Seconds()
+  ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, uri)
+}
diff --git a/go.mod b/go.mod
new file mode 100644 (file)
index 0000000..72b9a51
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,3 @@
+module git.ryanwatkins.me/goproglang
+
+go 1.14
diff --git a/httpserve/httpserve.go b/httpserve/httpserve.go
new file mode 100644 (file)
index 0000000..ef4576b
--- /dev/null
@@ -0,0 +1,41 @@
+package httpserve
+
+import (
+  "fmt"
+  "log"
+  "net/http"
+  "sync"
+  "strconv"
+  
+  "git.ryanwatkins.me/goproglang/lissajous"
+)
+
+var mu sync.Mutex
+var count int
+
+func Serve() {
+  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+    v := r.URL.Query().Get("cycles")
+    if v != "" {
+      cycles, _ := strconv.Atoi(v)
+      lissajous.Run(w, cycles)
+    } else {
+      cycles := 5
+      lissajous.Run(w, cycles)
+    }
+  })
+  http.HandleFunc("/count", counter)
+  log.Fatal(http.ListenAndServe("localhost:8000", nil))
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {
+  fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
+  mu.Lock()
+  count++
+  mu.Unlock()
+}
+func counter(w http.ResponseWriter, r *http.Request) {
+  mu.Lock()
+  fmt.Fprintf(w, "Count %d\n", count)
+  mu.Unlock()
+}
index 8e3e5c9f2799dbe84e5cbe33fd213b01b1c2ca9f..e43a51a9651896c858ebabff54f40abfbeceb136 100644 (file)
@@ -1,57 +1,59 @@
-package main
+package lissajous
 
 import (
-  // "fmt"
-  "image"
-  "image/color"
-  "image/gif"
-  "io"
-  "math"
-  "math/rand"
-  "os"
-  "time"
+       // "fmt"
+       "image"
+       "image/color"
+       "image/gif"
+       "io"
+       "math"
+       "math/rand"
+       "net/http"
+       // "os"
+       "time"
 )
 
-var palette = []color.Color{color.RGBA{0x00,0x16,0x00,0xff}, color.Black, color.White}
+var palette = []color.Color{color.RGBA{0x00, 0x16, 0x00, 0xff}, color.Black, color.White}
 
 const (
-  whiteIndex = 2
-  blackIndex = 1
-  greenIndex = 0
+       whiteIndex = 2
+       blackIndex = 1
+       greenIndex = 0
 )
-func main() {
-  rand.Seed(time.Now().UnixNano())
-  paletteIndex := uint8 (rand.Intn(2))
-  // fmt.Println("paletteIndex: ", paletteIndex)
-  lissajous(os.Stdout, paletteIndex)
+
+func Run(w http.ResponseWriter, c int) {
+       rand.Seed(time.Now().UnixNano())
+       paletteIndex := uint8(rand.Intn(2))
+       // fmt.Println("paletteIndex: ", paletteIndex)
+       lissajous(w, c, paletteIndex)
 }
-func lissajous(out io.Writer, paletteIndex uint8) {
-  const (
-    cycles = 5
-    res = 0.001
-    size = 100
-    nframes = 64
-    delay = 8
-  )
-  freq := rand.Float64() * 3.0
-  anim := gif.GIF{LoopCount: nframes}
-  phase := 0.0
-  for i := 0; i < nframes; i++ {
-    rect := image.Rect(0, 0, 2*size+1, 2*size+1)
-    img := image.NewPaletted(rect, palette)
-    for t:= 0.0; t < cycles*2*math.Pi; t += res {
-      x := math.Sin(t)
-      y := math.Sin(t*freq + phase)
-      img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), paletteIndex)
-    }
-    phase += 1
-    anim.Delay = append(anim.Delay, delay)
-    anim.Image = append(anim.Image, img)
-  }
-  gif.EncodeAll(out, &anim)
+func lissajous(out io.Writer, c int, paletteIndex uint8) {
+  cycles := float64(c)
+       const (
+               res     = 0.001
+               size    = 100
+               nframes = 64
+               delay   = 8
+       )
+       freq := rand.Float64() * 3.0
+       anim := gif.GIF{LoopCount: nframes}
+       phase := 0.0
+       for i := 0; i < nframes; i++ {
+               rect := image.Rect(0, 0, 2*size+1, 2*size+1)
+               img := image.NewPaletted(rect, palette)
+               for t := 0.0; t < cycles*2*math.Pi; t += res {
+                       x := math.Sin(t)
+                       y := math.Sin(t*freq + phase)
+                       img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), paletteIndex)
+               }
+               phase += 1
+               anim.Delay = append(anim.Delay, delay)
+               anim.Image = append(anim.Image, img)
+       }
+       gif.EncodeAll(out, &anim)
 }
 
 /* Exercise 1.6: Modify the Lissajous program to produce images in multiple colors by adding
-   more values to palette and then displaying them by changing the third argument of SetColorindex 
+   more values to palette and then displaying them by changing the third argument of SetColorindex
    in some interesting way
 */
diff --git a/lissajous/test.go b/lissajous/test.go
deleted file mode 100644 (file)
index 6fd6e45..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-package main
-
-
-import (
-  "os"
-)
-
-func main(){
-}
diff --git a/main.go b/main.go
new file mode 100644 (file)
index 0000000..30b3892
--- /dev/null
+++ b/main.go
@@ -0,0 +1,9 @@
+package main
+
+import (
+  "git.ryanwatkins.me/goproglang/httpserve"
+)
+
+func main() {
+  httpserve.Serve()
+}