config-service-impl.ts

import{promisesasfs}from'node:fs';
import{dirname}from'node:path';
importyamlfrom'js-yaml';
import{injectable,inject,named}from'@theia/core/shared/inversify';
importURIfrom'@theia/core/lib/common/uri';
import{ILogger}from'@theia/core/lib/common/logger';
import{FileUri}from'@theia/core/lib/common/file-uri';
import{Event,Emitter}from'@theia/core/lib/common/event';
import{BackendApplicationContribution}from'@theia/core/lib/node/backend-application';
import{
ConfigService,
Config,
NotificationServiceServer,
Network,
ConfigState,
}from'../common/protocol';
import{spawnCommand}from'./exec-util';
import{ArduinoDaemonImpl}from'./arduino-daemon-impl';
import{DefaultCliConfig,CLI_CONFIG,CliConfig}from'./cli-config';
import{Deferred}from'@theia/core/lib/common/promise-util';
import{EnvVariablesServer}from'@theia/core/lib/common/env-variables';
import{deepClone,nls}from'@theia/core';
import{ErrnoException}from'./utils/errors';
import{createArduinoCoreServiceClient}from'./arduino-core-service-client';
import{
ConfigurationSaveRequest,
SettingsSetValueRequest,
}from'./cli-protocol/cc/arduino/cli/commands/v1/settings_pb';

constdeepmerge=require('deepmerge');

