func TestUnmarshalNext(t *testing.T) { // We only need to check against a few, not all of them. tests := unmarshalingTests[:5] // Create a buffer with many concatenated JSON objects. var b bytes.Buffer for _, tt := range tests { b.WriteString(tt.json) } dec := json.NewDecoder(&b) for _, tt := range tests { // Make a new instance of the type of our expected object. p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message) err := tt.unmarshaler.UnmarshalNext(dec, p) if err != nil { t.Errorf("%s: %v", tt.desc, err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } p := &pb.Simple{} err := new(Unmarshaler).UnmarshalNext(dec, p) if err != io.EOF { t.Errorf("eof: got %v, expected io.EOF", err) } }
func testGetSrvKeyspace(t *testing.T, conn *vtgateconn.VTGateConn) { want := &topodatapb.SrvKeyspace{ Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{ &topodatapb.SrvKeyspace_KeyspacePartition{ ServedType: topodatapb.TabletType_REPLICA, ShardReferences: []*topodatapb.ShardReference{ &topodatapb.ShardReference{ Name: "shard0", KeyRange: &topodatapb.KeyRange{ Start: []byte{0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, End: []byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, }, }, }, }, ShardingColumnName: "sharding_column_name", ShardingColumnType: topodatapb.KeyspaceIdType_UINT64, ServedFrom: []*topodatapb.SrvKeyspace_ServedFrom{ &topodatapb.SrvKeyspace_ServedFrom{ TabletType: topodatapb.TabletType_MASTER, Keyspace: "other_keyspace", }, }, SplitShardCount: 128, } got, err := conn.GetSrvKeyspace(context.Background(), "big") if err != nil { t.Fatalf("GetSrvKeyspace error: %v", err) } if !proto.Equal(got, want) { t.Errorf("GetSrvKeyspace() = %v, want %v", proto.MarshalTextString(got), proto.MarshalTextString(want)) } }
func (_ singleTaskDecoder) DecodeToText(data []byte) (string, error) { var task single.Task var profileExtension single.ProfileExtension err := proto.Unmarshal(data, &task) if err != nil { return "", err } if task.Profile != nil && task.Profile.Extension != nil && task.Profile.Extension.TypeUrl == "type.googleapis.com/bacs.problem.single.ProfileExtension" { ext := task.Profile.Extension task.Profile = nil err = proto.Unmarshal(ext.Value, &profileExtension) if err != nil { return "", err } } text := proto.MarshalTextString(&task) profileExtensionText := proto.MarshalTextString(&profileExtension) if profileExtensionText != "" { text += "\n" text += profileExtensionText } return text, nil }
func TestProtoCopy(t *testing.T) { person := InitData("ronaflx", 195936, "*****@*****.**") copyPerson := person if !proto.Equal(person, copyPerson) { t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString( copyPerson)) } msg := proto.Clone(person) if !proto.Equal(person, msg) { t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString( msg)) } }
func TestHorizontalReshardingTaskEmittedTasks(t *testing.T) { reshardingTask := &HorizontalReshardingTask{} parameters := map[string]string{ // Required parameters. "keyspace": "test_keyspace", "source_shard_list": "10-20", "dest_shard_list": "10-18,18-20", "vtctld_endpoint": "localhost:15000", "vtworker_endpoint": "localhost:15001", // Optional parameters. "exclude_tables": "unrelated1,unrelated2", "min_healthy_rdonly_tablets": "1", } err := validateParameters(reshardingTask, parameters) if err != nil { t.Fatalf("Not all required parameters were specified: %v", err) } newTaskContainers, _, _ := reshardingTask.Run(parameters) // TODO(mberlin): Check emitted tasks against expected output. for _, tc := range newTaskContainers { t.Logf("new tasks: %v", proto.MarshalTextString(tc)) } }
func TestSpan(t *testing.T) { const input = `package main import "fmt" func main() { fmt.Println("Hello, world") }` unit, digest := oneFileCompilation("main.go", "main", input) fetcher := memFetcher{digest: input} pi, err := Resolve(unit, fetcher, nil) if err != nil { t.Fatalf("Resolve failed: %v\nInput unit:\n%s", err, proto.MarshalTextString(unit)) } tests := []struct { key func(*ast.File) ast.Node // return a node to compute a span for pos, end int // the expected span for the node }{ {func(*ast.File) ast.Node { return nil }, -1, -1}, // invalid node {func(*ast.File) ast.Node { return fakeNode{0, 2} }, -1, -1}, // invalid pos {func(*ast.File) ast.Node { return fakeNode{5, 0} }, 4, 4}, // invalid end {func(f *ast.File) ast.Node { return f.Name }, 8, 12}, // main {func(f *ast.File) ast.Node { return f.Imports[0].Path }, 21, 26}, // "fmt" {func(f *ast.File) ast.Node { return f.Decls[0] }, 14, 26}, // import "fmt" {func(f *ast.File) ast.Node { return f.Decls[1] }, 27, len(input)}, // func main() { ... } } for _, test := range tests { node := test.key(pi.Files[0]) pos, end := pi.Span(node) if pos != test.pos || end != test.end { t.Errorf("Span(%v): got pos=%d, end=%v; want pos=%d, end=%d", node, pos, end, test.pos, test.end) } } }
func TestTaskEmitsTaskWhichCannotBeInstantiated(t *testing.T) { scheduler := newTestScheduler(t) defer scheduler.ShutdownAndWait() scheduler.setTaskCreator(func(taskName string) Task { // TaskCreator which doesn't know TestingEchoTask (but emitted by TestingEmitEchoTask). switch taskName { case "TestingEmitEchoTask": return &TestingEmitEchoTask{} default: return nil } }) scheduler.registerClusterOperation("TestingEmitEchoTask") scheduler.Run() enqueueRequest := &automationpb.EnqueueClusterOperationRequest{ Name: "TestingEmitEchoTask", Parameters: map[string]string{ "echo_text": "to be emitted task should fail to instantiate", }, } enqueueResponse, err := scheduler.EnqueueClusterOperation(context.Background(), enqueueRequest) if err != nil { t.Fatalf("Failed to start cluster operation. Request: %v Error: %v", enqueueRequest, err) } details := waitForClusterOperation(t, scheduler, enqueueResponse.Id, "emitted TestingEchoTask", "no implementation found for: TestingEchoTask") if len(details.SerialTasks) != 1 { t.Errorf("A task has been emitted, but it shouldn't. Details:\n%v", proto.MarshalTextString(details)) } }
// Analyze will determine which analyzers to run and call them as appropriate. If necessary, it will // also modify the context before calling the analyzers. It recovers from all analyzer panics with a // note that the analyzer failed. func (s analyzerService) Analyze(ctx server.Context, in *rpcpb.AnalyzeRequest) (resp *rpcpb.AnalyzeResponse, err error) { resp = new(rpcpb.AnalyzeResponse) log.Printf("called with: %v", proto.MarshalTextString(in)) log.Print("starting analyzing") var nts []*notepb.Note var errs []*rpcpb.AnalysisFailure defer func() { resp.Note = nts resp.Failure = errs }() orgDir, restore, err := file.ChangeDir(*in.ShipshapeContext.RepoRoot) if err != nil { log.Printf("Internal error before analyzing: %v", err) appendFailure(&errs, "InternalFailure", err) return resp, err } defer func() { if err := restore(); err != nil { log.Printf("could not return back into %s from %s: %v", orgDir, *in.ShipshapeContext.RepoRoot, err) } }() reqCats := strset.New(in.Category...) for _, a := range s.analyzers { if reqCats.Contains(a.Category()) { runAnalyzer(a, in.ShipshapeContext, &nts, &errs) } } log.Printf("finished analyzing, sending back %d notes and %d errors", len(nts), len(errs)) return resp, nil }
// NewEncoder returns a new encoder based on content type negotiation. func NewEncoder(w io.Writer, format Format) Encoder { switch format { case FmtProtoDelim: return encoder(func(v *dto.MetricFamily) error { _, err := pbutil.WriteDelimited(w, v) return err }) case FmtProtoCompact: return encoder(func(v *dto.MetricFamily) error { _, err := fmt.Fprintln(w, v.String()) return err }) case FmtProtoText: return encoder(func(v *dto.MetricFamily) error { _, err := fmt.Fprintln(w, proto.MarshalTextString(v)) return err }) case FmtText: return encoder(func(v *dto.MetricFamily) error { _, err := MetricFamilyToText(w, v) return err }) } panic("expfmt.NewEncoder: unknown format") }
func (_ singleResultDecoder) DecodeToText(data []byte) (string, error) { var result single.Result err := proto.Unmarshal(data, &result) if err != nil { return "", err } return proto.MarshalTextString(&result), nil }
func (_ brokerStatusDecoder) DecodeToText(data []byte) (string, error) { var status rabbit.RabbitStatus err := proto.Unmarshal(data, &status) if err != nil { return "", err } return proto.MarshalTextString(&status), nil }
func ExampleConstHistogram() { desc := prometheus.NewDesc( "http_request_duration_seconds", "A histogram of the HTTP request durations.", []string{"code", "method"}, prometheus.Labels{"owner": "example"}, ) // Create a constant histogram from values we got from a 3rd party telemetry system. h := prometheus.MustNewConstHistogram( desc, 4711, 403.34, map[float64]uint64{25: 121, 50: 2403, 100: 3221, 200: 4233}, "200", "get", ) // Just for demonstration, let's check the state of the histogram by // (ab)using its Write method (which is usually only used by Prometheus // internally). metric := &dto.Metric{} h.Write(metric) fmt.Println(proto.MarshalTextString(metric)) // Output: // label: < // name: "code" // value: "200" // > // label: < // name: "method" // value: "get" // > // label: < // name: "owner" // value: "example" // > // histogram: < // sample_count: 4711 // sample_sum: 403.34 // bucket: < // cumulative_count: 121 // upper_bound: 25 // > // bucket: < // cumulative_count: 2403 // upper_bound: 50 // > // bucket: < // cumulative_count: 3221 // upper_bound: 100 // > // bucket: < // cumulative_count: 4233 // upper_bound: 200 // > // > }
func main() { flag.Parse() logger := xlog.NewPlainLogger() const usage = "usage: rcall service::method@addr [request_contents]" if len(flag.Args()) != 1 && len(flag.Args()) != 2 { logger.Fatal(usage) } svcAndAddr := strings.Split(flag.Arg(0), "@") if len(svcAndAddr) != 2 { logger.Fatal(usage) } svcAndMethod := strings.Split(svcAndAddr[0], "::") if len(svcAndMethod) != 2 { logger.Fatal(usage) } ctrl, err := rpc.NewController(rpc.Config{ Logger: xlog.NewNilLogger(), }) if err != nil { logger.Fatalf("Failed to create RPC controller: %s", err) } client, err := ctrl.NewClient(rpc.ClientOptions{ ServiceName: svcAndMethod[0], ServiceAddr: svcAndAddr[1], ConnPoolSize: 1, Retry: rpc.DefaultDialRetry, }) if err != nil { logger.Fatalf("Failed to create RPC client: %s", err) } var requestPB *string if len(flag.Args()) == 2 { s := flag.Arg(1) requestPB = &s } parentCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() ctx := &rpc.ClientContext{Context: parentCtx} responsePB, err := client.CallWithTextPB(svcAndMethod[1], ctx, requestPB) if err != nil { logger.Errorf("Error: %s", err) } if ctx.Metadata != nil { logger.Infof("Response metadata:\n%s", proto.MarshalTextString(ctx.Metadata)) } if responsePB == nil { logger.Info("Response: <nil>") } else { logger.Infof("Response:\n%s", *responsePB) } }
// DisplayStream creates a gRPC connection to the query target and makes a // Subscribe call for the queried paths and streams the response via // cfg.Display. func DisplayStream(ctx context.Context, query Query, cfg *Config) error { c, err := createClient(ctx, query, cfg) if err != nil { return err } request, err := createSubscribeRequest(query) if err != nil { return err } stream, err := c.Subscribe(ctx) if err != nil { return err } if err := stream.Send(request); err != nil { return err } log.Infof("Subscribed with:\n%s", proto.MarshalTextString(request)) for { resp, err := stream.Recv() log.V(2).Info(proto.MarshalTextString(resp)) if err != nil { // TODO(hines): This should be io.EOF but for some reason the server // currently sends this code. if grpc.Code(err) != codes.OutOfRange { return err } return nil } switch resp.Response.(type) { default: log.Infof("Unknown response:\n%s\n", resp.String()) case *ocpb.SubscribeResponse_Heartbeat: log.Infof("Heartbeat:%s\n", resp.String()) case *ocpb.SubscribeResponse_Update: cfg.Display([]byte(proto.MarshalTextString(resp))) case *ocpb.SubscribeResponse_SyncResponse: log.Infof("Sync Response: %s", resp.String()) if cfg.Once { stream.CloseSend() return nil } } } }
// Save writes all domain configuration and policy data. func (d *Domain) Save() error { file, err := util.CreatePath(d.ConfigPath, 0777, 0666) if err != nil { return err } ds := proto.MarshalTextString(&d.Config) fmt.Fprint(file, ds) file.Close() return d.Guard.Save(d.Keys.SigningKey) }
func TestUnmarshaling(t *testing.T) { for _, tt := range unmarshalingTests { // Make a new instance of the type of our expected object. p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message) err := UnmarshalString(tt.json, p) if err != nil { t.Error(err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } }
func TestResolve(t *testing.T) { // are you function enough not to back down? // Test resolution on a simple two-package system: // // Package foo is compiled as test data from the source // package foo // func Foo() int { return 0 } // // Package bar is specified as source and imports foo. // TODO(fromberger): Compile foo as part of the build. foo, err := readTestFile("kythe/go/indexer/testdata/foo.a") if err != nil { t.Fatalf("Unable to read foo.a: %v", err) } const bar = `package bar import "test/foo" func init() { println(foo.Foo()) } ` fetcher := memFetcher{ hexDigest(foo): string(foo), hexDigest([]byte(bar)): bar, } unit := &apb.CompilationUnit{ VName: &spb.VName{Language: "go", Corpus: "test", Path: "bar", Signature: ":pkg:"}, RequiredInput: []*apb.CompilationUnit_FileInput{{ VName: &spb.VName{Language: "go", Corpus: "test", Path: "foo", Signature: ":pkg:"}, Info: &apb.FileInfo{Path: "testdata/foo.a", Digest: hexDigest(foo)}, }, { Info: &apb.FileInfo{Path: "testdata/bar.go", Digest: hexDigest([]byte(bar))}, }}, SourceFile: []string{"testdata/bar.go"}, } pi, err := Resolve(unit, fetcher, nil) if err != nil { t.Fatalf("Resolve failed: %v\nInput unit:\n%s", err, proto.MarshalTextString(unit)) } if got, want := pi.Name, "bar"; got != want { t.Errorf("Package name: got %q, want %q", got, want) } if got, want := pi.ImportPath, "test/bar"; got != want { t.Errorf("Import path: got %q, want %q", got, want) } if dep, ok := pi.Dependencies["test/foo"]; !ok { t.Errorf("Missing dependency for test/foo in %+v", pi.Dependencies) } else if pi.VNames[dep] == nil { t.Errorf("Missing VName for test/foo in %+v", pi.VNames) } if got, want := len(pi.Files), len(unit.SourceFile); got != want { t.Errorf("Source files: got %d, want %d", got, want) } for _, err := range pi.Errors { t.Errorf("Unexpected resolution error: %v", err) } }
func main() { var params cmdParams flag.Var(¶ms, "param", "Task Parameter of the form key=value. May be repeated.") flag.Parse() if *task == "" { fmt.Println("Please specify a task using the --task parameter.") os.Exit(1) } if *automationServer == "" { fmt.Println("Please specify the automation server address using the --server parameter.") os.Exit(2) } fmt.Println("Connecting to Automation Server:", *automationServer) conn, err := grpc.Dial(*automationServer) if err != nil { fmt.Println("Cannot create connection:", err) os.Exit(3) } defer conn.Close() client := pbs.NewAutomationClient(conn) enqueueRequest := &pb.EnqueueClusterOperationRequest{ Name: *task, Parameters: params.parameters, } fmt.Printf("Sending request:\n%v", proto.MarshalTextString(enqueueRequest)) enqueueResponse, err := client.EnqueueClusterOperation(context.Background(), enqueueRequest) if err != nil { fmt.Println("Failed to enqueue ClusterOperation. Error:", err) os.Exit(4) } fmt.Println("Operation was enqueued. Details:", enqueueResponse) resp, errWait := waitForClusterOp(client, enqueueResponse.Id) if errWait != nil { fmt.Println("ERROR:", errWait) os.Exit(5) } fmt.Printf("SUCCESS: ClusterOperation finished.\n\nDetails:\n%v", proto.MarshalTextString(resp)) }
func TestDecodeLinkTicketBasic(t *testing.T) { ticket := &replication.ServiceLinkTicket{ PrimaryId: proto.String("dummyid"), PrimaryUrl: proto.String("http://dummy"), GeneratedBy: proto.String("dummy"), Ticket: []byte("dummyticket"), } m, err := proto.Marshal(ticket) if err != nil { t.Fatalf("proto.Marshal()=%q,_; want <nil>", err) } str := encodeAndTrimEqual(m) dec, err := replication.DecodeLinkTicket(str) if err != nil { t.Errorf("DecodeLinkTicket(%q) = _, %q; want <nil>", str, err) } if !reflect.DeepEqual(ticket, dec) { t.Errorf("DecodeLinkTicket(%q) = %q; want %q", str, proto.MarshalTextString(dec), proto.MarshalTextString(ticket)) } }
func TestUnmarshalling(t *testing.T) { for _, tt := range unmarshallingTests { // Make a new instance of the type of our expected object. p := proto.Clone(tt.pb) p.Reset() err := UnmarshalString(tt.json, p) if err != nil { t.Error(err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } }
func TestParseTextFiles(t *testing.T) { tests := []struct { path string out string }{ { path: "fixtures/textfile/no_metric_files", out: "fixtures/textfile/no_metric_files.out", }, { path: "fixtures/textfile/two_metric_files", out: "fixtures/textfile/two_metric_files.out", }, { path: "fixtures/textfile/nonexistent_path", out: "fixtures/textfile/nonexistent_path.out", }, } for i, test := range tests { c := textFileCollector{ path: test.path, } // Suppress a log message about `nonexistent_path` not existing, this is // expected and clutters the test output. err := flag.Set("log.level", "fatal") if err != nil { t.Fatal(err) } mfs := c.parseTextFiles() textMFs := make([]string, 0, len(mfs)) for _, mf := range mfs { if mf.GetName() == "node_textfile_mtime" { mf.GetMetric()[0].GetGauge().Value = proto.Float64(1) mf.GetMetric()[1].GetGauge().Value = proto.Float64(2) } textMFs = append(textMFs, proto.MarshalTextString(mf)) } sort.Strings(textMFs) got := strings.Join(textMFs, "") want, err := ioutil.ReadFile(test.out) if err != nil { t.Fatalf("%d. error reading fixture file %s: %s", i, test.out, err) } if string(want) != got { t.Fatalf("%d. want:\n\n%s\n\ngot:\n\n%s", i, string(want), got) } } }
func main() { username, password, subscriptions, addrs, opts := client.ParseFlags() if *getFlag != "" { c := client.New(username, password, addrs[0], opts) for _, notification := range c.Get(*getFlag) { var notifStr string if *jsonFlag { var err error if notifStr, err = openconfig.NotificationToJSON(notification); err != nil { glog.Fatal(err) } } else { notifStr = notification.String() } fmt.Println(notifStr) } return } publish := func(addr string, message proto.Message) { resp, ok := message.(*pb.SubscribeResponse) if !ok { glog.Errorf("Unexpected type of message: %T", message) return } if resp.GetHeartbeat() != nil && !glog.V(1) { return // Log heartbeats with verbose logging only. } var respTxt string var err error if *jsonFlag { respTxt, err = openconfig.SubscribeResponseToJSON(resp) if err != nil { glog.Fatal(err) } } else { respTxt = proto.MarshalTextString(resp) } fmt.Println(respTxt) } wg := new(sync.WaitGroup) for _, addr := range addrs { wg.Add(1) c := client.New(username, password, addr, opts) go c.Subscribe(wg, subscriptions, publish) } wg.Wait() }
func (c *context) Call(service, method string, in, out appengine_internal.ProtoMessage, opts *appengine_internal.CallOptions) error { req, err := proto.Marshal(in) if err != nil { return fmt.Errorf("error marshalling request: %v", err) } remReq := &pb.Request{ ServiceName: proto.String(service), Method: proto.String(method), Request: req, // NOTE: RequestId is unused in the server. } req, err = proto.Marshal(remReq) if err != nil { return fmt.Errorf("proto.Marshal: %v", err) } // TODO: Respect opts.Timeout? resp, err := c.client.Post(c.url, "application/octet-stream", bytes.NewReader(req)) if err != nil { return fmt.Errorf("error sending request: %v", err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if resp.StatusCode != http.StatusOK { return fmt.Errorf("bad response %d; body: %q", resp.StatusCode, body) } if err != nil { return fmt.Errorf("failed reading response: %v", err) } remResp := &pb.Response{} if err := proto.Unmarshal(body, remResp); err != nil { return fmt.Errorf("error unmarshalling response: %v", err) } if ae := remResp.GetApplicationError(); ae != nil { return &appengine_internal.APIError{ Code: ae.GetCode(), Detail: ae.GetDetail(), Service: service, } } if remResp.Response == nil { return fmt.Errorf("unexpected response: %s", proto.MarshalTextString(remResp)) } return proto.Unmarshal(remResp.Response, out) }
func TestSerializedDeserialize(t *testing.T) { original, err := ioutil.ReadFile("testdata/stateproto") if err != nil { t.Fatalf("Failed to read stateproto: %s", err) } state := new(disk.State) if err := proto.Unmarshal(original, state); err != nil { t.Fatalf("Failed to parse stateproto: %s", err) } ioutil.WriteFile("a", []byte(proto.MarshalTextString(state)), 0600) var buffer bytes.Buffer entities := serialise(&buffer, state) textual := append([]byte(nil), buffer.Bytes()...) ioutil.WriteFile("text", []byte(textual), 0600) newState := new(disk.State) if err := parse(newState, &buffer, entities); err != nil { t.Fatalf("Failed to parse textual stateproto: %s", err) } buffer.Reset() serialise(&buffer, state) textual2 := buffer.Bytes() if !bytes.Equal(textual, textual2) { } result, err := proto.Marshal(newState) if err != nil { t.Fatalf("Failed to serialise new state: %s", err) } if !bytes.Equal(original, result) { ioutil.WriteFile("b", []byte(proto.MarshalTextString(newState)), 0600) t.Fatalf("Result does not equal original") } }
func TestProtoSerialize(t *testing.T) { person := InitData("ronaflx", 195936, "*****@*****.**") msg, _ := proto.Marshal(person) another := &tutorial.Person{} proto.Unmarshal(msg, another) if !proto.Equal(person, another) { t.Error("expect person equal to another") } person_text := proto.MarshalTextString(person) proto.UnmarshalText(person_text, another) if !proto.Equal(person, another) { t.Error("expect person equal to another") } }
func convertMessageType(curPkg *ProtoPackage, msg *descriptor.DescriptorProto) (schema []*Field, err error) { if glog.V(4) { glog.Info("Converting message: ", proto.MarshalTextString(msg)) } for _, fieldDesc := range msg.GetField() { field, err := convertField(curPkg, fieldDesc, msg) if err != nil { glog.Errorf("Failed to convert field %s in %s: %v", fieldDesc.GetName(), msg.GetName(), err) return nil, err } schema = append(schema, field) } return }
func ExampleConstSummary() { desc := prometheus.NewDesc( "http_request_duration_seconds", "A summary of the HTTP request durations.", []string{"code", "method"}, prometheus.Labels{"owner": "example"}, ) // Create a constant summary from values we got from a 3rd party telemetry system. s := prometheus.MustNewConstSummary( desc, 4711, 403.34, map[float64]float64{0.5: 42.3, 0.9: 323.3}, "200", "get", ) // Just for demonstration, let's check the state of the summary by // (ab)using its Write method (which is usually only used by Prometheus // internally). metric := &dto.Metric{} s.Write(metric) fmt.Println(proto.MarshalTextString(metric)) // Output: // label: < // name: "code" // value: "200" // > // label: < // name: "method" // value: "get" // > // label: < // name: "owner" // value: "example" // > // summary: < // sample_count: 4711 // sample_sum: 403.34 // quantile: < // quantile: 0.5 // value: 42.3 // > // quantile: < // quantile: 0.9 // value: 323.3 // > // > }
func TestDecodeLinkTicketShouldHandleWebSafeBase64(t *testing.T) { ticket := &replication.ServiceLinkTicket{ PrimaryId: proto.String("dummyid"), PrimaryUrl: proto.String("http://dummy"), GeneratedBy: proto.String("dummy"), Ticket: []byte("dummyticket"), } m, err := proto.Marshal(ticket) if err != nil { t.Fatalf("proto.Marshal()=%q,_; want <nil>", err) } testValue := base64.StdEncoding.EncodeToString(m) if !strings.HasSuffix(testValue, "=") { t.Fatalf("ticket is not expected pattern %q. this test is meaningless without padding", testValue) } str := encodeAndTrimEqual(m) dec, err := replication.DecodeLinkTicket(str) if err != nil { t.Errorf("DecodeLinkTicket(%q) = _, %q; want <nil>", str, err) } if !reflect.DeepEqual(ticket, dec) { t.Errorf("DecodeLinkTicket(%q) = %q; want %q", str, proto.MarshalTextString(dec), proto.MarshalTextString(ticket)) } }
func TestClearAllExtensions(t *testing.T) { // unregistered extension desc := &proto.ExtensionDesc{ ExtendedType: (*pb.MyMessage)(nil), ExtensionType: (*bool)(nil), Field: 101010100, Name: "emptyextension", Tag: "varint,0,opt", } m := &pb.MyMessage{} if proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m)) } if err := proto.SetExtension(m, desc, proto.Bool(true)); err != nil { t.Errorf("proto.SetExtension(m, desc, true): got error %q, want nil", err) } if !proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got false, want true", proto.MarshalTextString(m)) } proto.ClearAllExtensions(m) if proto.HasExtension(m, desc) { t.Errorf("proto.HasExtension(%s): got true, want false", proto.MarshalTextString(m)) } }
func initHost(domain *tao.Domain) { var cfg tao.LinuxHostConfig configureFromOptions(&cfg) _, err := loadHost(domain, &cfg) options.FailIf(err, "Can't create host") // If we get here, keys were created and flags must be ok. file, err := util.CreatePath(hostConfigPath(), 0777, 0666) options.FailIf(err, "Can't create host configuration") cs := proto.MarshalTextString(&cfg) fmt.Fprint(file, cs) file.Close() }