@24i/smartapps-bigscreen-rnv-build-engine 0.0.2-alpha.1321 → 0.0.2-alpha.1323

package/engine/src/tasks/deploy/aswS3/aws.js

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+const runCmdSync = (cmd, options) => execSync(cmd, { stdio: 'inherit' });
+
+const isDir = (path) => fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+
+const cp = (source, destination) => {
+    let cmd = `aws s3 cp ${source} s3://${destination} --acl public-read`;
+    if (isDir(source)) {
+        cmd += ' --recursive';
+    }
+    runCmdSync(cmd);
+};
+
+const rm = (remoteDirPath) => {
+    let cmd = `aws s3 rm s3://${remoteDirPath}`;
+    if (remoteDirPath.endsWith('/')) {
+        cmd += ' --recursive';
+    }
+    runCmdSync(cmd);
+};
+
+export {
+    cp,
+    rm,
+};

package/engine/src/tasks/deploy/aswS3/deployS3.js

@@ -0,0 +1,71 @@
+import path from 'path';
+import fs from 'fs';
+import { Common } from 'rnv';
+import { resolveBaseUrl } from '../../../utils/resolveBaseUrl';
+import * as aws from './aws';
+
+const { getConfigProp } = Common;
+
+const uploadPackage = (c, sourcePath, uploadPath) => {
+    const packageOutputDirPath = `${sourcePath}/output`;
+    const outputFilenameList = fs.readdirSync(packageOutputDirPath);
+    const packageFileName = outputFilenameList[0];
+
+    const packageLocalPath = `"${packageOutputDirPath}/${packageFileName}"`;
+    const packageRemotePath = `"${uploadPath}/build/${packageFileName}"`;
+
+    aws.cp(packageLocalPath, packageRemotePath);
+};
+
+const uploadPublicDir = (sourcePath, uploadPath) => {
+    const publicDirLocalPath = path.join(sourcePath, 'project', 'public');
+    const publicDirRemotePath = `${uploadPath}/public`;
+
+    aws.cp(publicDirLocalPath, publicDirRemotePath);
+};
+
+const urlToS3Protocol = (url) => {
+    const hostWithPath = url.split('://')[1];
+    const bucketHostnameAwsPostfix = '.s3.amazonaws.com';
+
+    return hostWithPath.replace(bucketHostnameAwsPostfix, '');
+};
+
+const deployToS3 = async (c) => {
+    const { platform, runtime } = c;
+    const sourcePath = runtime.appDir;
+
+    const { isBuildHosted } = getConfigProp(c, platform, 'webpackConfig', {});
+    const baseUrl = resolveBaseUrl({
+        platform,
+        scheme: runtime.scheme || '',
+        appConfigId: runtime.appId,
+    });
+
+    if (!baseUrl) {
+        return false;
+    }
+
+    const uploadPath = urlToS3Protocol(baseUrl);
+
+    aws.rm(`${uploadPath}/`);
+    uploadPackage(c, sourcePath, uploadPath);
+
+    if (platform === 'hbbtv') {
+        // eslint-disable-next-line max-len
+        process.stdout.write(`For ${platform} platform, only ZIP package deployment is configured. Skipping deploying app content to AWS S3.\n`);
+        process.stdout.write('Deploy done.\n');
+        return true;
+    }
+
+    const sourceDirPath = isBuildHosted ? `${sourcePath}-public` : sourcePath;
+
+    uploadPublicDir(sourceDirPath, uploadPath);
+    process.stdout.write('Deploy done.\n');
+
+    return true;
+};
+
+export {
+    deployToS3,
+};

package/engine/src/tasks/deploy/hbbtv/deployHbbtv.js