@injectable()
exportclassConfigServiceImpl
implementsBackendApplicationContribution,ConfigService
{
 @inject(ILogger)
 @named('config')
privatereadonlylogger: ILogger;

 @inject(EnvVariablesServer)
privatereadonlyenvVariablesServer: EnvVariablesServer;

 @inject(ArduinoDaemonImpl)
privatereadonlydaemon: ArduinoDaemonImpl;

 @inject(NotificationServiceServer)
privatereadonlynotificationService: NotificationServiceServer;

privateconfig: ConfigState={
config: undefined,
messages: ['uninitialized'],
};
privatecliConfig: DefaultCliConfig|undefined;
privateready=newDeferred<void>();
privatereadonlyconfigChangeEmitter=newEmitter<{
oldState: ConfigState;
newState: ConfigState;
}>();

onStart(): void{
this.initConfig();
}

privateasyncgetCliConfigFileUri(): Promise<string>{
constconfigDirUri=awaitthis.envVariablesServer.getConfigDirUri();
returnnewURI(configDirUri).resolve(CLI_CONFIG).toString();
}

asyncgetConfiguration(): Promise<ConfigState>{
awaitthis.ready.promise;
return{ ...this.config};
}

// Used by frontend to update the config.
asyncsetConfiguration(config: Config): Promise<void>{
awaitthis.ready.promise;
if(Config.sameAs(this.config.config,config)){
return;
}
constoldConfigState=deepClone(this.config);
letcopyDefaultCliConfig: DefaultCliConfig|undefined=deepClone(
this.cliConfig
);
if(!copyDefaultCliConfig){
copyDefaultCliConfig=awaitthis.getFallbackCliConfig();
}
const{ additionalUrls, dataDirUri, sketchDirUri, network, locale }=
config;
copyDefaultCliConfig.directories={
data: FileUri.fsPath(dataDirUri),
user: FileUri.fsPath(sketchDirUri),
};
copyDefaultCliConfig.board_manager={
additional_urls: [...additionalUrls],
};
copyDefaultCliConfig.locale=locale||'en';
constproxy=Network.stringify(network);
copyDefaultCliConfig.network=proxy ? { proxy } : {};// must be an empty object to unset the default prop with the `WriteRequest`.

// always use the port of the daemon
constport=awaitthis.daemon.getPort();
awaitthis.updateDaemon(port,copyDefaultCliConfig);
awaitthis.writeDaemonState(port);

this.config.config=deepClone(config);
this.cliConfig=copyDefaultCliConfig;
try{
awaitthis.validateCliConfig(this.cliConfig);
deletethis.config.messages;
this.fireConfigChanged(oldConfigState,this.config);
}catch(err){
if(errinstanceofInvalidConfigError){
this.config.messages=err.errors;
this.fireConfigChanged(oldConfigState,this.config);
}else{
throwerr;
}
}
}

getcliConfiguration(): DefaultCliConfig|undefined{
returnthis.cliConfig;
}

getonConfigChange(): Event<{
oldState: ConfigState;
newState: ConfigState;
}>{
returnthis.configChangeEmitter.event;
}

privateasyncinitConfig(): Promise<void>{
this.logger.info('>>> Initializing CLI configuration...');
try{
constcliConfig=awaitthis.loadCliConfig();
this.logger.info('Loaded the CLI configuration.');
this.cliConfig=cliConfig;
const[config]=awaitPromise.all([
this.mapCliConfigToAppConfig(this.cliConfig),
this.ensureUserDirExists(this.cliConfig).catch((reason)=>{
if(reasoninstanceofError){
this.logger.warn(
`Could not ensure user directory existence: ${this.cliConfig?.directories.user}`,
reason
);
}
// NOOP. Try to create the folder if missing but swallow any errors.
// The validation will take care of the missing location handling.
}),
]);
this.config.config=config;
this.logger.info(
`Mapped the CLI configuration: ${JSON.stringify(this.config.config)}`
);
this.logger.info('Validating the CLI configuration...');
awaitthis.validateCliConfig(this.cliConfig);
deletethis.config.messages;
this.logger.info('The CLI config is valid.');
if(config){
this.ready.resolve();
this.logger.info('<<< Initialized the CLI configuration.');
return;
}
}catch(err: unknown){
this.logger.error('Failed to initialize the CLI configuration.',err);
if(errinstanceofInvalidConfigError){
this.config.messages=err.errors;
this.ready.resolve();
}
}
}

privateasyncloadCliConfig(
initializeIfAbsent=true
): Promise<DefaultCliConfig>{
constcliConfigFileUri=awaitthis.getCliConfigFileUri();
constcliConfigPath=FileUri.fsPath(cliConfigFileUri);
this.logger.info(`Loading CLI configuration from ${cliConfigPath}...`);
try{
constcontent=awaitfs.readFile(cliConfigPath,{
encoding: 'utf8',
});
constmodel=(yaml.safeLoad(content)||{})asCliConfig;
this.logger.info(`Loaded CLI configuration: ${JSON.stringify(model)}`);
if(model.directories?.data&&model.directories?.user){
this.logger.info(
"'directories.data' and 'directories.user' are set in the CLI configuration model."
);
returnmodelasDefaultCliConfig;
}
// The CLI can run with partial (missing `port`, `directories`), the IDE2 cannot.
// We merge the default CLI config with the partial user's config.
this.logger.info(
"Loading fallback CLI configuration to get 'directories.data' and 'directories.user'"
);
constfallbackModel=awaitthis.getFallbackCliConfig();
this.logger.info(
`Loaded fallback CLI configuration: ${JSON.stringify(fallbackModel)}`
);
constmergedModel=deepmerge(fallbackModel,model)asDefaultCliConfig;
this.logger.info(
`Merged CLI configuration with the fallback: ${JSON.stringify(
mergedModel
)}`
);
returnmergedModel;
}catch(error){
if(ErrnoException.isENOENT(error)){
if(initializeIfAbsent){
awaitthis.initCliConfigTo(dirname(cliConfigPath));
returnthis.loadCliConfig(false);
}
}
throwerror;
}
}

privateasyncgetFallbackCliConfig(): Promise<DefaultCliConfig>{
constcliPath=this.daemon.getExecPath();
const[configRaw,directoriesRaw]=awaitPromise.all([
spawnCommand(cliPath,['config','dump','--json']),
// Since CLI 1.0, the command `config dump` only returns user-modified values and not default ones.
// directories.user and directories.data are required by IDE2 so we get the default value explicitly.
spawnCommand(cliPath,['config','get','directories','--json']),
]);

constconfig=JSON.parse(configRaw);
const{ user, data }=JSON.parse(directoriesRaw);

return{ ...config.config,directories: { user, data }};
}

privateasyncinitCliConfigTo(fsPathToDir: string): Promise<void>{
constcliPath=this.daemon.getExecPath();
awaitspawnCommand(cliPath,['config','init','--dest-dir',fsPathToDir]);
}

privateasyncmapCliConfigToAppConfig(
cliConfig: DefaultCliConfig
): Promise<Config>{
const{ directories, locale ='en'}=cliConfig;
const{ user, data }=directories;
constadditionalUrls: Array<string>=[];
if(cliConfig.board_manager&&cliConfig.board_manager.additional_urls){
additionalUrls.push(
 ...Array.from(newSet(cliConfig.board_manager.additional_urls))
);
}
constnetwork=Network.parse(cliConfig.network?.proxy);
return{
dataDirUri: FileUri.create(data).toString(),
sketchDirUri: FileUri.create(user).toString(),
 additionalUrls,
 network,
 locale,
};
}

privatefireConfigChanged(
oldState: ConfigState,
newState: ConfigState
): void{
this.configChangeEmitter.fire({ oldState, newState });
this.notificationService.notifyConfigDidChange(newState);
}

privateasyncvalidateCliConfig(config: DefaultCliConfig): Promise<void>{
consterrors: string[]=[];
errors.push(...(awaitthis.checkAccessible(config)));
if(errors.length){
thrownewInvalidConfigError(errors);
}
}

privateasynccheckAccessible({
 directories,
}: DefaultCliConfig): Promise<string[]>{
try{
awaitfs.readdir(directories.user);
return[];
}catch(err){
console.error(
`Check accessible failed for input: ${directories.user}`,
err
);
return[
nls.localize(
'arduino/configuration/cli/inaccessibleDirectory',
"Could not access the sketchbook location at '{0}': {1}",
directories.user,
String(err)
),
];
}
}

privateasyncupdateDaemon(
port: number,
config: DefaultCliConfig
): Promise<void>{
constjson=JSON.stringify(config,null,2);
this.logger.info(`Updating daemon with 'data': ${json}`);

constupdatableConfig={
locale: config.locale,
'directories.user': config.directories.user,
'directories.data': config.directories.data,
'network.proxy': config.network?.proxy,
'board_manager.additional_urls':
config.board_manager?.additional_urls||[],
};

constclient=createArduinoCoreServiceClient({ port });

for(const[key,value]ofObject.entries(updatableConfig)){
constreq=newSettingsSetValueRequest();
req.setKey(key);
req.setEncodedValue(JSON.stringify(value));
awaitnewPromise<void>((resolve)=>{
client.settingsSetValue(req,(error)=>{
if(error){
this.logger.error(
`Could not update config with key: ${key} and value: ${value}`,
error
);
}
resolve();
});
});
}

client.close();
}

privateasyncwriteDaemonState(port: number): Promise<void>{
constclient=createArduinoCoreServiceClient({ port });
constreq=newConfigurationSaveRequest();
req.setSettingsFormat('yaml');

constconfigRaw=awaitnewPromise<string>((resolve,reject)=>{
client.configurationSave(req,(error,resp)=>{
try{
if(error){
reject(error);
return;
}
resolve(resp.getEncodedSettings());
}finally{
client.close();
}
});
});

constcliConfigUri=awaitthis.getCliConfigFileUri();
constcliConfigPath=FileUri.fsPath(cliConfigUri);
awaitfs.writeFile(cliConfigPath,configRaw,{encoding: 'utf-8'});
}

// #1445
privateasyncensureUserDirExists(
cliConfig: DefaultCliConfig
): Promise<void>{
awaitfs.mkdir(cliConfig.directories.user,{recursive: true});
}
}

classInvalidConfigErrorextendsError{
constructor(readonlyerrors: string[]){
super('InvalidConfigError:\n - '+errors.join('\n - '));
if(!errors.length){
thrownewError("Illegal argument: 'messages'. It must not be empty.");
}
Object.setPrototypeOf(this,InvalidConfigError.prototype);
}
}