13755753799

Committed 10 Mar 2025 02:47AM UTC coverage: 87.472%. Remained the same

Build # 13755753799

Build Type

Pull #1689

github

Committed by

web-flow

Commit Message

Merge 2a6771c28 into 72117c806

Pull Request Pull Request #1689: build(deps): bump dsanders11/project-actions from 1.5.2 to 1.7.0

Run Details

983 of 1223 branches covered (80.38%)

Branch coverage included in aggregate %.

3772 of 4213 relevant lines covered (89.53%)

34.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.55

/src/main/fiddle-core.ts

import { ChildProcess } from 'node:child_process';

import { ElectronVersions, Installer, Runner } from '@electron/fiddle-core';
import { BrowserWindow, IpcMainEvent, WebContents } from 'electron';

import { ELECTRON_DOWNLOAD_PATH, ELECTRON_INSTALL_PATH } from './constants';
import { ipcMainManager } from './ipc';
import {
  DownloadVersionParams,
  ProgressObject,
  StartFiddleParams,
} from '../interfaces';
import { IpcEvents } from '../ipc-events';

let installer: Installer;
let runner: Runner;

// Keep track of which fiddle process belongs to which WebContents
const fiddleProcesses = new WeakMap<WebContents, ChildProcess>();

const downloadingVersions = new Map<string, Promise<any>>();
const removingVersions = new Map<string, Promise<void>>();

/**
 * Start running an Electron fiddle.
 */
export async function startFiddle(
  webContents: WebContents,
  params: StartFiddleParams,
): Promise<void> {
  const {
    dir,
    enableElectronLogging,
    isValidBuild,
    localPath,
    options,
    version,
  } = params;
  const env = { ...process.env };

  if (enableElectronLogging) {
    env.ELECTRON_ENABLE_LOGGING = 'true';
    env.ELECTRON_DEBUG_NOTIFICATIONS = 'true';
    env.ELECTRON_ENABLE_STACK_DUMPING = 'true';
  } else {
    delete env.ELECTRON_ENABLE_LOGGING;
    delete env.ELECTRON_DEBUG_NOTIFICATIONS;
    delete env.ELECTRON_ENABLE_STACK_DUMPING;
  }

  Object.assign(env, params.env);

  const child = await runner.spawn(
    isValidBuild && localPath ? Installer.getExecPath(localPath) : version,
    dir,
    { args: options, cwd: dir, env },
  );
  fiddleProcesses.set(webContents, child);

  const pushOutput = (data: string | Buffer) => {
    ipcMainManager.send(
      IpcEvents.FIDDLE_RUNNER_OUTPUT,
      [data.toString()],
      webContents,
    );
  };

  child.stdout?.on('data', pushOutput);
  child.stderr?.on('data', pushOutput);

  child.on('close', async (code, signal) => {
    fiddleProcesses.delete(webContents);

    ipcMainManager.send(IpcEvents.FIDDLE_STOPPED, [code, signal], webContents);
  });
}

/**
 * Stop a currently running Electron fiddle.
 */
export function stopFiddle(webContents: WebContents): void {
  const child = fiddleProcesses.get(webContents);
  child?.kill();

  if (child) {
    // If the child process is still alive 1 second after we've
    // attempted to kill it by normal means, kill it forcefully.
    setTimeout(() => {
      if (child.exitCode === null) {
        child.kill('SIGKILL');
      }
    }, 1000);
  }
}