@@ -0,0 +1,144 @@
+import path from 'path';
+import fs from 'fs';
+import { Common } from 'rnv';
+import { NodeSSH } from 'node-ssh';
+import { getBaseConfig } from '../../../utils/getBaseConfig';
+
+const { getConfigProp } = Common;
+
+const deployConfig = {
+    host: 'nxg-bigscreen-test.24imedia.tv',
+    username: 'admin',
+    privateKeyRelativePath: 'certificates/id_rsa_24i_smartapps_bigscreen',
+    passphrase: '>>> please set the value via process.env.CI_SSH_KEY_PASSPHRASE <<<',
+    hostHomeDir: '/home/admin',
+    dockerHtmlRootDir: '/usr/share/nginx/html',
+    dockerContainerName: '24inginx',
+};
+
+const getSshKeyAbsolutePath = (c, sshKeyRelativePath) => {
+    if (!sshKeyRelativePath) return '';
+    return path.join(c.paths.project.dir, sshKeyRelativePath);
+};
+
+const makeSshConnection = async (c) => {
+    const { host, username, privateKeyRelativePath } = deployConfig;
+
+    const privateKey = getSshKeyAbsolutePath(c, privateKeyRelativePath);
+    const passphrase = process.env.CI_SSH_KEY_PASSPHRASE;
+
+    if (!privateKey || !passphrase) {
+        return null;
+    }
+
+    const ssh = new NodeSSH();
+    await ssh.connect({ host, username, privateKey, passphrase });
+    return ssh;
+};
+
+const getBuildPackageFileName = (c) => {
+    const packageOutputDirPath = `${c.runtime.appDir}/output`;
+    const outputFilenameList = fs.readdirSync(packageOutputDirPath);
+    return outputFilenameList[0];
+};
+
+const getLocalBuildPackagePath = (c) => {
+    const fileName = getBuildPackageFileName(c);
+    return path.join(c.runtime.appDir, 'output', fileName);
+};
+
+const getRemoteBuildDirRelativePath = (c, scheme = '', appConfigId = '') => {
+    const { projectDirName } = getConfigProp(c, 'hbbtv', 'deploy', {});
+    const appId = c.runtime.appId || appConfigId;
+    const version = getConfigProp(c, 'hbbtv', 'packageVersion', '');
+
+    if (!projectDirName || !appId) {
+        return '';
+    }
+
+    switch (c.runtime.scheme || scheme) {
+        case 'dev:latest': return `${projectDirName}/${appId}/latest/dev`;
+        case 'rc:latest': return `${projectDirName}/${appId}/latest/rc`;
+        case 'release:latest': return `${projectDirName}/${appId}/latest/release`;
+        case 'release:dist': return `${projectDirName}/${appId}/dist/v${version}`;
+        default: return '';
+    }
+};
+
+const resolveRemotePaths = (c) => {
+    const remoteBuildDirRelativePath = getRemoteBuildDirRelativePath(c);
+    const { hostHomeDir, dockerHtmlRootDir } = deployConfig;
+    const hostTempDirName = 'travis-ci-temp';
+
+    return {
+        serverTempDirPath: `${hostHomeDir}/${hostTempDirName}/${remoteBuildDirRelativePath}`,
+        dockerProjectDirPath: `${dockerHtmlRootDir}/${remoteBuildDirRelativePath}`,
+    };
+};
+
+const log = (msg) => process.stdout.write(msg);
+
+const getHbbTVDeployUrl = (c = getBaseConfig(), scheme = '', appConfigId = '') => {
+    const { host } = deployConfig;
+    const remoteDirRelativePath = getRemoteBuildDirRelativePath(c, scheme, appConfigId);
+
+    return `http://${host}/${remoteDirRelativePath}/public/index.html`;
+};
+
+const deployHbbTV = async (c) => {
+    if (c.platform !== 'hbbtv') return;
+
+    log('HbbTV deploy via SSH.\n\n');
+
+    const remotePaths = resolveRemotePaths(c);
+    const { dockerContainerName, host } = deployConfig;
+
+    const remotePackagePath = `${remotePaths.serverTempDirPath}/${getBuildPackageFileName(c)}`;
+    const dockerExecPrefix = `docker exec -t ${dockerContainerName}`;
+    const dockerAppDirPath = remotePaths.dockerProjectDirPath;
+
+    log('Creating connection...\n');
+    const ssh = await makeSshConnection(c);
+
+    if (ssh === null) {
+        //eslint-disable-next-line max-len
+        throw new Error('Connection failed - check "privateKeyRelativePath" or "process.env.CI_SSH_KEY_PASSPHRASE" deploy params.');
+    }
+
+    log('Clearing temporary dir on host side...\n');
+    await ssh.execCommand(`rm -Rf ${remotePaths.serverTempDirPath}`);
+
+    log('Transferring build package from local machine to host...\n');
+    await ssh.putFile(getLocalBuildPackagePath(c), remotePackagePath);
+
+    log('Unzipping transferred build package...\n');
+    await ssh.execCommand(`unzip ${remotePackagePath}`, { cwd: remotePaths.serverTempDirPath });
+
+    log('Removing transferred build package...\n');
+    await ssh.execCommand(`rm ${remotePackagePath}`);
+
+    log('Clearing docker dir on host side...\n');
+    await ssh.execCommand(`${dockerExecPrefix} rm -rf ${dockerAppDirPath}`);
+
+    const indexHtmlParentDirPath = `${dockerAppDirPath}/public`;
+
+    log('Creating requested path for build in docker...\n');
+    await ssh.execCommand(`${dockerExecPrefix} mkdir -p ${indexHtmlParentDirPath}`);
+
+    log('Copying unzipped build package from host to host\'s docker path...\n');
+    const sourcePath = `${remotePaths.serverTempDirPath}/.`;
+    const destPath = `${dockerContainerName}:${indexHtmlParentDirPath}`;
+    const cmd = `docker cp ${sourcePath} ${destPath}`;
+    await ssh.execCommand(cmd);
+
+    log('Clearing temporary dir on host side...\n');
+    await ssh.execCommand(`rm -Rf ${remotePaths.serverTempDirPath}`);
+
+    log(`\nThe build is deployed at ${getHbbTVDeployUrl(c)}\n`);
+    log('Deploy done.\n');
+};
+
+export {
+    deployHbbTV,
+    getHbbTVDeployUrl,
+};

