Beispiel #1
0
func load(t *testing.T, reg *Registry, src string) error {
	var req plugin.CodeGeneratorRequest
	if err := proto.UnmarshalText(src, &req); err != nil {
		t.Fatalf("proto.UnmarshalText(%s, &file) failed with %v; want success", src, err)
	}
	return reg.Load(&req)
}
Beispiel #2
0
func getHeader(sheet *xlsx.Sheet) (*tool.ExportHeaderV1, error) {

	headerString := strings.TrimSpace(sheet.Cell(0, 0).Value)

	// 可能是空的sheet
	if headerString == "" {
		return nil, nil
	}

	var header tool.ExportHeaderV1

	// 有可能的字符,一定是头
	if strings.Contains(headerString, "ProtoTypeName") ||
		strings.Contains(headerString, "RowFieldName") {
		if err := proto.UnmarshalText(headerString, &header); err != nil {

			return nil, err
		}
	} else {
		// 有字符, 但并不是头
		return nil, nil
	}

	return &header, nil
}
Beispiel #3
0
// tryParse attempts to parse the input, and verifies that it matches
// the FileDescriptorProto represented in text format.
func tryParse(t *testing.T, input, output string) {
	want := new(pb.FileDescriptorProto)
	if err := proto.UnmarshalText(output, want); err != nil {
		t.Fatalf("Test failure parsing a wanted proto: %v", err)
	}

	p := newParser("-", input)
	f := new(ast.File)
	if pe := p.readFile(f); pe != nil {
		t.Errorf("Failed parsing input: %v", pe)
		return
	}
	fset := &ast.FileSet{Files: []*ast.File{f}}
	if err := resolveSymbols(fset); err != nil {
		t.Errorf("Resolving symbols: %v", err)
		return
	}

	fds, err := gendesc.Generate(fset)
	if err != nil {
		t.Errorf("Generating FileDescriptorSet: %v", err)
		return
	}
	if n := len(fds.File); n != 1 {
		t.Errorf("Generated %d FileDescriptorProtos, want 1", n)
		return
	}
	got := fds.File[0]

	if !proto.Equal(got, want) {
		t.Errorf("Mismatch!\nGot:\n%v\nWant:\n%v", got, want)
	}
}
Beispiel #4
0
func (s *MySuite) TestDefaultDropPolicy(c *C) {
	policyTxt := `
		interval: 3600
		policy {
			comment: "Throw everything away"
			policy: DROP
		}
	`
	policyProto := &oproto.RetentionPolicy{}
	c.Assert(proto.UnmarshalText(policyTxt, policyProto), IsNil)
	policy := New(policyProto)

	input := &oproto.ValueStream{
		Variable: variable.NewFromString("/test/foo/bar").AsProto(),
		Value:    []*oproto.Value{},
	}
	for i := 0; i < 10; i++ {
		input.Value = append(input.Value, &oproto.Value{Timestamp: uint64(i), DoubleValue: 1.1})
	}
	output := policy.Apply(input)

	for _, value := range output.Value {
		log.Printf("Got output when none was expected: %s", value)
		c.Fail()
	}
}
Beispiel #5
0
func TestPatch(t *testing.T) {

	f, err := os.Open("Actor.pbt")
	if err != nil {
		t.Fatalf(err.Error())
		return
	}

	data, err := ioutil.ReadAll(f)

	if err != nil {
		t.Fatalf(err.Error())
		return
	}

	var file test.ActorFile

	err = proto.UnmarshalText(string(data), &file)

	if err != nil {
		t.Fatalf(err.Error())
		return
	}

	if file.Actor[0].Name != "A" {
		t.Fatalf("fail A")
	}

}
Beispiel #6
0
func scrapeMetrics(s *httptest.Server) ([]*prometheuspb.MetricFamily, error) {
	req, err := http.NewRequest("GET", s.URL+"/metrics", nil)
	if err != nil {
		return nil, fmt.Errorf("Unable to create http request: %v", err)
	}
	// Ask the prometheus exporter for its text protocol buffer format, since it's
	// much easier to parse than its plain-text format. Don't use the serialized
	// proto representation since it uses a non-standard varint delimiter between
	// metric families.
	req.Header.Add("Accept", scrapeRequestHeader)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("Unable to contact metrics endpoint of master: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != 200 {
		return nil, fmt.Errorf("Non-200 response trying to scrape metrics from master: %v", resp)
	}

	// Each line in the response body should contain all the data for a single metric.
	var metrics []*prometheuspb.MetricFamily
	scanner := bufio.NewScanner(resp.Body)
	for scanner.Scan() {
		var metric prometheuspb.MetricFamily
		if err := proto.UnmarshalText(scanner.Text(), &metric); err != nil {
			return nil, fmt.Errorf("Failed to unmarshal line of metrics response: %v", err)
		}
		glog.Infof("Got metric %q", metric.GetName())
		metrics = append(metrics, &metric)
	}
	return metrics, nil
}
Beispiel #7
0
func main() {

	data, err := ioutil.ReadFile("../Config.pbt")

	if err != nil {
		fmt.Println(err.Error())
		return
	}

	var config gamedef.Config

	// 加载配置
	err = proto.UnmarshalText(string(data), &config)

	if err != nil {
		fmt.Println(err.Error())
		return
	}

	// 创建索引
	table.MakeIndex(&config)

	// 使用被索引的文件
	for index, v := range table.SampleByID {
		fmt.Println(index, v)
	}

}
Beispiel #8
0
func Test(t *testing.T) {

	data, err := ioutil.ReadFile("Actor.pbt")

	if err != nil {
		t.Fatalf(err.Error())
		return
	}

	var file test.ActorFile

	err = proto.UnmarshalText(string(data), &file)

	if err != nil {
		t.Fatalf(err.Error())
		return
	}

	if file.Actor[1].Name != "葫芦\n娃" {
		t.Fatal("fail 1", file.Actor[1].Name)
	}

	if file.Actor[2].Name != "舒\"克\"" {
		t.Fatal("fail 2", file.Actor[2].Name)
	}

	outdata, err := json.MarshalIndent(&file, "", " ")
	ioutil.WriteFile("Actor_std.json", outdata, 777)

	testJson(t, &file)

}
Beispiel #9
0
// 获取一个字段的扩展信息
func GetFieldMeta(field interface{}) (*tool.FieldMetaV1, bool) {

	var metaStr string

	cm := field.(interface {
		ParseTaggedComment() []*pbmeta.TaggedComment
	})

	tc := cm.ParseTaggedComment()

	for _, c := range tc {

		if c.Name == "@" || c.Name == "tabtoy" {
			metaStr = c.Data
			break
		}

	}

	var meta tool.FieldMetaV1

	if err := proto.UnmarshalText(metaStr, &meta); err != nil {
		log.Errorf("parse field meta failed, [%s] %s", metaStr, err.Error())
		return nil, false
	}

	return &meta, true
}
Beispiel #10
0
func TestLoad(t *testing.T) {
	expected := &redditproto.UserAgent{}
	if err := proto.UnmarshalText(`
		user_agent: "test"
		client_id: "id"
		client_secret: "secret"
		username: "******"
		password: "******"
	`, expected); err != nil {
		t.Errorf("failed to build test expectation proto: %v", err)
	}

	testFile, err := ioutil.TempFile("", "user_agent")
	if err != nil {
		t.Errorf("failed to make test input file: %v", err)
	}

	if err := proto.MarshalText(testFile, expected); err != nil {
		t.Errorf("failed to write test input file: %v", err)
	}

	if _, err := loadAgentFile("notarealfile"); err == nil {
		t.Errorf("wanted error returned with nonexistent file as input")
	}

	actual, err := loadAgentFile(testFile.Name())
	if err != nil {
		t.Errorf("failed: %v", err)
	}

	if !proto.Equal(expected, actual) {
		t.Errorf("got %v; wanted %v", actual, expected)
	}
}
Beispiel #11
0
func createDomain() (*tao.Domain, *x509.CertPool, error) {
	var cfg tao.DomainConfig
	d, err := ioutil.ReadFile(*configPath)
	if err != nil {
		return nil, nil, err
	}
	if err := proto.UnmarshalText(string(d), &cfg); err != nil {
		return nil, nil, err
	}
	domain, err := tao.CreateDomain(cfg, *configPath, []byte(*domainPass))
	if domain == nil {
		log.Printf("domainserver: no domain path - %s, pass - %s, err - %s\n",
			*configPath, *domainPass, err)
		return nil, nil, err
	} else if err != nil {
		log.Printf("domainserver: Couldn't load the config path %s: %s\n",
			*configPath, err)
		return nil, nil, err
	}
	log.Printf("domainserver: Created domain\n")
	err = domain_service.InitAcls(domain, *trustedEntitiesPath)
	if err != nil {
		return nil, nil, err
	}
	err = domain.Save()
	if err != nil {
		return nil, nil, err
	}
	certPool := x509.NewCertPool()
	certPool.AddCert(domain.Keys.Cert)
	return domain, certPool, nil
}
Beispiel #12
0
func TestNew(t *testing.T) {
	if _, err := New("fakefile"); err == nil {
		t.Errorf("wanted to return error for nonexistent file")
	}

	testInput := &redditproto.UserAgent{}
	if err := proto.UnmarshalText(`
		user_agent: "test"
		client_id: "id"
		client_secret: "secret"
		username: "******"
		password: "******"
	`, testInput); err != nil {
		t.Errorf("failed to build test expectation proto: %v", err)
	}

	testFile, err := ioutil.TempFile("", "user_agent")
	if err != nil {
		t.Errorf("failed to make test input file: %v", err)
	}

	if err := proto.MarshalText(testFile, testInput); err != nil {
		t.Errorf("failed to write test input file: %v", err)
	}

	if _, err := New(testFile.Name()); err != nil {
		t.Errorf("error: %v", err)
	}
}
Beispiel #13
0
//build frontend config
func mustFEFromText(textcf string) *config.HttpFrontend {
	cf := &config.HttpFrontend{}
	err := proto.UnmarshalText(textcf, cf)
	if err != nil {
		panic(err)
	}
	return cf
}
Beispiel #14
0
func loadFile(t *testing.T, reg *Registry, src string) *descriptor.FileDescriptorProto {
	var file descriptor.FileDescriptorProto
	if err := proto.UnmarshalText(src, &file); err != nil {
		t.Fatalf("proto.UnmarshalText(%s, &file) failed with %v; want success", src, err)
	}
	reg.loadFile(&file)
	return &file
}
Beispiel #15
0
// This function reads in trusted entities from a file at trustedEntitiesPath. In particular,
// this file contains the text representation of a trusted_entities proto message, which contains
// the Tao names of trusted programs and hosts, information about trusted machines and trusted
// machine certificates.
// For each such trusted entity, this function adds ACL rules to the domain guard, and saves
// the changes before returning.
func InitAcls(domain *tao.Domain, trustedEntitiesPath string) error {
	text, err := ioutil.ReadFile(trustedEntitiesPath)
	if err != nil {
		log.Printf("Can't open trusted entities file: %s", trustedEntitiesPath)
		return err
	}
	trustedEntities := TrustedEntities{}
	err = proto.UnmarshalText(string(text), &trustedEntities)
	if err != nil {
		log.Printf("Can't parse trusted entities file: %s", trustedEntitiesPath)
		return err
	}
	for _, programTaoName := range trustedEntities.GetTrustedProgramTaoNames() {
		var programPrin auth.Prin
		_, err := fmt.Sscanf(programTaoName, "%v", &programPrin)
		if err != nil {
			log.Printf("Can't create program principal from: %s\nError: %s",
				programTaoName, err)
			return err
		}
		err = domain.Guard.Authorize(programPrin, "Execute", []string{})
		if err != nil {
			log.Printf("Can't authorize principal: %s\nError: %s", programPrin, err)
			return err
		}
	}
	for _, hostTaoName := range trustedEntities.GetTrustedHostTaoNames() {
		var hostPrin auth.Prin
		_, err := fmt.Sscanf(hostTaoName, "%v", &hostPrin)
		if err != nil {
			log.Printf("Can't create host principal from: %s\nError: %s",
				hostTaoName, err)
			return err
		}
		err = domain.Guard.Authorize(hostPrin, "Host", []string{})
		if err != nil {
			log.Printf("Can't authorize principal: %s\nError: %s", hostPrin, err)
			return err
		}
	}
	for _, machineInfo := range trustedEntities.GetTrustedMachineInfos() {
		machinePrin := auth.Prin{
			Type:    "MachineInfo",
			KeyHash: auth.Str(machineInfo),
		}
		err = domain.Guard.Authorize(machinePrin, "Root", []string{})
		if err != nil {
			log.Printf("Can't authorize principal: %s\nError: %s", machinePrin, err)
			return err
		}
	}
	err = domain.Save()
	if err != nil {
		log.Println("Can't save domain.", err)
	}
	return err
}
Beispiel #16
0
// Load reads a user agent from a protobuffer file and returns it.
func Load(filename string) (*UserAgent, error) {
	buf, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

	agent := &UserAgent{}
	return agent, proto.UnmarshalText(bytes.NewBuffer(buf).String(), agent)
}
Beispiel #17
0
func parseExecuteOptions(value string) (*querypb.ExecuteOptions, error) {
	if value == "" {
		return nil, nil
	}
	result := &querypb.ExecuteOptions{}
	if err := proto.UnmarshalText(value, result); err != nil {
		return nil, fmt.Errorf("failed to unmarshal options: %v", err)
	}
	return result, nil
}
Beispiel #18
0
func LoadPBTFile(filename string, msg proto.Message) error {

	content, err := ioutil.ReadFile(filename)

	if err != nil {
		return err
	}

	return proto.UnmarshalText(string(content), msg)
}
Beispiel #19
0
func TestAmbiguousAny(t *testing.T) {
	pb := &anypb.Any{}
	err := proto.UnmarshalText(`
	type_url: "ttt/proto3_proto.Nested"
	value: "\n\x05Monty"
	`, pb)
	t.Logf("result: %v (error: %v)", expandedMarshaler.Text(pb), err)
	if err != nil {
		t.Errorf("failed to parse ambiguous Any message: %v", err)
	}
}
Beispiel #20
0
func TestUnmarshalGolden(t *testing.T) {
	for _, tt := range goldenMessages {
		want := tt.m
		got := proto.Clone(tt.m)
		got.Reset()
		if err := proto.UnmarshalText(tt.t, got); err != nil {
			t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err)
		}
		if !anyEqual(got, want) {
			t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want)
		}
		got.Reset()
		if err := proto.UnmarshalText(tt.c, got); err != nil {
			t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err)
		}
		if !anyEqual(got, want) {
			t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want)
		}
	}
}
Beispiel #21
0
func mustLoad(filename string) *FileDescriptorSet {
	buf, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Fatalf("Failed reading %v: %v", filename, err)
	}
	fds := new(FileDescriptorSet)
	if err := proto.UnmarshalText(string(buf), fds); err != nil {
		log.Fatalf("Failed parsing %v: %v", filename, err)
	}
	return fds
}
Beispiel #22
0
func readConfig(configPath string, msg proto.Message) {
	protoBytes, err := ioutil.ReadFile(configPath)
	if err != nil {
		glog.Fatalf("Could not read config at path %v: %v", configPath, err)
	}

	err = proto.UnmarshalText(string(protoBytes), msg)
	if err != nil {
		glog.Fatalf("Could not parse config at path %v: %v", configPath, err)
	}
}
Beispiel #23
0
func configureFromFile() *tao.LinuxHostConfig {
	d, err := ioutil.ReadFile(hostConfigPath())
	if err != nil {
		options.Fail(err, "Can't read linux host configuration")
	}
	var cfg tao.LinuxHostConfig
	if err := proto.UnmarshalText(string(d), &cfg); err != nil {
		options.Fail(err, "Can't parse linux host configuration")
	}
	return &cfg
}
Beispiel #24
0
func LoadFromString(configStr string) (Config, error) {
	configProto := pb.AlertManagerConfig{}
	if err := proto.UnmarshalText(configStr, &configProto); err != nil {
		return Config{}, err
	}

	config := Config{AlertManagerConfig: configProto}
	err := config.Validate()

	return config, err
}
Beispiel #25
0
func main() {
	var secrets = make(map[string][]byte)
	var secret *doorky.DoorSecret
	var ts *doorky.Timeseries

	var wapi *WriteAPI
	var sapi *SpaceAPI

	var config doorky.DoorkyConfig
	var configPath string
	var configData []byte
	var bindAddress string
	var err error

	flag.StringVar(&configPath, "config", "Path to the configuration file", "")
	flag.StringVar(&bindAddress, "bind",
		"host:port pair to bind the HTTP server to", ":8080")
	flag.Parse()

	configData, err = ioutil.ReadFile(configPath)
	if err != nil {
		log.Fatal("Error reading config file ", configPath, ": ", err)
	}

	err = proto.UnmarshalText(string(configData), &config)
	if err != nil {
		log.Fatal("Error reading config file: ", err)
	}

	for _, secret = range config.GetSecret() {
		var secretInfo = sha256.Sum256([]byte(secret.GetSecret()))
		secrets[secret.GetName()] = secretInfo[:]
	}

	ts, err = doorky.NewTimeseries(config.GetDbServer(),
		time.Duration(config.GetDbTimeout())*time.Millisecond,
		config.GetDbCredentials(), config.GetKeyspace())
	if err != nil {
		log.Fatal("Error connecting to timeseries database: ", err)
	}

	wapi = NewWriteAPI(ts, secrets)
	http.Handle("/api/doorstatus", wapi)

	if config.SpaceapiMd != nil {
		sapi = NewSpaceAPI(ts, &config)
		http.Handle("/api/spaceapi", sapi)
	}
	err = http.ListenAndServe(bindAddress, nil)
	if err != nil {
		log.Fatal("Error listening to ", bindAddress, ": ", err)
	}
}
Beispiel #26
0
func readAndParsePolicy() *oproto.RetentionPolicyItem {
	item := &oproto.RetentionPolicyItem{}
	policyTxt, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		log.Fatalf("Error reading stdin: %s", err)
	}

	if err := proto.UnmarshalText(string(policyTxt), item); err != nil {
		log.Fatalf("Invalid policy text: %s", err)
	}
	return item
}
Beispiel #27
0
func readHealthcheck(f string) (*pb.Healthcheck, error) {
	p := &pb.Healthcheck{}
	b, err := ioutil.ReadFile(f)
	if err != nil {
		return nil, err
	}
	if err = proto.UnmarshalText(string(b), p); err != nil {
		return nil, err
	}
	proto.SetDefaults(p)
	return p, nil
}
Beispiel #28
0
// readConfig reads and parses recipe config at cfgPath.
func readConfig(cfgPath string) (*recipe_engine.Package, error) {
	contents, err := ioutil.ReadFile(cfgPath)
	if err != nil {
		return nil, fmt.Errorf("cannot read %q: %s", cfgPath, err)
	}

	var pkg recipe_engine.Package
	if err := proto.UnmarshalText(string(contents), &pkg); err != nil {
		return nil, fmt.Errorf("cannot parse %q: %s", cfgPath, err)
	}
	return &pkg, nil
}
Beispiel #29
0
func getHeader(sheet *xlsx.Sheet) *tool.ExportHeader {

	headerString := sheet.Cell(0, 0).Value

	var header tool.ExportHeader

	if err := proto.UnmarshalText(headerString, &header); err != nil {
		return nil
	}

	return &header
}
Beispiel #30
0
func FromText(textcf string) (*Config, error) {
	cf := new(Config)
	err := proto.UnmarshalText(textcf, cf)
	if err != nil {
		return nil, err
	}
	err = Validate(cf)
	if err != nil {
		return nil, err
	}
	return cf, nil
}