metrics.AddRequestsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -1)
		metrics.AddSeatsInQueues(req.ctx, qs.qCfg.Name, req.fsName, -req.MaxSeats())
		req.NoteQueued(false)
		qs.reqsGaugePair.RequestsWaiting.Add(-1)
		qs.seatDemandIntegrator.Set(float64(qs.totSeatsInUse + qs.totSeatsWaiting))
	}
	return false, qs.isIdleLocked()
}

func (qs *queueSet) IsIdle() bool {
	qs.lock.Lock()

func (r *ReplicationStats) getNodeQueueStats(bucket string) (qs ReplQNodeStats) {
	qs.NodeName = globalLocalNodeName
	qs.Uptime = UTCNow().Unix() - globalBootTime.Unix()
	qs.ActiveWorkers = globalReplicationStats.ActiveWorkers()
	qs.XferStats = make(map[RMetricName]XferStats)
	qs.QStats = r.qCache.getBucketStats(bucket)
	qs.TgtXferStats = make(map[string]map[RMetricName]XferStats)

	r.RLock()

func (q *QUICConn) NextEvent() QUICEvent {
	qs := q.conn.quic
	if last := qs.nextEvent - 1; last >= 0 && len(qs.events[last].Data) > 0 {
		// Write over some of the previous event's data,
		// to catch callers erroniously retaining it.
		qs.events[last].Data[0] = 0
	}
	if qs.nextEvent >= len(qs.events) && qs.waitingForDrain {
		qs.waitingForDrain = false
		<-qs.signalc
		<-qs.blockedc
	}
	if qs.nextEvent >= len(qs.events) {

	cqc.cts.lock.Lock()
	defer cqc.cts.lock.Unlock()
	qs := cqc.cqs
	if qs == nil {
		qs = &ctlrTestQueueSet{cts: cqc.cts, qc: cqc.qc, dc: dc}
		cqc.cts.queues[cqc.qc.Name] = qs
	} else {
		qs.qc, qs.dc = cqc.qc, dc
	}
	return qs
}

func (cqs *ctlrTestQueueSet) IsIdle() bool {
	cqs.cts.lock.Lock()
	defer cqs.cts.lock.Unlock()
	klog.V(7).Infof("For %p QS %s, countActive==%d", cqs, cqs.qc.Name, cqs.countActive)

	}

	var qs ReplicationQueueStats
	for _, bs := range bucketStats {
		qs.Nodes = append(qs.Nodes, bs.QueueStats.Nodes...)
	}
	qs.Uptime = UTCNow().Unix() - globalBootTime.Unix()

	var ps ProxyMetric
	for _, bs := range bucketStats {
		ps.add(bs.ProxyStats)
	}
	bs = BucketStats{
		ReplicationStats: s,
		QueueStats:       qs,
		ProxyStats:       ps,
	}

		if versionRE.MatchString(errStr) {
			base.Errorf("go: %s", errStr)
			return
		}
	}

	if qs := q.String(); qs != "" {
		base.Errorf("go: %s: %s", qs, errStr)
	} else {
		base.Errorf("go: %s", errStr)
	}
}

func reportConflict(pq *query, m module.Version, conflict versionReason) {
	if pq.conflict != nil {

            String qs = req.getQueryString();
            redir = new StringBuffer( redir.substring( 0, redir.length() - req.getPathInfo().length() ));
            redir.append( '/' );
            redir.append(dr.server);
            redir.append( '/' );
            redir.append(dr.share);
            redir.append( '/' );
            if( qs != null ) {

            resp.flushBuffer();
            return;
        }
        catch ( DfsReferral dr ) {
            StringBuffer redir = req.getRequestURL();
            String qs = req.getQueryString();
            DfsReferralData refdata = dr.getData();
            redir = new StringBuffer(redir.substring(0, redir.length() - req.getPathInfo().length()));
            redir.append('/');

	}
	if bz := req.PostFormValue("z"); bz != "post" {
		t.Errorf(`req.PostFormValue("z") = %q, want "post"`, bz)
	}
	if qs := req.Form["q"]; !reflect.DeepEqual(qs, []string{"foo", "bar"}) {
		t.Errorf(`req.Form["q"] = %q, want ["foo", "bar"]`, qs)
	}
	if both := req.Form["both"]; !reflect.DeepEqual(both, []string{"y", "x"}) {
		t.Errorf(`req.Form["both"] = %q, want ["y", "x"]`, both)
	}

000000e0  87 e8 3c 3e 58 8d 1b b2  4e 2d 7d c1 f8 aa 16 ca  |..<>X...N-}.....|
000000f0  2a 3e 8f aa 52 14 e4 f2  2a b9 6e 62 46 ab ed 3a  |*>..R...*.nbF..:|
00000100  ff a1 51 53 92 7a 78 c4  ed 9d fd 1f b4 62 2e e7  |..QS.zx......b..|
00000110  cc 9d 09 fa 06 2e 9e 55  e5 98 9e b8 be e9 12 94  |.......U........|
00000120  33 58 6b be 71 a1 4f f8  a0 83 85 f8 7e b4 28 a7  |3Xk.q.O.....~.(.|