code: func (r *Request) transformUnstructuredResponseError(resp *http.Response, req *http.Request, body []byte) error {
  	if body == nil && resp.Body != nil {
  		if data, err := ioutil.ReadAll(&io.LimitedReader{R: resp.Body, N: maxUnstructuredResponseTextBytes}); err == nil {
  			body = data
  		}
  	}
  	retryAfter, _ := retryAfterSeconds(resp)
  	return r.newUnstructuredResponseError(body, isTextResponse(resp), resp.StatusCode, req.Method, retryAfter)
  }
docs: // transformUnstructuredResponseError handles an error from the server that is not in a structured form.
  // It is expected to transform any response that is not recognizable as a clear server sent error from the
  // K8S API using the information provided with the request. In practice, HTTP proxies and client libraries
  // introduce a level of uncertainty to the responses returned by servers that in common use result in
  // unexpected responses. The rough structure is:
  //
  // 1. Assume the server sends you something sane - JSON + well defined error objects + proper codes
  //    - this is the happy path
  //    - when you get this output, trust what the server sends
  // 2. Guard against empty fields / bodies in received JSON and attempt to cull sufficient info from them to
  //    generate a reasonable facsimile of the original failure.
  //    - Be sure to use a distinct error type or flag that allows a client to distinguish between this and error 1 above
  // 3. Handle true disconnect failures / completely malformed data by moving up to a more generic client error
  // 4. Distinguish between various connection failures like SSL certificates, timeouts, proxy errors, unexpected
  //    initial contact, the presence of mismatched body contents from posted content types
  //    - Give these a separate distinct error type and capture as much as possible of the original message
  //
  // TODO: introduce transformation of generic http.Client.Do() errors that separates 4.