Using callback instead of channel+goroutine for Init

cli/instance/instance.go

@@ -68,17 +68,12 @@ func Init(instance *rpc.Instance) []*status.Status {
 		return append(errs, err)
 	}
 
-	initChan, err := commands.Init(&rpc.InitRequest{
-		Instance: instance,
-	})
-	if err != nil {
-		return append(errs, err)
-	}
-
 	downloadCallback := output.ProgressBar()
 	taskCallback := output.TaskProgress()
 
-	for res := range initChan {
+	err := commands.Init(&rpc.InitRequest{
+		Instance: instance,
+	}, func(res *rpc.InitResponse) {
 		if err := res.GetError(); err != nil {
 			errs = append(errs, status.FromProto(err))
 		}
@@ -91,6 +86,9 @@ func Init(instance *rpc.Instance) []*status.Status {
 				taskCallback(progress.TaskProgress)
 			}
 		}
+	})
+	if err != nil {
+		return append(errs, err)
 	}
 
 	return errs

commands/core/install.go

@@ -54,7 +54,7 @@ func PlatformInstall(ctx context.Context, req *rpc.PlatformInstallRequest,
 		return nil, err
 	}
 
-	_, status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: req.Instance.Id}})
+	status := commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil)
 	if status != nil {
 		return nil, status.Err()
 	}

commands/core/uninstall.go

@@ -67,7 +67,7 @@ func PlatformUninstall(ctx context.Context, req *rpc.PlatformUninstallRequest, t
 		}
 	}
 
-	_, status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: req.Instance.Id}})
+	status := commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil)
 	if status != nil {
 		return nil, status.Err()
 	}

commands/core/upgrade.go

@@ -49,7 +49,7 @@ func PlatformUpgrade(ctx context.Context, req *rpc.PlatformUpgradeRequest,
 		return nil, err
 	}
 
-	_, status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: req.Instance.Id}})
+	status := commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil)
 	if status != nil {
 		return nil, status.Err()
 	}

commands/daemon/daemon.go

