return n, err
}

func (r *respBodyMonitor) Close() (err error) {
	err = r.ReadCloser.Close()
	r.errorStatus(err)
	return err
}

func (r *respBodyMonitor) errorStatus(err error) {
	if xnet.IsNetworkOrHostDown(err, r.expectTimeouts) {
		r.errorStatusOnce.Do(func() {
			atomic.AddUint64(&globalStats.errs, 1)
		})
	}
}

// dumpHTTP - dump HTTP request and response.

	defer cancel()

	err := target.checkAndInitClient(ctx)
	if err != nil {
		return err
	}

	err = target.send(eventData)
	if xnet.IsNetworkOrHostDown(err, false) {
		return store.ErrNotConnected
	}
	return err
}

// send - sends the event to the target.
func (target *ElasticsearchTarget) send(eventData event.Event) error {

		}
	}
	req.Header.Set("User-Agent", getUserAgent(mode))

	client := &http.Client{Transport: getUpdateTransport(timeout)}
	resp, err := client.Do(req)
	if err != nil {
		if xnet.IsNetworkOrHostDown(err, false) {
			return content, AdminError{
				Code:       AdminUpdateURLNotReachable,
				Message:    err.Error(),
				StatusCode: http.StatusServiceUnavailable,
			}
		}
		return content, AdminError{

			}
		case isErrReadQuorum(serr), isErrWriteQuorum(serr):
			// destination has some quorum issues, perform removeObject() anyways
			// to complete the operation.
		default:
			if err != nil && minio.IsNetworkOrHostDown(err, true) && !globalBucketTargetSys.isOffline(tgt.EndpointURL()) {
				globalBucketTargetSys.markOffline(tgt.EndpointURL())
			}
			// mark delete marker replication as failed if target cluster not ready to receive

	}

	if values == nil {
		values = make(url.Values)
	}

	respBody, err = client.restClient.Call(ctx, method, values, body, length)
	if err == nil {
		return respBody, nil
	}

	if xnet.IsNetworkOrHostDown(err, true) {
		return nil, errPeerNotReachable
	}

	return nil, err
}

// Stringer provides a canonicalized representation of node.
func (client *peerRESTClient) String() string {

	versionID := ""
	if len(params) >= 1 {
		bucket = params[0]
	}
	if len(params) >= 2 {
		object = params[1]
	}
	if len(params) >= 3 {
		versionID = params[2]
	}

	if xnet.IsNetworkOrHostDown(err, false) {
		return BackendDown{Err: err.Error()}
	}

	minioErr, ok := err.(minio.ErrorResponse)
	if !ok {
		// We don't interpret non MinIO errors. As minio errors will

			}
		}(i)
	}
	wg.Wait()
	errMap := make(map[string]error, len(c.state.Peers))
	for i, depID := range depIDs {
		errMap[depID] = errs[i]
		if errs[i] != nil && minio.IsNetworkOrHostDown(errs[i], true) {
			ep := c.state.Peers[depID].Endpoint
			epURL, _ := url.Parse(ep)
			if !globalBucketTargetSys.isOffline(epURL) {
				globalBucketTargetSys.markOffline(epURL)
			}
		}
	}