package/engine/src/tasks/engineTasks.js

@@ -0,0 +1,23 @@
+import buildTask from './task.rnv.build';
+import configureTask from './task.rnv.configure';
+import deployTask from './task.rnv.deploy';
+import packageTask from './task.rnv.package';
+import startTask from './task.rnv.start';
+import projectConfigureTask from './task.rnv.project.configure';
+import configureSoftTask from './task.rnv.configureSoft';
+import hooksRunTask from './task.rnv.hooks.run';
+
+const engineTaskList = [
+    buildTask,
+    configureTask,
+    deployTask,
+    packageTask,
+    startTask,
+    projectConfigureTask,
+    configureSoftTask,
+    hooksRunTask,
+];
+
+export {
+    engineTaskList,
+};

package/engine/src/tasks/task.rnv.build.js

@@ -0,0 +1,126 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import { TaskManager, Constants, Logger, PlatformManager } from 'rnv';
+import { getConfigProp, getPlatformBuildDir, getPlatformProjectDir } from 'rnv/dist/core/common';
+import { enginePlatforms, enginePlatformList } from '../enginePlatforms';
+import { handlePlatformSdk, SDKTizen, SDKWebos, SDKWebpack } from '../sdks';
+import { resolveBuildVersion } from '../utils/resolveBuildVersion';
+
+const { logErrorPlatform } = PlatformManager;
+const { logTask } = Logger;
+const { buildWeb } = SDKWebpack;
+const { buildTizenProject } = SDKTizen;
+const { buildWebOSProject } = SDKWebos;
+const { executeOrSkipTask } = TaskManager;
+
+const { TASK_BUILD, TASK_PACKAGE, PARAMS } = Constants;
+
+const getPackageExtensionByPlatform = (platform = '') => {
+    switch (platform) {
+        case 'tizen':
+            return 'wgt';
+        case 'webos':
+            return 'ipk';
+        default:
+            return 'zip';
+    }
+};
+
+const getBuildVersionForFileName = (c) => {
+    const { platform, runtime } = c;
+    const { scheme, appId } = runtime;
+
+    switch (c.runtime.scheme) {
+        case 'dev:latest':
+            return 'latest.dev';
+        case 'rc:latest':
+            return 'latest.rc';
+        case 'release:latest':
+            return 'latest.release';
+        default:
+            return resolveBuildVersion({
+                platform,
+                scheme,
+                appConfigId: appId,
+            });
+    }
+};
+
+const makeBuildName = (c) => {
+    const platformName = c.platform;
+
+    const appNameInFileName = getConfigProp(c, platformName, 'appNameInFileName', '');
+    const buildVersion = getBuildVersionForFileName(c);
+    const appConfigId = c.runtime.appId || '';
+    const extension = getPackageExtensionByPlatform(platformName);
+
+    return `${appNameInFileName}_${platformName}_${buildVersion}_${appConfigId}.${extension}`;
+};
+
+const makeZipOutput = (c) => {
+    const platformBuildDir = getPlatformBuildDir(c);
+    const copiedProjectBuildDir = `${platformBuildDir}/build`;
+
+    const defaultZipFileName = `${c.platform}_${c.runtime.appId}.zip`;
+    const fileName = makeBuildName(c) || defaultZipFileName;
+
+    execSync(`cp -r ${getPlatformProjectDir(c)}/public ${copiedProjectBuildDir}`);
+    execSync(`rm -rf ${platformBuildDir}/output`);
+    execSync(`mkdir ${platformBuildDir}/output`);
+    execSync(`zip -r ../output/${fileName} *`, { cwd: copiedProjectBuildDir });
+    execSync(`rm -rf ${copiedProjectBuildDir}`);
+};
+
+const renameOutput = (c) => {
+    const packageOutputDirPath = `${c.runtime.appDir}/output`;
+    if (!fs.existsSync(packageOutputDirPath)) return;
+
+    const outputFilenameList = fs.readdirSync(packageOutputDirPath);
+    const packageFileName = outputFilenameList[0];
+    const newFilename = makeBuildName(c);
+
+    if (newFilename) {
+        const oldPath = `${packageOutputDirPath}/${packageFileName}`;
+        const newPath = `${packageOutputDirPath}/${newFilename}`;
+        fs.renameSync(oldPath, newPath);
+    }
+};
+
+export const taskRnvBuild = async (c, parentTask, originTask) => {
+    logTask('taskRnvBuild', `parent:${parentTask}`);
+    const { platform } = c;
+
+    c.runtime.forceBundleAssets = true;
+
+    await handlePlatformSdk(c); // handling SDKs here to reduce rnv messages and prompts
+    await executeOrSkipTask(c, TASK_PACKAGE, TASK_BUILD, originTask);
+
+    switch (platform) {
+        case enginePlatforms.ENTONE:
+        case enginePlatforms.HBBTV:
+        case enginePlatforms.WEBTV:
+            await buildWeb(c);
+            makeZipOutput(c);
+            return;
+        case enginePlatforms.TIZEN:
+            await buildTizenProject(c, platform);
+            renameOutput(c);
+            return;
+        case enginePlatforms.WEBOS:
+            await buildWebOSProject(c, platform);
+            renameOutput(c);
+            return;
+        default:
+            logErrorPlatform(c);
+    }
+};
+
+// keeping default export due to rnv
+// eslint-disable-next-line import/no-default-export
+export default {
+    description: 'Build project binary',
+    fn: taskRnvBuild,
+    task: 'build',
+    params: PARAMS.withBase(PARAMS.withConfigure()),
+    platforms: enginePlatformList,
+};

