Xinwen Deng / aem-src

/*
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2016 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 */
/* eslint max-nested-callbacks: [2, 4]*/
/* globals Promise, FileReader */
define('screens/player/firmware/log/impl/logger-filesystem', [
    'underscore',
    'screens/player/shared/serviceadmin',
    'screens/player/firmware/platform/cordova-helper',
    'screens/player/firmware/log/logger',
    'screens/player/log/logger',
    'module'
], function(_, ServiceAdmin, CordovaHelper, LoggerInterface, Logger, mod) {
    'use strict';

    var DIRECTORY_NAME = 'logs';
    var FILE_NAME = 'error';
    var BROWSER_STORAGE_QUOTA = 50 * 1024 * 1024; // 50MB

    var DEFAULT_ROTATION = {
        filesize: 1024 * 1024 // 1MB
    };

    /**
     * instance of the Logger
     */
    var _logger;

    var _fileSystemReference;
    var _fileReference;
    var _directoryReference;

    var _rotationOptions;

    var _writeQueuePrevious = Promise.resolve();

    /**
     * The write function used for the logger
     *
     * @param {Date} date the date to write
     * @param {Logger.LEVEL} level the log level
     * @param {String} message the message to write
     * @returns {Promise} a promise that the message was written
     */
    function write(date, level, message) {

        function writeFn() {
            return createFileWriter(_fileReference)
                .then(function(fileWriter) {
                    // handle rotation options
                    if (_rotationOptions.filesize && fileWriter.length > _rotationOptions.filesize) {

                        return moveFile(_fileReference, _directoryReference, FILE_NAME + '-' + Date.now() + '.log')
                            .then(function() {
                                return getFile(_directoryReference, FILE_NAME + '.log');
                            })
                            .then(function(file) {
                                _fileReference = file;
                                return createFileWriter(file);
                            });
                    }
                    return Promise.resolve(fileWriter);
                })
                .then(function(fileWriter) {
                    fileWriter.seek(fileWriter.length);

                    var output = (new Date(date)).toISOString() + ' ';
                    output += '*' + Logger.LEVEL_MAP[level] + '* ';
                    output += '[' + date + '] ';
                    output += message + '\n';

                    var dataObj = new Blob([output], { type: 'text/plain' });

                    return writeFile(fileWriter, dataObj);
                });
        }

        // we ignore any kind of errors to not interupt the writing
        _writeQueuePrevious = _writeQueuePrevious.then(writeFn, writeFn);

        return _writeQueuePrevious;
    }

    /**
     * Get a FileSystem access
     * @returns {Promise} which resolves with a FileSystem object
     */
    function getFileSystemAccess() {
        return new Promise(function(resolve, reject) {
            var requestFs = window.requestFileSystem || window.webkitRequestFileSystem;

            requestFs(
                window.PERSISTENT,
                0,
                resolve,
                reject
            );
        });
    }

    /**
     * Requests a FileSystem quota. Some environments do not require this,
     * therefor we resolve without requesting
     * @returns {Promise} a promise that the quota was requested
     */
    function requestFileSystemQuota() {
        return new Promise(function(resolve, reject) {
            var storageInfoFn = window.storageInfo || window.webkitStorageInfo;

            // the environment does not need to request a quota
            if (!storageInfoFn || !storageInfoFn.requestQuota) {
                resolve();
                return;
            }

            storageInfoFn.requestQuota(
                window.PERSISTENT,
                BROWSER_STORAGE_QUOTA,
                resolve,
                reject
            );
        });
    }

    /**
     * Gets a file or creates one if not existent
     * @param {DirectoryEntry} directory the parent directory
     * @param {String} filename the file name
     * @returns {Promise} which resolves to a FileEntry
     */
    function getFile(directory, filename) {
        return new Promise(function(resolve, reject) {
            directory.getFile(filename, {
                create: true
            }, resolve, reject);
        });
    }

    /**
     * Gets a directory or creates one if not existent
     * @param {FileSystem} fileSystem the file system
     * @param {String} directoryName the directory name
     * @returns {Promise} which resolves to a DirectoryEntry
     */
    function getDirectory(fileSystem, directoryName) {
        return new Promise(function(resolve, reject) {
            fileSystem.getDirectory(directoryName,
                { create: true },
                resolve,
                reject);
        });
    }

    /**
     * Reads a file as text
     * @param {FileEntry} fileEntry The file entry
     * @returns {Promise} which resolves with a string containing the file content
     */
    function readFile(fileEntry) {
        return new Promise(function(resolve, reject) {
            fileEntry.file(function(file) {
                var reader = new FileReader();

                reader.onloadend = function(ev) {
                    if (ev.target.readyState === FileReader.DONE) {
                        resolve(ev.target.result);
                    }
                };

                reader.readAsText(file);
            }, reject);
        });
    }

    /**
     * Reads the list of files in a directory
     * @param {DirectoryEntry} directoryEntry The directory entry
     * @returns {Promise} which resolves to an array
     */
    function readDirectory(directoryEntry) {
        return new Promise(function(resolve, reject) {
            var directoryReader = directoryEntry.createReader();

            directoryReader.readEntries(resolve, reject);

        });
    }

    /**
     * Removes a file
     * @param {FileEntry} fileEntry The file entry
     * @returns {Promise} a promise that the file was removed
     */
    function removeFile(fileEntry) {
        return new Promise(function(resolve, reject) {
            fileEntry.remove(resolve, reject);
        });
    }

    /**
     * Moves an existing file to a new location
     * @param {FileEntry} fileEntry The file entry
     * @param {DirectoryEntry} directoryEntry The new directory to move to
     * @param {string} newFileName The new file name
     * @returns {Promise} a promise that the file was moved
     */
    function moveFile(fileEntry, directoryEntry, newFileName) {
        return new Promise(function(resolve, reject) {
            fileEntry.moveTo(directoryEntry, newFileName, resolve, reject);
        });
    }

    /**
     * Creates a file writer
     * @param {FileEntry} fileEntry The file entry
     * @returns {Promise} which resolves to a FileWriter
     */
    function createFileWriter(fileEntry) {
        return new Promise(function(resolve, reject) {
            fileEntry.createWriter(resolve, reject);
        });
    }

    /**
     * Writes data to a filewriter
     * @param {FileWriter} fileWriter The file writer
     * @param {Blob} dataObj The data to write
     * @returns {Promise} a promise that the data was written
     */
    function writeFile(fileWriter, dataObj) {
        return new Promise(function(resolve, reject) {
            fileWriter.onwriteend = function(e) {
                resolve();
            };

            fileWriter.onerror = function(e) {
                reject(e.toString());
            };

            fileWriter.write(dataObj);
        });
    }

    /**
     * Preferences service that loads the preferences via the "AppPreferences" cordova plugin.
     *
     * @class LoggerFileSystem
     * @implements {Logger}
     */
    var LoggerFileSystem = _.extend({}, LoggerInterface, {

        serviceId: mod.id,

        serviceRanking: 10,

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        activate: function() {
            // Cordova will set window.requestFileSystem and chrome supports window.webkitRequestFileSystem
            if (!window.cordova && !window.requestFileSystem && !window.webkitRequestFileSystem) {
                return Promise.reject('No FileSystem API available.');
            }

            // Wait for the 'deviceready' event on cordova, otherwise window.requestFileSystem is not available
            // TODO: create a proper SPI for this
            var promise = window.cordova ? CordovaHelper.ready() : Promise.resolve();

            _rotationOptions = DEFAULT_ROTATION;

            return promise
                .then(requestFileSystemQuota)
                .then(getFileSystemAccess)
                .then(function(fileSystem) {
                    _fileSystemReference = fileSystem;

                    return Promise.resolve(_fileSystemReference);
                })
                .then(function(filesystem) {
                    return getDirectory(filesystem.root, DIRECTORY_NAME);
                })
                .then(function(directory) {
                    _directoryReference = directory;
                    return getFile(directory, FILE_NAME + '.log');
                })
                .then(function(file) {
                    _fileReference = file;
                    return Promise.resolve(file);
                })
                .then(function() {
                    // configure logger
                    _logger = new Logger('firmware', {
                        write: write
                    });
                    _logger.print();
                    Logger.catchExceptions(_logger);
                    Logger.patchConsole(_logger);
                });
        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        deactivate: function() {
            _fileSystemReference = _fileReference = _directoryReference = null;
            Logger.catchExceptions(false);
            Logger.patchConsole(false);

            return Promise.resolve();
        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        getWriter: function() {
            return _logger;
        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        listLogs: function() {
            return new Promise(function(resolve, reject) {
                readDirectory(_directoryReference).then(function(files) {
                    var ret = [];
                    for (var i = 0; i < files.length; i++) {
                        if (files[i].isFile) {
                            ret.push(files[i].name);
                        }
                    }
                    resolve(ret);
                }, reject);
            });

        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        setDefaultLogRotation: function(options) {
            _rotationOptions = options;
        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        getLogBlob: function(name) {
            return getFile(_directoryReference, name)
                .then(readFile)
                .then(function(result) {
                    var dataObj = new Blob([result], { type: 'text/plain' });
                    return Promise.resolve(dataObj);
                });
        },

        /**
         * @memberof LoggerFileSystem
         * @inheritdoc
         */
        pruneLogs: function(name) {
            function deleteFile(fileName) {
                return function() {
                    return new Promise(function(resolve, reject) {
                        getFile(_directoryReference, fileName)
                            .then(removeFile, reject)
                            .then(resolve)
                            .catch(reject);
                    });
                };
            }

            var files = name ? Promise.resolve([].concat(name)) : this.listLogs();

            return files
                .then(function(toBeDeleted) {
                    var promiseFnArr = [];
                    for (var i = 0; i < toBeDeleted.length; i++) {
                        promiseFnArr.push(deleteFile(toBeDeleted[i]));
                    }
                    return Promise.resolve(promiseFnArr);
                })
                .then(function(promiseFnArr) {
                    return promiseFnArr.reduce(function(prev, cur) {
                        console.log(prev, cur);
                        return prev.then(cur);
                    }, Promise.resolve());
                });
        }
    });

    return LoggerFileSystem;
});

/* istanbul ignore next */
require([
    'screens/player/firmware/log/impl/logger-filesystem',
    'screens/player/shared/serviceadmin'
], function(Service, ServiceAdmin) {
    'use strict';
    ServiceAdmin.register(Service);
});