[RSDK-8294] Use Global Connection to App in Internal Cloud Service and Local Robot

cli/client_test.go

@@ -156,7 +156,7 @@ func setupWithRunningPart(
 				Model: resource.DefaultServiceModel,
 			},
 		},
-	}, logging.NewInMemoryLogger(t))
+	}, nil, logging.NewInMemoryLogger(t))
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)

components/camera/client_test.go

@@ -627,7 +627,7 @@ func setupRealRobot(
 	t.Helper()
 
 	ctx := context.Background()
-	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, logger)
+	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	// We initialize with a stream config such that the stream server is capable of creating video stream and
@@ -652,7 +652,7 @@ func setupRealRobotWithOptions(
 	t.Helper()
 
 	ctx := context.Background()
-	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, logger)
+	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	// We initialize with a stream config such that the stream server is capable of creating video stream and

examples/customresources/demos/remoteserver/server.go

@@ -6,9 +6,11 @@ import (
 	"errors"
 
 	goutils "go.viam.com/utils"
+	"go.viam.com/utils/rpc"
 
 	"go.viam.com/rdk/config"
 	_ "go.viam.com/rdk/examples/customresources/models/mygizmo"
+	"go.viam.com/rdk/grpc"
 	"go.viam.com/rdk/logging"
 	robotimpl "go.viam.com/rdk/robot/impl"
 	"go.viam.com/rdk/robot/web"
@@ -40,7 +42,17 @@ func mainWithArgs(ctx context.Context, args []string, logger logging.Logger) (er
 		return err
 	}
 
-	myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, logger)
+	var appConn rpc.ClientConn
+	if cfg.Cloud != nil && cfg.Cloud.AppAddress != "" {
+		appConn, err = grpc.NewAppConn(ctx, cfg.Cloud.AppAddress, cfg.Cloud.Secret, cfg.Cloud.ID, logger)
+		if err != nil {
+			return nil
+		}
+
+		defer goutils.UncheckedErrorFunc(appConn.Close)
+	}
+
+	myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, appConn, logger)
 	if err != nil {
 		return err
 	}

examples/customresources/demos/remoteserver/server_test.go

@@ -42,7 +42,7 @@ func TestGizmo(t *testing.T) {
 
 		cfgServer, err := config.Read(ctx, utils.ResolveFile("./examples/customresources/demos/remoteserver/remote.json"), logger, nil)
 		test.That(t, err, test.ShouldBeNil)
-		remoteB, err := robotimpl.New(ctx, cfgServer, logger.Sublogger("remoteB"))
+		remoteB, err := robotimpl.New(ctx, cfgServer, nil, logger.Sublogger("remoteB"))
 		test.That(t, err, test.ShouldBeNil)
 		options := weboptions.New()
 		options.Network.BindAddress = remoteAddrB
@@ -116,7 +116,7 @@ func TestGizmo(t *testing.T) {
 			},
 		},
 	}
-	mainPart, err := robotimpl.New(ctx, mainPartConfig, logger.Sublogger("mainPart.client"))
+	mainPart, err := robotimpl.New(ctx, mainPartConfig, nil, logger.Sublogger("mainPart.client"))
 	defer func() {
 		test.That(t, mainPart.Close(context.Background()), test.ShouldBeNil)
 	}()

module/concurrent_reconfigure_test.go

@@ -33,7 +33,7 @@ func setupTestRobotWithModules(
 			},
 		},
 	}
-	rob, err := robotimpl.New(ctx, cfg, logger)
+	rob, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	t.Cleanup(func() {
 		test.That(t, rob.Close(ctx), test.ShouldBeNil)

module/module_interceptors_test.go

@@ -171,7 +171,7 @@ func TestModuleClientTimeoutInterceptor(t *testing.T) {
 			Name:  "helper1",
 		}},
 	}
-	r, err := robotimpl.New(ctx, cfg, logger)
+	r, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer func() {
 		test.That(t, r.Close(ctx), test.ShouldBeNil)

module/module_test.go

@@ -166,7 +166,7 @@ func TestModuleFunctions(t *testing.T) {
 		},
 	}}
 
