if ok {
			return result.conn, result.err
		}
	case <-listener.ctx.Done():
	}
	return nil, syscall.EINVAL
}

// Close - closes underneath all TCP listeners.
func (listener *httpListener) Close() (err error) {
	listener.ctxCanceler()

	for i := range listener.listeners {
		listener.listeners[i].Close()
	}

	return nil
}

	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - closes underneath connections to PostgreSQL database.
func (target *PostgreSQLTarget) Close() error {
	close(target.quitCh)
	if target.updateStmt != nil {
		// FIXME: log returned error. ignore time being.
		_ = target.updateStmt.Close()
	}

	if target.deleteStmt != nil {
		// FIXME: log returned error. ignore time being.

import (
	"context"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/client-go/kubernetes"
)

// Use UUID of kube-system Namespace as unique identifier for cluster.
// (see https://docs.google.com/document/d/1F__vEKeI41P7PPUCMM9PVPYY34pyrvQI5rbTJVnS5c4)
func clusterUID(client kubernetes.Interface) (types.UID, error) {

	for i := range dac {
		dac[i].Cluster.TypeUrl = v3.ClusterType
	}
	sort.Slice(dac, func(i, j int) bool {
		cluster := &cluster.Cluster{}
		err = dac[i].Cluster.UnmarshalTo(cluster)
		if err != nil {
			return false
		}
		name := cluster.Name
		err = dac[j].Cluster.UnmarshalTo(cluster)
		if err != nil {
			return false
		}
		return name < cluster.Name
	})
	if stripVersions {
		for i := range dac {

Xiaopeng Han <******@****.***> 1710237729 +0800

      return webSocket!!.processNextFrame()
    }

    override fun close() {
      if (closed) {
        throw AssertionError("Already closed")
      }
      try {
        source.close()
      } catch (ignored: IOException) {
      }
      try {
        sink.close()
      } catch (ignored: IOException) {
      }
      closed = true
    }

    override fun cancel() {
      canceled = true

	return c.CallWithHTTPMethod(ctx, http.MethodPost, rpcMethod, values, body, length)
}

// Close closes all idle connections of the underlying http client
func (c *Client) Close() {
	atomic.StoreInt32(&c.connected, closed)
}

// NewClient - returns new REST client.
func NewClient(uu *url.URL, tr http.RoundTripper, auth func() string) *Client {
	connected := int32(online)

            @Throws(IOException::class)
            override fun close() {
              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    body.charStream().close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun readerClosedAfterBomClosesUnderlyingSource() {
    val closed = AtomicBoolean()
    val body: ResponseBody =

    }
  }

  /**
   * Closes this connection. This cancels all open streams and unanswered pings. It closes the
   * underlying input and output streams and shuts down internal task queues.
   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,

            It will be closed if no further activity occurs. Thank you.
          close-issue-message: >
            This issue was closed because it has been inactive for 7 days since being marked as stale.
            Please reopen if you'd like to work on this further.
          days-before-pr-stale: 14
          days-before-pr-close: 14