package/engine/src/tasks/task.rnv.configure.js

@@ -0,0 +1,52 @@
+import { TaskManager, Constants, Logger, PlatformManager } from 'rnv';
+import { generateSvgSpriteMap } from '@24i/smartapps-bigscreen-icon/hooks/generateSvgSpritemap';
+import { enginePlatformList, enginePlatforms } from '../enginePlatforms';
+import { SDKTizen, SDKWebos, SDKWebpack } from '../sdks';
+
+const { logErrorPlatform, copySharedPlatforms } = PlatformManager;
+const { logTask } = Logger;
+const { TASK_PLATFORM_CONFIGURE, TASK_CONFIGURE, PARAMS } = Constants;
+const { configureWebProject } = SDKWebpack;
+const { configureTizenProject } = SDKTizen;
+const { configureWebOSProject } = SDKWebos;
+const { executeTask } = TaskManager;
+
+export const taskRnvConfigure = async (c, parentTask, originTask) => {
+    logTask('taskRnvConfigure');
+
+    await executeTask(c, TASK_PLATFORM_CONFIGURE, TASK_CONFIGURE, originTask);
+    await copySharedPlatforms(c);
+
+    const generateSvgSpriteMapHook = generateSvgSpriteMap({
+        iconsFolder: '/icons', // relative to project path
+        cssOutput: '../../platformAssets/runtime/icons.css', // relative to build dir path
+        jsonOutput: '/icons.json', // relative to platformAssets dir
+        maskList: c.buildConfig?.common?.svgIconsMaskList || [],
+    });
+    await generateSvgSpriteMapHook(c);
+
+    if (c.program.only && !!parentTask) return true;
+
+    switch (c.platform) {
+        case enginePlatforms.ENTONE:
+        case enginePlatforms.HBBTV:
+        case enginePlatforms.WEBTV:
+            return configureWebProject(c);
+        case enginePlatforms.TIZEN:
+            return configureTizenProject(c);
+        case enginePlatforms.WEBOS:
+            return configureWebOSProject(c);
+        default:
+            return logErrorPlatform(c);
+    }
+};
+
+// keeping default export due to rnv
+// eslint-disable-next-line import/no-default-export
+export default {
+    description: 'Configure current project',
+    fn: taskRnvConfigure,
+    task: 'configure',
+    params: PARAMS.withBase(PARAMS.withConfigure()),
+    platforms: enginePlatformList,
+};

