bertybridge

Documentation

Overview

Package bertybridge is the main gomobile entrypoint, used to generate iOS and Android frameworks.

Example

package main

import (
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"os"

	"github.com/gogo/protobuf/proto"

	"berty.tech/berty/v2/go/framework/bertybridge"
	"berty.tech/berty/v2/go/pkg/bertyaccount"
	"berty.tech/berty/v2/go/pkg/bertytypes"
)

func main() {
	tmpdir, err := ioutil.TempDir("", "example")
	checkErr(err)
	defer os.RemoveAll(tmpdir)

	// create and start the bridge
	var b *bertybridge.Bridge
	{
		config := bertybridge.NewConfig()
		if false { // disabled in example, but not commented to be sure that compiler performs various checks
			config.SetLifeCycleDriver(nil)
			config.SetLoggerDriver(nil)
			config.SetNotificationDriver(nil)
		}

		b, err = bertybridge.NewBridge(config)
		checkErr(err)

		defer b.Close()
		fmt.Println("[+] initialized.")
	}

	args := []string{
		"--log.filters=info+:bty*,-*.grpc warn+:*.grpc error+:*",
		"--log.format=console",
		"--node.display-name=",
		"--node.listeners=/ip4/127.0.0.1/tcp/0/grpcws",
		"--p2p.swarm-listeners=/ip4/0.0.0.0/tcp/0,/ip6/0.0.0.0/tcp/0",
		"--p2p.local-discovery=false",
		"--p2p.webui-listener=:3000",
		"--store.dir=" + tmpdir,
	}

	// open account
	{
		// create `OpenAccount_Request` Input
		reqb64, err := encodeProtoMessage(&bertyaccount.CreateAccount_Request{
			Args: args,
		})
		checkErr(err)

		// invoke through bridge client
		ret, err := b.InvokeBridgeMethod("/berty.account.v1.AccountService/CreateAccount", reqb64)
		checkErr(err)

		// deserialize reply
		var res bertyaccount.ClientInvokeUnary_Reply
		err = decodeProtoMessage(ret, &res)
		checkErr(err)

		fmt.Println("[+] account opened.")
	}

	// check for GRPC listeners
	{
		// create `GetGRPCListenerAddrs_Request` Input
		reqb64, err := encodeProtoMessage(&bertyaccount.GetGRPCListenerAddrs_Request{})
		checkErr(err)

		// invoke through bridge client
		ret, err := b.InvokeBridgeMethod("/berty.account.v1.AccountService/GetGRPCListenerAddrs", reqb64)
		checkErr(err)

		// deserialize reply
		var res bertyaccount.GetGRPCListenerAddrs_Reply
		err = decodeProtoMessage(ret, &res)
		checkErr(err)

		hasGRPCWeb := false
		hasGRPCWebSocket := false
		for _, entry := range res.Entries {
			switch entry.Proto {
			case "ip4/tcp/grpcweb":
				hasGRPCWeb = true
			case "ip4/tcp/grpcws":
				hasGRPCWebSocket = true
			}
		}

		fmt.Println("[+] has grpc-web listener:           ", hasGRPCWeb)       // no, because `--node.listeners` does not contain grpcweb
		fmt.Println("[+] has websocket listener:          ", hasGRPCWebSocket) // yes, because `--node.listeners`` contains grpcws
	}

	// make unary call to underlying `BertyMessenger` Service
	{
		// create `InstanceGetConfiguration` Input
		input := &bertytypes.InstanceGetConfiguration_Request{}
		payload, err := proto.Marshal(input)
		checkErr(err)

		// Serialize request
		in := &bertyaccount.ClientInvokeUnary_Request{
			MethodDesc: &bertyaccount.MethodDesc{
				Name: "/berty.protocol.v1.ProtocolService/InstanceGetConfiguration",
			},
			Payload: payload,
		}

		reqb64, err := encodeProtoMessage(in)
		checkErr(err)

		// invoke through bridge client
		ret, err := b.InvokeBridgeMethod("/berty.account.v1.AccountService/ClientInvokeUnary", reqb64)
		checkErr(err)

		var output bertyaccount.ClientInvokeUnary_Reply
		err = decodeProtoMessage(ret, &output)
		checkErr(err)

		var res bertytypes.InstanceGetConfiguration_Reply
		err = proto.Unmarshal(output.Payload, &res)
		checkErr(err)

		fmt.Println("[+] has more than one swarm listener:", len(res.Listeners) > 1)
		// log.Println("ret", godev.PrettyJSON(output))
	}

}

func checkErr(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "%+v\n", err)
		panic(err)
	}
}

func decodeProtoMessage(input string, output proto.Message) error {
	dec, err := base64.StdEncoding.DecodeString(input)
	if err != nil {
		return err
	}

	return proto.Unmarshal(dec, output)
}

func encodeProtoMessage(input proto.Message) (string, error) {
	data, err := proto.Marshal(input)
	if err != nil {
		return "", err
	}

	return base64.StdEncoding.EncodeToString(data), nil
}

Output:

[+] initialized.
[+] account opened.
[+] has grpc-web listener:            false
[+] has websocket listener:           true
[+] has more than one swarm listener: true

Index

• Constants
• type Bridge
  • func NewBridge(config *Config) (*Bridge, error)
  • func (b *Bridge) Close() error
  • func (b *Bridge) HandleState(appstate int)
  • func (b *Bridge) HandleTask() LifeCycleBackgroundTask
  • func (b *Bridge) InvokeBridgeMethod(method string, b64message string) (string, error)
  • func (b *Bridge) InvokeBridgeMethodWithPromiseBlock(promise PromiseBlock, method string, b64message string)
  • func (b *Bridge) WillTerminate()
• type Config
  • func NewConfig() *Config
  • func (c *Config) AppendCLIArg(arg string)
  • func (c *Config) SetLifeCycleDriver(lc LifeCycleDriver)
  • func (c *Config) SetLoggerDriver(dLogger NativeLoggerDriver)
  • func (c *Config) SetNotificationDriver(driver NotificationDriver)
  • func (c *Config) SetRootDir(rootdir string)
• type LifeCycleBackgroundTask
• type LifeCycleDriver
• type LifeCycleHandler
• type LocalNotification
• type NativeLoggerDriver
• type NotificationDriver
• type PromiseBlock

Examples

• Package

Constants

const (
	AppStateUnknown int = iota
	AppStateActive
	AppStateInactive
	AppStateBackground
)

Types

type Bridge

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

func NewBridge

func NewBridge(config *Config) (*Bridge, error)

func (*Bridge) Close

func (b *Bridge) Close() error

func (*Bridge) HandleState

func (b *Bridge) HandleState(appstate int)

func (*Bridge) HandleTask

func (b *Bridge) HandleTask() LifeCycleBackgroundTask

func (*Bridge) InvokeBridgeMethod

func (b *Bridge) InvokeBridgeMethod(method string, b64message string) (string, error)

func (*Bridge) InvokeBridgeMethodWithPromiseBlock

func (b *Bridge) InvokeBridgeMethodWithPromiseBlock(promise PromiseBlock, method string, b64message string)

func (*Bridge) WillTerminate

func (b *Bridge) WillTerminate()

type Config

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

Config is used to build a bertybridge configuration using only simple types or types returned by the bertybridge package.

func NewConfig

func NewConfig() *Config

func (*Config) AppendCLIArg

func (c *Config) AppendCLIArg(arg string)

func (*Config) SetLifeCycleDriver

func (c *Config) SetLifeCycleDriver(lc LifeCycleDriver)

func (*Config) SetLoggerDriver

func (c *Config) SetLoggerDriver(dLogger NativeLoggerDriver)

func (*Config) SetNotificationDriver

func (c *Config) SetNotificationDriver(driver NotificationDriver)

func (*Config) SetRootDir

func (c *Config) SetRootDir(rootdir string)

type LifeCycleBackgroundTask

type LifeCycleBackgroundTask interface {
	Execute() (success bool)
	Cancel()
}

type LifeCycleDriver

type LifeCycleDriver interface {
	GetCurrentState() int
	RegisterHandler(handler LifeCycleHandler)
}

type LifeCycleHandler

type LifeCycleHandler interface {
	HandleState(appstate int)
	HandleTask() LifeCycleBackgroundTask
	WillTerminate()
}

type LocalNotification

type LocalNotification struct {
	Title    string
	Body     string
	Interval float64
}

type NativeLoggerDriver

type NativeLoggerDriver interface {
	Log(level, namespace, message string) error
	LevelEnabler(level string) bool
}

type NotificationDriver

type NotificationDriver interface {
	Post(notif *LocalNotification) error
}

type PromiseBlock

type PromiseBlock interface {
	CallResolve(reply string)
	CallReject(error error)
}