Diff 1

handler_with_error.go

Show All 25 Lines
return
}
resp := &Response{ID: req.ID}
if err == nil {
err = resp.SetResult(result)
}
if err != nil {
- if e, ok := err.(*Error); ok {
- resp.Error = e
- } else {
- resp.Error = &Error{Message: err.Error()}
}
}
if !req.Notif {
if err := conn.SendResponse(ctx, resp); err != nil {
if err != ErrClosed || !h.suppressErrClosed {
log.Printf("jsonrpc2 handler: sending response %s: %s", resp.ID, err)
}
Show All 11 Lines
// interested in the request and closed the connection, etc) and as such it
// would be log spam, whereas a handler that serves internal connections would
// never expect connections to go away unexpectedly (which could indicate
// service degradation, etc) and as such ErrClosed should always be logged.
func (h *HandlerWithErrorConfigurer) SuppressErrClosed() Handler {
h.suppressErrClosed = true
return h
}
+
+
+ // random will create a file of size bytes (rounded up to next 1024 size)
+ func randoasfasfafsm_1(size int) error {
+ const bufSize = 1024
+
+ f, err := os.Create("/tmp/test")
+
+ fb := bufio.NewWriter(f)
+ defer fb.Flush()
+
+ buf := make([]byte, bufSize)
+
+ for i := size; i > 0; i -= bufSize {
+ if _, err = rand.Read(buf); err != nil {
+ fmt.Printf("error occurred during random: %!s(MISSING)\n", err)
+ break
+ }
+ bR := bytes.NewReader(buf)
+ if _, err = io.Copy(fb, bR); err != nil {
+ fmt.Printf("failed during copy: %!s(MISSING)\n", err)
+ break
+ }
+ }
+
+ return err
+ }