package/engine/src/tasks/task.rnv.configureSoft.js

@@ -0,0 +1,31 @@
+import { logTask } from 'rnv/dist/core/systemManager/logger';
+import { isBuildSchemeSupported } from 'rnv/dist/core/configManager/schemeParser';
+import { isPlatformSupported } from 'rnv/dist/core/platformManager';
+import { configureRuntimeDefaults } from 'rnv/dist/core/runtimeManager';
+import { executeTask } from 'rnv/dist/core/taskManager';
+import { TASK_APP_CONFIGURE, TASK_CONFIGURE_SOFT, PARAMS } from 'rnv/dist/core/constants';
+import { checkSdk } from 'rnv/dist/core/sdkManager/installer';
+import { replaceRelevantStringsInConfig } from '../utils/replaceRelevantStringsInConfig';
+
+export const taskRnvConfigureSoft = async (c, parentTask, originTask) => {
+    logTask('taskRnvConfigureSoft');
+
+    await configureRuntimeDefaults(c);
+    await executeTask(c, TASK_APP_CONFIGURE, parentTask, originTask);
+    await isPlatformSupported(c);
+    await isBuildSchemeSupported(c);
+    await checkSdk(c);
+    await configureRuntimeDefaults(c);
+    replaceRelevantStringsInConfig(c);
+    return true;
+};
+
+// keeping default export due to rnv
+// eslint-disable-next-line import/no-default-export
+export default {
+    description: 'Configure system and project wothout recreating files (used for --only)',
+    fn: taskRnvConfigureSoft,
+    task: TASK_CONFIGURE_SOFT,
+    params: PARAMS.withBase(),
+    platforms: [],
+};

package/engine/src/tasks/task.rnv.deploy.js

@@ -0,0 +1,40 @@
+import { TaskManager, Constants, Logger, PlatformManager } from 'rnv';
+import { enginePlatformList, enginePlatforms } from '../enginePlatforms';
+import { deployToS3 } from './deploy/aswS3/deployS3';
+import { deployHbbTV } from './deploy/hbbtv/deployHbbtv';
+
+const { logErrorPlatform } = PlatformManager;
+const { logTask } = Logger;
+const { TASK_EXPORT, TASK_DEPLOY, PARAMS } = Constants;
+const { executeOrSkipTask } = TaskManager;
+
+export const taskRnvDeploy = async (c, parentTask, originTask) => {
+    logTask('taskRnvDeploy', `parent:${parentTask}`);
+
+    await executeOrSkipTask(c, TASK_EXPORT, TASK_DEPLOY, originTask);
+
+    switch (c.platform) {
+        case enginePlatforms.HBBTV:
+            await deployHbbTV(c);
+            await deployToS3(c);
+            return true;
+        case enginePlatforms.ENTONE:
+        case enginePlatforms.TIZEN:
+        case enginePlatforms.WEBOS:
+        case enginePlatforms.WEBTV:
+            return deployToS3(c);
+        default:
+            logErrorPlatform(c);
+            return false;
+    }
+};
+
+// keeping default export due to rnv
+// eslint-disable-next-line import/no-default-export
+export default {
+    description: 'Deploy the binary via selected deployment integration or build hook',
+    fn: taskRnvDeploy,
+    task: 'deploy',
+    params: PARAMS.withBase(PARAMS.withConfigure()),
+    platforms: enginePlatformList,
+};

