AmzFwdHeaderLastModified       = "x-amz-fwd-header-Last-Modified"

	AmzFwdHeaderObjectLockMode        = "x-amz-fwd-header-x-amz-object-lock-mode"
	AmzFwdHeaderObjectLockLegalHold   = "x-amz-fwd-header-x-amz-object-lock-legal-hold"
	AmzFwdHeaderObjectLockRetainUntil = "x-amz-fwd-header-x-amz-object-lock-retain-until-date"
	AmzFwdHeaderMPPartsCount          = "x-amz-fwd-header-x-amz-mp-parts-count"

	exit_1
fi

./mc mb --with-lock minio3/newbucket-olock
sleep 5

enabled_minio2=$(./mc stat --json minio2/newbucket-olock | jq -r .ObjectLock.enabled)
if [ $? -ne 0 ]; then
	echo "expected bucket to be mirrored with object-lock but not present, exiting..."
	exit_1
fi

if [ "${enabled_minio2}" != "Enabled" ]; then
	echo "expected bucket to be mirrored with object-lock enabled, exiting..."
	exit_1
fi

		}
	case debugWaitForExit:
		c.reconnectMu.Lock()
		c.handleMsgWg.Wait()
		c.reconnectMu.Unlock()
	case debugSetConnPingDuration:
		c.connMu.Lock()
		defer c.connMu.Unlock()
		c.connPingInterval = args[0].(time.Duration)
		if c.connPingInterval < time.Second {
			panic("CONN ping interval too low")
		}
	case debugSetClientPingDuration:
		c.connMu.Lock()
		defer c.connMu.Unlock()

func (list *TargetList) incCurrentSendCalls(id TargetID) {
	list.statLock.Lock()
	defer list.statLock.Unlock()

	stats, ok := list.targetStats[id]
	if !ok {
		stats = targetStat{}
	}

	stats.currentSendCalls++
	list.targetStats[id] = stats
	return
}

func (list *TargetList) decCurrentSendCalls(id TargetID) {
	list.statLock.Lock()
	defer list.statLock.Unlock()

	stats, ok := list.targetStats[id]

	return h.Bucket
}

func (h *healingTracker) setBucket(bucket string) {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.Bucket = bucket
}

func (h *healingTracker) getObject() string {
	h.mu.RLock()
	defer h.mu.RUnlock()

	return h.Object
}

func (h *healingTracker) setObject(object string) {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.Object = object
}

		if m.cancelFn != nil {
			m.cancelFn(context.Canceled)
		}
		// Wait for senders to release.
		m.respMu.Lock()
	}

	defer m.respMu.Unlock()
	m.closeLocked()
}

func (m *muxClient) closeLocked() {
	if m.closed {
		return
	}
	// We hold the lock, so nobody can modify m.respWait while we're closing.
	if m.respWait != nil {
		xioutil.SafeClose(m.respWait)
		m.respWait = nil
	}

   * additional context. Otherwise [e] is returned as-is.
   */
  private fun <E : IOException?> callDone(e: E): E {
    lock.assertNotHeld()

    val connection = this.connection
    if (connection != null) {
      connection.lock.assertNotHeld()
      val toClose: Socket? =
        connection.withLock {
          // Sets this.connection to null.
          releaseConnectionNoEvents()

						</c:set>
						<la:password property="oldPassword" class="form-control"
									 placeholder="${ph_old_password}" />
						<div class="input-group-append">
							<span class="input-group-text"><em class="fa fa-lock fa-fw"></span>
						</div>
					</div>
					<div class="input-group mb-3">
						<c:set var="ph_new_password">
							<la:message key="labels.profile.placeholder_new_password" />
						</c:set>

	registerPeerRESTHandlers(router, commonGrid)

	// Register bootstrap REST router for distributed setups.
	registerBootstrapRESTHandlers(commonGrid)

	// Register distributed namespace lock routers.
	registerLockRESTHandlers(lockGrid)

	// Add lock grid to router
	router.Handle(grid.RouteLockPath, adminMiddleware(lockGrid.Handler(storageServerRequestValidate), noGZFlag, noObjLayerFlag))

	// Add grid to router

				defer t.updating.Unlock()
				t.update(context.Background())
			}()
		}
		return *v, nil
	}

	// Get lock. Either we get it or we wait for it.
	t.updating.Lock()
	defer t.updating.Unlock()

	if time.Since(time.UnixMilli(t.lastUpdateMs.Load())) < ttl {
		// There is a new value, release lock and return it.
		if v = t.val.Load(); v != nil {
			return *v, nil
		}
	}