export async function setupFiddleCore(versions: ElectronVersions) {
  // For managing downloads and versions for electron
  installer = new Installer({
    electronDownloads: ELECTRON_DOWNLOAD_PATH,
    electronInstall: ELECTRON_INSTALL_PATH,
  });

  // Broadcast state changes to all windows
  installer.on('state-changed', (event) => {
    for (const window of BrowserWindow.getAllWindows()) {
      ipcMainManager.send(
        IpcEvents.VERSION_STATE_CHANGED,
        [event],
        window.webContents,
      );
    }
  });

  runner = await Runner.create({ installer, versions });

  ipcMainManager.on(
    IpcEvents.GET_VERSION_STATE,
    (event: IpcMainEvent, version: string) => {
      event.returnValue = installer.state(version);
    },
  );
  ipcMainManager.handle(
    IpcEvents.DOWNLOAD_VERSION,
    async (
      event: IpcMainEvent,
      version: string,
      opts?: Partial<DownloadVersionParams>,
    ) => {
      const webContents = event.sender;

      if (removingVersions.has(version)) {
        throw new Error('Version is being removed');
      }

      if (!downloadingVersions.has(version)) {
        const promise = installer.ensureDownloaded(version, {
          ...opts,
          progressCallback: (progress: ProgressObject) => {
            ipcMainManager.send(
              IpcEvents.VERSION_DOWNLOAD_PROGRESS,
              [version, progress],
              webContents,
            );
          },
        });

        downloadingVersions.set(version, promise);
      }

      try {
        await downloadingVersions.get(version);
      } finally {
        downloadingVersions.delete(version);
      }
    },
  );
  ipcMainManager.handle(
    IpcEvents.REMOVE_VERSION,
    async (_: IpcMainEvent, version: string) => {
      if (downloadingVersions.has(version)) {
        throw new Error('Version is being downloaded');
      }

      if (!removingVersions.has(version)) {
        removingVersions.set(version, installer.remove(version));
      }

      try {
        await removingVersions.get(version);
        return installer.state(version);
      } finally {
        removingVersions.delete(version);
      }
    },
  );
  ipcMainManager.handle(
    IpcEvents.START_FIDDLE,
    async (event: IpcMainEvent, params: StartFiddleParams) => {
      await startFiddle(event.sender, params);
    },
  );
  ipcMainManager.on(IpcEvents.STOP_FIDDLE, (event: IpcMainEvent) => {
    stopFiddle(event.sender);
  });
}

