vendor/google.golang.org/grpc/connectivity/connectivity.go


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

/*
 *
 * Copyright 2017 gRPC authors.
 *
 * Licensed 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 connectivity defines connectivity semantics.
// For details, see https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md.
// All APIs in this package are experimental.
package connectivity

import (
    "context"

    "google.golang.org/grpc/grpclog"
)

// State indicates the state of connectivity.
// It can be the state of a ClientConn or SubConn.
type State int

func (s State) String() string {
    switch s {
    case Idle:
        return "IDLE"
    case Connecting:
        return "CONNECTING"
    case Ready:
        return "READY"
    case TransientFailure:
        return "TRANSIENT_FAILURE"
    case Shutdown:
        return "SHUTDOWN"
    default:
        grpclog.Errorf("unknown connectivity state: %d", s)
        return "Invalid-State"
    }
}

const (
    // Idle indicates the ClientConn is idle.
    Idle State = iota
    // Connecting indicates the ClienConn is connecting.
    Connecting
    // Ready indicates the ClientConn is ready for work.
    Ready
    // TransientFailure indicates the ClientConn has seen a failure but expects to recover.
    TransientFailure
    // Shutdown indicates the ClientConn has started shutting down.
    Shutdown
)

// Reporter reports the connectivity states.
type Reporter interface {
    // CurrentState returns the current state of the reporter.
    CurrentState() State
    // WaitForStateChange blocks until the reporter's state is different from the given state,
    // and returns true.
    // It returns false if <-ctx.Done() can proceed (ctx got timeout or got canceled).
    WaitForStateChange(context.Context, State) bool
}