Rearrange RPC calls

edriouk · edriouk · commit 775cfac63571 · 2026-04-21T10:26:50.000+02:00
diff --git a/src/solutions/solution-manager.ts b/src/solutions/solution-manager.ts
@@ -147,7 +147,7 @@ export class SolutionManagerImpl implements SolutionManager {
         if (!this.isSolutionActivated()) {
             return;
         }
-        if (await this.loadSolution()) {
+        if (await this.loadSolution(true)) { // some RPC data can change (e.g. different CMSIS_PACK_ROOT)
             this.requestConvert(false, true, false);
         }
     }
@@ -163,7 +163,7 @@ export class SolutionManagerImpl implements SolutionManager {
 
         if (solutionPath) {
             this.setLoadState(newState, false);
-            if (await this.loadSolution()) {
+            if (await this.loadSolution(true)) { // first load, read RPC data for fast update of the views
                 // trigger solution convert without RTE update
                 this.requestConvert(false, false, true);
             }
@@ -176,7 +176,7 @@ export class SolutionManagerImpl implements SolutionManager {
         if (!this.loadState.solutionPath) {
             return;
         }
-        if (await this.loadSolution()) {
+        if (await this.loadSolution(false)) { // no update RTE before convert
             this.requestConvert(true, false, false);
         }
     }
@@ -217,7 +217,7 @@ export class SolutionManagerImpl implements SolutionManager {
         }
     }
 
-    private async loadSolution(): Promise<boolean> {
+    private async loadSolution(updateRpcData: boolean): Promise<boolean> {
         if (this.loadingSolution || !this.loadState.solutionPath) {
             return false;
         }
@@ -226,12 +226,15 @@ export class SolutionManagerImpl implements SolutionManager {
             this.csolution = new CSolution();
             await this.csolution.load(this.loadState.solutionPath);
 
+            // read if RPC data if requested
+            if (updateRpcData) {
+                await this.updateRpcData();
+            }
             // Create new state object with loaded flag
             const newState: SolutionLoadState = {
                 ...this.loadState,
                 loaded: true
             };
-            await this.updateRpcData();
             this.setLoadState(newState, true);
         } catch (error) {
             console.error(`Failed to load ${this.loadState.solutionPath}`, error);
@@ -245,6 +248,7 @@ export class SolutionManagerImpl implements SolutionManager {
         if (!this.csolution) {
             return;
         }
+        await this.updateRpcData(); // refresh RPC data
         await this.loadSolutionBuildFiles();
 
         if (data.severity != 'error') {
diff --git a/src/views/manage-components-packs/components-packs-webview-main.test.ts b/src/views/manage-components-packs/components-packs-webview-main.test.ts
@@ -597,9 +597,13 @@ describe('ComponentsPacksWebviewMain', () => {
 
         it('performs full reload sequence when reload=true', async () => {
             const svc = setupCsolutionServiceMocks();
+            (componentsPacksWebviewMain as any).currentProject = {
+                solutionPath: 'solPath',
+                project: { projectId: 'proj.cproject.yml', projectName: 'proj' }
+            };
             (componentsPacksWebviewMain as any).getActiveContext = jest.fn().mockReturnValue('activeCtx');
 
-            await (componentsPacksWebviewMain as any).loadSolution('solPath', 'activeTs', 'activeCtx', true);
+            await (componentsPacksWebviewMain as any).loadSolution('activeCtx', true);
 
             // Ordering-sensitive state messages (exclude the final undefined clear + others at end)
             const stateMessages = webviewManager.sendMessage.mock.calls
@@ -610,16 +614,11 @@ describe('ComponentsPacksWebviewMain', () => {
             // Expect the progressive messages in order (final undefined may appear anywhere in array depending on Promise.all)
             expect(stateMessages).toEqual(
                 expect.arrayContaining([
-                    'Connecting to rpc daemon',
-                    'Loading Solution...',
-                    'Retrieving assigned items...'
+                    'Loading Solution data...'
                 ])
             );
-            expect(stateMessages.indexOf('Connecting to rpc daemon')).toBeLessThan(stateMessages.indexOf('Loading Solution...'));
-            expect(stateMessages.indexOf('Loading Solution...')).toBeLessThan(stateMessages.indexOf('Retrieving assigned items...'));
 
             expect(svc.loadPacks).not.toHaveBeenCalled();
-            expect(svc.loadSolution).toHaveBeenCalledWith({ solution: 'solPath', activeTarget: 'activeTs' });
             expect(svc.getUsedItems).toHaveBeenCalledWith({ context: 'activeCtx' });
             expect(svc.getPacksInfo).toHaveBeenCalledWith({ context: 'activeCtx', all: false });
             expect(svc.getComponentsTree).toHaveBeenCalledWith({ context: 'activeCtx', all: false });
@@ -636,18 +635,24 @@ describe('ComponentsPacksWebviewMain', () => {
 
         it('skips heavy reload steps when reload=false', async () => {
             const svc = setupCsolutionServiceMocks();
+            (componentsPacksWebviewMain as any).currentProject = {
+                solutionPath: 'solPath',
+                project: { projectId: 'proj.cproject.yml', projectName: 'proj' }
+            };
+            (componentsPacksWebviewMain as any).getActiveContext = jest.fn().mockReturnValue('activeCtx');
 
             (componentsPacksWebviewMain as any).usedItems = usedItemsReturn;
-            await (componentsPacksWebviewMain as any).loadSolution('solPath', 'activeTs', 'activeCtx', false);
+            await (componentsPacksWebviewMain as any).loadSolution('activeCtx', false);
 
             // Heavy operations not called
             expect(svc.loadPacks).not.toHaveBeenCalled();
             expect(svc.loadSolution).not.toHaveBeenCalled();
 
-            // Still refresh tree, usedItems and validations
+            // Still refresh tree and validations
             expect(svc.getComponentsTree).toHaveBeenCalledTimes(1);
             expect(svc.validateComponents).toHaveBeenCalledTimes(1);
-            expect(svc.getUsedItems).toHaveBeenCalled();
+            // sendDirtyState({ skipApply: true }) still calls isDirty(), which refreshes used items once.
+            expect(svc.getUsedItems).toHaveBeenCalledWith({ context: 'activeCtx' });
 
             const compTreeMsg = webviewManager.sendMessage.mock.calls.map(c => c[0]).find(m => m.type === 'SOLUTION_LOADED');
             expect(compTreeMsg?.componentTree).toBe(componentTreeReturn);
@@ -658,6 +663,10 @@ describe('ComponentsPacksWebviewMain', () => {
 
         it('handles errors and sends error messages', async () => {
             const error = new Error('Boom failure');
+            (componentsPacksWebviewMain as any).currentProject = {
+                solutionPath: 'solPath',
+                project: { projectId: 'proj.cproject.yml', projectName: 'proj' }
+            };
             setupCsolutionServiceMocks({
                 getComponentsTree: jest.fn().mockRejectedValue(error),
                 getLogMessages: jest.fn().mockResolvedValue({
@@ -667,7 +676,7 @@ describe('ComponentsPacksWebviewMain', () => {
                 })
             });
 
-            await (componentsPacksWebviewMain as any).loadSolution('solPath', 'activeTs', 'ctx', true);
+            await (componentsPacksWebviewMain as any).loadSolution('ctx', true);
 
             // Expect error sequence: SET_COMPONENT_TREE with cleared data & SET_ERROR_MESSAGES with merged messages
             const calls = webviewManager.sendMessage.mock.calls.map(c => c[0]);
@@ -1187,35 +1196,35 @@ describe('ComponentsPacksWebviewMain', () => {
             await (componentsPacksWebviewMain as any).load('proj/board.cproject.yml', true);
 
             expect(clearSpy).toHaveBeenCalled();
-            expect(loadSolutionSpy).toHaveBeenCalledWith('/solutions/app.csolution.yml', 'Debug', 'ctxProj', true);
+            expect(loadSolutionSpy).toHaveBeenCalledWith('ctxProj', true);
             expect(sendSelectedProjectSpy).toHaveBeenCalledWith('proj/board.cproject.yml');
             expect((componentsPacksWebviewMain as any).project.project.projectName).toBe('board');
         });
     });
 
     describe('loadSolution failure handling', () => {
-        it('throws when csolution load fails and surfaces rpc log messages', async () => {
+        it('surfaces rpc log messages when loading solution data fails', async () => {
             webviewManager.sendMessage.mockClear();
             (componentsPacksWebviewMain as any).currentProject = { solutionPath: path.join('root', 'solution.csolution.yml'), project: { projectId: 'proj', projectName: 'proj' } };
             (componentsPacksWebviewMain as any).csolutionService = {
                 getVersion: jest.fn().mockResolvedValue('1.0.0'),
                 loadPacks: jest.fn().mockResolvedValue(undefined),
-                loadSolution: jest.fn().mockResolvedValue({ success: false }),
-                getUsedItems: jest.fn(),
+                loadSolution: jest.fn().mockResolvedValue({ success: true }),
+                getUsedItems: jest.fn().mockRejectedValue(new Error('Boom failure')),
                 getPacksInfo: jest.fn().mockResolvedValue({ packs: [] }),
                 getComponentsTree: jest.fn(),
                 validateComponents: jest.fn(),
                 getLogMessages: jest.fn().mockResolvedValue({ errors: ['E'], warnings: ['W'], info: ['I'] })
             };
 
-            await (componentsPacksWebviewMain as any).loadSolution('solPath', 'ts', 'ctx', true);
+            await (componentsPacksWebviewMain as any).loadSolution('ctx', true);
 
             const errorMessages = webviewManager.sendMessage.mock.calls
                 .map(c => c[0])
                 .filter(m => m.type === 'SET_ERROR_MESSAGES');
             const lastErrorMessage = errorMessages.at(-1);
             expect(lastErrorMessage).toBeDefined();
-            expect(lastErrorMessage?.messages.map((m: any) => m.message)).toEqual(expect.arrayContaining(['Failed loading solution: solPath due to previous errors', 'E', 'W', 'I']));
+            expect(lastErrorMessage?.messages.map((m: any) => m.message)).toEqual(expect.arrayContaining(['Boom failure', 'E', 'W', 'I']));
         });
     });
 
diff --git a/src/views/manage-components-packs/components-packs-webview-main.ts b/src/views/manage-components-packs/components-packs-webview-main.ts
@@ -381,13 +381,12 @@ export class ComponentsPacksWebviewMain {
             this.currentProject = { solutionPath: csolution.solutionPath, project: createProject(projectId) };
             const actx = this.getActiveContext();
 
-            const activeTs = csolution.getActiveTargetSetName() ?? '';
-            await this.loadSolution(csolution.solutionPath, activeTs, actx, reload);
+            await this.loadSolution(actx, reload);
             await this.sendSelectedProject(backToForwardSlashes(projectId));
         }
     }
 
-    private async loadSolution(solutionPath: string, activeTargetSet: string, activeContext: string, reload: boolean): Promise<void> {
+    private async loadSolution(activeContext: string, reload: boolean): Promise<void> {
         await this.webviewManager.sendMessage({ type: 'SET_ERROR_MESSAGES', messages: [] });
 
         // Abort if conversion is still in progress; handleSolutionLoadChange will trigger reload on converted=true
@@ -400,15 +399,7 @@ export class ComponentsPacksWebviewMain {
             if (reload) {
                 this.availablePacksCache = {};
                 this.unlinkRequests.clear();
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Connecting to rpc daemon' });
-
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Loading Solution...' });
-                const solutionSuccess = await this.csolutionService.loadSolution({ solution: solutionPath, activeTarget: activeTargetSet });
-                if (!solutionSuccess.success) {
-                    throw new Error(`Failed loading solution: ${solutionPath} due to previous errors`);
-                }
-
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Retrieving assigned items...' });
+                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Loading Solution data...' });
                 this.usedItems = await this.csolutionService.getUsedItems({ context: activeContext });
             }
             await this.webviewManager.sendMessage({ type: 'SET_UNLINKREQUESTS_STACK', unlinkRequests: Array.from(this.unlinkRequests) });

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ export class SolutionManagerImpl implements SolutionManager {`
`147`	`147`	`if (!this.isSolutionActivated()) {`
`148`	`148`	`return;`
`149`	`149`	`}`
`150`		`- if (await this.loadSolution()) {`
	`150`	`+ if (await this.loadSolution(true)) { // some RPC data can change (e.g. different CMSIS_PACK_ROOT)`
`151`	`151`	`this.requestConvert(false, true, false);`
`152`	`152`	`}`
`153`	`153`	`}`
`@@ -163,7 +163,7 @@ export class SolutionManagerImpl implements SolutionManager {`
`163`	`163`
`164`	`164`	`if (solutionPath) {`
`165`	`165`	`this.setLoadState(newState, false);`
`166`		`- if (await this.loadSolution()) {`
	`166`	`+ if (await this.loadSolution(true)) { // first load, read RPC data for fast update of the views`
`167`	`167`	`// trigger solution convert without RTE update`
`168`	`168`	`this.requestConvert(false, false, true);`
`169`	`169`	`}`
`@@ -176,7 +176,7 @@ export class SolutionManagerImpl implements SolutionManager {`
`176`	`176`	`if (!this.loadState.solutionPath) {`
`177`	`177`	`return;`
`178`	`178`	`}`
`179`		`- if (await this.loadSolution()) {`
	`179`	`+ if (await this.loadSolution(false)) { // no update RTE before convert`
`180`	`180`	`this.requestConvert(true, false, false);`
`181`	`181`	`}`
`182`	`182`	`}`
`@@ -217,7 +217,7 @@ export class SolutionManagerImpl implements SolutionManager {`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
`220`		`- private async loadSolution(): Promise<boolean> {`
	`220`	`+ private async loadSolution(updateRpcData: boolean): Promise<boolean> {`
`221`	`221`	`if (this.loadingSolution \|\| !this.loadState.solutionPath) {`
`222`	`222`	`return false;`
`223`	`223`	`}`
`@@ -226,12 +226,15 @@ export class SolutionManagerImpl implements SolutionManager {`
`226`	`226`	`this.csolution = new CSolution();`
`227`	`227`	`await this.csolution.load(this.loadState.solutionPath);`
`228`	`228`
	`229`	`+ // read if RPC data if requested`
	`230`	`+ if (updateRpcData) {`
	`231`	`+ await this.updateRpcData();`
	`232`	`+ }`
`229`	`233`	`// Create new state object with loaded flag`
`230`	`234`	`const newState: SolutionLoadState = {`
`231`	`235`	`...this.loadState,`
`232`	`236`	`loaded: true`
`233`	`237`	`};`
`234`		`- await this.updateRpcData();`
`235`	`238`	`this.setLoadState(newState, true);`
`236`	`239`	`} catch (error) {`
`237`	`240`	console.error(`Failed to load ${this.loadState.solutionPath}`, error);
`@@ -245,6 +248,7 @@ export class SolutionManagerImpl implements SolutionManager {`
`245`	`248`	`if (!this.csolution) {`
`246`	`249`	`return;`
`247`	`250`	`}`
	`251`	`+ await this.updateRpcData(); // refresh RPC data`
`248`	`252`	`await this.loadSolutionBuildFiles();`
`249`	`253`
`250`	`254`	`if (data.severity != 'error') {`