save initial work

Author: mikey179

delete_repo.go

@@ -0,0 +1,23 @@
+
+import (
+	"database/sql"
+	"fmt"
+)
+
+// START OMIT
+func Delete(db *sql.DB, theStream *Stream) error {
+	stmt, err := db.Prepare("DELETE FROM streams WHERE path = ?")
+	if err != nil {
+		return fmt.Errorf("could not prepare DELETE statement: %v", err)
+	}
+
+	defer stmt.Close()
+	_, err = stmt.Exec(theStream.Path)
+	if err != nil {
+		return fmt.Errorf("could not execute DELETE statement: %v", err)
+	}
+
+	return nil
+}
+
+// END OMIT

error_context.go

@@ -0,0 +1,15 @@
+import (
+	"fmt"
+	"os"
+)
+
+// START OMIT
+func readConfig(configFile string) error {
+	f, err := os.Open(configFile)
+	if err != nil {
+		return fmt.Errorf("could not read config from file %s: %v", configFile, err)
+	}
+	// do something with the open *File f
+}
+
+// END OMIT

error_nocontext.go

@@ -0,0 +1,14 @@
+import (
+	"os"
+)
+
+// START OMIT
+func readConfig(configFile string) error {
+	f, err := os.Open(configFile)
+	if err != nil {
+		return err
+	}
+	// do something with the open *File f
+}
+
+// END OMIT

errorhttphandler.go

@@ -0,0 +1,11 @@
+import "net/http"
+
+// START OMIT
+func (fn myHttpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if err := fn(w, r); err != nil {
+		mylogger.Println(err)
+	}
+}
+
+http.Handle("/delete", appHandler(deleteStream(s, u)))
+// END OMIT

httphandler.go

@@ -0,0 +1 @@
+func(http.ResponseWriter, *http.Request)

open.go

@@ -0,0 +1 @@
+func Open(name string) (file *File, err error)

open_usage.go

@@ -0,0 +1,5 @@
+f, err := os.Open("filename.ext")
+if err != nil {
+    log.Fatal(err)
+}
+// do something with the open *File f

slides.slide

@@ -0,0 +1,88 @@
+Error handling with Go
+
+8 May 2018
+
+
+Frank Kleine
+
+
+
+@bovigo
+
+* Errors, what are they?
+
+Errors can happen in each stage of the creation and execution of a program.
+
+  Error handling refers to the anticipation, detection, and resolution of
+  programming, application, and communications errors.
+
+From [[https://searchsoftwarequality.techtarget.com/definition/error-handling][What is error handling?]], Margaret Rouse
+
+: Wikipedia offers "Exception handling only" - I don't like that.
+
+* Errors in Go
+
+From the os package, os.Open:
+.code open.go
+
+And in usage it looks something like this:
+.code open_usage.go
+
+Standard library is full of interesting examples. It's always worth to dive into it.
+
+: Built-in error type. Golang.org blog article, a recommended read.
+
+* Your errors
+
+Always add context to an error before returning it.
+.code error_nocontext.go /START OMIT/,/END OMIT/
+vs.
+.code error_context.go /START OMIT/,/END OMIT/
+
+* Errors in non end user functions
+
+- E.g. functions that don't provide direct output to a user of a program.
+- Your backend functions, e.g. repositories, dealing with other services, etc.
+- Functions that most likely don't know how to deal with an error and must return immediately.
+
+* Example: repository function
+
+.code delete_repo.go /START OMIT/,/END OMIT/
+
+* Errors in end user functions
+
+- Functions that must provide direct output to a user
+- E.g. HTTP handlers, main func of a CLI program
+- Function must continue after the error happened to render some helpful output for the user (and hopefully log the error)
+
+* Example: HTTP handler
+
+- Default HTTP handler doesn't offer to return an error
+.code httphandler.go
+- Leads to repetitive code
+- Prevent this by specifying your own HTTP handler
+.code userhttphandler.go /START OMIT/,/END OMIT/
+- And a handler which handles the error
+.code errorhttphandler.go /START OMIT/,/END OMIT/
+
+* User defined handler
+
+.code userhandler.go /START OMIT/,/END OMIT/
+
+* What about pkg/errors?
+
+- A package by Dave Cheney, provides utility functions for working with errors.
+- Adds stack traces to errors
+- Uses chaining of errors, each error can have a cause
+
+It's a great and interesting package. However, I never found the need in my code to add the weight of more code and dependencies for a perceived little gain.
+
+(Disclaimer: Your mileage will vary.)
+
+(Provoking opinion: if you need stack traces your code base in a single artefact is too large. Except when you ship a binary to a customer. Than you want stack traces.)
+
+
+* Links
+
+- [[https://blog.golang.org/error-handling-and-go][Golang.org article about Go error handling]]
+- [[https://github.com/pkg/errors][pkg/errors]]

userhandler.go

@@ -0,0 +1,44 @@
+import (
+	"fmt"
+	"net/http"
+)
+// START OMIT
+func deleteStream(s Streams, u Upstream) myHttpHandler {
+	return func(w *responseWriter, r *http.Request) (reterr error) {
+		data := map[string]interface{}
+		stream, err := s.FindByPath(r.URL.Path)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			data["title"] = "Internal Server Error"
+			data["error"] = "stream_lookup_error"
+			reterr = fmt.Errorf("could not load stream %s from database: %v", r.URL.Path, err)
+		} else if stream == nil {
+			w.WriteHeader(http.StatusNotFound)
+			data["title"] = "Not Found"
+			data["error"] = "stream_does_not_exist"
+		} else {
+			data["title"] = stream.Title
+			nowStreaming, err := u.NowStreaming(stream.Path)
+			if err != nil {
+				w.WriteHeader(http.StatusBadGateway)
+				data["error"] = "stream_availability_error_not_sure_if_safe_to_delete"
+				reterr = fmt.Errorf("failed to check availability for stream %q: %v", stream.Path, err)
+			} else if nowStreaming {
+				w.WriteHeader(http.StatusLocked)
+				data["error"] = "stream_can_not_be_deleted_while_streaming"
+			} else {
+				err := s.Delete(stream)
+				if err != nil {
+					w.WriteHeader(http.StatusInternalServerError)
+					data["error"] = "could_not_delete_stream"
+					reterr = fmt.Errorf("failed to delete stream %q: %v", stream.Path, err)
+				}
+			}
+		}
+
+		w.Render("deleted.gtmpl", data)
+		return
+	}
+}
+
+// END OMIT

userhttphandler.go

@@ -0,0 +1,6 @@
+import "net/http"
+
+// START OMIT
+type myHttpHandler func(http.ResponseWriter, *http.Request) error
+
+// END OMIT