@@ -184,21 +184,12 @@ func (s *ArduinoCoreServerImpl) Create(_ context.Context, req *rpc.CreateRequest
 
 // Init FIXMEDOC
 func (s *ArduinoCoreServerImpl) Init(req *rpc.InitRequest, stream rpc.ArduinoCoreService_InitServer) error {
-	messageChan, err := commands.Init(req)
+	err := commands.Init(req, func(message *rpc.InitResponse) {
+		stream.Send(message)
+	})
 	if err != nil {
-		return stream.Send(&rpc.InitResponse{
-			Message: &rpc.InitResponse_Error{
-				Error: err.Proto(),
-			},
-		})
+		return err.Err()
 	}
-
-	for message := range messageChan {
-		if err := stream.Send(message); err != nil {
-			return err
-		}
-	}
-
 	return nil
 }
 

commands/instances.go

@@ -166,172 +166,170 @@ func Create(req *rpc.CreateRequest) (*rpc.CreateResponse, *status.Status) {
 // Failures don't stop the loading process, in case of loading failure the Platform or library
 // is simply skipped and an error gRPC status is sent in the returned channel.
 // Channel is closed when loading is finished.
-func Init(req *rpc.InitRequest) (<-chan *rpc.InitResponse, *status.Status) {
+func Init(req *rpc.InitRequest, resp func(r *rpc.InitResponse)) *status.Status {
+	if resp == nil {
+		resp = func(r *rpc.InitResponse) {}
+	}
 	instance := instances[req.Instance.Id]
 	if instance == nil {
-		return nil, status.Newf(codes.InvalidArgument, "Invalid instance ID")
+		return status.Newf(codes.InvalidArgument, "Invalid instance ID")
 	}
 
-	outChan := make(chan *rpc.InitResponse)
-	go func() {
-		defer close(outChan)
-
-		// Load Platforms
-		urls := []string{globals.DefaultIndexURL}
-		urls = append(urls, configuration.Settings.GetStringSlice("board_manager.additional_urls")...)
-		for _, u := range urls {
-			URL, err := utils.URLParse(u)
-			if err != nil {
-				s := status.Newf(codes.InvalidArgument, "Invalid additional URL: %v", err)
-				outChan <- &rpc.InitResponse{
-					Message: &rpc.InitResponse_Error{
-						Error: s.Proto(),
-					},
-				}
-				continue
-			}
-
-			if URL.Scheme == "file" {
-				indexFile := paths.New(URL.Path)
+	// Load Platforms
+	urls := []string{globals.DefaultIndexURL}
+	urls = append(urls, configuration.Settings.GetStringSlice("board_manager.additional_urls")...)
+	for _, u := range urls {
+		URL, err := utils.URLParse(u)
+		if err != nil {
+			s := status.Newf(codes.InvalidArgument, "Invalid additional URL: %v", err)
+			resp(&rpc.InitResponse{
+				Message: &rpc.InitResponse_Error{
+					Error: s.Proto(),
+				},
+			})
+			continue
+		}
 
-				_, err := instance.PackageManager.LoadPackageIndexFromFile(indexFile)
-				if err != nil {
-					s := status.Newf(codes.FailedPrecondition, "Loading index file: %v", err)
-					outChan <- &rpc.InitResponse{
-						Message: &rpc.InitResponse_Error{
-							Error: s.Proto(),
-						},
-					}
-				}
-				continue
-			}
+		if URL.Scheme == "file" {
+			indexFile := paths.New(URL.Path)
 
-			if err := instance.PackageManager.LoadPackageIndex(URL); err != nil {
+			_, err := instance.PackageManager.LoadPackageIndexFromFile(indexFile)
+			if err != nil {
 				s := status.Newf(codes.FailedPrecondition, "Loading index file: %v", err)
-				outChan <- &rpc.InitResponse{
+				resp(&rpc.InitResponse{
 					Message: &rpc.InitResponse_Error{
 						Error: s.Proto(),
 					},
-				}
+				})
 			}
+			continue
 		}
 
-		// We load hardware before verifying builtin tools are installed
-		// otherwise we wouldn't find them and reinstall them each time
-		// and they would never get reloaded.
-		for _, err := range instance.PackageManager.LoadHardware() {
-			outChan <- &rpc.InitResponse{
+		if err := instance.PackageManager.LoadPackageIndex(URL); err != nil {
+			s := status.Newf(codes.FailedPrecondition, "Loading index file: %v", err)
+			resp(&rpc.InitResponse{
 				Message: &rpc.InitResponse_Error{
-					Error: err.Proto(),
+					Error: s.Proto(),
 				},
-			}
+			})
 		}
+	}
 
-		taskCallback := func(msg *rpc.TaskProgress) {
-			outChan <- &rpc.InitResponse{
-				Message: &rpc.InitResponse_InitProgress{
-					InitProgress: &rpc.InitResponse_Progress{
-						TaskProgress: msg,
-					},
+	// We load hardware before verifying builtin tools are installed
+	// otherwise we wouldn't find them and reinstall them each time
+	// and they would never get reloaded.
+	for _, err := range instance.PackageManager.LoadHardware() {
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_Error{
+				Error: err.Proto(),
+			},
+		})
+	}
+
+	taskCallback := func(msg *rpc.TaskProgress) {
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_InitProgress{
+				InitProgress: &rpc.InitResponse_Progress{
+					TaskProgress: msg,
 				},
-			}
-		}
+			},
+		})
+	}
 
-		downloadCallback := func(msg *rpc.DownloadProgress) {
-			outChan <- &rpc.InitResponse{
-				Message: &rpc.InitResponse_InitProgress{
-					InitProgress: &rpc.InitResponse_Progress{
-						DownloadProgress: msg,
-					},
+	downloadCallback := func(msg *rpc.DownloadProgress) {
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_InitProgress{
+				InitProgress: &rpc.InitResponse_Progress{
+					DownloadProgress: msg,
 				},
-			}
-		}
+			},
+		})
+	}
 
-		// Install tools if necessary
-		toolHasBeenInstalled := false
-		ctagsTool, err := getBuiltinCtagsTool(instance.PackageManager)
+	// Install tools if necessary
+	toolHasBeenInstalled := false
+	ctagsTool, err := getBuiltinCtagsTool(instance.PackageManager)
+	if err != nil {
+		s := status.Newf(codes.Internal, err.Error())
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_Error{
+				Error: s.Proto(),
+			},
+		})
+	} else {
+		ctagsInstalled, err := instance.installToolIfMissing(ctagsTool, downloadCallback, taskCallback)
+		toolHasBeenInstalled = toolHasBeenInstalled || ctagsInstalled
 		if err != nil {
 			s := status.Newf(codes.Internal, err.Error())
-			outChan <- &rpc.InitResponse{
+			resp(&rpc.InitResponse{
 				Message: &rpc.InitResponse_Error{
 					Error: s.Proto(),
 				},
-			}
-		} else {
-			ctagsInstalled, err := instance.installToolIfMissing(ctagsTool, downloadCallback, taskCallback)
-			toolHasBeenInstalled = toolHasBeenInstalled || ctagsInstalled
-			if err != nil {
-				s := status.Newf(codes.Internal, err.Error())
-				outChan <- &rpc.InitResponse{
-					Message: &rpc.InitResponse_Error{
-						Error: s.Proto(),
-					},
-				}
-			}
+			})
 		}
+	}
 
-		serialDiscoveryTool, _ := getBuiltinSerialDiscoveryTool(instance.PackageManager)
+	serialDiscoveryTool, _ := getBuiltinSerialDiscoveryTool(instance.PackageManager)
+	if err != nil {
+		s := status.Newf(codes.Internal, err.Error())
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_Error{
+				Error: s.Proto(),
+			},
+		})
+	} else {
+		serialDiscoveryToolInstalled, err := instance.installToolIfMissing(serialDiscoveryTool, downloadCallback, taskCallback)
+		toolHasBeenInstalled = toolHasBeenInstalled || serialDiscoveryToolInstalled
 		if err != nil {
 			s := status.Newf(codes.Internal, err.Error())
-			outChan <- &rpc.InitResponse{
+			resp(&rpc.InitResponse{
 				Message: &rpc.InitResponse_Error{
 					Error: s.Proto(),
 				},
-			}
-		} else {
-			serialDiscoveryToolInstalled, err := instance.installToolIfMissing(serialDiscoveryTool, downloadCallback, taskCallback)
-			toolHasBeenInstalled = toolHasBeenInstalled || serialDiscoveryToolInstalled
-			if err != nil {
-				s := status.Newf(codes.Internal, err.Error())
-				outChan <- &rpc.InitResponse{
-					Message: &rpc.InitResponse_Error{
-						Error: s.Proto(),
-					},
-				}
-			}
-		}
-
-		if toolHasBeenInstalled {
-			// We installed at least one new tool after loading hardware
-			// so we must reload again otherwise we would never found them.
-			for _, err := range instance.PackageManager.LoadHardware() {
-				outChan <- &rpc.InitResponse{
-					Message: &rpc.InitResponse_Error{
-						Error: err.Proto(),
-					},
-				}
-			}
-		}
-
-		// Load libraries
-		for _, pack := range instance.PackageManager.Packages {
-			for _, platform := range pack.Platforms {
-				if platformRelease := instance.PackageManager.GetInstalledPlatformRelease(platform); platformRelease != nil {
-					instance.lm.AddPlatformReleaseLibrariesDir(platformRelease, libraries.PlatformBuiltIn)
-				}
-			}
+			})
 		}
+	}
 