1	import { ChildProcess } from 'node:child_process';
2
3	import { ElectronVersions, Installer, Runner } from '@electron/fiddle-core';	2✔
4	import { BrowserWindow, IpcMainEvent, WebContents } from 'electron';	2✔
5
6	import { ELECTRON_DOWNLOAD_PATH, ELECTRON_INSTALL_PATH } from './constants';	2✔
7	import { ipcMainManager } from './ipc';	2✔
8	import {
9	DownloadVersionParams,
10	ProgressObject,
11	StartFiddleParams,
12	} from '../interfaces';
13	import { IpcEvents } from '../ipc-events';	2✔
14
15	let installer: Installer;
16	let runner: Runner;
17
18	// Keep track of which fiddle process belongs to which WebContents
19	const fiddleProcesses = new WeakMap<WebContents, ChildProcess>();	2✔
20
21	const downloadingVersions = new Map<string, Promise<any>>();	2✔
22	const removingVersions = new Map<string, Promise<void>>();	2✔
23
24	/**
25	* Start running an Electron fiddle.
26	*/
27	export async function startFiddle(	2✔
28	webContents: WebContents,
29	params: StartFiddleParams,
30	): Promise<void> {
31	const {
32	dir,
33	enableElectronLogging,
34	isValidBuild,
35	localPath,
36	options,
37	version,
38	} = params;	3✔
39	const env = { ...process.env };	3✔
40
41	if (enableElectronLogging) {	3✔
42	env.ELECTRON_ENABLE_LOGGING = 'true';	1✔
43	env.ELECTRON_DEBUG_NOTIFICATIONS = 'true';	1✔
44	env.ELECTRON_ENABLE_STACK_DUMPING = 'true';	1✔
45	} else {
46	delete env.ELECTRON_ENABLE_LOGGING;	2✔
47	delete env.ELECTRON_DEBUG_NOTIFICATIONS;	2✔
48	delete env.ELECTRON_ENABLE_STACK_DUMPING;	2✔
49	}
50
51	Object.assign(env, params.env);	3✔
52
53	const child = await runner.spawn(	3✔
54	isValidBuild && localPath ? Installer.getExecPath(localPath) : version,	9!
55	dir,
56	{ args: options, cwd: dir, env },
57	);
58	fiddleProcesses.set(webContents, child);	3✔
59
60	const pushOutput = (data: string \| Buffer) => {	3✔
61	ipcMainManager.send(	×
62	IpcEvents.FIDDLE_RUNNER_OUTPUT,
63	[data.toString()],
64	webContents,
65	);
66	};
67
68	child.stdout?.on('data', pushOutput);	3!
69	child.stderr?.on('data', pushOutput);	3!
70
71	child.on('close', async (code, signal) => {	3✔
72	fiddleProcesses.delete(webContents);	×
73
74	ipcMainManager.send(IpcEvents.FIDDLE_STOPPED, [code, signal], webContents);	×
75	});
76	}
77
78	/**
79	* Stop a currently running Electron fiddle.
80	*/
81	export function stopFiddle(webContents: WebContents): void {	2✔
82	const child = fiddleProcesses.get(webContents);	×
83	child?.kill();	×
84
85	if (child) {	×
86	// If the child process is still alive 1 second after we've
87	// attempted to kill it by normal means, kill it forcefully.
88	setTimeout(() => {	×
89	if (child.exitCode === null) {	×
90	child.kill('SIGKILL');	×
91	}
92	}, 1000);
93	}
94	}
95
96	export async function setupFiddleCore(versions: ElectronVersions) {	2✔
97	// For managing downloads and versions for electron
98	installer = new Installer({	5✔
99	electronDownloads: ELECTRON_DOWNLOAD_PATH,
100	electronInstall: ELECTRON_INSTALL_PATH,
101	});
102
103	// Broadcast state changes to all windows
104	installer.on('state-changed', (event) => {	5✔
105	for (const window of BrowserWindow.getAllWindows()) {	×
106	ipcMainManager.send(	×
107	IpcEvents.VERSION_STATE_CHANGED,
108	[event],
109	window.webContents,
110	);
111	}
112	});
113
114	runner = await Runner.create({ installer, versions });	5✔
115
116	ipcMainManager.on(	5✔
117	IpcEvents.GET_VERSION_STATE,
118	(event: IpcMainEvent, version: string) => {
119	event.returnValue = installer.state(version);	×
120	},
121	);
122	ipcMainManager.handle(	5✔
123	IpcEvents.DOWNLOAD_VERSION,
124	async (
125	event: IpcMainEvent,
126	version: string,
127	opts?: Partial<DownloadVersionParams>,
128	) => {
129	const webContents = event.sender;	×
130
131	if (removingVersions.has(version)) {	×
132	throw new Error('Version is being removed');	×
133	}
134
135	if (!downloadingVersions.has(version)) {	×
136	const promise = installer.ensureDownloaded(version, {	×
137	...opts,
138	progressCallback: (progress: ProgressObject) => {
139	ipcMainManager.send(	×
140	IpcEvents.VERSION_DOWNLOAD_PROGRESS,
141	[version, progress],
142	webContents,
143	);
144	},
145	});
146
147	downloadingVersions.set(version, promise);	×
148	}
149
150	try {	×
151	await downloadingVersions.get(version);	×
152	} finally {
153	downloadingVersions.delete(version);	×
154	}
155	},
156	);
157	ipcMainManager.handle(	5✔
158	IpcEvents.REMOVE_VERSION,
159	async (_: IpcMainEvent, version: string) => {
160	if (downloadingVersions.has(version)) {	×
161	throw new Error('Version is being downloaded');	×
162	}
163
164	if (!removingVersions.has(version)) {	×
165	removingVersions.set(version, installer.remove(version));	×
166	}
167
168	try {	×
169	await removingVersions.get(version);	×
170	return installer.state(version);	×
171	} finally {
172	removingVersions.delete(version);	×
173	}
174	},
175	);
176	ipcMainManager.handle(	5✔
177	IpcEvents.START_FIDDLE,
178	async (event: IpcMainEvent, params: StartFiddleParams) => {
179	await startFiddle(event.sender, params);	×
180	},
181	);
182	ipcMainManager.on(IpcEvents.STOP_FIDDLE, (event: IpcMainEvent) => {	5✔
183	stopFiddle(event.sender);	×
184	});
185	}

electron / fiddle / 13755753799

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous