Update ingress godeps

vendor/k8s.io/kubernetes/pkg/util/runtime/runtime.go

@@ -18,23 +18,32 @@ package runtime
 
 import (
 	"fmt"
-	"github.com/golang/glog"
 	"runtime"
+
+	"github.com/golang/glog"
 )
 
-// For testing, bypass HandleCrash.
-var ReallyCrash bool
+var (
+	// ReallyCrash controls the behavior of HandleCrash and now defaults
+	// true. It's still exposed so components can optionally set to false
+	// to restore prior behavior.
+	ReallyCrash = true
+)
 
 // PanicHandlers is a list of functions which will be invoked when a panic happens.
 var PanicHandlers = []func(interface{}){logPanic}
 
-//TODO search the public functions
-// HandleCrash simply catches a crash and logs an error. Meant to be called via defer.
-// Additional context-specific handlers can be provided, and will be called in case of panic
+// HandleCrash simply catches a crash and logs an error. Meant to be called via
+// defer.  Additional context-specific handlers can be provided, and will be
+// called in case of panic.  HandleCrash actually crashes, after calling the
+// handlers and logging the panic message.
+//
+// TODO: remove this function. We are switching to a world where it's safe for
+// apiserver to panic, since it will be restarted by kubelet. At the beginning
+// of the Kubernetes project, nothing was going to restart apiserver and so
+// catching panics was important. But it's actually much simpler for montoring
+// software if we just exit when an unexpected panic happens.
 func HandleCrash(additionalHandlers ...func(interface{})) {
-	if ReallyCrash {
-		return
-	}
 	if r := recover(); r != nil {
 		for _, fn := range PanicHandlers {
 			fn(r)
@@ -42,11 +51,20 @@ func HandleCrash(additionalHandlers ...func(interface{})) {
 		for _, fn := range additionalHandlers {
 			fn(r)
 		}
+		if ReallyCrash {
+			// Actually proceed to panic.
+			panic(r)
+		}
 	}
 }
 
 // logPanic logs the caller tree when a panic occurs.
 func logPanic(r interface{}) {
+	callers := getCallers(r)
+	glog.Errorf("Observed a panic: %#v (%v)\n%v", r, r, callers)
+}
+
+func getCallers(r interface{}) string {
 	callers := ""
 	for i := 0; true; i++ {
 		_, file, line, ok := runtime.Caller(i)
@@ -55,7 +73,8 @@ func logPanic(r interface{}) {
 		}
 		callers = callers + fmt.Sprintf("%v:%v\n", file, line)
 	}
-	glog.Errorf("Recovered from panic: %#v (%v)\n%v", r, r, callers)
+
+	return callers
 }
 
 // ErrorHandlers is a list of functions which will be invoked when an unreturnable
@@ -92,3 +111,18 @@ func GetCaller() string {
 	}
 	return f.Name()
 }
+
+// RecoverFromPanic replaces the specified error with an error containing the
+// original error, and  the call tree when a panic occurs. This enables error
+// handlers to handle errors and panics the same way.
+func RecoverFromPanic(err *error) {
+	if r := recover(); r != nil {
+		callers := getCallers(r)
+
+		*err = fmt.Errorf(
+			"recovered from panic %q. (err=%v) Call stack:\n%v",
+			r,
+			*err,
+			callers)
+	}
+}