}

    public static void setError(final int statusCode, final String message) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(WEB_API_EXCEPTION, new WebApiException(statusCode, message)));
    }

    public static void setError(final int statusCode, final Exception e) {

    }

    public String getWhy() {
        return why;
    }

    public void setWhy(String why) {
        this.why = why;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public boolean isError() {
        return error == null;
    }

    public String getDependencyConflictId() {

	reqInfo := (&logger.ReqInfo{}).AppendTags("remotePeer", addr)
	ctx := logger.SetReqInfo(GlobalContext, reqInfo)
	peersLogOnceIf(ctx, err, "add-node-err-"+addr)
	nodeInfo.SetAddr(addr)
	nodeInfo.SetError(err.Error())
}

// GetSysErrors - Memory information
func (sys *NotificationSys) GetSysErrors(ctx context.Context) []madmin.SysErrors {
	reply := make([]madmin.SysErrors, len(sys.peerClients))

				mu.Unlock()
			}
		}(i)
	}
	wg.Wait()

	// We already saw write failures, no need to proceed into read's
	if retError != "" {
		return SpeedTestResult{
			Uploads:     totalBytesWritten,
			Downloads:   totalBytesRead,
			UploadTimes: uploadTimes,
			Error:       retError,
		}, nil
	}

	downloadsCtx, downloadsCancel := context.WithTimeout(ctx, opts.duration)
	defer downloadsCancel()

	}

	fd := int(netns.Fd())
	resp, err := latestConn.send(ctx, data, &fd)
	if err != nil {
		return err
	}

	if resp.GetAck().GetError() != "" {
		log.Errorf("failed to add workload: %s", resp.GetAck().GetError())
		return fmt.Errorf("got ack error: %s", resp.GetAck().GetError())
	}
	return nil
}

// TODO ctx is unused here
// nolint: unparam

        String key = getMetadataKey(repository, file);

        return readLastUpdated(touchfile, key);
    }

    @Override
    public String getError(Artifact artifact, ArtifactRepository repository) {
        File touchFile = getTouchfile(artifact);
        return getError(touchFile, getRepositoryKey(repository));
    }

    @Override
    public void touch(Artifact artifact, ArtifactRepository repository, String error) {

@Deprecated
public interface UpdateCheckManager {

    boolean isUpdateRequired(Artifact artifact, ArtifactRepository repository);

    void touch(Artifact artifact, ArtifactRepository repository, String error);

    String getError(Artifact artifact, ArtifactRepository repository);

    boolean isUpdateRequired(RepositoryMetadata metadata, ArtifactRepository repository, File file);

                            edge.isResolved(),
                            edge.getTarget() == null
                                    ? null
                                    : edge.getTarget().getMd().getError());
                    MetadataGraphVertex newV = res.addVertex(newMd);
                    MetadataGraphVertex sourceV = res.addVertex(edge.getSource().getMd());

                    res.addEdge(sourceV, newV, edge);

                artifact.setResolved(true);
            } else if (!artifact.getFile().exists()) {
                String error = updateCheckManager.getError(artifact, repository);
                if (error != null) {
                    throw new TransferFailedException("Failure to resolve " + remotePath + " from "
                            + repository.getUrl()

pkg syscall (linux-386), type Timex struct, Calcnt int32
pkg syscall (linux-386), type Timex struct, Constant int32
pkg syscall (linux-386), type Timex struct, Errcnt int32
pkg syscall (linux-386), type Timex struct, Esterror int32
pkg syscall (linux-386), type Timex struct, Freq int32
pkg syscall (linux-386), type Timex struct, Jitcnt int32
pkg syscall (linux-386), type Timex struct, Jitter int32