package/engine/src/tasks/task.rnv.hooks.run.js

@@ -0,0 +1,61 @@
+import inquirer from 'inquirer';
+import { logTask, logInfo } from 'rnv/dist/core/systemManager/logger';
+import { buildHooks } from 'rnv/dist/core/projectManager/buildHooks';
+import { executeTask } from 'rnv/dist/core/taskManager';
+import { fsExistsSync } from 'rnv/dist/core/systemManager/fileutils';
+import {
+    TASK_HOOKS_RUN, TASK_PROJECT_CONFIGURE, PARAMS, PARAM_KEYS,
+} from 'rnv/dist/core/constants';
+
+export const taskRnvHooksRun = async (c, parentTask, originTask) => {
+    logTask('taskRnvHooksRun');
+
+    if (fsExistsSync(c.paths.project.config)) {
+        await executeTask(c, TASK_PROJECT_CONFIGURE, TASK_HOOKS_RUN, originTask);
+    } else {
+        logInfo('Your are running your buildHook outside of renative project');
+    }
+
+    await buildHooks(c);
+
+    if (!c.buildHooks) {
+        return Promise.reject(new Error('Build hooks have not been compiled properly!'));
+    }
+
+    let hookName = c.program?.exeMethod;
+    let showHookList = false;
+    if (!hookName || hookName === true) {
+        showHookList = true;
+    } else if (!c.buildHooks[hookName]) {
+        showHookList = true;
+    }
+
+    if (showHookList) {
+        const hooksList = Object.keys(c.buildHooks);
+
+        const { selectedHook } = await inquirer.prompt({
+            name: 'selectedHook',
+            type: 'list',
+            message: 'Pick an available hook:',
+            choices: hooksList
+        });
+        hookName = selectedHook;
+    }
+    await c.buildHooks[hookName](c);
+
+    return true;
+};
+
+// keeping default export due to rnv
+// eslint-disable-next-line import/no-default-export
+export default {
+    description: 'Run specific build hook',
+    fn: taskRnvHooksRun,
+    task: TASK_HOOKS_RUN,
+    params: PARAMS.withBase([PARAM_KEYS.exeMethod]),
+    platforms: [],
+    skipAppConfig: true,
+    skipPlatforms: true,
+    forceBuildHookRebuild: true,
+    isGlobalScope: true
+};

package/engine/src/tasks/task.rnv.package.js

@@ -0,0 +1,27 @@
+import { TaskManager, Constants, Logger } from 'rnv';
+import { getConfigProp } from 'rnv/dist/core/common';
+import { configureFilesystem } from 'rnv/dist/core/systemManager/fileutils';
+import { doResolve } from 'rnv/dist/core/systemManager/resolve';
+import { isSystemWin } from 'rnv/dist/core/systemManager/utils';
+import { enginePlatformList } from '../enginePlatforms';
+
+const { logTask } = Logger;
+const { TASK_PACKAGE, TASK_CONFIGURE, PARAMS } = Constants;
+const { executeOrSkipTask } = TaskManager;
+
+export const taskRnvPackage = async (c, parentTask, originTask) => {
+    logTask('taskRnvPackage', `parent:${parentTask}`);
+
+    configureFilesystem(getConfigProp, doResolve, isSystemWin); // rnv fix for initializeBuilder
+
+    await executeOrSkipTask(c, TASK_CONFIGURE, TASK_PACKAGE, originTask);
+    return true;
+};
+
+export default {
+    description: 'Package source files into bundle',
+    fn: taskRnvPackage,
+    task: 'package',
+    params: PARAMS.withBase(PARAMS.withConfigure()),
+    platforms: enginePlatformList,
+};