Error handling

Error handling

  • Go does not have an exception mechanism, like the try/catch in Java or .NET for instance: you cannot throw exceptions. Instead it has a defer-panic-and-recover mechanism.

  • The Go way to handle errors is for functions and methods to return an error object as their only or last return value—or nil if no error occurred—and for calling functions to always check the error they receive.

  • Handle the errors and return from the function in which the error occurred with an error message to the user: that way if something does go wrong, your program will continue to function and the user will be notified. The purpose of panic-and-recover is to deal with genuinely exceptional (so unexpected) problems and not with normal errors.

  • The idiomatic way in Go to detect and report error-conditions

    • A function which can result in an error returns two variables, a value and an error-code; the latter is nil in case of success, and != nil in case of an error-condition.
    • After the function call the error is checked, in case of an error ( if error != nil) the execution of the actual function (or if necessary the entire program) is stopped.

!!Never ignore errors, because ignoring them can lead to program crashes!!

Error interface

  • Go has a predefined error interface type:

    type error interface {
        Error() string
    }
    
  • Defining errors

    err := errors.New("math - square root of negative number")
    
  • Making an error-object with fmt

    if f < 0 {
        return 0, fmt.Errorf("math: square root of negative number %g", f)
    }
    

Run-time exceptions & panicking

  • When execution errors occur, such as attempting to index an array out of bounds or a type assertion failing, the Go runtime triggers a run-time panic with a value of the interface type runtime.Error, and the program crashes with a message of the error; this value has a RuntimeError()-method, to distinguish it from a normal error.

  • A panic can also be initiated from code with the panic function is used, which effectively creates a run-time error that will stop the program. It takes 1 argument of any type, usually a string, to be printed out when the program dies. The Go runtime takes care to stop the program and issuing some debug information.

  • If panic is called from a nested function, it immediately stops execution of the current function, all defer statements are guaranteed to execute and then control is given to the function caller, which receives this call to panic. This bubbles up to the top level, executing defers, and at the top of the stack the program crashes and the error condition is reported on the command-line using the value given to panic: this termination sequence is called panicking.

Error-handling & panicking in custom package

  • Best practice for custom package

    a. Always recover from panic in your package: no explicit panic() should be allowed to cross a package boundary

    b. Return errors as error values to the callers of your package.

  • Sample

    • Parse package

      package parse
      import (
          "fmt"
          "strings"
          "strconv"
      )
      // A ParseError indicates an error in converting a word into an integer.
      type ParseError struct {
          Index int // The index into the space-separated list of words.
          Word string // The word that generated the parse error.
          // The raw error that precipitated this error, if any.
          Error err
      }
      // String returns a human-readable error message.
      func (e *ParseError) String() string {
          return fmt.Sprintf("pkg parse: error parsing %q as int", e.Word)
      }
      // Parse parses the space-separated words in in put as integers.
      func Parse(input string) (numbers []int, err error) {
          defer func() {
              if r := recover(); r != nil {
                  var ok bool
                  err, ok = r.(error)
                  if !ok {
                  err = fmt.Errorf("pkg: %v", r)
                  }
              }
          }()
          fields := strings.Fields(input)
          numbers = fields2numbers(fields) // here panic can occur
          return
      }
                  
      func fields2numbers(fields []string) (numbers []int) {
          if len(fields) == 0 {
              panic("no words to parse")
          }
          for idx, field := range fields {
              num, err := strconv.Atoi(field)
              if err != nil {
              panic(&ParseError{idx, field, err})
              }
          numbers = append(numbers, num)
      }
      return
      }
      
    • main package

      func main() {
          var examples = []string{
              "1 2 3 4 5",
              "100 50 25 12.5 6.25",
              "2 + 2 = 4",
              "1st class",
              ""
          }
      
          for _, ex := range examples {
              fmt.Printf("Parsing %q:\n ", ex)
              nums, err := parse.Parse(ex)
              if err != nil {
                  // here String() method from ParseError is used
                  fmt.Println(err)
              continue
          }
      
          fmt.Println(nums)
      }
      
      /* Output:
          Parsing "w1 2 3 4 5":
          360
          Ivo Balbaert
          [1 2 3 4 5]
          Parsing "100 50 25 12.5 6.25":
          pkg parse: error parsing "12.5" as int
          Parsing "2 + 2 = 4":
          pkg parse: error parsing "+" as int
          Parsing "1st class":
          pkg parse: error parsing "1st" as int
          Parsing "":
          pkg: no words to parse
      */
      
      

Recover

  • recover is only useful when called inside a deferred function (see § 6.4) : it then retrieves the error value passed through the call of panic; when used in normal execution a call to recover will return nil and have no other effect.

  • Summarized: panic causes the stack to unwind until a deferred recover() is found or the program terminates

Similar try-catch block in Go

func protect(g func()) {
    defer func() {
        log.Println("done")
        // Println executes normally even if there is a panic
        if err := recover(); err != nil {
          log.Printf("run time panic: %v", err)
        }
    }()
    log.Println("start")
    g() // possible runtime-error
}

Sample of panic, defer & recover

func badCall() {
	panic("bad end")
}

func test() {
	defer func() {
		if e := recover(); e != nil {
			fmt.Printf("Panicking %s\r\n", e)
		}
	}()
	badCall()
	fmt.Printf("After bad call\r\n")
}

func main() {
	fmt.Printf("Calling test\r\n")
	test()
	fmt.Printf("Test completed\r\n")
}

An error-handling scheme with closures

  • Combining the defer/panic/recover mechanism with closures can result in a far more elegant scheme that we will now discuss. However it is only applicable when all functions have the same signature, which is rather restrictive.

  • The scheme uses 2 helper functions:

    i) check: a function which tests whether an error occurred, and panics if so:

    func check(err error) { if err != nil { panic(err) } }
    

    ii) errorhandler: this is a wrapper function. It takes a function fn of our type fType1 and returns such a function by calling fn. However it contains the defer/recover mechanism

    func errorHandler(fn fType1) fType1 {
        return func(a type1, b type2) {
            defer func() {
            if e, ok := recover().(error); ok {
               log.Printf("run time panic: %v", err)
    
            }
            }()
            fn(a, b)
        }
    }
    

