gapi

type Filter ¶

type Filter struct {
	// contains filtered or unexported fields
}

Filter is a parsed Google filter expression, in the syntax Cloud Logging and Cloud Monitoring share: terms joined by AND (or just a space) and OR, NOT or -, and parentheses. OR binds tighter than AND, as in Logging.

field OP value      OP is one of = != > >= < <= : =~ !~
field = fn(a, b)    a value function (Monitoring: starts_with, one_of, ...)
fn(a, b)            a function alone (Logging: log_id("x"))
word, "a phrase"    a global text search

The service gives the terms their meaning: see Match.

func ParseFilter(s string) (*Filter, error)

func (f *Filter) Match(term func(field, op, value string) bool, text func(string) bool) bool

type JWT ¶

type JWT struct {
	Header, Claims map[string]any
	// contains filtered or unexported fields
}

JWT is a parsed compact JWT whose signature has not been checked.

func ParseJWT(s string) (*JWT, error)

func (j *JWT) Exp() time.Time

func (j *JWT) Str(claim string) string

func (j *JWT) Verify(pub *rsa.PublicKey) bool

type KeyDirectory ¶

type KeyDirectory interface {
	// ServiceAccountKeys returns the enabled public keys of an enabled
	// service account by key id; nil when it doesn't exist or is disabled.
	ServiceAccountKeys(email string) map[string]*rsa.PublicKey
}

KeyDirectory is what the IAM service offers the token endpoint.

type Mux ¶

type Mux struct {
	// contains filtered or unexported fields
}

Mux serves Rules by calling a service's gRPC handlers, the way REST does.

func NewMux(impl any, rules ...Rule) *Mux

func (m *Mux) Match(r *http.Request) bool

func (m *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Ops ¶

type Ops struct {
	longrunningpb.UnimplementedOperationsServer
	// contains filtered or unexported fields
}

Ops is the shared google.longrunning.Operations service: every GCP service that returns an Operation stores it here, and clients poll it by name over gRPC or REST (GET /v1|v2/projects/p/locations/l/operations/o).

ponytail: operations are in memory only and never expire; persist them if a restart mid-operation ever matters.

func NewOps(*core.Hub) *Ops

func Operations(h *core.Hub) *Ops

func (o *Ops) CancelOperation(ctx context.Context, r *longrunningpb.CancelOperationRequest) (*emptypb.Empty, error)

func (o *Ops) Delegate(client func() longrunningpb.OperationsClient)

func (o *Ops) DeleteOperation(ctx context.Context, r *longrunningpb.DeleteOperationRequest) (*emptypb.Empty, error)

func (o *Ops) Done(parent string, meta, resp proto.Message) *longrunningpb.Operation

func (o *Ops) DoneJSON(parent string, meta, resp map[string]any) map[string]any

func (o *Ops) GetOperation(ctx context.Context, r *longrunningpb.GetOperationRequest) (*longrunningpb.Operation, error)

func (o *Ops) Info() core.Info

func (o *Ops) ListOperations(ctx context.Context, r *longrunningpb.ListOperationsRequest) (*longrunningpb.ListOperationsResponse, error)

func (o *Ops) RegisterGRPC(g *grpc.Server)

func (o *Ops) Reset()

func (o *Ops) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (o *Ops) Start(parent string, meta proto.Message, run func() (proto.Message, error)) *longrunningpb.Operation

func (o *Ops) WaitOperation(ctx context.Context, r *longrunningpb.WaitOperationRequest) (*longrunningpb.Operation, error)

type REST ¶

type REST struct {
	Versions    []string // path versions, e.g. {"v2"}
	Collections []string // first collection after projects/<p>[/locations/<l>] that this service claims
	Desc        *grpc.ServiceDesc
	Impl        any // the gRPC server implementation
	Routes      map[string]Route
}

REST serves a Google API's REST surface by calling its gRPC handlers.

Routes are keyed "VERB shape[:verb]", where shape is the path after /<version>/projects/<p>/ with every resource id replaced by "*":

"POST locations/*/services"          → parent = projects/p/locations/l
"GET locations/*/services/*"         → name   = projects/p/locations/l/services/s
"POST locations/*/jobs/*:run"        → name   = projects/p/locations/l/jobs/j

The resource name is the path up to its last even segment, so collection calls get the parent and item calls get the item. Query parameters become request fields by their JSON names (serviceId, pageSize, updateMask).

func (a *REST) Match(r *http.Request) bool

func (a *REST) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (a *REST) Split(path string) (project string, parts []string, ok bool)

type Route ¶

type Route struct {
	Method string            // gRPC method name, e.g. "CreateService"
	Field  string            // request field the path's resource name fills, dotted ("parent", "service.name")
	Body   string            // request field the JSON body fills; "" means the whole body is the request
	Desc   *grpc.ServiceDesc // overrides REST.Desc for services with several gRPC services
}

Route maps one REST call onto a gRPC method.

type Rule ¶

type Rule struct {
	HTTP   string
	Method string // gRPC method name; with Fn, the operation name shown in the request log
	Body   string // request field the JSON body fills; "" means the whole body is the request
	// Fn handles the call instead of a gRPC method: r has the body in
	// core.Body(r) and vars holds the path variables. A proto.Message is
	// answered as protojson, anything else as plain JSON.
	Fn func(r *http.Request, vars map[string]string) (any, error)
}

Rule is one REST call, written as in a google.api.http annotation:

"POST /v1/{name=projects/*/serviceAccounts/*}:disable"

"*" is one path segment and "**" the rest of the path. A {variable} fills the request field of that (dotted, JSON) name with the segments it covers. It is the Mux's answer to REST paths that REST's projects/<p>/<collection> shape can't express: organizations, top-level collections, ids without a "projects/" prefix.

type Token ¶

type Token struct {
	Email, Scope string
	Expires      time.Time
}

Token is what an access token carries.

func ParseAccessToken(s string) (t Token, ok bool)