func NewApp(t testing.TB, dataDir string) *server.App {
app, err := server.New(dataDir)
if err != nil {
t.Fatal(err)
}
return app
}
func (c *pingCommand) Run() error {
app, err := server.New(clibazil.Bazil.Config.DataDir.String())
if err != nil {
return err
}
defer app.Close()
pub := (*[ed25519.PublicKeySize]byte)(&c.Arguments.Pub)
auth := &grpcedtls.Authenticator{
Config: app.GetTLSConfig,
PeerPub: pub,
}
addr := c.Arguments.Addr
conn, err := grpc.Dial(addr, grpc.WithTransportCredentials(auth))
if err != nil {
return fmt.Errorf("did not connect: %v", err)
}
defer conn.Close()
client := wire.NewPeerClient(conn)
r, err := client.Ping(context.Background(), &wire.PingRequest{})
if err != nil {
return fmt.Errorf("could not greet: %v", err)
}
log.Printf("pong: %#v", r)
return nil
}
func (cmd *runCommand) Run() error {
app, err := server.New(clibazil.Bazil.Config.DataDir.String())
if err != nil {
return err
}
defer app.Close()
c := control.New(app)
return c.ListenAndServe()
}
func TestSharingAdd(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
secret := [32]byte{1, 2, 3, 4, 5}
addReq := &wire.SharingKeyAddRequest{
Name: "foo",
Secret: secret[:],
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
if _, err := rpcClient.SharingKeyAdd(ctx, addReq); err != nil {
t.Fatalf("adding sharing key failed: %v", err)
}
check := func(tx *db.Tx) error {
sharingKey, err := tx.SharingKeys().Get("foo")
if err != nil {
t.Fatalf("error checking sharing key: %v", err)
}
var key [32]byte
sharingKey.Secret(&key)
if g, e := key, secret; g != e {
t.Errorf("wrong secret stored: %x != %x", g, e)
}
return nil
}
if err := app.DB.View(check); err != nil {
t.Error(err)
}
}
func TestPeerAdd(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
pub := peer.PublicKey{1, 2, 3, 4, 5}
addReq := &wire.PeerAddRequest{
Pub: pub[:],
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
if _, err := rpcClient.PeerAdd(ctx, addReq); err != nil {
t.Fatalf("adding peer failed: %v", err)
}
getPeer := func(tx *db.Tx) error {
p, err := tx.Peers().Get(&pub)
if err != nil {
t.Fatalf("checking stored peer: %v", err)
}
if g, e := *p.Pub(), pub; g != e {
t.Errorf("wrong public key stored: %x != %x", g, e)
}
return nil
}
if err := app.DB.View(getPeer); err != nil {
t.Fatal(err)
}
}
func (c *casCommand) getSharingKey(name string, out *[32]byte) error {
app, err := server.New(cli.Bazil.Config.DataDir.String())
if err != nil {
return err
}
defer app.Close()
view := func(tx *db.Tx) error {
sharingKey, err := tx.SharingKeys().Get(name)
if err != nil {
return err
}
sharingKey.Secret(out)
return nil
}
if err := app.DB.View(view); err != nil {
return err
}
return nil
}
func (cmd *runCommand) Run() error {
gomaxprocs.SetToNumCPU()
app, err := server.New(clibazil.Bazil.Config.DataDir.String())
if err != nil {
return err
}
defer app.Close()
errCh := make(chan error)
var wg sync.WaitGroup
w, err := http.New(app)
if err != nil {
return err
}
wg.Add(1)
go func() {
defer wg.Done()
defer w.Close()
errCh <- w.Serve()
}()
c, err := control.New(app)
if err != nil {
return err
}
wg.Add(1)
go func() {
defer wg.Done()
defer c.Close()
errCh <- c.Serve()
}()
log.Printf("Listening on %s", w.Addr())
wg.Wait()
// We only care about the first error; the rest are likely to be
// about closed listeners.
return <-errCh
}
func TestSharingAddBadNameEmpty(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
secret := [32]byte{1, 2, 3, 4, 5}
addReq := &wire.SharingKeyAddRequest{
Name: "",
Secret: secret[:],
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
_, err = rpcClient.SharingKeyAdd(ctx, addReq)
if err == nil {
t.Fatalf("expected error from SharingKeyAdd with empty name")
}
if err := checkRPCError(err, codes.InvalidArgument, "invalid sharing key name"); err != nil {
t.Error(err)
}
if err := app.DB.View(checkNoSharingKey("foo")); err != nil {
t.Error(err)
}
}
func TestSharingAddBadSecretShort(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
tooShort := make([]byte, 33)
addReq := &wire.SharingKeyAddRequest{
Name: "foo",
Secret: tooShort,
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
_, err = rpcClient.SharingKeyAdd(ctx, addReq)
if err == nil {
t.Fatalf("expected error from SharingKeyAdd with too short secret")
}
if err := checkRPCError(err, codes.InvalidArgument, "sharing key must be exactly 32 bytes"); err != nil {
t.Error(err)
}
if err := app.DB.View(checkNoSharingKey("foo")); err != nil {
t.Error(err)
}
}
func TestPeerAddBadPubLong(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
tooLong := make([]byte, 33)
addReq := &wire.PeerAddRequest{
Pub: tooLong,
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
_, err = rpcClient.PeerAdd(ctx, addReq)
if err == nil {
t.Fatalf("expected error from PeerAdd with too long public key")
}
if err := checkRPCError(err, codes.InvalidArgument, "bad peer public key: peer public key must be exactly 32 bytes"); err != nil {
t.Error(err)
}
if err := checkHasNoPeers(app); err != nil {
t.Error(err)
}
}
func TestPeerAddBadPubSelf(t *testing.T) {
tmp := tempdir.New(t)
defer tmp.Cleanup()
app, err := server.New(tmp.Path)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
defer wg.Wait()
ctrl := controltest.ListenAndServe(t, &wg, app)
defer ctrl.Close()
addReq := &wire.PeerAddRequest{
Pub: app.Keys.Sign.Pub[:],
}
rpcConn, err := grpcunix.Dial(filepath.Join(app.DataDir, "control"))
if err != nil {
t.Fatal(err)
}
defer rpcConn.Close()
rpcClient := wire.NewControlClient(rpcConn)
ctx := context.Background()
_, err = rpcClient.PeerAdd(ctx, addReq)
if err == nil {
t.Fatalf("expected error from PeerAdd with its own public key")
}
if err := checkRPCError(err, codes.InvalidArgument, "cannot add self as peer"); err != nil {
t.Error(err)
}
if err := checkHasNoPeers(app); err != nil {
t.Error(err)
}
}