Harshavardhana <******@****.***> 1706132204 -0800

    }
    writerQueue.execute("$connectionName ping") {
      writePing(false, DEGRADED_PING, 0)
    }
  }

  class Builder(
    /** True if this peer initiated the connection; false if this peer accepted the connection. */
    internal var client: Boolean,
    internal val taskRunner: TaskRunner,
  ) {
    internal lateinit var socket: BufferedSocket

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

/**
 * Settings describe characteristics of the sending peer, which are used by the receiving peer.
 * Settings are [connection][Http2Connection] scoped.
 */
class Settings {
  /** Bitfield of which flags that values. */
  private var set: Int = 0

  /** Flag values. */

 *    from the peer.
 *
 * Web sockets may fail due to HTTP upgrade problems, connectivity problems, or if either peer
 * chooses to short-circuit the graceful shutdown process:
 *
 *  * **Canceled:** the web socket connection failed. Messages that were successfully enqueued by
 *    either peer may not have been transmitted to the other.
 *

    peer.play()

    // Play it back.
    val connection =
      Http2Connection
        .Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket().asBufferedSocket(), "peer")
        .pushObserver(Http2ConnectionTest.IGNORE)
        .listener(realConnection)
        .build()
    connection.start(sendConnectionPreface = false)

    // verify the peer received the ACK
    val ackFrame = peer.takeFrame()

        this.initialCredits = initialCredits;
    }

    /**
     * Get number of credits granted by peer
     *
     * @return granted credits
     */
    public int getCreditsGranted() {
        return creditsGranted;
    }

    /**
     * Set number of credits granted by peer
     *
     * @param creditsGranted credits granted
     */
    public void setCreditsGranted(int creditsGranted) {

	}
	if !info.Enabled {
		return nil
	}
	for _, peer := range info.Sites {
		if peer.DeploymentID == globalDeploymentID() {
			continue
		}
		rs, err := loadSiteResyncMetadata(ctx, objAPI, peer.DeploymentID)
		if err != nil {
			return err
		}
		sm.Lock()
		if _, ok := sm.peerResyncMap[peer.DeploymentID]; !ok {
			sm.peerResyncMap[peer.DeploymentID] = resyncState{resyncID: rs.ResyncID, LastSaved: time.Time{}}

}

// FindGridHostsFromPeerStr will return a matching peer from provided peer (as string)
func (l EndpointServerPools) FindGridHostsFromPeerStr(peer string) (peerGrid string) {
	if peer == "" {
		return ""
	}
	for _, ep := range l {
		for _, endpoint := range ep.Endpoints {
			if endpoint.IsLocal {
				continue
			}

			if endpoint.Host == peer {
				return endpoint.GridHost()
			}
		}
	}

		"Average dial time of internode TCP calls in nanoseconds")
	internodeSentBytesTotalMD = NewCounterMD(internodeSentBytesTotal,
		"Total number of bytes sent to other peer nodes")
	internodeRecvBytesTotalMD = NewCounterMD(internodeRecvBytesTotal,
		"Total number of bytes received from other peer nodes")
)

// loadNetworkInternodeMetrics - reads internode network metrics.
//
// This is a `MetricsLoaderFn`.

  /** Returns a possibly-empty list of certificates that identify this peer. */
  @get:JvmName("localCertificates") val localCertificates: List<Certificate>,
  // Delayed provider of peerCertificates, to allow lazy cleaning.
  peerCertificatesFn: () -> List<Certificate>,
) {
  /** Returns a possibly-empty list of certificates that identify the remote peer. */
  @get:JvmName("peerCertificates")