Merge "services/device/devicex: mkdir -p"
diff --git a/runtime/flow/model.go b/runtime/flow/model.go
new file mode 100644
index 0000000..df250b4
--- /dev/null
+++ b/runtime/flow/model.go
@@ -0,0 +1,38 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package Flow contains a super-interface of the Flow defined in v23/flow/model.go
+// to expose information that rpc implementors need to correctly implement the protocol
+// (i.e. VOM TypeEncoder, RPC BlessingCache).
+//
+// TODO(suharshs): We currently do not want to expose those in the flow API
+// because the flow API should be independent of the RPC code, so this is
+// our current way of punting on this.
+package flow
+
+import (
+ "v.io/v23/flow"
+)
+
+// Flow is the interface for a flow-controlled channel multiplexed over underlying network connections.
+type Flow interface {
+ flow.Flow
+
+ // SharedData returns a SharedData cache used for all flows on the underlying authenticated
+ // connection.
+ SharedData() SharedData
+}
+
+// SharedData is a thread-safe store that allows data to be shared across the underlying
+// authenticated connection that a flow is multiplexed over.
+type SharedData interface {
+ // Get returns the 'value' associated with 'key'.
+ Get(key interface{}) interface{}
+
+ // GetOrInsert returns the 'value' associated with 'key'. If an entry already exists in the
+ // cache with the 'key', the 'value' is returned, otherwise 'create' is called to create a new
+ // value N, the cache is updated, and N is returned. GetOrInsert may be called from
+ // multiple goroutines concurrently.
+ GetOrInsert(key interface{}, create func() interface{}) interface{}
+}
diff --git a/runtime/internal/flow/model.go b/runtime/internal/flow/model.go
deleted file mode 100644
index 53de3e1..0000000
--- a/runtime/internal/flow/model.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flow
-
-import (
- "io"
- "v.io/v23/context"
- "v.io/v23/naming"
- "v.io/v23/security"
-)
-
-// Manager is the interface for managing the creation of Flows.
-type Manager interface {
- // Acceptor creates a Acceptor that can be used to accept new flows from addresses
- // that the Manager is listening on.
- //
- // For example:
- // err := m.Listen(ctx, "tcp", ":0")
- // a, err := m.Acceptor(ctx, blessings)
- // for {
- // flow, err := a.Accept(ctx)
- // // process flow
- // }
- //
- // can be used to accept Flows initiated by remote processes to the endpoints returned
- // by Acceptor.Endpoints. All created Acceptors accept Flows from all addresses the
- // Manager is listening on, but are differentiated by a RoutingID unique to each
- // Acceptor.
- //
- // 'blessings' are the Blessings presented to the Client during authentication.
- Acceptor(ctx *context.T, blessings security.Blessings) (Acceptor, error)
-
- // Listen causes the Manager to accept flows from the provided protocol and address.
- // Listen may be called muliple times.
- Listen(ctx *context.T, protocol, address string) error
-
- // Dial creates a Flow to the provided remote endpoint. 'auth' is used to authorize
- // the remote end.
- //
- // To maximize re-use of connections, the Manager will also Listen on Dialed
- // connections for the lifetime of the connection.
- //
- // TODO(suharshs): Revisit passing in an authorizer here. Perhaps restrict server
- // authorization to a smaller set of policies, or use a different mechanism to
- // allow the user to specify a policy.
- Dial(ctx *context.T, remote naming.Endpoint, auth security.Authorizer) (Flow, error)
-
- // Closed returns a channel that remains open for the lifetime of the Manager
- // object. Once the channel is closed any operations on the Manager will
- // necessarily fail.
- Closed() <-chan struct{}
-}
-
-// Flow is the interface for a flow-controlled channel multiplexed on connection.
-type Flow interface {
- io.ReadWriter
-
- // LocalEndpoint returns the local vanadium Endpoint
- LocalEndpoint() naming.Endpoint
- // RemoteEndpoint returns the remote vanadium Endpoint
- RemoteEndpoint() naming.Endpoint
- // LocalBlessings returns the blessings presented by the local end of the flow during authentication.
- LocalBlessings() security.Blessings
- // RemoteBlessings returns the blessings presented by the remote end of the flow during authentication.
- RemoteBlessings() security.Blessings
- // LocalDischarges returns the discharges presented by the local end of the flow during authentication.
- //
- // Discharges are organized in a map keyed by the discharge-identifier.
- LocalDischarges() map[string]security.Discharge
- // RemoteDischarges returns the discharges presented by the remote end of the flow during authentication.
- //
- // Discharges are organized in a map keyed by the discharge-identifier.
- RemoteDischarges() map[string]security.Discharge
-
- // Closed returns a channel that remains open until the flow has been closed or
- // the ctx to the Dial or Accept call used to create the flow has been cancelled.
- Closed() <-chan struct{}
-}
-
-// Acceptor is the interface for accepting Flows created by a remote process.
-type Acceptor interface {
- // ListeningEndpoints returns the endpoints that the Manager has explicitly
- // listened on. The Acceptor will accept new flows on these endpoints.
- // Returned endpoints all have a RoutingID unique to the Acceptor.
- ListeningEndpoints() []naming.Endpoint
- // Accept blocks until a new Flow has been initiated by a remote process.
- Accept(ctx *context.T) (Flow, error)
- // Closed returns a channel that remains open until the Acceptor has been closed.
- // i.e. the context provided to Manager.Acceptor() has been cancelled. Once the
- // channel is closed, all calls to Accept will result in an error.
- Closed() <-chan struct{}
-}
diff --git a/services/application/applicationd/impl_test.go b/services/application/applicationd/impl_test.go
index 68b07f9..b045bbf 100644
--- a/services/application/applicationd/impl_test.go
+++ b/services/application/applicationd/impl_test.go
@@ -5,6 +5,7 @@
package main_test
import (
+ "fmt"
"io/ioutil"
"os"
"reflect"
@@ -303,3 +304,238 @@
t.Fatalf("Incorrect output: expected %v, got %v", envelopeV1, output)
}
}
+
+// TestTidyNow tests that TidyNow operates correctly.
+func TestTidyNow(t *testing.T) {
+ ctx, shutdown := test.V23Init()
+ defer shutdown()
+
+ dir, prefix := "", ""
+ store, err := ioutil.TempDir(dir, prefix)
+ if err != nil {
+ t.Fatalf("TempDir(%q, %q) failed: %v", dir, prefix, err)
+ }
+ defer os.RemoveAll(store)
+ dispatcher, err := appd.NewDispatcher(store)
+ if err != nil {
+ t.Fatalf("NewDispatcher() failed: %v", err)
+ }
+
+ server, err := xrpc.NewDispatchingServer(ctx, "", dispatcher)
+ if err != nil {
+ t.Fatalf("NewServer(%v) failed: %v", dispatcher, err)
+ }
+
+ defer func() {
+ if err := server.Stop(); err != nil {
+ t.Fatalf("Stop() failed: %v", err)
+ }
+ }()
+ endpoint := server.Status().Endpoints[0].String()
+
+ // Create client stubs for talking to the server.
+ stub := repository.ApplicationClient(naming.JoinAddressName(endpoint, "search"))
+ stubs := make([]repository.ApplicationClientStub, 0)
+ for _, vn := range []string{"v0", "v1", "v2", "v3"} {
+ s := repository.ApplicationClient(naming.JoinAddressName(endpoint, fmt.Sprintf("search/%s", vn)))
+ stubs = append(stubs, s)
+ }
+ blessings, sig := newPublisherSignature(t, ctx, []byte("binarycontents"))
+
+ // Create example envelopes.
+ envelopeV1 := application.Envelope{
+ Args: []string{"--help"},
+ Env: []string{"DEBUG=1"},
+ Binary: application.SignedFile{
+ File: "/v23/name/of/binary",
+ Signature: sig,
+ },
+ Publisher: blessings,
+ }
+ envelopeV2 := application.Envelope{
+ Args: []string{"--verbose"},
+ Env: []string{"DEBUG=0"},
+ Binary: application.SignedFile{
+ File: "/v23/name/of/binary",
+ Signature: sig,
+ },
+ Publisher: blessings,
+ }
+ envelopeV3 := application.Envelope{
+ Args: []string{"--verbose", "--spiffynewflag"},
+ Env: []string{"DEBUG=0"},
+ Binary: application.SignedFile{
+ File: "/v23/name/of/binary",
+ Signature: sig,
+ },
+ Publisher: blessings,
+ }
+
+ stuffEnvelopes(t, ctx, stubs, []profEnvTuple{
+ {
+ &envelopeV1,
+ []string{"base", "media"},
+ },
+ })
+
+ // Verify that we have one
+ testGlob(t, ctx, endpoint, []string{
+ "",
+ "search",
+ "search/v0",
+ })
+
+ // Tidy when already tidy does not alter.
+ if err := stubs[0].TidyNow(ctx); err != nil {
+ t.Errorf("TidyNow failed: %v", err)
+ }
+ testGlob(t, ctx, endpoint, []string{
+ "",
+ "search",
+ "search/v0",
+ })
+
+ stuffEnvelopes(t, ctx, stubs, []profEnvTuple{
+ {
+ &envelopeV1,
+ []string{"base", "media"},
+ },
+ {
+ &envelopeV2,
+ []string{"media"},
+ },
+ {
+ &envelopeV3,
+ []string{"base"},
+ },
+ })
+
+ // Now there are three envelopes which is one more than the
+ // numberOfVersionsToKeep set for the test. However
+ // we need both envelopes v0 and v2 to keep two versions for
+ // profile media and envelopes v0 and v3 to keep two versions
+ // for profile base so we continue to have three versions.
+ if err := stubs[0].TidyNow(ctx); err != nil {
+ t.Errorf("TidyNow failed: %v", err)
+ }
+ testGlob(t, ctx, endpoint, []string{
+ "",
+ "search",
+ "search/v0",
+ "search/v1",
+ "search/v2",
+ })
+
+ // And the newest version for each profile differs because
+ // not every version supports all profiles.
+ output1, err := stub.Match(ctx, []string{"media"})
+ if err != nil {
+ t.Fatalf("Match(%v) failed: %v", "media", err)
+ }
+ if !reflect.DeepEqual(envelopeV2, output1) {
+ t.Fatalf("Incorrect output: expected %v, got %v", envelopeV2, output1)
+ }
+
+ output2, err := stub.Match(ctx, []string{"base"})
+ if err != nil {
+ t.Fatalf("Match(%v) failed: %v", "base", err)
+ }
+ if !reflect.DeepEqual(envelopeV3, output2) {
+ t.Fatalf("Incorrect output: expected %v, got %v", envelopeV3, output2)
+ }
+
+ // Test that we can add an envelope for v3 with profile media and after calling
+ // TidyNow(), there will be all versions still in glob but v0 will only match profile
+ // base and not have an envelope for profile media.
+ if err := stubs[3].Put(ctx, []string{"media"}, envelopeV3); err != nil {
+ t.Fatalf("Put() failed: %v", err)
+ }
+
+ if err := stubs[0].TidyNow(ctx); err != nil {
+ t.Errorf("TidyNow failed: %v", err)
+ }
+ testGlob(t, ctx, endpoint, []string{
+ "",
+ "search",
+ "search/v0",
+ "search/v1",
+ "search/v2",
+ "search/v3",
+ })
+
+ output3, err := stubs[0].Match(ctx, []string{"base"})
+ if err != nil {
+ t.Fatalf("Match(%v) failed: %v", "base", err)
+ }
+ if !reflect.DeepEqual(envelopeV3, output2) {
+ t.Fatalf("Incorrect output: expected %v, got %v", envelopeV3, output3)
+ }
+
+ output4, err := stubs[0].Match(ctx, []string{"base"})
+ if err != nil {
+ t.Fatalf("Match(%v) failed: %v", "base", err)
+ }
+ if !reflect.DeepEqual(envelopeV3, output2) {
+ t.Fatalf("Incorrect output: expected %v, got %v", envelopeV3, output4)
+ }
+
+ _, err = stubs[0].Match(ctx, []string{"media"})
+ if verror.ErrorID(err) != verror.ErrNoExist.ID {
+ t.Fatalf("got error %v, expected %v", err, verror.ErrNoExist)
+ }
+
+ stuffEnvelopes(t, ctx, stubs, []profEnvTuple{
+ {
+ &envelopeV1,
+ []string{"base", "media"},
+ },
+ {
+ &envelopeV2,
+ []string{"base", "media"},
+ },
+ {
+ &envelopeV3,
+ []string{"base", "media"},
+ },
+ {
+ &envelopeV3,
+ []string{"base", "media"},
+ },
+ })
+
+ // Now there are four versions for all profiles so tidying
+ // will remove the older versions.
+ if err := stubs[0].TidyNow(ctx); err != nil {
+ t.Errorf("TidyNow failed: %v", err)
+ }
+
+ testGlob(t, ctx, endpoint, []string{
+ "",
+ "search",
+ "search/v2",
+ "search/v3",
+ })
+}
+
+type profEnvTuple struct {
+ e *application.Envelope
+ p []string
+}
+
+func testGlob(t *testing.T, ctx *context.T, endpoint string, expected []string) {
+ matches, _, err := testutil.GlobName(ctx, naming.JoinAddressName(endpoint, ""), "...")
+ if err != nil {
+ t.Errorf("Unexpected Glob error: %v", err)
+ }
+ if !reflect.DeepEqual(matches, expected) {
+ t.Errorf("unexpected Glob results. Got %q, want %q", matches, expected)
+ }
+}
+
+func stuffEnvelopes(t *testing.T, ctx *context.T, stubs []repository.ApplicationClientStub, pets []profEnvTuple) {
+ for i, pet := range pets {
+ if err := stubs[i].Put(ctx, pet.p, *pet.e); err != nil {
+ t.Fatalf("%d: Put(%v) failed: %v", i, pet, err)
+ }
+ }
+}
diff --git a/services/application/applicationd/only_for_test.go b/services/application/applicationd/only_for_test.go
new file mode 100644
index 0000000..0b3724e
--- /dev/null
+++ b/services/application/applicationd/only_for_test.go
@@ -0,0 +1,9 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func init() {
+ numberOfVersionsToKeep = 2
+}
diff --git a/services/application/applicationd/service.go b/services/application/applicationd/service.go
index 2fc2a5f..e11f26d 100644
--- a/services/application/applicationd/service.go
+++ b/services/application/applicationd/service.go
@@ -5,7 +5,6 @@
package main
import (
- "fmt"
"sort"
"strings"
@@ -72,7 +71,7 @@
defer i.store.Unlock()
if version == "" {
- versions, err := i.allAppVersions(name)
+ versions, err := i.allAppVersionsForProfiles(name, profiles)
if err != nil {
return empty, err
}
@@ -187,15 +186,13 @@
return apps, nil
}
-func (i *appRepoService) allAppVersions(appName string) ([]string, error) {
- profiles, err := i.store.BindObject(naming.Join("/applications", appName)).Children()
- if err != nil {
- return nil, err
- }
+func (i *appRepoService) allAppVersionsForProfiles(appName string, profiles []string) ([]string, error) {
uniqueVersions := make(map[string]struct{})
for _, profile := range profiles {
versions, err := i.store.BindObject(naming.Join("/applications", appName, profile)).Children()
- if err != nil {
+ if verror.ErrorID(err) == verror.ErrNoExist.ID {
+ continue
+ } else if err != nil {
return nil, err
}
set.String.Union(uniqueVersions, set.String.FromSlice(versions))
@@ -203,6 +200,14 @@
return set.String.ToSlice(uniqueVersions), nil
}
+func (i *appRepoService) allAppVersions(appName string) ([]string, error) {
+ profiles, err := i.store.BindObject(naming.Join("/applications", appName)).Children()
+ if err != nil {
+ return nil, err
+ }
+ return i.allAppVersionsForProfiles(appName, profiles)
+}
+
func (i *appRepoService) GlobChildren__(ctx *context.T, _ rpc.ServerCall) (<-chan string, error) {
ctx.VI(0).Infof("%v.GlobChildren__()", i.suffix)
i.store.Lock()
@@ -334,6 +339,64 @@
return nil
}
+func (i *appRepoService) tidyRemoveVersions(call rpc.ServerCall, tname, appName, profile string, versions []string) error {
+ for _, v := range versions {
+ path := naming.Join(tname, "/applications", appName, profile, v)
+ object := i.store.BindObject(path)
+ if err := object.Remove(call); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// numberOfVersionsToKeep can be set for tests.
+var numberOfVersionsToKeep = 5
+
func (i *appRepoService) TidyNow(ctx *context.T, call rpc.ServerCall) error {
- return fmt.Errorf("method not implemented")
+ ctx.VI(2).Infof("%v.TidyNow()", i.suffix)
+ i.store.Lock()
+ defer i.store.Unlock()
+
+ tname, err := i.store.BindTransactionRoot("").CreateTransaction(call)
+ if err != nil {
+ return err
+ }
+
+ apps, err := i.allApplications()
+ if err != nil {
+ return err
+ }
+
+ for _, app := range apps {
+ profiles, err := i.store.BindObject(naming.Join("/applications", app)).Children()
+ if err != nil {
+ return err
+ }
+
+ for _, profile := range profiles {
+ versions, err := i.store.BindObject(naming.Join("/applications", app, profile)).Children()
+ if err != nil {
+ return err
+ }
+
+ lv := len(versions)
+ if lv <= numberOfVersionsToKeep {
+ continue
+ }
+
+ // Per assumption in Match, version names should ascend.
+ sort.Strings(versions)
+ versionsToRemove := versions[0 : lv-numberOfVersionsToKeep]
+ if err := i.tidyRemoveVersions(call, tname, app, profile, versionsToRemove); err != nil {
+ return err
+ }
+ }
+ }
+
+ if err := i.store.BindTransaction(tname).Commit(call); err != nil {
+ return verror.New(ErrOperationFailed, ctx)
+ }
+ return nil
+
}
diff --git a/services/device/deviced/internal/impl/dispatcher.go b/services/device/deviced/internal/impl/dispatcher.go
index 5cd449e..d1824ea 100644
--- a/services/device/deviced/internal/impl/dispatcher.go
+++ b/services/device/deviced/internal/impl/dispatcher.go
@@ -40,8 +40,8 @@
securityAgent *securityAgentState
restartHandler func()
testMode bool
- // reap is the app process monitoring subsystem.
- reap *reaper
+ // runner is responsible for running app instances.
+ runner *appRunner
// tidying is the automatic state tidying subsystem.
tidying chan<- tidyRequests
}
@@ -107,14 +107,16 @@
return &claimable{token: pairingToken, permsStore: permsStore, permsDir: permsDir, notify: notify}, notify
}
-// NewDispatcher is the device manager dispatcher factory.
-func NewDispatcher(ctx *context.T, config *config.State, mtAddress string, testMode bool, restartHandler func(), permStore *pathperms.PathStore) (rpc.Dispatcher, error) {
+// NewDispatcher is the device manager dispatcher factory. It returns a new
+// dispatcher as well as a shutdown function, to be called when the dispatcher
+// is no longer needed.
+func NewDispatcher(ctx *context.T, config *config.State, mtAddress string, testMode bool, restartHandler func(), permStore *pathperms.PathStore) (rpc.Dispatcher, func(), error) {
if err := config.Validate(); err != nil {
- return nil, verror.New(errInvalidConfig, ctx, config, err)
+ return nil, nil, verror.New(errInvalidConfig, ctx, config, err)
}
uat, err := NewBlessingSystemAssociationStore(config.Root)
if err != nil {
- return nil, verror.New(errCantCreateAccountStore, ctx, err)
+ return nil, nil, verror.New(errCantCreateAccountStore, ctx, err)
}
InitSuidHelper(ctx, config.Helper)
d := &dispatcher{
@@ -135,39 +137,30 @@
// If we're in 'security agent mode', set up the key manager agent.
if len(os.Getenv(ref.EnvAgentEndpoint)) > 0 {
if keyMgrAgent, err := keymgr.NewAgent(); err != nil {
- return nil, verror.New(errNewAgentFailed, ctx, err)
+ return nil, nil, verror.New(errNewAgentFailed, ctx, err)
} else {
d.internal.securityAgent = &securityAgentState{
keyMgrAgent: keyMgrAgent,
}
}
}
- reap, err := newReaper(ctx, config.Root, &appRunner{
+ runner := &appRunner{
callback: d.internal.callback,
securityAgent: d.internal.securityAgent,
appServiceName: naming.Join(d.config.Name, appsSuffix),
- })
- if err != nil {
- return nil, verror.New(errCantCreateAppWatcher, ctx, err)
+ mtAddress: d.mtAddress,
}
- d.internal.reap = reap
+ d.internal.runner = runner
+ reap, err := newReaper(ctx, config.Root, runner)
+ if err != nil {
+ return nil, nil, verror.New(errCantCreateAppWatcher, ctx, err)
+ }
+ runner.reap = reap
if testMode {
- return &testModeDispatcher{d}, nil
+ return &testModeDispatcher{d}, reap.shutdown, nil
}
- return d, nil
-}
-
-// Shutdown the dispatcher.
-func Shutdown(ctx *context.T, rpcd rpc.Dispatcher) {
- switch d := rpcd.(type) {
- case *dispatcher:
- d.internal.reap.shutdown()
- case *testModeDispatcher:
- Shutdown(ctx, d.realDispatcher)
- default:
- ctx.Panicf("%v not a supported dispatcher type.", rpcd)
- }
+ return d, reap.shutdown, nil
}
// Logging invoker that logs any error messages before returning.
@@ -333,13 +326,7 @@
suffix: components[1:],
uat: d.uat,
permsStore: d.permsStore,
- runner: &appRunner{
- reap: d.internal.reap,
- callback: d.internal.callback,
- securityAgent: d.internal.securityAgent,
- mtAddress: d.mtAddress,
- appServiceName: naming.Join(d.config.Name, appsSuffix),
- },
+ runner: d.internal.runner,
})
appSpecificAuthorizer, err := newAppSpecificAuthorizer(auth, d.config, components[1:], d.permsStore)
if err != nil {
diff --git a/services/device/deviced/internal/impl/instance_reaping.go b/services/device/deviced/internal/impl/instance_reaping.go
index 320f097..9b2f4ce 100644
--- a/services/device/deviced/internal/impl/instance_reaping.go
+++ b/services/device/deviced/internal/impl/instance_reaping.go
@@ -43,14 +43,13 @@
}
type reaper struct {
- c chan pidInstanceDirPair
- startState *appRunner
- ctx *context.T
+ c chan pidInstanceDirPair
+ ctx *context.T
}
var stashedPidMap map[string]int
-func newReaper(ctx *context.T, root string, startState *appRunner) (*reaper, error) {
+func newReaper(ctx *context.T, root string, appRunner *appRunner) (*reaper, error) {
pidMap, restartCandidates, err := findAllTheInstances(ctx, root)
// Used only by the testing code that verifies that all processes
@@ -61,16 +60,14 @@
}
r := &reaper{
- c: make(chan pidInstanceDirPair),
- startState: startState,
- ctx: ctx,
+ c: make(chan pidInstanceDirPair),
+ ctx: ctx,
}
- r.startState.reap = r
- go r.processStatusPolling(ctx, pidMap)
+ go r.processStatusPolling(ctx, pidMap, appRunner)
// Restart daemon jobs if they're not running (say because the machine crashed.)
for _, idir := range restartCandidates {
- go r.startState.restartAppIfNecessary(ctx, idir)
+ go appRunner.restartAppIfNecessary(ctx, idir)
}
return r, nil
}
@@ -92,16 +89,16 @@
// functionality. For example, use the kevent facility in darwin or
// replace init. See http://www.incenp.org/dvlpt/wait4.html for
// inspiration.
-func (r *reaper) processStatusPolling(ctx *context.T, trackedPids map[string]int) {
+func (r *reaper) processStatusPolling(ctx *context.T, trackedPids map[string]int, appRunner *appRunner) {
poll := func(ctx *context.T) {
for idir, pid := range trackedPids {
switch err := syscall.Kill(pid, 0); err {
case syscall.ESRCH:
// No such PID.
- go r.startState.restartAppIfNecessary(ctx, idir)
+ go appRunner.restartAppIfNecessary(ctx, idir)
ctx.VI(2).Infof("processStatusPolling discovered pid %d ended", pid)
markNotRunning(ctx, idir)
- go r.startState.restartAppIfNecessary(ctx, idir)
+ go appRunner.restartAppIfNecessary(ctx, idir)
delete(trackedPids, idir)
case nil, syscall.EPERM:
ctx.VI(2).Infof("processStatusPolling saw live pid: %d", pid)
diff --git a/services/device/deviced/internal/starter/starter.go b/services/device/deviced/internal/starter/starter.go
index 37b7dc3..848eccc 100644
--- a/services/device/deviced/internal/starter/starter.go
+++ b/services/device/deviced/internal/starter/starter.go
@@ -330,7 +330,7 @@
}
args.ConfigState.Name = endpoints[0].Name()
- dispatcher, err := impl.NewDispatcher(ctx, args.ConfigState, mt, args.TestMode, args.RestartCallback, permStore)
+ dispatcher, dShutdown, err := impl.NewDispatcher(ctx, args.ConfigState, mt, args.TestMode, args.RestartCallback, permStore)
if err != nil {
shutdown()
return nil, err
@@ -341,7 +341,7 @@
// the dispatcher and exposing it in Status.
ctx.Infof("Stopping device server...")
server.Stop()
- impl.Shutdown(ctx, dispatcher)
+ dShutdown()
ctx.Infof("Stopped device.")
}
if err := server.ServeDispatcher(args.name(mt), dispatcher); err != nil {
diff --git a/services/groups/groupsd/groupsd_v23_test.go b/services/groups/groupsd/groupsd_v23_test.go
index e304cf4..9334799 100644
--- a/services/groups/groupsd/groupsd_v23_test.go
+++ b/services/groups/groupsd/groupsd_v23_test.go
@@ -67,11 +67,11 @@
// Test simple group resolution.
{
- var buffer bytes.Buffer
- clientBin.Start("relate", groupB, "a/b/c/d").WaitOrDie(&buffer, &buffer)
+ var buffer, stderrBuf bytes.Buffer
+ clientBin.Start("relate", groupB, "a/b/c/d").WaitOrDie(&buffer, &stderrBuf)
var got relateResult
if err := json.Unmarshal(buffer.Bytes(), &got); err != nil {
- t.Fatalf("Unmarshal(%v) failed: %v", buffer.Bytes(), err)
+ t.Fatalf("Unmarshal(%v) failed: %v", buffer.String(), err)
}
want := relateResult{
Remainder: set.String.FromSlice([]string{"c/d", "d"}),
@@ -81,15 +81,18 @@
if !reflect.DeepEqual(got, want) {
t.Errorf("got %v, want %v", got, want)
}
+ if got, want := stderrBuf.Len(), 0; got != want {
+ t.Errorf("got %v, want %v", got, want)
+ }
}
// Test recursive group resolution.
{
- var buffer bytes.Buffer
- clientBin.Start("relate", groupA, "a/b/c/d").WaitOrDie(&buffer, &buffer)
+ var buffer, stderrBuf bytes.Buffer
+ clientBin.Start("relate", groupA, "a/b/c/d").WaitOrDie(&buffer, &stderrBuf)
var got relateResult
if err := json.Unmarshal(buffer.Bytes(), &got); err != nil {
- t.Fatalf("Unmarshal(%v) failed: %v", buffer.Bytes(), err)
+ t.Fatalf("Unmarshal(%v) failed: %v", buffer.String(), err)
}
want := relateResult{
Remainder: set.String.FromSlice([]string{"b/c/d", "c/d", "d"}),
@@ -99,17 +102,20 @@
if !reflect.DeepEqual(got, want) {
t.Errorf("got %v, want %v", got, want)
}
+ if got, want := stderrBuf.Len(), 0; got != want {
+ t.Errorf("got %v, want %v", got, want)
+ }
}
// Test group resolution failure. Note that under-approximation is
// used as the default to handle resolution failures.
{
clientBin.Start("add", groupB, "<grp:groups-server/groupC>").WaitOrDie(os.Stdout, os.Stderr)
- var buffer bytes.Buffer
- clientBin.Start("relate", groupB, "a/b/c/d").WaitOrDie(&buffer, &buffer)
+ var buffer, stderrBuf bytes.Buffer
+ clientBin.Start("relate", groupB, "a/b/c/d").WaitOrDie(&buffer, &stderrBuf)
var got relateResult
if err := json.Unmarshal(buffer.Bytes(), &got); err != nil {
- t.Fatalf("Unmarshal(%v) failed: %v", buffer.Bytes(), err)
+ t.Fatalf("Unmarshal(%v) failed: %v", buffer.String(), err)
}
want := relateResult{
Remainder: set.String.FromSlice([]string{"c/d", "d"}),
@@ -124,6 +130,9 @@
if !reflect.DeepEqual(got, want) {
t.Errorf("got %v, want %v", got, want)
}
+ if got, want := stderrBuf.Len(), 0; got != want {
+ t.Errorf("got %v, want %v", got, want)
+ }
}
// Delete the groups.
diff --git a/services/groups/internal/store/leveldb/store.go b/services/groups/internal/store/leveldb/store.go
index 5f38f52..23d0733 100644
--- a/services/groups/internal/store/leveldb/store.go
+++ b/services/groups/internal/store/leveldb/store.go
@@ -31,7 +31,7 @@
// Open opens a groups server store located at the given path,
// creating it if it doesn't exist.
func Open(path string) (store.Store, error) {
- db, err := leveldb.Open(path)
+ db, err := leveldb.Open(path, leveldb.OpenOptions{CreateIfMissing: true, ErrorIfExists: false})
if err != nil {
return nil, convertError(err)
}
diff --git a/services/wspr/browsprd/main_nacl.go b/services/wspr/browsprd/main_nacl.go
index 7e0b2bd..08940f7 100644
--- a/services/wspr/browsprd/main_nacl.go
+++ b/services/wspr/browsprd/main_nacl.go
@@ -26,6 +26,7 @@
"v.io/x/ref/services/wspr/internal/app"
"v.io/x/ref/services/wspr/internal/browspr"
"v.io/x/ref/services/wspr/internal/channel/channel_nacl"
+ "v.io/x/ref/services/wspr/internal/principal"
"v.io/x/ref/services/wspr/internal/rpc/server"
)
@@ -138,11 +139,11 @@
}
func (inst *browsprInstance) newPrincipal(ecdsaKey *ecdsa.PrivateKey, blessingRootsData, blessingRootsSig, blessingStoreData, blessingStoreSig string) (security.Principal, error) {
- roots, err := browspr.NewFileSerializer(blessingRootsData, blessingRootsSig, inst.fs)
+ roots, err := principal.NewFileSerializer(blessingRootsData, blessingRootsSig, inst.fs)
if err != nil {
return nil, fmt.Errorf("failed to create blessing roots serializer:%s", err)
}
- store, err := browspr.NewFileSerializer(blessingStoreData, blessingStoreSig, inst.fs)
+ store, err := principal.NewFileSerializer(blessingStoreData, blessingStoreSig, inst.fs)
if err != nil {
return nil, fmt.Errorf("failed to create blessing store serializer:%s", err)
}
@@ -193,15 +194,15 @@
return nil, fmt.Errorf("HandleStartMessage did not receive StartMessage, received: %v, %v", val, err)
}
- principal, err := inst.newPersistantPrincipal(msg.IdentitydBlessingRoot.Names)
+ p, err := inst.newPersistantPrincipal(msg.IdentitydBlessingRoot.Names)
if err != nil {
return nil, err
}
blessingName := "browspr-default-blessing"
- blessing, err := principal.BlessSelf(blessingName)
+ blessing, err := p.BlessSelf(blessingName)
if err != nil {
- return nil, fmt.Errorf("principal.BlessSelf(%v) failed: %v", blessingName, err)
+ return nil, fmt.Errorf("p.BlessSelf(%v) failed: %v", blessingName, err)
}
// If msg.IdentitydBlessingRoot has a public key and names, then add
@@ -222,18 +223,18 @@
pattern := security.BlessingPattern(name)
// Trust the identity servers blessing root.
- principal.Roots().Add(key, pattern)
+ p.Roots().Add(key, pattern)
// Use our blessing to only talk to the identity server.
- if _, err := principal.BlessingStore().Set(blessing, pattern); err != nil {
- return nil, fmt.Errorf("principal.BlessingStore().Set(%v, %v) failed: %v", blessing, pattern, err)
+ if _, err := p.BlessingStore().Set(blessing, pattern); err != nil {
+ return nil, fmt.Errorf("p.BlessingStore().Set(%v, %v) failed: %v", blessing, pattern, err)
}
}
} else {
inst.logger.VI(1).Infof("IdentitydBlessingRoot.PublicKey is empty. Will allow browspr blessing to be shareable with all principals.")
// Set our blessing as shareable with all peers.
- if _, err := principal.BlessingStore().Set(blessing, security.AllPrincipals); err != nil {
- return nil, fmt.Errorf("principal.BlessingStore().Set(%v, %v) failed: %v", blessing, security.AllPrincipals, err)
+ if _, err := p.BlessingStore().Set(blessing, security.AllPrincipals); err != nil {
+ return nil, fmt.Errorf("p.BlessingStore().Set(%v, %v) failed: %v", blessing, security.AllPrincipals, err)
}
}
@@ -241,7 +242,7 @@
// TODO(suharshs,mattr): Should we worried about not shutting down here?
ctx, _ := v23.Init()
- ctx, err = v23.WithPrincipal(ctx, principal)
+ ctx, err = v23.WithPrincipal(ctx, p)
if err != nil {
return nil, err
}
@@ -265,12 +266,18 @@
listenSpec := v23.GetListenSpec(ctx)
listenSpec.Proxy = msg.Proxy
+ principalSerializer, err := principal.NewFileSerializer(browsprDir+"/principalData", browsprDir+"/principalSignature", inst.fs)
+ if err != nil {
+ return nil, fmt.Errorf("principal.NewFileSerializer() failed: %v", err)
+ }
+
inst.logger.VI(1).Infof("Starting browspr with config: proxy=%q mounttable=%q identityd=%q identitydBlessingRoot=%q ", msg.Proxy, msg.NamespaceRoot, msg.Identityd, msg.IdentitydBlessingRoot)
inst.browspr = browspr.NewBrowspr(ctx,
inst.BrowsprOutgoingPostMessage,
&listenSpec,
msg.Identityd,
- []string{msg.NamespaceRoot})
+ []string{msg.NamespaceRoot},
+ principalSerializer)
// Add the rpc handlers that depend on inst.browspr.
inst.channel.RegisterRequestHandler("auth:create-account", inst.browspr.HandleAuthCreateAccountRpc)
diff --git a/services/wspr/internal/account/account.go b/services/wspr/internal/account/account.go
index 7d977d6..213404e 100644
--- a/services/wspr/internal/account/account.go
+++ b/services/wspr/internal/account/account.go
@@ -47,7 +47,6 @@
ctx *context.T
blesser BlesserService
principalManager *principal.PrincipalManager
- accounts []string
}
func NewAccountManager(identitydEndpoint string, principalManager *principal.PrincipalManager) *AccountManager {
@@ -72,13 +71,11 @@
return "", fmt.Errorf("Error adding account: %v", err)
}
- am.accounts = append(am.accounts, account)
-
return account, nil
}
func (am *AccountManager) GetAccounts() []string {
- return am.accounts
+ return am.principalManager.GetAccounts()
}
func (am *AccountManager) AssociateAccount(ctx *context.T, origin, account string, cavs []Caveat) error {
diff --git a/services/wspr/internal/browspr/browspr.go b/services/wspr/internal/browspr/browspr.go
index 409ea62..e0cc5ec 100644
--- a/services/wspr/internal/browspr/browspr.go
+++ b/services/wspr/internal/browspr/browspr.go
@@ -15,6 +15,7 @@
"v.io/v23/rpc"
"v.io/v23/vdl"
"v.io/v23/vtrace"
+ "v.io/x/ref/lib/security"
"v.io/x/ref/services/wspr/internal/account"
"v.io/x/ref/services/wspr/internal/app"
"v.io/x/ref/services/wspr/internal/principal"
@@ -39,7 +40,8 @@
postMessage func(instanceId int32, ty, msg string),
listenSpec *rpc.ListenSpec,
identd string,
- wsNamespaceRoots []string) *Browspr {
+ wsNamespaceRoots []string,
+ principalSerializer security.SerializerReaderWriter) *Browspr {
if listenSpec.Proxy == "" {
ctx.Fatalf("a vanadium proxy must be set")
}
@@ -58,7 +60,12 @@
// TODO(nlacasse, bjornick) use a serializer that can actually persist.
var err error
p := v23.GetPrincipal(ctx)
- if browspr.principalManager, err = principal.NewPrincipalManager(p, &principal.InMemorySerializer{}); err != nil {
+
+ if principalSerializer == nil {
+ ctx.Fatalf("principalSerializer must not be nil")
+ }
+
+ if browspr.principalManager, err = principal.NewPrincipalManager(p, principalSerializer); err != nil {
ctx.Fatalf("principal.NewPrincipalManager failed: %s", err)
}
@@ -167,7 +174,8 @@
// HandleAuthGetAccountsRpc gets the root account name from the account manager.
func (b *Browspr) HandleAuthGetAccountsRpc(*vdl.Value) (*vdl.Value, error) {
- return vdl.ValueFromReflect(reflect.ValueOf(b.accountManager.GetAccounts()))
+ accounts := b.accountManager.GetAccounts()
+ return vdl.ValueFromReflect(reflect.ValueOf(accounts))
}
// HandleAuthOriginHasAccountRpc returns true iff the origin has an associated
diff --git a/services/wspr/internal/browspr/browspr_account_test.go b/services/wspr/internal/browspr/browspr_account_test.go
index ff35bbf..7c0ae4f 100644
--- a/services/wspr/internal/browspr/browspr_account_test.go
+++ b/services/wspr/internal/browspr/browspr_account_test.go
@@ -6,6 +6,8 @@
import (
"fmt"
+ "reflect"
+ "sort"
"testing"
"v.io/v23"
@@ -15,6 +17,7 @@
"v.io/v23/vdl"
_ "v.io/x/ref/runtime/factories/generic"
+ "v.io/x/ref/services/wspr/internal/principal"
"v.io/x/ref/test"
)
@@ -48,7 +51,7 @@
spec := v23.GetListenSpec(ctx)
spec.Proxy = "/mock/proxy"
mockPostMessage := func(_ int32, _, _ string) {}
- browspr := NewBrowspr(ctx, mockPostMessage, &spec, "/mock:1234/identd", nil)
+ browspr := NewBrowspr(ctx, mockPostMessage, &spec, "/mock:1234/identd", nil, principal.NewInMemorySerializer())
principal := v23.GetPrincipal(browspr.ctx)
browspr.accountManager.SetMockBlesser(newMockBlesserService(principal))
@@ -109,8 +112,13 @@
if err != nil {
t.Fatalf("browspr.HandleAuthGetAccountsRpc(%v) failed: %v", nilValue, err)
}
- if want := vdl.ValueOf([]string{account1.RawString(), account2.RawString()}); !vdl.EqualValue(want, gotAccounts2) {
- t.Fatalf("Expected account to be %v but got empty but got %v", want, gotAccounts2)
+ var got []string
+ if err := vdl.Convert(&got, gotAccounts2); err != nil {
+ t.Fatalf("vdl.Convert failed: %v", err)
+ }
+ sort.Strings(got)
+ if want := []string{account1.RawString(), account2.RawString()}; !reflect.DeepEqual(want, got) {
+ t.Fatalf("Expected account to be %v but got %v", want, got)
}
// Verify that principalManager has both accounts
diff --git a/services/wspr/internal/browspr/browspr_test.go b/services/wspr/internal/browspr/browspr_test.go
index 20b1466..4ca50c8 100644
--- a/services/wspr/internal/browspr/browspr_test.go
+++ b/services/wspr/internal/browspr/browspr_test.go
@@ -25,6 +25,7 @@
"v.io/x/ref/services/mounttable/mounttablelib"
"v.io/x/ref/services/wspr/internal/app"
"v.io/x/ref/services/wspr/internal/lib"
+ "v.io/x/ref/services/wspr/internal/principal"
"v.io/x/ref/test"
)
@@ -161,7 +162,7 @@
}
v23.GetNamespace(ctx).SetRoots(root)
- browspr := NewBrowspr(ctx, postMessageHandler, &spec, "/mock:1234/identd", []string{root})
+ browspr := NewBrowspr(ctx, postMessageHandler, &spec, "/mock:1234/identd", []string{root}, principal.NewInMemorySerializer())
// browspr sets its namespace root to use the "ws" protocol, but we want to force "tcp" here.
browspr.namespaceRoots = []string{root}
diff --git a/services/wspr/internal/browspr/file_serializer_nacl.go b/services/wspr/internal/principal/file_serializer_nacl.go
similarity index 93%
rename from services/wspr/internal/browspr/file_serializer_nacl.go
rename to services/wspr/internal/principal/file_serializer_nacl.go
index ceed808..5a73758 100644
--- a/services/wspr/internal/browspr/file_serializer_nacl.go
+++ b/services/wspr/internal/principal/file_serializer_nacl.go
@@ -2,12 +2,14 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package browspr
+package principal
import (
"io"
"os"
"runtime/ppapi"
+
+ "v.io/x/ref/lib/security"
)
// fileSerializer implements vsecurity.SerializerReaderWriter that persists state to
@@ -21,6 +23,8 @@
signatureFile string
}
+var _ security.SerializerReaderWriter = (*fileSerializer)(nil)
+
func (fs *fileSerializer) Readers() (data io.ReadCloser, sig io.ReadCloser, err error) {
if fs.data == nil || fs.signature == nil {
return nil, nil, nil
diff --git a/services/wspr/internal/principal/in_memory_serializer.go b/services/wspr/internal/principal/in_memory_serializer.go
new file mode 100644
index 0000000..5ae1dad
--- /dev/null
+++ b/services/wspr/internal/principal/in_memory_serializer.go
@@ -0,0 +1,39 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package principal
+
+import (
+ "io"
+
+ "v.io/x/ref/lib/security"
+)
+
+// inMemorySerializer implements SerializerReaderWriter. This Serializer should only
+// be used in tests.
+type inMemorySerializer struct {
+ data bufferCloser
+ signature bufferCloser
+ hasData bool
+}
+
+var _ security.SerializerReaderWriter = (*inMemorySerializer)(nil)
+
+func NewInMemorySerializer() *inMemorySerializer {
+ return &inMemorySerializer{}
+}
+
+func (s *inMemorySerializer) Readers() (io.ReadCloser, io.ReadCloser, error) {
+ if !s.hasData {
+ return nil, nil, nil
+ }
+ return &s.data, &s.signature, nil
+}
+
+func (s *inMemorySerializer) Writers() (io.WriteCloser, io.WriteCloser, error) {
+ s.hasData = true
+ s.data.Reset()
+ s.signature.Reset()
+ return &s.data, &s.signature, nil
+}
diff --git a/services/wspr/internal/principal/principal.go b/services/wspr/internal/principal/principal.go
index f13ac68..dc7dca2 100644
--- a/services/wspr/internal/principal/principal.go
+++ b/services/wspr/internal/principal/principal.go
@@ -33,7 +33,6 @@
import (
"bytes"
"fmt"
- "io"
"net/url"
"sync"
"time"
@@ -91,28 +90,6 @@
return nil
}
-// InMemorySerializer implements SerializerReaderWriter. This Serializer should only
-// be used in tests.
-type InMemorySerializer struct {
- data bufferCloser
- signature bufferCloser
- hasData bool
-}
-
-func (s *InMemorySerializer) Readers() (io.ReadCloser, io.ReadCloser, error) {
- if !s.hasData {
- return nil, nil, nil
- }
- return &s.data, &s.signature, nil
-}
-
-func (s *InMemorySerializer) Writers() (io.WriteCloser, io.WriteCloser, error) {
- s.hasData = true
- s.data.Reset()
- s.signature.Reset()
- return &s.data, &s.signature, nil
-}
-
// PrincipalManager manages app principals. We only serialize the accounts
// associated with this principal manager and the mapping of apps to permissions
// that they were given.
@@ -261,6 +238,19 @@
return nil
}
+// GetAccounts returns a list of account names known to the Principal Manager.
+func (i *PrincipalManager) GetAccounts() []string {
+ i.mu.Lock()
+ defer i.mu.Unlock()
+
+ accounts := make([]string, 0, len(i.state.Accounts))
+ for account := range i.state.Accounts {
+ accounts = append(accounts, account)
+ }
+
+ return accounts
+}
+
// AddOrigin adds an origin to the manager linked to the given account.
func (i *PrincipalManager) AddOrigin(origin string, account string, caveats []security.Caveat, expirations []time.Time) error {
i.mu.Lock()
diff --git a/services/wspr/internal/principal/principal_test.go b/services/wspr/internal/principal/principal_test.go
index 858d2cc..189c052 100644
--- a/services/wspr/internal/principal/principal_test.go
+++ b/services/wspr/internal/principal/principal_test.go
@@ -134,7 +134,7 @@
func TestPrincipalManager(t *testing.T) {
root := testutil.NewPrincipal()
- m, err := NewPrincipalManager(root, &InMemorySerializer{})
+ m, err := NewPrincipalManager(root, NewInMemorySerializer())
if err != nil {
t.Fatalf("NewPrincipalManager failed: %v", err)
}
@@ -150,7 +150,7 @@
func TestPrincipalManagerPersistence(t *testing.T) {
root := testutil.NewPrincipal()
- serializer := &InMemorySerializer{}
+ serializer := NewInMemorySerializer()
m, err := NewPrincipalManager(root, serializer)
if err != nil {
t.Fatalf("NewPrincipalManager failed: %v", err)
@@ -174,7 +174,7 @@
func TestOriginHasAccount(t *testing.T) {
root := testutil.NewPrincipal()
- m, err := NewPrincipalManager(root, &InMemorySerializer{})
+ m, err := NewPrincipalManager(root, NewInMemorySerializer())
if err != nil {
t.Fatalf("NewPrincipalManager failed: %v", err)
}
diff --git a/services/wspr/wsprlib/wspr.go b/services/wspr/wsprlib/wspr.go
index d626ed5..4622136 100644
--- a/services/wspr/wsprlib/wspr.go
+++ b/services/wspr/wsprlib/wspr.go
@@ -123,10 +123,10 @@
pipes: map[*http.Request]*pipe{},
}
- // TODO(nlacasse, bjornick) use a serializer that can actually persist.
p := v23.GetPrincipal(ctx)
var err error
- if wspr.principalManager, err = principal.NewPrincipalManager(p, &principal.InMemorySerializer{}); err != nil {
+ // TODO(nlacasse): Use a serializer that can actually persist, as we do in browspr.
+ if wspr.principalManager, err = principal.NewPrincipalManager(p, principal.NewInMemorySerializer()); err != nil {
ctx.Fatalf("principal.NewPrincipalManager failed: %s", err)
}