-		if err := instance.lm.LoadIndex(); err != nil {
-			s := status.Newf(codes.FailedPrecondition, "Loading index file: %v", err)
-			outChan <- &rpc.InitResponse{
+	if toolHasBeenInstalled {
+		// We installed at least one new tool after loading hardware
+		// so we must reload again otherwise we would never found them.
+		for _, err := range instance.PackageManager.LoadHardware() {
+			resp(&rpc.InitResponse{
 				Message: &rpc.InitResponse_Error{
-					Error: s.Proto(),
+					Error: err.Proto(),
 				},
-			}
+			})
 		}
+	}
 
-		for _, err := range instance.lm.RescanLibraries() {
-			s := status.Newf(codes.FailedPrecondition, "Loading libraries: %v", err)
-			outChan <- &rpc.InitResponse{
-				Message: &rpc.InitResponse_Error{
-					Error: s.Proto(),
-				},
+	// Load libraries
+	for _, pack := range instance.PackageManager.Packages {
+		for _, platform := range pack.Platforms {
+			if platformRelease := instance.PackageManager.GetInstalledPlatformRelease(platform); platformRelease != nil {
+				instance.lm.AddPlatformReleaseLibrariesDir(platformRelease, libraries.PlatformBuiltIn)
 			}
 		}
-	}()
+	}
+
+	if err := instance.lm.LoadIndex(); err != nil {
+		s := status.Newf(codes.FailedPrecondition, "Loading index file: %v", err)
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_Error{
+				Error: s.Proto(),
+			},
+		})
+	}
 
-	return outChan, nil
+	for _, err := range instance.lm.RescanLibraries() {
+		s := status.Newf(codes.FailedPrecondition, "Loading libraries: %v", err)
+		resp(&rpc.InitResponse{
+			Message: &rpc.InitResponse_Error{
+				Error: s.Proto(),
+			},
+		})
+	}
+
+	return nil
 }
 
 // Destroy FIXMEDOC

commands/lib/install.go

@@ -77,7 +77,7 @@ func LibraryInstall(ctx context.Context, req *rpc.LibraryInstallRequest,
 		}
 	}
 
-	_, status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: req.Instance.Id}})
+	status := commands.Init(&rpc.InitRequest{Instance: req.Instance}, nil)
 	if status != nil {
 		return fmt.Errorf("rescanning libraries: %s", status.Err())
 	}

commands/lib/upgrade.go

@@ -33,7 +33,7 @@ func LibraryUpgradeAll(instanceID int32, downloadCB commands.DownloadProgressCB,
 		return err
 	}
 
-	_, status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: instanceID}})
+	status := commands.Init(&rpc.InitRequest{Instance: &rpc.Instance{Id: instanceID}}, nil)
 	if status != nil {
 		return fmt.Errorf("rescanning libraries: %s", status.Err())
 	}