pkg syscall (freebsd-riscv64), type RoutingMessage interface, unexported methods #53466
pkg syscall (freebsd-riscv64), type RtMetrics struct #53466
pkg syscall (freebsd-riscv64), type RtMetrics struct, Expire uint64 #53466
pkg syscall (freebsd-riscv64), type RtMetrics struct, Filler [3]uint64 #53466
pkg syscall (freebsd-riscv64), type RtMetrics struct, Hopcount uint64 #53466

pkg syscall (darwin-386), type RoutingMessage interface, unexported methods
pkg syscall (darwin-386), type RtMetrics struct
pkg syscall (darwin-386), type RtMetrics struct, Expire int32
pkg syscall (darwin-386), type RtMetrics struct, Filler [4]uint32
pkg syscall (darwin-386), type RtMetrics struct, Hopcount uint32
pkg syscall (darwin-386), type RtMetrics struct, Locks uint32

    }

    private void processTask(final ExecutorService executorService, final TimeoutTask task) {
        try {
            executorService.execute(() -> {
                try {
                    task.expired();
                } catch (final Exception e) {
                    if (e instanceof InterruptedException) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Interrupted.", e);

        private final JobLog jobLog;

        public MonitorTarget(final JobLog jobLog) {
            this.jobLog = jobLog;
        }

        @Override
        public void expired() {
            if (jobLog.getEndTime() == null) {
                jobLog.setLastUpdated(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
                if (logger.isDebugEnabled()) {

	// Consequently, if err != nil, reply is always false
	_, err := l.ll.RUnlock(context.Background(), *args)
	return l.makeResp(resp, err)
}

// ForceUnlockHandler - query expired lock status.
func (l *lockRESTServer) ForceUnlockHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	resp := lockRPCForceUnlock.NewResponse()

	_, err := l.ll.ForceUnlock(context.Background(), *args)

	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	// Report the ILMExpiryStats only if at least one site has replication of ILM expiry enabled
	var replicateILMExpiry bool
	for _, site := range info.Sites {
		if site.ReplicateILMExpiry {
			replicateILMExpiry = true
			break
		}
	}
	if !replicateILMExpiry {

			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
		for _, rl := range lcCfg.Rules {
			updRule, ok := updatedRules[rl.ID]
			// original rule had expiry that is no longer in the new config,
			// or rule is present but missing expiration flags
			if (!rl.Expiration.IsNull() || !rl.NoncurrentVersionExpiration.IsNull()) &&

	"github.com/minio/pkg/v3/policy"
)

// supportedHeadGetReqParams - supported request parameters for GET and HEAD presigned request.
var supportedHeadGetReqParams = map[string]string{
	"response-expires":             xhttp.Expires,
	"response-content-type":        xhttp.ContentType,
	"response-cache-control":       xhttp.CacheControl,
	"response-content-encoding":    xhttp.ContentEncoding,

        "Logon failure: user account restriction.", "Logon failure: account logon time restriction violation.",
        "Logon failure: user not allowed to log on to this computer.", "Logon failure: the specified account password has expired.",
        "Logon failure: account currently disabled.", "No mapping between account names and security IDs was done.",

/**
 * Implementation of {@code Futures#withTimeout}.
 *
 * <p>Future that delegates to another but will finish early (via a {@link TimeoutException} wrapped
 * in an {@link ExecutionException}) if the specified duration expires. The delegate future is
 * interrupted and cancelled if it times out.
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault