@webos-tools/cli 3.0.0

package/lib/pull.js

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const async = require('async'),
+    fs = require('fs'),
+    mkdirp = require('mkdirp'),
+    npmlog = require('npmlog'),
+    path = require('path'),
+    streamBuffers = require('stream-buffers'),
+    util = require('util'),
+    errHndl = require('./base/error-handler'),
+    novacom = require('./base/novacom'),
+    spinner = require('./util/spinner');
+
+(function() {
+    const log = npmlog;
+    log.heading = 'pull';
+    log.level = 'warn';
+
+    const pull = {
+        pull: function(srcPaths, dstPath, options, next, middleCb) {
+            if (typeof next !== 'function') {
+                throw errHndl.getErrMsg("MISSING_CALLBACK", "next", util.inspect(next));
+            }
+
+            const writeIsFile = new streamBuffers.WritableStreamBuffer(),
+                writeIsDir = new streamBuffers.WritableStreamBuffer(),
+                writeDirList = new streamBuffers.WritableStreamBuffer(),
+                writeFileList = new streamBuffers.WritableStreamBuffer();
+
+            let iCount = 0,
+                totalSize = 0,
+                timeStart = new Date().getTime(),
+                timeEnd = new Date().getTime(),
+                sourcePath = srcPaths,
+                destinationPath = dstPath,
+                stringArray = [];
+
+            String.prototype.replaceAll = function(token, newToken, ignoreCase) {
+                let str = this + "",
+                    i = -1;
+
+                if (typeof token === "string") {
+                    if (ignoreCase) {
+                        while((i = str.toLowerCase().indexOf(token, i >= 0 ? i + newToken.length : 0)) !== -1) {
+                            str = str.substring(0, i) + newToken + str.substring(i + token.length);
+                        }
+                    } else {
+                        return this.split(token).join(newToken);
+                    }
+                }
+                return str;
+            };
+
+            function _makeSession(next) {
+                if (options.session) {
+                    return next(null, options.session);
+                } else {
+                    const printTarget = true;
+                    options.session = new novacom.Session(options.device, printTarget, next);
+                }
+            }
+
+            function _transferFiles(session, next) {
+                log.verbose('pull#transferFiles()', 'sourcePath:' + sourcePath + ', destinationPath:'+ destinationPath);
+                try {
+                    const orginalSourcePath = sourcePath,
+                        dirIndex = sourcePath.length;
+
+                    sourcePath = sourcePath.replaceAll(" ","\\ ");
+                    let cmd = "[ -f " + sourcePath + " ] && echo 'f' || echo 'nf'";
+
+                    session.run(cmd, null, writeIsFile, null, function() {
+                        if (!options.silent) {
+                            spinner.start();
+                        }
+                        timeStart = new Date().getTime();
+                        if (writeIsFile.getContentsAsString() === 'f\n') {
+                            fs.exists(destinationPath, function(exists) {
+                                let stats;
+                                try {
+                                    stats = fs.lstatSync(destinationPath);
+                                    if (exists) {
+                                        if (stats.isDirectory()) {
+                                            destinationPath = path.resolve(destinationPath, path.basename(orginalSourcePath));
+                                        }
+                                    }
+                                } catch (err) {
+                                    return setImmediate(next, errHndl.getErrMsg(err));
+                                } 
+                                session.get(sourcePath, destinationPath, function(err) {
+                                    if (err) {
+                                        return setImmediate(next, err);
+                                    } else {
+                                        if (!options.ignore) {
+                                            spinner.stop();
+                                            middleCb("Pull: " + sourcePath + " -> " + destinationPath);
+                                        }
+                                        totalSize += stats.size;
+                                        iCount++;
+                                        setImmediate(next);
+                                    }
+                                });
+                            });
+                        } else {
+                            cmd = "[ -d " + sourcePath + " ] && echo 'd' || echo 'nd'";
+                            session.run(cmd, null, writeIsDir, null,  function() {
+                                function _copyAllFolders(next) {
+                                    cmd = "find " + sourcePath + " -type d -follow -print";
+                                    session.run(cmd, null, writeDirList, null, function() {
+                                        stringArray = writeDirList.getContentsAsString().split('\n');
+                                        async.eachSeries(stringArray, function(item, callback) {
+                                            const filepath = path.join(destinationPath, item.substring(dirIndex));
+                                            mkdirp(filepath, function(err) {
+                                                if (!options.ignore && path.resolve(filepath) !== destinationPath) {
+                                                    spinner.stop();
+                                                    middleCb("Pull: " + item + " -> " + filepath);
+                                                }
+                                                setImmediate(callback, err);
+                                            });
+                                        }, function(err) {
+                                               setImmediate(next, err);
+                                        });
+                                    });
+                                }
+
+                                function _copyAllFiles(next) {
+                                    cmd = "find " + sourcePath + " -type f -follow -print";
+                                    session.run(cmd, null, writeFileList, null, function() {
+                                        if (writeFileList.size() === 0) {
+                                            return setImmediate(next);
+                                        }
+
+                                        stringArray = writeFileList.getContentsAsString().split('\n');
+                                        stringArray.pop();
+                                        async.eachSeries(stringArray, function(item, callback) {
+                                            const filepath = path.join(destinationPath, item.substring(dirIndex));
+                                            session.get(item.replaceAll(" ","\\ "), filepath, function(err) {
+                                                if (err) {
+                                                    return setImmediate(next, err);
+                                                } else {
+                                                    if (!options.ignore) {
+                                                        spinner.stop();
+                                                        middleCb("Pull: " + item + " -> " + filepath);
+                                                    }
+                                                    iCount++;
+                                                    const stat = fs.lstatSync(filepath);
+                                                    totalSize += stat.size;
+                                                    setImmediate(callback);
+                                                }
+                                            });
+                                        }, function(err) {
+                                               setImmediate(next, err);
+                                        });
+                                    });
+                                }
+
+                                if (writeIsDir.getContentsAsString() === 'd\n') {
+                                    destinationPath = path.resolve(path.join(destinationPath, path.basename(sourcePath)));
+                                    try {
+                                        const stat = fs.lstatSync(destinationPath);
+                                        if (!stat.isDirectory()) {
+                                            return next(errHndl.getErrMsg("NOT_DIRTYPE_PATH", destinationPath));
+                                        }
+                                    } catch(e) {
+                                        if (e && e.code === 'ENOENT') {
+                                            mkdirp.sync(destinationPath);
+                                        } else {
+                                            return next(e);
+                                        }
+                                    }
+
+                                    if (!options.ignore) {
+                                        spinner.stop();
+                                        middleCb("Pull: " + sourcePath + " -> " + destinationPath);
+                                    }
+
+                                    async.waterfall([
+                                            _copyAllFolders,
+                                            _copyAllFiles
+                                    ], function(err, result) {
+                                           setImmediate(next, err, result);
+                                    });
+                                } else {
+                                    const err = errHndl.getErrMsg("NOT_EXIST_PATH", "SOURCE", sourcePath);
+                                    return setImmediate(next, err);
+                                }
+                            });
+                        }
+                    });
+                }
+                catch (err) {
+                    let error;
+                    if (err.code === 1) {
+                        error = errHndl.getErrMsg("INVALID_VALUE", "path", err);
+                    }
+                    finish(error);
+                }
+            }
+
+            function finish(err, result) {
+                log.silly("pull#finsish()", "err:", err, ", result:", result);
+                if (!err) {
+                    timeEnd = new Date().getTime();
+                    const timeDur = (timeEnd-timeStart)/1000;
+                    if (!options.silent) {
+                        spinner.stop();
+                        middleCb(iCount+" file(s) pulled");
+                        middleCb(Math.round((totalSize)/(1024*timeDur))+" KB/s ("+totalSize+" bytes in "+timeDur+"s)");
+                    }
+                    result = {msg:"Success"};
+                }
+                return next(err, result);
+            }
+
+            async.waterfall([
+                _makeSession,
+                _transferFiles
+            ], function(err, result) {
+                finish(err, result);
+            });
+        }
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = pull;
+    }
+}());

