Golang Data.UnmarshalBinary方法代碼示例

// backupMetastore will backup the metastore on the host to the passed in path. Database and retention policy backups
// will force a backup of the metastore as well as requesting a specific shard backup from the command line
func (cmd *Command) backupMetastore() error {
	metastoreArchivePath, err := cmd.nextPath(filepath.Join(cmd.path, Metafile))
	if err != nil {
		return err
	}

	cmd.Logger.Printf("backing up metastore to %s", metastoreArchivePath)

	req := &snapshotter.Request{
		Type: snapshotter.RequestMetastoreBackup,
	}

	return cmd.downloadAndVerify(req, metastoreArchivePath, func(file string) error {
		var data meta.Data
		binData, err := ioutil.ReadFile(file)
		if err != nil {
			return err
		}
		if data.UnmarshalBinary(binData) != nil {
			cmd.Logger.Println("Invalid metadata blob, ensure the metadata service is running (default port 8088)")
			return errors.New("invalid metadata received")
		}
		return nil
	})
}

// unpackMeta reads the metadata from the snapshot and initializes a raft
// cluster and replaces the root metadata.
func (cmd *Command) unpackMeta(mr *snapshot.MultiReader, sf snapshot.File, config *Config) error {
	// Read meta into buffer.
	var buf bytes.Buffer
	if _, err := io.CopyN(&buf, mr, sf.Size); err != nil {
		return fmt.Errorf("copy: %s", err)
	}

	// Unpack into metadata.
	var data meta.Data
	if err := data.UnmarshalBinary(buf.Bytes()); err != nil {
		return fmt.Errorf("unmarshal: %s", err)
	}

	// Copy meta config and remove peers so it starts in single mode.
	c := config.Meta
	c.Peers = nil

	// Initialize meta store.
	store := meta.NewStore(config.Meta)
	store.RaftListener = newNopListener()
	store.ExecListener = newNopListener()
	store.RPCListener = newNopListener()

	// Determine advertised address.
	_, port, err := net.SplitHostPort(config.Meta.BindAddress)
	if err != nil {
		return fmt.Errorf("split bind address: %s", err)
	}
	hostport := net.JoinHostPort(config.Meta.Hostname, port)

	// Resolve address.
	addr, err := net.ResolveTCPAddr("tcp", hostport)
	if err != nil {
		return fmt.Errorf("resolve tcp: addr=%s, err=%s", hostport, err)
	}
	store.Addr = addr
	store.RemoteAddr = addr

	// Open the meta store.
	if err := store.Open(); err != nil {
		return fmt.Errorf("open store: %s", err)
	}
	defer store.Close()

	// Wait for the store to be ready or error.
	select {
	case <-store.Ready():
	case err := <-store.Err():
		return err
	}

	// Force set the full metadata.
	if err := store.SetData(&data); err != nil {
		return fmt.Errorf("set data: %s", err)
	}

	return nil
}

// Ensure the data can be marshaled and unmarshaled.
func TestData_MarshalBinary(t *testing.T) {
	data := meta.Data{
		Term:  10,
		Index: 20,
		Nodes: []meta.NodeInfo{
			{ID: 1, Host: "host0"},
			{ID: 2, Host: "host1"},
		},
		Databases: []meta.DatabaseInfo{
			{
				Name: "db0",
				DefaultRetentionPolicy: "default",
				RetentionPolicies: []meta.RetentionPolicyInfo{
					{
						Name:               "rp0",
						ReplicaN:           3,
						Duration:           10 * time.Second,
						ShardGroupDuration: 3 * time.Millisecond,
						ShardGroups: []meta.ShardGroupInfo{
							{
								ID:        100,
								StartTime: time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC),
								EndTime:   time.Date(2000, time.February, 1, 0, 0, 0, 0, time.UTC),
								Shards: []meta.ShardInfo{
									{
										ID: 200,
										Owners: []meta.ShardOwner{
											{NodeID: 1},
											{NodeID: 3},
											{NodeID: 4},
										},
									},
								},
							},
						},
					},
				},
				ContinuousQueries: []meta.ContinuousQueryInfo{
					{Query: "SELECT count() FROM foo"},
				},
			},
		},
		Users: []meta.UserInfo{
			{
				Name:       "susy",
				Hash:       "ABC123",
				Admin:      true,
				Privileges: map[string]influxql.Privilege{"db0": influxql.AllPrivileges},
			},
		},
	}

	// Marshal the data struture.
	buf, err := data.MarshalBinary()
	if err != nil {
		t.Fatal(err)
	}

	// Unmarshal into new data.
	var other meta.Data
	if err := other.UnmarshalBinary(buf); err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(data.Nodes, other.Nodes) {
		t.Fatalf("unexpected nodes: %#v", other.Nodes)
	} else if !reflect.DeepEqual(data.Databases, other.Databases) {
		spew.Dump(data.Databases)
		spew.Dump(other.Databases)
		t.Fatalf("unexpected databases: %#v", other.Databases)
	} else if !reflect.DeepEqual(data.Users, other.Users) {
		t.Fatalf("unexpected users: %#v", other.Users)
	}
}

// unpackMeta reads the metadata from the backup directory and initializes a raft
// cluster and replaces the root metadata.
func (cmd *Command) unpackMeta() error {
	// find the meta file
	metaFiles, err := filepath.Glob(filepath.Join(cmd.backupFilesPath, backup.Metafile+".*"))
	if err != nil {
		return err
	}
	if len(metaFiles) == 0 {
		return fmt.Errorf("no metastore backups in %s", cmd.backupFilesPath)
	}

	// Read the metastore backup
	f, err := os.Open(metaFiles[len(metaFiles)-1])
	if err != nil {
		return err
	}

	var buf bytes.Buffer
	if _, err := io.Copy(&buf, f); err != nil {
		return fmt.Errorf("copy: %s", err)
	}

	// Unpack into metadata.
	var data meta.Data
	if err := data.UnmarshalBinary(buf.Bytes()); err != nil {
		return fmt.Errorf("unmarshal: %s", err)
	}

	// Initialize meta store.
	store := meta.NewStore(cmd.MetaConfig)
	store.RaftListener = newNopListener()
	store.ExecListener = newNopListener()
	store.RPCListener = newNopListener()

	// Determine advertised address.
	_, port, err := net.SplitHostPort(cmd.MetaConfig.BindAddress)
	if err != nil {
		return fmt.Errorf("split bind address: %s", err)
	}
	hostport := net.JoinHostPort(cmd.MetaConfig.Hostname, port)

	// Resolve address.
	addr, err := net.ResolveTCPAddr("tcp", hostport)
	if err != nil {
		return fmt.Errorf("resolve tcp: addr=%s, err=%s", hostport, err)
	}
	store.Addr = addr
	store.RemoteAddr = addr

	// Open the meta store.
	if err := store.Open(); err != nil {
		return fmt.Errorf("open store: %s", err)
	}
	defer store.Close()

	// Wait for the store to be ready or error.
	select {
	case <-store.Ready():
	case err := <-store.Err():
		return err
	}

	// Force set the full metadata.
	if err := store.SetData(&data); err != nil {
		return fmt.Errorf("set data: %s", err)
	}

	return nil
}