103 lines
3.0 KiB
Go
103 lines
3.0 KiB
Go
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
package thrift
|
|
|
|
import (
|
|
"net"
|
|
)
|
|
|
|
// socketConn is a wrapped net.Conn that tries to do connectivity check.
|
|
type socketConn struct {
|
|
net.Conn
|
|
|
|
buffer [1]byte
|
|
}
|
|
|
|
var _ net.Conn = (*socketConn)(nil)
|
|
|
|
// createSocketConnFromReturn is a language sugar to help create socketConn from
|
|
// return values of functions like net.Dial, tls.Dial, net.Listener.Accept, etc.
|
|
func createSocketConnFromReturn(conn net.Conn, err error) (*socketConn, error) {
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &socketConn{
|
|
Conn: conn,
|
|
}, nil
|
|
}
|
|
|
|
// wrapSocketConn wraps an existing net.Conn into *socketConn.
|
|
func wrapSocketConn(conn net.Conn) *socketConn {
|
|
// In case conn is already wrapped,
|
|
// return it as-is and avoid double wrapping.
|
|
if sc, ok := conn.(*socketConn); ok {
|
|
return sc
|
|
}
|
|
|
|
return &socketConn{
|
|
Conn: conn,
|
|
}
|
|
}
|
|
|
|
// isValid checks whether there's a valid connection.
|
|
//
|
|
// It's nil safe, and returns false if sc itself is nil, or if the underlying
|
|
// connection is nil.
|
|
//
|
|
// It's the same as the previous implementation of TSocket.IsOpen and
|
|
// TSSLSocket.IsOpen before we added connectivity check.
|
|
func (sc *socketConn) isValid() bool {
|
|
return sc != nil && sc.Conn != nil
|
|
}
|
|
|
|
// IsOpen checks whether the connection is open.
|
|
//
|
|
// It's nil safe, and returns false if sc itself is nil, or if the underlying
|
|
// connection is nil.
|
|
//
|
|
// Otherwise, it tries to do a connectivity check and returns the result.
|
|
//
|
|
// It also has the side effect of resetting the previously set read deadline on
|
|
// the socket. As a result, it shouldn't be called between setting read deadline
|
|
// and doing actual read.
|
|
func (sc *socketConn) IsOpen() bool {
|
|
if !sc.isValid() {
|
|
return false
|
|
}
|
|
return sc.checkConn() == nil
|
|
}
|
|
|
|
// Read implements io.Reader.
|
|
//
|
|
// On Windows, it behaves the same as the underlying net.Conn.Read.
|
|
//
|
|
// On non-Windows, it treats len(p) == 0 as a connectivity check instead of
|
|
// readability check, which means instead of blocking until there's something to
|
|
// read (readability check), or always return (0, nil) (the default behavior of
|
|
// go's stdlib implementation on non-Windows), it never blocks, and will return
|
|
// an error if the connection is lost.
|
|
func (sc *socketConn) Read(p []byte) (n int, err error) {
|
|
if len(p) == 0 {
|
|
return 0, sc.read0()
|
|
}
|
|
|
|
return sc.Conn.Read(p)
|
|
}
|