func (s *assertingService) PingList(ping *pb.PingRequest, stream pb.TestService_PingListServer) error {
// Send user trailers and headers.
stream.SendHeader(metadata.Pairs(serverHeaderMdKey, "I like turtles."))
for i := 0; i < countListResponses; i++ {
stream.Send(&pb.PingResponse{Value: ping.Value, Counter: int32(i)})
}
stream.SetTrailer(metadata.Pairs(serverTrailerMdKey, "I like ending turtles."))
return nil
}
func TestValidateTTNAuthContext(t *testing.T) {
for _, env := range strings.Split("ACCOUNT_SERVER_PROTO ACCOUNT_SERVER_URL", " ") {
if os.Getenv(env) == "" {
t.Skipf("Skipping auth server test: %s configured", env)
}
}
accountServer := fmt.Sprintf("%s://%s",
os.Getenv("ACCOUNT_SERVER_PROTO"),
os.Getenv("ACCOUNT_SERVER_URL"),
)
a := assertions.New(t)
c := new(Component)
c.Config.KeyDir = os.TempDir()
c.Config.AuthServers = map[string]string{
"ttn-account-preview": accountServer,
}
err := c.initAuthServers()
a.So(err, assertions.ShouldBeNil)
{
ctx := context.Background()
_, err = c.ValidateTTNAuthContext(ctx)
a.So(err, assertions.ShouldNotBeNil)
}
{
md := metadata.Pairs()
ctx := metadata.NewContext(context.Background(), md)
_, err = c.ValidateTTNAuthContext(ctx)
a.So(err, assertions.ShouldNotBeNil)
}
{
md := metadata.Pairs(
"id", "dev",
)
ctx := metadata.NewContext(context.Background(), md)
_, err = c.ValidateTTNAuthContext(ctx)
a.So(err, assertions.ShouldNotBeNil)
}
{
md := metadata.Pairs(
"id", "dev",
"token", "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJ0dG4tYWNjb3VudC1wcmV2aWV3Iiwic3ViIjoiZGV2IiwidHlwZSI6InJvdXRlciIsImlhdCI6MTQ3NjQzOTQzOH0.Duz-E5aMYEPY_Nf5Pky7Qmjbs1dMp9PN9nMqbSzoU079b8TPL4DH2SKcRHrrMqieB3yhJb3YaQBfY6dKWfgVz8BmTeKlGXfFrqEj91y30J7r9_VsHRzgDMJedlqXryvf0S_yD27TsJ7TMbGYyE00T4tAX3Uf6wQZDhdyHNGtdf4jtoAjzOxVAodNtXZp26LR7fFk56UstBxOxztBMzyzmAdiTG4lSyEqq7zsuJcFjmHB9MfEoD4ZT-iTRL1ohFjGuj2HN49oPyYlZAVPP7QajLyNsLnv-nDqXE_QecOjAcEq4PLNJ3DpXtX-lo8I_F1eV9yQnDdQQi4EUvxmxZWeBA",
)
ctx := metadata.NewContext(context.Background(), md)
_, err = c.ValidateTTNAuthContext(ctx)
a.So(err, assertions.ShouldBeNil)
}
}
func main() {
conn, err := grpc.Dial("localhost:4001", grpc.WithInsecure())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := projects.NewProjectsServiceClient(conn)
if len(os.Args) < 3 {
log.Fatal("You need to pass me a known command!")
}
ctx := metadata.NewContext(context.Background(), metadata.Pairs("client", "test-client"))
switch os.Args[1] {
case "search":
Search(c, ctx, strings.Join(os.Args[2:], " "))
case "ssearch":
SlowSearch(c, ctx, strings.Join(os.Args[2:], " "))
case "find":
Find(c, ctx, os.Args[2])
case "create":
if len(os.Args) < 4 {
log.Fatal("pass me an id and a name")
}
Create(c, ctx, os.Args[2], strings.Join(os.Args[3:], " "))
default:
log.Fatal("unknown command!")
}
}
func (b *balancer) processServerList(l *lbpb.ServerList, seq int) {
servers := l.GetServers()
var (
sl []addrInfo
addrs []grpc.Address
)
for _, s := range servers {
// TODO: Support ExpirationInterval
md := metadata.Pairs("lb-token", s.LoadBalanceToken)
addr := grpc.Address{
Addr: fmt.Sprintf("%s:%d", s.IpAddress, s.Port),
Metadata: &md,
}
sl = append(sl, addrInfo{
addr: addr,
// TODO: Support dropRequest feature.
})
addrs = append(addrs, addr)
}
b.mu.Lock()
defer b.mu.Unlock()
if b.done || seq < b.seq {
return
}
if len(sl) > 0 {
// reset b.next to 0 when replacing the server list.
b.next = 0
b.addrs = sl
b.addrCh <- addrs
}
return
}
func (spider *spider) parseList(ctx context.Context, resp *crawl.Response) error {
defer spider.c.Close()
var currentTitle string
resp.Find("div#unterMenu a").Each(func(_ int, s *goquery.Selection) {
c, _ := s.Attr("class")
switch c {
case "unterMenuTitel":
currentTitle = strings.ToLower(s.Text())
case "unterMenuName":
ctx = metadata.NewContext(ctx, metadata.Pairs(
"type", currentTitle,
"title", s.Text(),
))
href, _ := s.Attr("href")
spider.c.Execute(ctx, &crawl.Request{
URL: strings.TrimSpace(href),
Referer: resp.URL().String(),
Callbacks: crawl.Callbacks("user-agents"),
})
}
})
close(spider.results)
return nil
}
func (m authMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// get token from Authorization header
authToken, err := authtoken.FromRequest(r)
if err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return
}
// context and metadata
md := metadata.Pairs("traceID", "ABC", "fromName", "api")
ctx := context.Background()
ctx = metadata.NewContext(ctx, md)
// verify token w/ auth service
_, err = m.VerifyToken(ctx, &auth.AuthRequest{
AuthToken: authToken,
})
if err != nil {
http.Error(w, "Unauthorized", http.StatusForbidden)
return
}
// Call the next handler on success.
m.next.ServeHTTP(w, r)
}
func (h *handlerManager) validateTTNAuthAppContext(ctx context.Context, appID string) (context.Context, *claims.Claims, error) {
md, err := api.MetadataFromContext(ctx)
if err != nil {
return ctx, nil, err
}
// If token is empty, try to get the access key and convert it into a token
token, err := api.TokenFromMetadata(md)
if err != nil || token == "" {
key, err := api.KeyFromMetadata(md)
if err != nil {
return ctx, nil, errors.NewErrInvalidArgument("Metadata", "neither token nor key present")
}
token, err := h.handler.Component.ExchangeAppKeyForToken(appID, key)
if err != nil {
return ctx, nil, err
}
md = metadata.Join(md, metadata.Pairs("token", token))
ctx = metadata.NewContext(ctx, md)
}
claims, err := h.handler.Component.ValidateTTNAuthContext(ctx)
if err != nil {
return ctx, nil, err
}
if h.clientRate.Limit(claims.Subject) {
return ctx, claims, grpc.Errorf(codes.ResourceExhausted, "Rate limit for client reached")
}
if h.applicationRate.Limit(appID) {
return ctx, claims, grpc.Errorf(codes.ResourceExhausted, "Rate limit for application reached")
}
return ctx, claims, nil
}
func (ac *Application) Ping(c *cli.Context) {
message := c.String("message")
host := vapi.HostDefaultPort(c.String("host"), vapi.DefaultPortString)
fmt.Printf("ping: host %s: message: %s\n", host, message)
log.Tracef("request-secret:%s", ac.Cfg.Rpc.Secret)
md := metadata.Pairs("request-secret", ac.Cfg.Rpc.Secret)
ctx := context.Background()
ctx = metadata.NewContext(ctx, md)
dopts := vapi.DefaultDialOptions()
con, err := vapi.Connect(host, dopts)
if err != nil {
log.Warnf("Connect %s: %s", host, err)
}
ping := &vapi.PingRequest{
Message: message,
}
res, err := con.Client.Ping(ctx, ping)
if err != nil {
log.Warnf("Ping %s: %s", host, err)
}
fmt.Printf("%#v\n", res)
}
// Open opens a table.
func (c *Client) Open(table string) *Table {
return &Table{
c: c,
table: table,
md: metadata.Pairs(resourcePrefixHeader, c.fullTableName(table)),
}
}
func TestGRPCRequireLeader(t *testing.T) {
defer testutil.AfterTest(t)
cfg := ClusterConfig{Size: 3}
clus := newClusterV3NoClients(t, &cfg)
defer clus.Terminate(t)
clus.Members[1].Stop(t)
clus.Members[2].Stop(t)
client, err := NewClientV3(clus.Members[0])
if err != nil {
t.Fatalf("cannot create client: %v", err)
}
defer client.Close()
// wait for election timeout, then member[0] will not have a leader.
time.Sleep(time.Duration(3*electionTicks) * tickDuration)
md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader)
ctx := metadata.NewContext(context.Background(), md)
reqput := &pb.PutRequest{Key: []byte("foo"), Value: []byte("bar")}
if _, err := toGRPC(client).KV.Put(ctx, reqput); grpc.ErrorDesc(err) != rpctypes.ErrNoLeader.Error() {
t.Errorf("err = %v, want %v", err, rpctypes.ErrNoLeader)
}
}
func main() {
fs := flag.NewFlagSet("", flag.ExitOnError)
var (
grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server")
accessToken = fs.String("grpc.token", "test", "JWT used to gRPC calls")
)
flag.Usage = fs.Usage // only show our flags
fs.Parse(os.Args[1:])
conn, err := grpc.Dial(*grpcAddr)
if err != nil {
fmt.Printf("Error: %v", err)
}
// create client and call
client := protobuf.NewAddClient(conn)
// create context with JWT
md := metadata.Pairs("token", *accessToken)
ctx := context.Background()
ctx = metadata.NewContext(ctx, md)
var header, trailer metadata.MD
result, err := client.Add(ctx, &protobuf.AddRequest{A: 1, B: 2}, grpc.Header(&header), grpc.Trailer(&trailer))
if err != nil {
fmt.Printf("Error: %v", err)
}
fmt.Printf("Result: %v\n", result.V)
conn.Close()
}
// NewServerHandlerTransport returns a ServerTransport handling gRPC
// from inside an http.Handler. It requires that the http Server
// supports HTTP/2.
func NewServerHandlerTransport(w http.ResponseWriter, r *http.Request) (ServerTransport, error) {
if r.ProtoMajor != 2 {
return nil, errors.New("gRPC requires HTTP/2")
}
if r.Method != "POST" {
return nil, errors.New("invalid gRPC request method")
}
if !validContentType(r.Header.Get("Content-Type")) {
return nil, errors.New("invalid gRPC request content-type")
}
if _, ok := w.(http.Flusher); !ok {
return nil, errors.New("gRPC requires a ResponseWriter supporting http.Flusher")
}
if _, ok := w.(http.CloseNotifier); !ok {
return nil, errors.New("gRPC requires a ResponseWriter supporting http.CloseNotifier")
}
st := &serverHandlerTransport{
rw: w,
req: r,
closedCh: make(chan struct{}),
writes: make(chan func()),
}
if v := r.Header.Get("grpc-timeout"); v != "" {
to, err := timeoutDecode(v)
if err != nil {
return nil, StreamErrorf(codes.Internal, "malformed time-out: %v", err)
}
st.timeoutSet = true
st.timeout = to
}
var metakv []string
if r.Host != "" {
metakv = append(metakv, ":authority", r.Host)
}
for k, vv := range r.Header {
k = strings.ToLower(k)
if isReservedHeader(k) && !isWhitelistedPseudoHeader(k) {
continue
}
for _, v := range vv {
if k == "user-agent" {
// user-agent is special. Copying logic of http_util.go.
if i := strings.LastIndex(v, " "); i == -1 {
// There is no application user agent string being set
continue
} else {
v = v[:i]
}
}
metakv = append(metakv, k, v)
}
}
st.headerMD = metadata.Pairs(metakv...)
return st, nil
}
func (client *BfTrderClient) DeleteTick(req *BfDeleteTickReq) {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
client.Datafeed.DeleteTick(ctx, req)
}
func (client *BfTrderClient) CancleOrder(req *BfCancelOrderReq) {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
client.Gateway.CancelOrder(ctx, req)
}
func (client *BfTrderClient) QueryOrders() {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
client.Gateway.QueryOrders(ctx, &BfVoid{})
}
func (s *ProxyHappySuite) TestDirectorErrorIsPropagated() {
// See SetupSuite where the StreamDirector has a special case.
ctx := metadata.NewContext(s.ctx, metadata.Pairs(rejectingMdKey, "true"))
_, err := s.testClient.Ping(ctx, &pb.PingRequest{Value: "foo"})
require.Error(s.T(), err, "Director should reject this RPC")
assert.Equal(s.T(), codes.PermissionDenied, grpc.Code(err))
assert.Equal(s.T(), "testing rejection", grpc.ErrorDesc(err))
}
//===datafeed api===
func (client *BfTrderClient) InsertContract(req *BfContractData) {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
client.Datafeed.InsertContract(ctx, req)
}
// Context returns monitor connection context for gateway
func (cl *gatewayClient) Context() (monitorContext context.Context) {
cl.RLock()
defer cl.RUnlock()
return metadata.NewContext(context.Background(), metadata.Pairs(
"id", cl.id,
"token", cl.token,
))
}
func (c *routerClientForGateway) getContext() context.Context {
c.mu.RLock()
defer c.mu.RUnlock()
md := metadata.Pairs(
"id", c.gatewayID,
"token", c.token,
)
return metadata.NewContext(c.bgCtx, md)
}
func (client *BfTrderClient) DfPing(req *BfPingData) (resp *BfPingData, err error) {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
resp, err = client.Datafeed.Ping(ctx, req)
return
}
func (client *BfTrderClient) CleanAll() {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
_, _ = client.Datafeed.CleanAll(ctx, &BfVoid{})
return
}
//===gateway api===
func (client *BfTrderClient) SendOrder(req *BfSendOrderReq) (resp *BfSendOrderResp, err error) {
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(deadline*time.Second))
defer cancel()
resp, err = client.Gateway.SendOrder(ctx, req)
return
}
// Get a context that includes fsid
func (f *fs) getContext() context.Context {
// TODO: Make timeout configurable
c, _ := context.WithTimeout(context.Background(), 10*time.Second)
c = metadata.NewContext(
c,
metadata.Pairs("fsid", f.fsid),
)
return c
}
// TestV3LeaseFailover ensures the old leader drops lease keepalive requests within
// election timeout after it loses its quorum. And the new leader extends the TTL of
// the lease to at least TTL + election timeout.
func TestV3LeaseFailover(t *testing.T) {
clus := NewClusterV3(t, &ClusterConfig{Size: 3})
defer clus.Terminate(t)
toIsolate := clus.waitLeader(t, clus.Members)
lc := toGRPC(clus.Client(toIsolate)).Lease
// create lease
lresp, err := lc.LeaseGrant(context.TODO(), &pb.LeaseGrantRequest{TTL: 5})
if err != nil {
t.Fatal(err)
}
if lresp.Error != "" {
t.Fatal(lresp.Error)
}
// isolate the current leader with its followers.
clus.Members[toIsolate].Pause()
lreq := &pb.LeaseKeepAliveRequest{ID: lresp.ID}
md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader)
mctx := metadata.NewContext(context.Background(), md)
ctx, cancel := context.WithCancel(mctx)
defer cancel()
lac, err := lc.LeaseKeepAlive(ctx)
if err != nil {
t.Fatal(err)
}
defer lac.CloseSend()
// send keep alive to old leader until the old leader starts
// to drop lease request.
var expectedExp time.Time
for {
if err = lac.Send(lreq); err != nil {
break
}
lkresp, rxerr := lac.Recv()
if rxerr != nil {
break
}
expectedExp = time.Now().Add(time.Duration(lkresp.TTL) * time.Second)
time.Sleep(time.Duration(lkresp.TTL/2) * time.Second)
}
clus.Members[toIsolate].Resume()
clus.waitLeader(t, clus.Members)
// lease should not expire at the last received expire deadline.
time.Sleep(expectedExp.Sub(time.Now()) - 500*time.Millisecond)
if !leaseExist(t, clus, lresp.ID) {
t.Error("unexpected lease not exists")
}
}
func (a *internalAPIServer) versionAndCtx(ctx context.Context) (int64, context.Context, error) {
version, err := a.router.Version()
if err != nil {
return 0, nil, err
}
newCtx := metadata.NewContext(
ctx,
metadata.Pairs("version", fmt.Sprint(version)),
)
return version, newCtx, nil
}
func (client *BfTrderClient) DisconnectPush() {
log.Printf("disconnectPush")
ctx := context.Background()
ctx = metadata.NewContext(ctx, metadata.Pairs("clientid", clientId_))
_, err := client.Gateway.DisconnectPush(ctx, &BfVoid{})
if err != nil {
log.Fatalf("DisconnectPush,%v", err)
}
}
func (s *testServer) EmptyCall(ctx context.Context, in *testpb.Empty) (*testpb.Empty, error) {
if md, ok := metadata.FromContext(ctx); ok {
// For testing purpose, returns an error if there is attached metadata other than
// the user agent set by the client application.
if _, ok := md["user-agent"]; !ok {
return nil, grpc.Errorf(codes.DataLoss, "got extra metadata")
}
grpc.SendHeader(ctx, metadata.Pairs("ua", md["user-agent"]))
}
return new(testpb.Empty), nil
}
func (s *testServer) FullDuplexCall(stream testpb.TestService_FullDuplexCallServer) error {
if md, ok := metadata.FromContext(stream.Context()); ok {
if initialMetadata, ok := md[initialMetadataKey]; ok {
header := metadata.Pairs(initialMetadataKey, initialMetadata[0])
stream.SendHeader(header)
}
if trailingMetadata, ok := md[trailingMetadataKey]; ok {
trailer := metadata.Pairs(trailingMetadataKey, trailingMetadata[0])
stream.SetTrailer(trailer)
}
}
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
return nil
}
if err != nil {
return err
}
status := in.GetResponseStatus()
if status != nil && *status.Code != 0 {
return grpc.Errorf(codes.Code(*status.Code), *status.Message)
}
cs := in.GetResponseParameters()
for _, c := range cs {
if us := c.GetIntervalUs(); us > 0 {
time.Sleep(time.Duration(us) * time.Microsecond)
}
pl, err := serverNewPayload(in.GetResponseType(), c.GetSize())
if err != nil {
return err
}
if err := stream.Send(&testpb.StreamingOutputCallResponse{
Payload: pl,
}); err != nil {
return err
}
}
}
}
// GetContext returns a new context
func GetContext(ctx log.Interface, extraPairs ...string) context.Context {
token, err := GetTokenSource(ctx).Token()
if err != nil {
ctx.WithError(err).Fatal("Could not get token")
}
md := metadata.Pairs(
"id", GetID(),
"service-name", "ttnctl",
"service-version", fmt.Sprintf("%s-%s (%s)", viper.GetString("version"), viper.GetString("gitCommit"), viper.GetString("buildDate")),
"token", token.AccessToken,
)
return metadata.NewContext(context.Background(), md)
}
/*
AnnotateContext adds context information such as metadata from the request.
If there are no metadata headers in the request, then the context returned
will be the same context.
*/
func AnnotateContext(ctx context.Context, req *http.Request) context.Context {
var pairs []string
for key, val := range req.Header {
if strings.HasPrefix(key, metadataHeaderPrefix) {
pairs = append(pairs, key[len(metadataHeaderPrefix):], val[0])
}
}
if len(pairs) != 0 {
ctx = metadata.NewContext(ctx, metadata.Pairs(pairs...))
}
return ctx
}