Start external program

func main() {
	// 1) os.StartProcess //
	/*********************/
	/* Linux: */
	env := os.Environ()
	procAttr := &os.ProcAttr{
		Env: env,
		Files: []*os.File{
			os.Stdin,
			os.Stdout,
			os.Stderr,
		},
	}
	pid, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, procAttr)
	if err != nil {
		fmt.Printf("Error %v starting process!", err) //
		os.Exit(1)
	}
	fmt.Printf("The process id is %v", pid)
	/* Output:
	The process id is &{21275 0 0 {{0 0} 0 0 0 0}}The process id is &{21276 0 0 {{0 0} 0 0 0 0}}total 54
	-rwxrwxrwx 1 root root   250 Sep 21 19:33 csv_data.txt
	-rwxrwxrwx 1 root root 25227 Oct  4 23:34 hello.go
	-rwxrwxrwx 1 root root  6708 Sep 21 10:25 hello.go.txt
	-rwxrwxrwx 1 root root   130 Sep 21 11:08 output.txt
	-rwxrwxrwx 1 root root  8898 Sep 21 12:10 target_hello.txt
	-rwxrwxrwx 1 root root  1619 Sep 22 14:40 urlshorten.go.txt
	-rwxrwxrwx 1 root root   182 Sep 21 13:50 vcard.json
	*/
	// 2nd example: show all processes
	pid, err = os.StartProcess("/bin/ps", []string{"-e", "opid,ppid,comm"}, procAttr)
	if err != nil {
		fmt.Printf("Error %v starting process!", err) //
		os.Exit(1)
	}
	fmt.Printf("The process id is %v", pid)
	// 2) cmd.Run //
	/***************/
	cmd := exec.Command("gedit") // this opens a gedit-window
	err = cmd.Run()
	if err != nil {
		fmt.Printf("Error %v executing command!", err)
		os.Exit(1)
	}
	fmt.Printf("The command is %v", cmd)
}

Testing

  • Table-driven test

    var tests = [] struct {
        in
        // Test table
        string
        out string
    }{
        {"in1", "exp1"},
        {"in2", "exp2"},
        {"in3", "exp3"},
    // ....
    }
    
    func verify(t *testing.T, testnum int, testcase, input, output, expected string) {
        if input != output {
            t.Errorf("%d. %s with input = %s: output %s != %s", testnum, testcase, input, output, expected)
        }
    }
    
    func TestFunction(t *testing.T) {
        for i, tt := range tests {
            s := FuncToBeTested(tt.in)
            verify(t, i, "FuncToBeTested: ", tt.in, s, tt.out)
        }
    }