package/lib/pusher.js

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const async = require('async'),
+    fs = require('fs'),
+    log = require('npmlog'),
+    path = require('path'),
+    streamBuffers = require('stream-buffers'),
+    util = require('util'),
+    errHndl = require('./base/error-handler'),
+    novacom = require('./base/novacom'),
+    spinner = require('./util/spinner');
+
+(function() {
+    log.heading = 'push';
+    log.level = 'warn';
+
+    const TYPE = {
+        "FILE": 'f',
+        "DIR": 'd',
+        "NEW": 'n'
+    };
+
+    let copyfilesCount = 0,
+        totalSize = 0;
+
+    function Pusher() {}
+    module.exports = Pusher;
+
+    Pusher.prototype.push = function(srcPaths, dstPath, options, next, middleCb) {
+        copyfilesCount = 0, totalSize = 0;
+        /**
+            1 file : dest  => dest is a file or an existing directory.
+            N files : dest => dest should be an new or existing directory. (If directory is a file, error occurs.)
+            dir : dest => dest should be an new or existing directory. (If directory is a file, error occurs.)
+        */
+        log.verbose("pusher#push()", "srcPaths:", srcPaths, ", dstPath:", dstPath);
+        const startTime = new Date().getTime();
+        let curDstType, copyDstType;
+
+        async.waterfall([
+            function(next) {
+                if (options.session) {
+                    return next(null, options.session);
+                } else {
+                    const printTarget = true;
+                    options.session = new novacom.Session(options.device, printTarget, next);
+                }
+            },
+            function(session, next) {
+                getDestType(session, dstPath, function(err, type) {
+                    curDstType = type;
+                    if (!err && type === TYPE.FILE && srcPaths.length > 1) {
+                        err = errHndl.getErrMsg("EXISTING_FILETYPE_PATH");
+                    }
+                    next(err);
+                });
+            },
+            function(next) {
+                let dst;
+
+                spinner.start();
+                async.eachSeries(srcPaths, function(src, next) {
+                    async.waterfall([
+                        fs.lstat.bind(fs, src),
+                        function(srcStats, next) {
+                            dst = dstPath;
+                            if (srcStats.isFile() && srcPaths.length === 1) {
+                                if (curDstType === TYPE.DIR) {
+                                    dst = path.join(dstPath, path.basename(src));
+                                }
+                                copyDstType = TYPE.FILE;
+                            } else {
+                                copyDstType = curDstType;
+                            }
+                            next();
+                        },
+                        function(next) {
+                            copyFilesToDst(options.session, src, dst, copyDstType, options, middleCb, next);
+                        }
+                    ], function(err) {
+                        next(err);
+                    });
+                }, next);
+            }
+        ], function(err) {
+            const result = {};
+            spinner.stop();
+            if (!err) {
+                const durSecs = (new Date().getTime() - startTime) / 1000;
+                spinner.stop();
+                middleCb(copyfilesCount + " file(s) pushed");
+                middleCb(Math.round((totalSize)/(1024*durSecs)) + " KB/s (" + totalSize + " bytes in " + durSecs + "s)");
+
+                result.msg = "Success";
+            } else if (err.code && err.syscall) {
+                err = errHndl.getErrMsg(err);
+            }
+            next(err, result);
+        });
+    };
+
+    function copyFilesToDst(session, src, dst, dstType, options, middleCb, next) {
+        log.verbose("pusher#copyFilesToDir()","src:", src, ", dst:", dst);
+
+        const successMsg = function(_src, _dst, _size, _ignore) {
+            if (!_ignore) {
+                spinner.stop();
+                middleCb("Push:" + _src + " -> " + _dst);
+            }
+            copyfilesCount++;
+            totalSize += _size;
+        };
+
+        async.waterfall([
+            fs.lstat.bind(fs, src),
+            function(stats, next) {
+                if (stats.isDirectory()) {
+                    log.verbose("pusher#copyFilesToDir()", "src is a directory");
+                    if (dstType === TYPE.FILE) {
+                        return next(errHndl.getErrMsg("EXISTING_FILETYPE_PATH"));
+                    }
+
+                    const files = fs.readdirSync(src);
+                    dst = path.join(dst, path.basename(src));
+
+                    if (process.platform.indexOf('win') === 0) {
+                        dst = dst.replace(/\\/g, '/');
+                    }
+
+                    if (src.length !== 1 && !options.ignore) {
+                        spinner.stop();
+                        middleCb("Push:" + src + " -> " + dst);
+                    }
+
+                    mkDir(session, dst, function(err) {
+                        if (err) {
+                            return setImmediate(next, err);
+                        }
+
+                        async.forEach(files, function(file, next) {
+                            const nSrc = path.join(src, file);
+                            copyFilesToDst(session, nSrc, dst, TYPE.NEW, options, middleCb, function(copyError) {
+                                next(copyError);
+                            });
+                        }, function(error) {
+                            next(error);
+                        });
+                    });
+                } else {
+                    let dstFile;
+
+                    if (dstType === TYPE.FILE) {
+                        dstFile = dst;
+                        dst = path.join(dst, '..');
+                    } else {
+                        dstFile = path.join(dst, path.basename(src));
+                    }
+
+                    if (process.platform.indexOf('win') === 0) {
+                        dst = dst.replace(/\\/g, '/');
+                        dstFile = dstFile.replace(/\\/g, '/');
+                    }
+
+                    mkDir(session, dst, function(err) {
+                        log.verbose("pusher#copyFilesToDir()", "mkDir#dst:", dst, ", err:", err);
+                        session.put(src, dstFile, function(error) {
+                            if (!error) {
+                                successMsg(src, dstFile, stats.size, options.ignore);
+                            }
+                            next(error);
+                        });
+                    });
+                }
+            }
+        ], function(err) {
+            next(err);
+        });
+    }
+
+    function mkDir(session, dstPath, next) {
+        async.series([
+            session.run.bind(session, "/bin/mkdir -p " + dstPath, null, null, null)
+        ], function(err) {
+            if (err && err.code === 1) {
+                err = errHndl.getErrMsg("FAILED_CREATE_DIR");
+            }
+            next(err);
+        });
+    }
+
+    function getDestType(session, dstPath, next) {
+        const wStream = new streamBuffers.WritableStreamBuffer();
+        let cmdDstType = "[ -d %s ] && echo 'd' || ([ -f %s ] && echo 'f' || echo 'n')";
+
+        if (process.platform.indexOf('win') === 0) {
+            dstPath = dstPath.replace(/\\/g, '/');
+        }
+
+        cmdDstType = util.format(cmdDstType, dstPath, dstPath);
+        session.run(cmdDstType, null, wStream, null, function(err) {
+            const dstType = wStream.getContentsAsString().trim();
+            log.verbose("pusher#push()","destionation type:", dstType);
+            next(err, dstType);
+        });
+    }
+}());

package/lib/session.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2020-2024 LG Electronics Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const npmlog = require('npmlog'),
+    errHndl = require('./base/error-handler'),
+    luna = require('./base/luna');
+
+(function() {
+    const log = npmlog;
+    log.heading = 'session';
+    log.level = 'warn';
+
+    const session ={
+        log: log,
+        getSessionList: function(options, next) {
+            log.info("session#getSessionList()", "options.display:", options.display);
+            const target = options.session.getDevice(),
+                addr = target.lunaAddr.getSessionList,
+                param = {
+                    // luna param
+                    subscribe: false
+                };
+            let matchedSessionId = false;
+
+            luna.sendWithoutErrorHandle(options, addr, param, function(lineObj, next) {
+                const resultValue = lineObj;
+
+                // case of exist sessionManager(auto)
+                if (resultValue.returnValue) {
+                    if (!options.display) {
+                        options.display = 0;
+                    }
+
+                    // if sessionList is empty
+                    if (resultValue.sessionList.length === 0) {
+                        return next(errHndl.getErrMsg("SELECT_PROFILE"));
+                    }
+
+                    for (let i = 0; i < resultValue.sessionList.length; i++) {
+                        if (resultValue.sessionList[i].deviceSetInfo.displayId === undefined) {
+                            return next(errHndl.getErrMsg("NOT_EXIST_DISPLAY"));
+                        }
+                        // compare returned displayId with input display
+                        if (resultValue.sessionList[i].deviceSetInfo.displayId === Number(options.display)) {
+                            // case the same, is going to call session call
+                            options.sessionId = resultValue.sessionList[i].sessionId;
+                            options.sessionInsptPort = resultValue.sessionList[i].deviceSetInfo.port.inspectorWam;
+                            options.sessionCall = true;
+                            matchedSessionId = true;
+                            log.info("session#getSessionList()", "options.sessionId:", options.sessionId, ", options.sessionCall:", options.sessionCall);
+                        }
+                    }
+
+                    if (!matchedSessionId) {
+                        return next(errHndl.getErrMsg("INVALID_VALUE", "DISPLAY_ID", options.display));
+                    }
+                } else {
+                    log.verbose("session#getSessionList()", "Error:", resultValue.errorText);
+                    if (options.returnWithError) {
+                        return next(errHndl.getErrMsg("NOT_SUPPORT_SESSION"));
+                    }
+                }
+                next(null, {});
+            }, next);
+        }
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = session;
+    }
+}());