-	myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, logger)
+	myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	parentAddr, err := myRobot.ModuleAddress()
@@ -425,7 +425,7 @@ func TestAttributeConversion(t *testing.T) {
 			},
 		}}
 
-		myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, logger)
+		myRobot, err := robotimpl.RobotFromConfig(ctx, cfg, nil, logger)
 		test.That(t, err, test.ShouldBeNil)
 
 		parentAddr, err := myRobot.ModuleAddress()

module/version_reconfigure_test.go

@@ -58,7 +58,7 @@ func TestValidationFailureDuringReconfiguration(t *testing.T) {
 		},
 	}
 
-	robot, err := robotimpl.New(ctx, cfg, logger)
+	robot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer robot.Close(ctx)
 
@@ -132,7 +132,7 @@ func TestVersionBumpWithNewImplicitDeps(t *testing.T) {
 		},
 	}
 
-	robot, err := robotimpl.New(ctx, cfg, logger)
+	robot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer robot.Close(ctx)
 

robot/framesystem/framesystem_test.go

@@ -22,7 +22,7 @@ import (
 func TestEmptyConfigFrameService(t *testing.T) {
 	logger := logging.NewTestLogger(t)
 	ctx := context.Background()
-	r, err := robotimpl.New(ctx, &config.Config{}, logger)
+	r, err := robotimpl.New(ctx, &config.Config{}, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	fsCfg, err := r.FrameSystemConfig(ctx)
 	test.That(t, err, test.ShouldBeNil)
@@ -96,7 +96,7 @@ func TestNewFrameSystemFromConfigWithTransforms(t *testing.T) {
 	cfg, err := config.Read(context.Background(), rdkutils.ResolveFile("robot/impl/data/fake.json"), logger, nil)
 	test.That(t, err, test.ShouldBeNil)
 
-	r, err := robotimpl.New(context.Background(), cfg, logger)
+	r, err := robotimpl.New(context.Background(), cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer r.Close(context.Background())
 	fsCfg, err := r.FrameSystemConfig(ctx)
@@ -227,7 +227,7 @@ func TestNewFrameSystemFromBadConfig(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			cfg, err := config.Read(ctx, rdkutils.ResolveFile("robot/impl/data/fake_wrongconfig"+tc.num+".json"), logger, nil)
 			test.That(t, err, test.ShouldBeNil)
-			r, err := robotimpl.New(ctx, cfg, logger)
+			r, err := robotimpl.New(ctx, cfg, nil, logger)
 			test.That(t, err, test.ShouldBeNil)
 			defer r.Close(ctx)
 			fsCfg, err := r.FrameSystemConfig(ctx)
@@ -242,7 +242,7 @@ func TestNewFrameSystemFromBadConfig(t *testing.T) {
 
 	cfg, err := config.Read(ctx, rdkutils.ResolveFile("robot/impl/data/fake.json"), logger, nil)
 	test.That(t, err, test.ShouldBeNil)
-	r, err := robotimpl.New(ctx, cfg, logger)
+	r, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	defer r.Close(ctx)
 

robot/impl/local_robot.go

@@ -341,6 +341,7 @@ func newWithResources(
 	ctx context.Context,
 	cfg *config.Config,
 	resources map[resource.Name]resource.Resource,
+	conn rpc.ClientConn,
 	logger logging.Logger,
 	opts ...Option,
 ) (robot.LocalRobot, error) {
@@ -434,6 +435,12 @@ func newWithResources(
 		r.packageManager = packages.NewDeferredPackageManager(
 			ctx,
 			func(ctx context.Context) (packagespb.PackageServiceClient, error) {
+				if conn != nil {
+					return packagespb.NewPackageServiceClient(conn), err
+				}
+
+				// NOTE(bashar-515): this case where `conn` is nil, `cfg.Cloud` is non-nil, and `cfg.Cloud.AppAddress` is not the empty string
+				// is only encountered in tests. It is not an actual path expected to be taken in prod
 				_, cloudConn, err := r.cloudConnSvc.AcquireConnection(ctx)
 				return packagespb.NewPackageServiceClient(cloudConn), err
 			},
@@ -548,10 +555,11 @@ func newWithResources(
 func New(
 	ctx context.Context,
 	cfg *config.Config,
+	conn rpc.ClientConn,
 	logger logging.Logger,
 	opts ...Option,
 ) (robot.LocalRobot, error) {
-	return newWithResources(ctx, cfg, nil, logger, opts...)
+	return newWithResources(ctx, cfg, nil, conn, logger, opts...)
 }
 
 // removeOrphanedResources is called by the module manager to remove resources
@@ -1002,16 +1010,22 @@ func RobotFromConfigPath(ctx context.Context, cfgPath string, logger logging.Log
 		logger.CError(ctx, "cannot read config")
 		return nil, err
 	}
-	return RobotFromConfig(ctx, cfg, logger, opts...)
+	return RobotFromConfig(ctx, cfg, nil, logger, opts...)
 }
 
 // RobotFromConfig is a helper to process a config and then create a robot based on it.
-func RobotFromConfig(ctx context.Context, cfg *config.Config, logger logging.Logger, opts ...Option) (robot.LocalRobot, error) {
+func RobotFromConfig(
+	ctx context.Context,
+	cfg *config.Config,
+	conn rpc.ClientConn,
+	logger logging.Logger,
+	opts ...Option,
+) (robot.LocalRobot, error) {
 	processedCfg, err := config.ProcessConfig(cfg)
 	if err != nil {
 		return nil, err
 	}
-	return New(ctx, processedCfg, logger, opts...)
+	return New(ctx, processedCfg, conn, logger, opts...)
 }
 
 // RobotFromResources creates a new robot consisting of the given resources. Using RobotFromConfig is preferred
@@ -1022,7 +1036,7 @@ func RobotFromResources(
 	logger logging.Logger,
 	opts ...Option,
 ) (robot.LocalRobot, error) {
-	return newWithResources(ctx, &config.Config{}, resources, logger, opts...)
+	return newWithResources(ctx, &config.Config{}, resources, nil, logger, opts...)
 }
 
 // DiscoverComponents takes a list of discovery queries and returns corresponding

robot/impl/utils.go

@@ -27,7 +27,7 @@ func setupLocalRobot(
 	var rOpts []Option
 	rOpts = append(rOpts, opts...)
 	rOpts = append(rOpts, WithViamHomeDir(t.TempDir()))
-	r, err := New(ctx, cfg, logger, rOpts...)
+	r, err := New(ctx, cfg, nil, logger, rOpts...)
 	test.That(t, err, test.ShouldBeNil)
 	t.Cleanup(func() {
 		test.That(t, r.Close(ctx), test.ShouldBeNil)

robot/session_test.go

@@ -179,7 +179,7 @@ func TestSessions(t *testing.T) {
 			test.That(t, err, test.ShouldBeNil)
 
 			ctx := context.Background()
-			r, err := robotimpl.New(ctx, cfg, logger.Sublogger("main"))
+			r, err := robotimpl.New(ctx, cfg, nil, logger.Sublogger("main"))
 			test.That(t, err, test.ShouldBeNil)
 
 			options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)
@@ -376,7 +376,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 
 	ctx := context.Background()
-	remoteRobot, err := robotimpl.New(ctx, cfg, logger)
+	remoteRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, remoteAddr := robottestutils.CreateBaseOptionsAndListener(t)
@@ -408,7 +408,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	cfg, err = config.FromReader(context.Background(), "", strings.NewReader(roboConfig), logger, nil)
 	test.That(t, err, test.ShouldBeNil)
 
-	r, err := robotimpl.New(ctx, cfg, logger.Sublogger("main"))
+	r, err := robotimpl.New(ctx, cfg, nil, logger.Sublogger("main"))
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)
@@ -482,7 +482,7 @@ func TestSessionsWithRemote(t *testing.T) {
 	dummyRemMotor1.stopCh = stopChs["remMotor1"].Chan
 	dummyRemMotor1.mu.Unlock()
 
-	r, err = robotimpl.New(ctx, cfg, logger)
+	r, err = robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr = robottestutils.CreateBaseOptionsAndListener(t)
@@ -568,7 +568,7 @@ func TestSessionsMixedClients(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 
 	ctx := context.Background()
-	r, err := robotimpl.New(ctx, cfg, logger.Sublogger("main"))
+	r, err := robotimpl.New(ctx, cfg, nil, logger.Sublogger("main"))
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)
@@ -661,7 +661,7 @@ func TestSessionsMixedOwnersNoAuth(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 
 	ctx := context.Background()
-	r, err := robotimpl.New(ctx, cfg, logger.Sublogger("main"))
+	r, err := robotimpl.New(ctx, cfg, nil, logger.Sublogger("main"))
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)
@@ -768,7 +768,7 @@ func TestSessionsMixedOwnersImplicitAuth(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 
 	ctx := context.Background()
-	r, err := robotimpl.New(ctx, cfg, logger.Sublogger("main"))
+	r, err := robotimpl.New(ctx, cfg, nil, logger.Sublogger("main"))
 	test.That(t, err, test.ShouldBeNil)
 
 	options, _, addr := robottestutils.CreateBaseOptionsAndListener(t)

robot/web/stream/stream_test.go

@@ -36,7 +36,7 @@ func setupRealRobot(t *testing.T, robotConfig *config.Config, logger logging.Log
 	t.Helper()
 
 	ctx := context.Background()
-	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, logger)
+	robot, err := robotimpl.RobotFromConfig(ctx, robotConfig, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 
 	// We initialize with a stream config such that the stream server is capable of creating video stream and

services/motion/builtin/builtin_test.go

@@ -47,7 +47,7 @@ func setupMotionServiceFromConfig(t *testing.T, configFilename string) (motion.S
 	logger := logging.NewTestLogger(t)
 	cfg, err := config.Read(ctx, configFilename, logger, nil)
 	test.That(t, err, test.ShouldBeNil)
-	myRobot, err := robotimpl.New(ctx, cfg, logger)
+	myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	svc, err := motion.FromRobot(myRobot, "builtin")
 	test.That(t, err, test.ShouldBeNil)

services/motion/builtin/move_on_map_test.go

@@ -41,7 +41,7 @@ func TestMoveOnMap(t *testing.T) {
 	t.Run("Timeout", func(t *testing.T) {
 		cfg, err := config.Read(ctx, "../data/real_wheeled_base.json", logger, nil)
 		test.That(t, err, test.ShouldBeNil)
-		myRobot, err := robotimpl.New(ctx, cfg, logger)
+		myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 		test.That(t, err, test.ShouldBeNil)
 		defer func() {
 			test.That(t, myRobot.Close(context.Background()), test.ShouldBeNil)

services/navigation/builtin/builtin_test.go

@@ -59,7 +59,7 @@ func setupNavigationServiceFromConfig(t *testing.T, configFilename string) (navi
 	cfg, err := config.Read(ctx, configFilename, logger, nil)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, cfg.Ensure(false, logger), test.ShouldBeNil)
-	myRobot, err := robotimpl.New(ctx, cfg, logger)
+	myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 	test.That(t, err, test.ShouldBeNil)
 	svc, err := navigation.FromRobot(myRobot, "test_navigation")
 	test.That(t, err, test.ShouldBeNil)
@@ -596,7 +596,7 @@ func TestNavSetUpFromFaultyConfig(t *testing.T) {
 		cfg, err := config.Read(ctx, tc.configPath, logger, nil)
 		test.That(t, err, test.ShouldBeNil)
 		test.That(t, cfg.Ensure(false, logger), test.ShouldBeNil)
-		myRobot, err := robotimpl.New(ctx, cfg, logger)
+		myRobot, err := robotimpl.New(ctx, cfg, nil, logger)
 		test.That(t, err, test.ShouldBeNil)
 		_, err = navigation.FromRobot(myRobot, "test_navigation")
 		test.That(t, err, test.ShouldNotBeNil)

web/server/entrypoint.go

@@ -529,7 +529,7 @@ func (s *robotServer) serveWeb(ctx context.Context, cfg *config.Config) (err err
 	// state of initializing until reconfigured with full config.
 	minimalProcessedConfig.Initial = true
 
-	myRobot, err := robotimpl.New(ctx, &minimalProcessedConfig, s.logger, robotOptions...)
+	myRobot, err := robotimpl.New(ctx, &minimalProcessedConfig, s.conn, s.logger, robotOptions...)
 	if err != nil {
 		cancel()
 		return err