1236 lines
58 KiB
JavaScript
1236 lines
58 KiB
JavaScript
"use strict";
|
||
window.packageRoot = 'packages://hot-update-tools/';
|
||
|
||
var fs = require('fire-fs');
|
||
var path = require('fire-path');
|
||
var Electron = require('electron');
|
||
var { remote } = require('electron');
|
||
var CfgUtil = Editor.require('packages://hot-update-tools/core/CfgUtil.js');
|
||
var FileUtil = Editor.require('packages://hot-update-tools/core/FileUtil.js');
|
||
var Mail = Editor.require('packages://hot-update-tools/mail/Mail.js');
|
||
var OSS = Editor.require('packages://hot-update-tools/node_modules/ali-oss');
|
||
var CO = Editor.require('packages://hot-update-tools/node_modules/co');
|
||
|
||
Editor.Panel.extend({
|
||
style: fs.readFileSync(Editor.url('packages://hot-update-tools/panel/index.css', 'utf8')) + "",
|
||
template: fs.readFileSync(Editor.url('packages://hot-update-tools/panel/index.html', 'utf8')) + "",
|
||
$: {
|
||
logTextArea: '#logTextArea',
|
||
hotAddressSelect: '#hotAddressSelect',
|
||
testEnvSelect: '#testEnvSelect',
|
||
},
|
||
ready() {
|
||
let logCtrl = this.$logTextArea;
|
||
let logListScrollToBottom = function () {
|
||
setTimeout(function () {
|
||
logCtrl.scrollTop = logCtrl.scrollHeight;
|
||
}, 10);
|
||
};
|
||
|
||
|
||
let hotAddressSelectCtrl = this.$hotAddressSelect;
|
||
window.hotAddressSelectCtrl = hotAddressSelectCtrl;
|
||
|
||
function selectionLast(index) {
|
||
setTimeout(function () {
|
||
hotAddressSelectCtrl.selectedIndex = index;
|
||
}, 10);
|
||
}
|
||
|
||
function getSelectIp() {
|
||
let ip = hotAddressSelectCtrl.$select.value;
|
||
console.log(ip);
|
||
return ip;
|
||
}
|
||
|
||
|
||
// 初始化vue面板
|
||
window.plugin = new window.Vue({
|
||
el: this.shadowRoot,
|
||
created: function () {
|
||
this._initPluginCfg();
|
||
},
|
||
init: function () {
|
||
},
|
||
data: {
|
||
srcDirPath: "",
|
||
resDirPath: "",
|
||
projManifestPath: "",
|
||
verManifestPath: "",
|
||
|
||
version: "",
|
||
remoteServerVersion: "",// 远程服务器版本
|
||
isShowRemoteServerVersion: false,// 是否显示远程服务器版本号
|
||
genManifestDir: "",
|
||
serverRootDir: "",
|
||
resourceRootDir: "",
|
||
localServerPath: "",
|
||
logView: "",
|
||
|
||
copyProgress: 0,
|
||
totalNum: 0,// 操作文件总数
|
||
curNum: 0,// 当前操作的次数
|
||
|
||
serverVersion: "-",// 服务器版本
|
||
serverPackageUrl: "",
|
||
localGameVersion: "-",//游戏版本号
|
||
localGamePackageUrl: "",
|
||
localGameProjectManifest: "",
|
||
localGameVersionManifest: "",
|
||
localGameProjectManifestUrl: "",//assets的url
|
||
localGameVersionManifestUrl: "",//
|
||
|
||
// 测试环境逻辑变量
|
||
testEnvLocal: true,
|
||
testEnvALi: false,
|
||
testEnvEmail: false,// 发送邮件界面
|
||
testEnvSelect: 0,
|
||
|
||
// 热更资源服务器配置历史记录
|
||
isShowUseAddrBtn: false,
|
||
isShowDelAddrBtn: false,
|
||
hotAddressArray: [],
|
||
|
||
// 邮件逻辑变量
|
||
emailContent: "邮件内容!",
|
||
addMailPeople: "",
|
||
emailPeopleArray: [
|
||
"xu_yanfeng@126.com",
|
||
],
|
||
},
|
||
computed: {},
|
||
methods: {
|
||
//////////////////////////////////阿里云环境/////////////////////////////////////////////////////
|
||
onBtnClickAliTest() {
|
||
let client = new OSS({
|
||
region: 'oss-cn-beijing',
|
||
//云账号AccessKey有所有API访问权限，建议遵循阿里云安全最佳实践，部署在服务端使用RAM子账号或STS，部署在客户端使用STS。
|
||
accessKeyId: 'LTAIOxxDqJpJbzfy',
|
||
accessKeySecret: 'kZRbbX3nNtxWlx5XWsR8uRrJzj4X5C',
|
||
bucket: 'happycars'
|
||
});
|
||
CO(function* () {
|
||
client.useBucket('happycars');
|
||
// let ret = yield client.list();
|
||
// yield client.get('');
|
||
// for (let i = 0; i < ret.objects.length; i++) {
|
||
// let item = ret.objects[i];
|
||
// console.log(i + ": " + item.url);
|
||
// }
|
||
// console.log(ret);
|
||
function* listDir(dir) {
|
||
let list = yield client.list({
|
||
prefix: dir,
|
||
delimiter: '/'
|
||
});
|
||
list.prefixes.forEach(function (subDir) {
|
||
console.log("目录: " + subDir);
|
||
});
|
||
list.objects.forEach(function (obj) {
|
||
console.log("文件: " + obj.name);
|
||
});
|
||
}
|
||
|
||
yield listDir('hot');
|
||
}).catch(function (err) {
|
||
console.log(err);
|
||
})
|
||
},
|
||
//////////////////////////////////发送邮件/////////////////////////////////////////////////////
|
||
onBtnClickSendMail() {
|
||
// Editor.Ipc.sendToMain('hot-update-tools:test', 'Hello, this is simple panel');
|
||
Mail.sendMail(this.remoteServerVersion, this.emailContent, null, function () {
|
||
this._addLog("发送邮件完毕!");
|
||
}.bind(this));
|
||
},
|
||
onInputMailPeopleOver() {
|
||
if (this.isPeopleExist() === false) {
|
||
this.emailPeopleArray.push(this.addMailPeople);
|
||
}
|
||
},
|
||
isPeopleExist() {
|
||
console.log("isPeopleExist");
|
||
if (this.addMailPeople === null || this.addMailPeople === "") {
|
||
return false;
|
||
}
|
||
for (let i = 0; i < this.emailPeopleArray.length; i++) {
|
||
let itemPeople = this.emailPeopleArray[i];
|
||
if (itemPeople === this.addMailPeople) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
///////////////////////////////////////////////////////////////////////////////////////
|
||
// 测试
|
||
onTest() {
|
||
|
||
},
|
||
onBtnClickPackVersion() {
|
||
this._packageVersion();
|
||
},
|
||
// 打包目录
|
||
_packageDir(rootPath, zip) {
|
||
let dir = fs.readdirSync(rootPath);
|
||
for (let i = 0; i < dir.length; i++) {
|
||
let itemDir = dir[i];
|
||
let itemFullPath = path.join(rootPath, itemDir);
|
||
let stat = fs.statSync(itemFullPath);
|
||
if (stat.isFile()) {
|
||
zip.file(itemDir, fs.readFileSync(itemFullPath));
|
||
} else if (stat.isDirectory()) {
|
||
this._packageDir(itemFullPath, zip.folder(itemDir));
|
||
}
|
||
}
|
||
},
|
||
// 将当前版本打包
|
||
_packageVersion() {
|
||
this._addLog("[Pack] 开始打包版本 ...");
|
||
let JSZip = Editor.require("packages://hot-update-tools/node_modules/jszip");
|
||
let zip = new JSZip();
|
||
|
||
// 打包manifest文件
|
||
let version = path.join(this.genManifestDir, "version.manifest");
|
||
zip.file(`version.${this.version}.manifest`, fs.readFileSync(version));
|
||
let project = path.join(this.genManifestDir, "project.manifest");
|
||
zip.file("project.manifest", fs.readFileSync(project));
|
||
|
||
// 要打包的资源
|
||
let srcPath = path.join(this.resourceRootDir, "src");
|
||
this._packageDir(srcPath, zip.folder("src"));
|
||
|
||
let resPath = path.join(this.resourceRootDir, "remote");
|
||
this._packageDir(resPath, zip.folder("remote"));
|
||
|
||
// 打包的文件名
|
||
let versionData = fs.readFileSync(version, 'utf-8');
|
||
let versionJson = JSON.parse(versionData);
|
||
let versionStr = versionJson.version;// 版本
|
||
this._addLog("[Pack] 打包版本:" + versionStr);
|
||
if (versionStr !== this.version) {
|
||
this._addLog("[Pack] 打包版本和当前填写的版本不一致,出现异常,停止打包!");
|
||
return;
|
||
}
|
||
// 打包到目录,生成zip
|
||
versionStr = versionStr.replace('.', '_');
|
||
let zipName = "ver_" + versionStr + ".zip";
|
||
let zipDir = CfgUtil.getPackZipDir();
|
||
if (!fs.existsSync(zipDir)) {
|
||
fs.mkdirSync(zipDir);
|
||
}
|
||
let zipFilePath = path.join(zipDir, zipName);
|
||
if (fs.existsSync(zipFilePath)) {// 存在该版本的zip
|
||
fs.unlinkSync(zipFilePath);
|
||
this._addLog("[Pack] 发现该版本的zip, 已经删除!");
|
||
} else {
|
||
|
||
}
|
||
zip.generateNodeStream({ type: 'nodebuffer', streamFiles: true })
|
||
.pipe(fs.createWriteStream(zipFilePath))
|
||
.on('finish', function () {
|
||
this._addLog("[Pack] 打包成功: " + zipFilePath);
|
||
}.bind(this))
|
||
.on('error', function (event) {
|
||
this._addLog("[Pack] 打包失败:" + event.message);
|
||
}.bind(this));
|
||
},
|
||
onBuildFinished(time) {
|
||
// 当构建完成的时候,genTime和buildTime是一致的
|
||
console.log("hot - onBuildFinished");
|
||
CfgUtil.updateBuildTime(time);
|
||
},
|
||
onChangeSelectHotAddress(event) {
|
||
console.log("change");
|
||
this.isShowUseAddrBtn = true;
|
||
this.isShowDelAddrBtn = true;
|
||
this._updateShowUseAddrBtn();
|
||
},
|
||
_updateShowUseAddrBtn() {
|
||
let selectURL = window.hotAddressSelectCtrl.value;
|
||
if (this.serverRootDir === selectURL) {
|
||
this.isShowUseAddrBtn = false;
|
||
}
|
||
},
|
||
// 增加热更历史地址
|
||
_addHotAddress(addr) {
|
||
let isAddIn = true;
|
||
for (let i = 0; i < this.hotAddressArray.length; i++) {
|
||
let item = this.hotAddressArray[i];
|
||
if (item === addr) {
|
||
isAddIn = false;
|
||
break;
|
||
}
|
||
}
|
||
if (isAddIn) {
|
||
this.hotAddressArray.push(addr);
|
||
this._addLog("[HotAddress]历史记录添加成功:" + addr);
|
||
} else {
|
||
// this._addLog("[HotAddress]历史记录已经存在该地址: " + addr);
|
||
}
|
||
},
|
||
// 删除热更历史地址
|
||
onBtnClickDelSelectedHotAddress() {
|
||
let address = window.hotAddressSelectCtrl.value;
|
||
if (this.hotAddressArray.length > 0) {
|
||
let isDel = false;
|
||
for (let i = 0; i < this.hotAddressArray.length;) {
|
||
let item = this.hotAddressArray[i];
|
||
if (item === address) {
|
||
this.hotAddressArray.splice(i, 1);
|
||
isDel = true;
|
||
this._addLog("删除历史地址成功: " + item);
|
||
} else {
|
||
i++;
|
||
}
|
||
}
|
||
|
||
if (isDel) {
|
||
this.isShowDelAddrBtn = false;
|
||
this.isShowUseAddrBtn = false;
|
||
this._saveConfig();
|
||
}
|
||
} else {
|
||
this._addLog("历史地址已经为空");
|
||
}
|
||
},
|
||
onBtnClickUseSelectedHotAddress() {
|
||
let address = window.hotAddressSelectCtrl.value;
|
||
this.serverRootDir = address;
|
||
this.onInPutUrlOver();
|
||
this._updateShowUseAddrBtn();
|
||
},
|
||
_addLog(str) {
|
||
let time = new Date();
|
||
// this.logView = "[" + time.toLocaleString() + "]: " + str + "\n" + this.logView;
|
||
this.logView += "[" + time.toLocaleString() + "]: " + str + "\n";
|
||
logListScrollToBottom();
|
||
},
|
||
_getFileIsExist(path) {
|
||
try {
|
||
fs.accessSync(path, fs.F_OK);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
return true;
|
||
},
|
||
|
||
onCleanAPPCfg() {
|
||
CfgUtil.cleanConfig();
|
||
},
|
||
|
||
_saveConfig() {
|
||
let data = {
|
||
version: this.version,
|
||
serverRootDir: this.serverRootDir,
|
||
resourceRootDir: this.resourceRootDir,
|
||
genManifestDir: CfgUtil.getMainFestDir(),
|
||
|
||
localServerPath: this.localServerPath,
|
||
hotAddressArray: this.hotAddressArray,
|
||
};
|
||
CfgUtil.saveConfig(data);
|
||
},
|
||
_initPluginCfg() {
|
||
console.log("init cfg");
|
||
// manifest输出目录
|
||
this.genManifestDir = CfgUtil.getMainFestDir();
|
||
if (FileUtil.isFileExit(this.genManifestDir) === false) {
|
||
FileUtil.mkDir(this.genManifestDir);
|
||
}
|
||
|
||
|
||
// 用户自定义配置
|
||
CfgUtil.initCfg(function (data) {
|
||
if (data) {
|
||
this.version = data.version;
|
||
this.serverRootDir = data.serverRootDir;
|
||
this.resourceRootDir = data.resourceRootDir;
|
||
this.localServerPath = data.localServerPath;
|
||
this.hotAddressArray = data.hotAddressArray || [];
|
||
this._updateServerVersion();
|
||
this._getRemoteServerVersion();
|
||
} else {
|
||
this._saveConfig();
|
||
}
|
||
this._initResourceBuild();
|
||
this.initLocalGameVersion();
|
||
}.bind(this));
|
||
|
||
},
|
||
// 导入生成的manifest到游戏项目中
|
||
importManifestToGame() {
|
||
let projectFile = path.join(this.genManifestDir, "project.manifest");
|
||
let versionFile = path.join(this.genManifestDir, "version.manifest")
|
||
|
||
// let strArr = this.localGameProjectManifestUrl.split("project.manifest");
|
||
// let dir = strArr[0];
|
||
let dir = "db://assets";
|
||
Editor.assetdb.import([projectFile, versionFile], dir,
|
||
function (err, results) {
|
||
results.forEach(function (result) {
|
||
console.log(result.path);
|
||
// result.uuid
|
||
// result.parentUuid
|
||
// result.url
|
||
// result.path
|
||
// result.type
|
||
});
|
||
}.bind(this));
|
||
this.initLocalGameVersion();
|
||
|
||
|
||
// let spawn = require('child_process').spawn;
|
||
// let free = spawn('cmd', []);
|
||
// // 捕获标准输出并将其打印到控制台
|
||
// free.stdout.on('data', function (data) {
|
||
// console.log('standard output:\n' + data);
|
||
// });
|
||
//
|
||
// // 捕获标准错误输出并将其打印到控制台
|
||
// free.stderr.on('data', function (data) {
|
||
// console.log('standard error output:\n' + data);
|
||
// });
|
||
//
|
||
// // 注册子进程关闭事件
|
||
// free.on('exit', function (code, signal) {
|
||
// console.log('child process eixt ,exit:' + code);
|
||
// });
|
||
},
|
||
initLocalGameVersion() {
|
||
Editor.assetdb.queryAssets('db://assets/**\/*', "raw-asset", function (err, results) {
|
||
let versionCfg = "";
|
||
let projectCfg = "";
|
||
results.forEach(function (result) {
|
||
if (result.path.indexOf("version.manifest") !== -1) {
|
||
versionCfg = result.path;
|
||
this.localGameVersionManifestUrl = result.url;
|
||
} else if (result.path.indexOf("project.manifest") !== -1) {
|
||
projectCfg = result.path;
|
||
this.localGameProjectManifestUrl = result.url;
|
||
}
|
||
}.bind(this));
|
||
console.log("version: " + versionCfg);
|
||
console.log("project: " + projectCfg);
|
||
|
||
if (versionCfg.length === 0) {
|
||
this._addLog("项目中没有配置文件: version.manifest");
|
||
return;
|
||
}
|
||
if (projectCfg.length === 0) {
|
||
this._addLog("项目中没有配置文件: project.manifest");
|
||
return;
|
||
}
|
||
|
||
this.localGameVersionManifest = versionCfg;
|
||
this.localGameProjectManifest = projectCfg;
|
||
|
||
let verVersion = "";
|
||
let projVersion = "";
|
||
fs.readFile(versionCfg, 'utf-8', function (err, data) {
|
||
if (!err) {
|
||
let verData = JSON.parse(data);
|
||
verVersion = verData.version;
|
||
fs.readFile(projectCfg, 'utf-8', function (err, data) {
|
||
if (!err) {
|
||
let projectData = JSON.parse(data);
|
||
projVersion = projectData.version;
|
||
if (projVersion === verVersion) {
|
||
this.localGameVersion = projVersion;
|
||
this.localGamePackageUrl = projectData.packageUrl;
|
||
} else {
|
||
this._addLog("游戏中的 project.manifest 和 version.manifest 中的version字段值不一致,请检查配置文件");
|
||
}
|
||
} else {
|
||
// this.localGameVersion = "没有在项目中发现热更新文件";
|
||
this._addLog("读取项目中的配置文件失败: " + projectCfg);
|
||
}
|
||
}.bind(this))
|
||
} else {
|
||
this._addLog("读取项目中的配置文件失败: " + versionCfg);
|
||
}
|
||
}.bind(this))
|
||
}.bind(this));
|
||
/*
|
||
Editor.assetdb.deepQuery(function (err, results) {
|
||
results.forEach(function (result) {
|
||
if (result.type !== "folder" &&
|
||
result.type !== "texture" &&
|
||
result.type !== "sprite-frame" &&
|
||
result.type !== "javascript" &&
|
||
result.type !== "dragonbones-atlas" &&
|
||
result.type !== "prefab" &&
|
||
result.type !== "audio-clip" &&
|
||
result.type !== "animation-clip" &&
|
||
result.type !== "scene" &&
|
||
result.type !== "dragonbones" &&
|
||
result.type !== "particle" &&
|
||
result.type !== "label-atlas" &&
|
||
result.type !== "text" &&
|
||
result.type !== "" &&
|
||
result.type !== ""
|
||
) {
|
||
let fullName = result.name + result.extname;
|
||
console.log(result.type + " : " + fullName);
|
||
}
|
||
});
|
||
});
|
||
*/
|
||
},
|
||
// build目录
|
||
_initResourceBuild() {
|
||
if (this.resourceRootDir.length === 0) {
|
||
// Editor.Profile.load('profile://local/builder.json', (err, profile) => {
|
||
// if (!err) {
|
||
// console.log(profile);
|
||
// }
|
||
// });
|
||
// 没有填写resource目录,自动提示
|
||
let projectDir = path.join(Editor.assetdb.library, "../");
|
||
let buildCfg = path.join(projectDir, "local/builder.json");
|
||
if (FileUtil.isFileExit(buildCfg)) {
|
||
fs.readFile(buildCfg, 'utf-8', function (err, data) {
|
||
if (!err) {
|
||
let buildData = JSON.parse(data);
|
||
let buildDir = buildData.buildPath;
|
||
let buildFullDir = path.join(projectDir, buildDir);
|
||
let jsbDir = path.join(buildFullDir, "jsb-default");
|
||
this._checkResourceRootDir(jsbDir);
|
||
}
|
||
}.bind(this))
|
||
} else {
|
||
this._addLog("发现没有构建项目, 使用前请先构建项目!");
|
||
}
|
||
}
|
||
},
|
||
_checkResourceRootDir(jsbDir) {
|
||
if (FileUtil.isFileExit(jsbDir)) {
|
||
let srcPath = path.join(jsbDir, "src");
|
||
let resPath = path.join(jsbDir, "remote");
|
||
if (FileUtil.isFileExit(srcPath) === false) {
|
||
this._addLog("没有发现 " + srcPath + ", 请先构建项目.");
|
||
return false;
|
||
}
|
||
if (FileUtil.isFileExit(resPath) === false) {
|
||
this._addLog("没有发现 " + resPath + ", 请先构建项目.");
|
||
return false;
|
||
}
|
||
this.resourceRootDir = jsbDir;
|
||
return true;
|
||
} else {
|
||
this._addLog("没有发现 " + jsbDir + ", 请先构建项目.");
|
||
return false;
|
||
}
|
||
},
|
||
onClickGenCfg(event) {
|
||
// 检查是否需要构建项目
|
||
let times = CfgUtil.getBuildTimeGenTime();
|
||
let genTime = times.genTime;
|
||
let buildTime = times.buildTime;
|
||
if (genTime === buildTime) {// 构建完版本之后没有生成manifest文件
|
||
CfgUtil.updateGenTime(new Date().getTime(), this.version);// 更新生成时间
|
||
} else {
|
||
this._addLog("[生成] 你需要重新构建项目,因为上次构建已经和版本关联:" + CfgUtil.cfgData.genVersion);
|
||
return;
|
||
}
|
||
|
||
|
||
if (!this.version || this.version.length <= 0) {
|
||
this._addLog("[生成] 版本号未填写");
|
||
return;
|
||
}
|
||
if (!this.serverRootDir || this.serverRootDir.length <= 0) {
|
||
this._addLog("[生成] 服务器地址未填写");
|
||
return;
|
||
}
|
||
|
||
// 检查resource目录
|
||
if (this.resourceRootDir.length === 0) {
|
||
this._addLog("[生成] 请先指定 <build项目资源文件目录>");
|
||
return;
|
||
}
|
||
if (this._checkResourceRootDir(this.resourceRootDir) === false) {
|
||
return;
|
||
}
|
||
|
||
if (!this.genManifestDir || this.genManifestDir.length <= 0) {
|
||
this._addLog("[生成] manifest文件生成地址未填写");
|
||
return;
|
||
}
|
||
|
||
if (!fs.existsSync(this.genManifestDir)) {
|
||
this._addLog("[生成] manifest存储目录不存在: " + this.genManifestDir);
|
||
return;
|
||
}
|
||
|
||
this._saveConfig();
|
||
this._genVersion(this.version, this.serverRootDir, this.resourceRootDir, this.genManifestDir);
|
||
},
|
||
// serverUrl 必须以/结尾
|
||
// genManifestDir 建议在assets目录下
|
||
// buildResourceDir 默认为 build/jsb-default/
|
||
// -v 10.1.1 -u http://192.168.191.1//cocos/remote-assets/ -s build/jsb-default/ -d assets
|
||
_genVersion(version, serverUrl, buildResourceDir, genManifestDir) {
|
||
this._addLog("[Build] 开始生成manifest配置文件....");
|
||
let projectFile = "project.manifest";
|
||
let versionFile = "version.manifest";
|
||
let manifest = {
|
||
version: version,
|
||
packageUrl: serverUrl,
|
||
remoteManifestUrl: "",
|
||
remoteVersionUrl: "",
|
||
assets: {},
|
||
searchPaths: []
|
||
};
|
||
|
||
if (serverUrl[serverUrl.length - 1] === "/") {
|
||
manifest.remoteManifestUrl = serverUrl + projectFile;
|
||
manifest.remoteVersionUrl = serverUrl + versionFile;
|
||
} else {
|
||
manifest.remoteManifestUrl = serverUrl + "/" + projectFile;
|
||
manifest.remoteVersionUrl = serverUrl + "/" + versionFile;
|
||
}
|
||
let dest = genManifestDir;
|
||
let src = buildResourceDir;
|
||
|
||
let readDir = function (dir, obj) {
|
||
let stat = fs.statSync(dir);
|
||
if (!stat.isDirectory()) {
|
||
return;
|
||
}
|
||
let subpaths = fs.readdirSync(dir), subpath, size, md5, compressed, relative;
|
||
for (let i = 0; i < subpaths.length; ++i) {
|
||
if (subpaths[i][0] === '.') {
|
||
continue;
|
||
}
|
||
subpath = path.join(dir, subpaths[i]);
|
||
stat = fs.statSync(subpath);
|
||
if (stat.isDirectory()) {
|
||
readDir(subpath, obj);
|
||
}
|
||
else if (stat.isFile()) {
|
||
// Size in Bytes
|
||
size = stat['size'];
|
||
// let crypto = require('crypto');
|
||
md5 = require('crypto').createHash('md5').update(fs.readFileSync(subpath, 'binary')).digest('hex');
|
||
compressed = path.extname(subpath).toLowerCase() === '.zip';
|
||
|
||
relative = path.relative(src, subpath);
|
||
relative = relative.replace(/\\/g, '/');
|
||
relative = encodeURI(relative);
|
||
obj[relative] = {
|
||
'size': size,
|
||
'md5': md5
|
||
};
|
||
if (compressed) {
|
||
obj[relative].compressed = true;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
let mkdirSync = function (path) {
|
||
try {
|
||
fs.mkdirSync(path);
|
||
} catch (e) {
|
||
if (e.code !== 'EEXIST') throw e;
|
||
}
|
||
};
|
||
|
||
// Iterate res and src folder
|
||
readDir(path.join(src, 'src'), manifest.assets);
|
||
readDir(path.join(src, 'remote'), manifest.assets);
|
||
|
||
let destManifest = path.join(dest, 'project.manifest');
|
||
let destVersion = path.join(dest, 'version.manifest');
|
||
|
||
|
||
mkdirSync(dest);
|
||
|
||
// 生成project.manifest
|
||
fs.writeFileSync(destManifest, JSON.stringify(manifest));
|
||
this._addLog("[Build] 生成 project.manifest成功");
|
||
// 生成version.manifest
|
||
delete manifest.assets;
|
||
delete manifest.searchPaths;
|
||
fs.writeFileSync(destVersion, JSON.stringify(manifest));
|
||
this._addLog("[Build] 生成 version.manifest成功");
|
||
this._packageVersion();
|
||
},
|
||
// 选择物理server路径
|
||
onSelectLocalServerPath(event) {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择本地测试服务器目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
});
|
||
if (res !== -1) {
|
||
this.localServerPath = res[0];
|
||
this._saveConfig();
|
||
this._updateServerVersion();
|
||
}
|
||
},
|
||
// 拷贝文件到测试服务器
|
||
onCopyFileToLocalServer() {
|
||
// 检查要拷贝的目录情况
|
||
if (!fs.existsSync(this.localServerPath)) {
|
||
this._addLog("本地测试服务器目录不存在:" + this.localServerPath);
|
||
return;
|
||
}
|
||
|
||
// 检查资源目录
|
||
let srcPath = path.join(this.resourceRootDir, "src");
|
||
let resPath = path.join(this.resourceRootDir, "remote");
|
||
if (!fs.existsSync(this.resourceRootDir)) {
|
||
this._addLog("资源目录不存在: " + this.resourceRootDir + ", 请先构建项目");
|
||
return;
|
||
} else {
|
||
if (!fs.existsSync(srcPath)) {
|
||
this._addLog(this.resourceRootDir + "不存在src目录, 无法拷贝文件");
|
||
return;
|
||
}
|
||
if (!fs.existsSync(resPath)) {
|
||
this._addLog(this.resourceRootDir + "不存在res目录, 无法拷贝文件");
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 检查manifest文件
|
||
let project = path.join(this.genManifestDir, "project.manifest");
|
||
let version = path.join(this.genManifestDir, "version.manifest");
|
||
if (!this.genManifestDir || this.genManifestDir.length <= 0) {
|
||
this._addLog("manifest文件生成地址未填写");
|
||
return;
|
||
} else {
|
||
if (!this._getFileIsExist(project)) {
|
||
this._addLog(project + "不存在, 请点击生成配置");
|
||
return;
|
||
}
|
||
if (!this._getFileIsExist(version)) {
|
||
this._addLog(version + "不存在, 请点击生成配置");
|
||
return;
|
||
}
|
||
}
|
||
this._addLog("[部署] 开始拷贝文件到:" + this.localServerPath);
|
||
this.curNum = 0;
|
||
this.copyProgress = 0;
|
||
|
||
//删除老文件
|
||
this._addLog("[部署] 删除目录路径: " + this.localServerPath);
|
||
let delNum = this._getFileNum(this.localServerPath);
|
||
this._addLog("[部署] 删除文件个数:" + delNum);
|
||
this._delDir(this.localServerPath);
|
||
|
||
|
||
this.totalNum = this._getTotalCopyFileNum();
|
||
this._addLog("[部署] 复制文件个数:" + this.totalNum);
|
||
|
||
this._copySourceDirToDesDir(srcPath, path.join(this.localServerPath, "src"));
|
||
this._copySourceDirToDesDir(resPath, path.join(this.localServerPath, "remote"));
|
||
this._copyFileToDesDir(project, this.localServerPath);
|
||
this._copyFileToDesDir(version, this.localServerPath);
|
||
},
|
||
|
||
// 获取要操作的文件总数量
|
||
_getTotalCopyFileNum() {
|
||
// let delNum = this._getFileNum(this.localServerPath);
|
||
let srcNum = this._getFileNum(path.join(this.resourceRootDir, "src"));
|
||
let resNum = this._getFileNum(path.join(this.resourceRootDir, "remote"));
|
||
return srcNum + resNum + 2 + 2;// 2个manifest,2个目录(src, res)
|
||
},
|
||
|
||
addProgress() {
|
||
this.curNum++;
|
||
let p = this.curNum / this.totalNum;
|
||
p = p ? p : 0;
|
||
// console.log("进度: " + p * 100);
|
||
this.copyProgress = p * 100;
|
||
if (p >= 1) {
|
||
this._addLog("[部署] 部署到指定目录成功:" + this.localServerPath);
|
||
this._updateServerVersion();
|
||
}
|
||
},
|
||
// 刷新服务器版本号
|
||
refreshLocalServerVersion() {
|
||
this._updateServerVersion();
|
||
},
|
||
_updateServerVersion() {
|
||
if (this.localServerPath.length > 0) {
|
||
let path = require("fire-path");
|
||
let fs = require("fire-fs");
|
||
let versionCfg = path.join(this.localServerPath, "version.manifest");
|
||
fs.readFile(versionCfg, 'utf-8', function (err, data) {
|
||
if (!err) {
|
||
let cfg = JSON.parse(data);
|
||
this.serverVersion = cfg.version;
|
||
this.serverPackageUrl = cfg.packageUrl;
|
||
} else {
|
||
let projectCfg = path.join(this.localServerPath, "project.manifest");
|
||
fs.readFile(projectCfg, 'utf-8', function (err, data) {
|
||
if (!err) {
|
||
let projectCfg = JSON.parse(data);
|
||
this.serverVersion = projectCfg.version;
|
||
this.serverPackageUrl = projectCfg.packageUrl;
|
||
} else {
|
||
this._addLog("无法获取到本地测试服务器版本号");
|
||
}
|
||
}.bind(this));
|
||
}
|
||
}.bind(this));
|
||
} else {
|
||
this._addLog("请选择本机server物理路径");
|
||
}
|
||
},
|
||
// 获取文件个数
|
||
_getFileNum(url) {
|
||
let i = 0;
|
||
let lookDir = function (fileUrl) {
|
||
let files = fs.readdirSync(fileUrl);//读取该文件夹
|
||
for (let k in files) {
|
||
i++;
|
||
let filePath = path.join(fileUrl, files[k]);
|
||
let stats = fs.statSync(filePath);
|
||
if (stats.isDirectory()) {
|
||
lookDir(filePath);
|
||
}
|
||
}
|
||
};
|
||
lookDir(url);
|
||
return i;
|
||
},
|
||
_delDir(rootFile) {
|
||
let self = this;
|
||
//删除所有的文件(将所有文件夹置空)
|
||
let emptyDir = function (fileUrl) {
|
||
let files = fs.readdirSync(fileUrl);//读取该文件夹
|
||
for (let k in files) {
|
||
let filePath = path.join(fileUrl, files[k]);
|
||
let stats = fs.statSync(filePath);
|
||
if (stats.isDirectory()) {
|
||
emptyDir(filePath);
|
||
} else {
|
||
fs.unlinkSync(filePath);
|
||
// self.addProgress();
|
||
// console.log("删除文件:" + filePath);
|
||
}
|
||
}
|
||
};
|
||
//删除所有的空文件夹
|
||
let rmEmptyDir = function (fileUrl) {
|
||
let files = fs.readdirSync(fileUrl);
|
||
if (files.length > 0) {
|
||
for (let k in files) {
|
||
let rmDir = path.join(fileUrl, files[k]);
|
||
rmEmptyDir(rmDir);
|
||
}
|
||
if (fileUrl !== rootFile) {// 不删除根目录
|
||
fs.rmdirSync(fileUrl);
|
||
// self.addProgress();
|
||
// console.log('删除空文件夹' + fileUrl);
|
||
}
|
||
} else {
|
||
if (fileUrl !== rootFile) {// 不删除根目录
|
||
fs.rmdirSync(fileUrl);
|
||
// self.addProgress();
|
||
// console.log('删除空文件夹' + fileUrl);
|
||
}
|
||
}
|
||
};
|
||
emptyDir(rootFile);
|
||
rmEmptyDir(rootFile);
|
||
},
|
||
// 拷贝文件到目录
|
||
_copyFileToDesDir(file, desDir) {
|
||
if (this._getFileIsExist(file)) {
|
||
let readable = fs.createReadStream(file);// 创建读取流
|
||
let copyFileName = path.basename(file);
|
||
let fileName = path.join(desDir, copyFileName);
|
||
let writable = fs.createWriteStream(fileName);// 创建写入流
|
||
readable.pipe(writable);// 通过管道来传输流
|
||
this.addProgress();
|
||
}
|
||
},
|
||
// 拷贝文件夹
|
||
_copySourceDirToDesDir(source, des) {
|
||
let self = this;
|
||
// 在复制目录前需要判断该目录是否存在，不存在需要先创建目录
|
||
let exists = function (src, dst, callback) {
|
||
fs.exists(dst, function (exists) {
|
||
// 已存在
|
||
if (exists) {
|
||
callback(src, dst);
|
||
}
|
||
// 不存在
|
||
else {
|
||
fs.mkdir(dst, function () {
|
||
self.addProgress();
|
||
callback(src, dst);
|
||
});
|
||
}
|
||
});
|
||
};
|
||
/*
|
||
* 复制目录中的所有文件包括子目录
|
||
* @param{ String } 需要复制的目录
|
||
* @param{ String } 复制到指定的目录
|
||
*/
|
||
let copy = function (src, dst) {
|
||
// 读取目录中的所有文件/目录
|
||
fs.readdir(src, function (err, paths) {
|
||
if (err) {
|
||
throw err;
|
||
}
|
||
paths.forEach(function (path) {
|
||
let _src = src + '/' + path,
|
||
_dst = dst + '/' + path,
|
||
readable, writable;
|
||
fs.stat(_src, function (err, st) {
|
||
if (err) {
|
||
throw err;
|
||
}
|
||
if (st.isFile()) {// 判断是否为文件
|
||
readable = fs.createReadStream(_src);// 创建读取流
|
||
writable = fs.createWriteStream(_dst);// 创建写入流
|
||
readable.pipe(writable);// 通过管道来传输流
|
||
// console.log("拷贝文件:" + _dst);
|
||
self.addProgress();
|
||
} else if (st.isDirectory()) {// 如果是目录则递归调用自身
|
||
exists(_src, _dst, copy);
|
||
}
|
||
});
|
||
});
|
||
});
|
||
};
|
||
// 复制目录
|
||
exists(source, des, copy);
|
||
},
|
||
_isVersionPass(newVersion, baseVersion) {
|
||
if (newVersion === undefined || newVersion === null ||
|
||
baseVersion === undefined || baseVersion === null) {
|
||
return false;
|
||
}
|
||
|
||
let arrayA = newVersion.split('.');
|
||
let arrayB = baseVersion.split('.');
|
||
let len = arrayA.length > arrayB.length ? arrayA.length : arrayB.length;
|
||
|
||
for (let i = 0; i < len; i++) {
|
||
let itemA = arrayA[i];
|
||
let itemB = arrayB[i];
|
||
|
||
// 新版本1.2 老版本 1.2.3
|
||
if (itemA === undefined && itemB !== undefined) {
|
||
return false;
|
||
}
|
||
|
||
// 新版本1.2.1, 老版本1.2
|
||
if (itemA !== undefined && itemB === undefined) {
|
||
return true;
|
||
}
|
||
|
||
if (itemA && itemB && parseInt(itemA) > parseInt(itemB)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
onInputVersionOver() {
|
||
let buildVersion = CfgUtil.cfgData.genVersion;
|
||
let buildTime = CfgUtil.cfgData.buildTime;
|
||
let genTime = CfgUtil.cfgData.genTime;// 生成manifest时间
|
||
|
||
let remoteVersion = this.remoteServerVersion;
|
||
if (remoteVersion !== null && remoteVersion !== undefined) {// 存在远程版本
|
||
if (this._isVersionPass(this.version, remoteVersion)) {
|
||
this._addLog("上次构建时版本号: " + buildVersion);
|
||
if (this._isVersionPass(this.version, buildVersion)) {// 上次构建版本和远程版本一致
|
||
this._addLog("版本通过验证!");
|
||
} else {
|
||
this._addLog("[Warning] 要构建的版本低于上次构建版本: " + this.version + "<=" + buildVersion);
|
||
}
|
||
} else {
|
||
this._addLog("[Warning] version 填写的版本低于远程版本");
|
||
}
|
||
|
||
|
||
} else {// 未发现远程版本
|
||
|
||
}
|
||
// let nowTime = new Date().getTime();
|
||
// if (nowTime !== buildTime) {
|
||
// if (genVersion === this.version) {
|
||
// this._addLog("版本一致,请构建项目");
|
||
// } else {
|
||
// }
|
||
// }
|
||
this._saveConfig();
|
||
},
|
||
onInPutUrlOver(event) {
|
||
let url = this.serverRootDir;
|
||
let index1 = url.indexOf("http://");
|
||
let index2 = url.indexOf("https://");
|
||
if (index1 === -1 && index2 === -1) {
|
||
let reg = /^([hH][tT]{2}[pP]:\/\/|[hH][tT]{2}[pP][sS]:\/\/)(([A-Za-z0-9-~]+)\.)+([A-Za-z0-9-~\/])+$/;
|
||
if (!reg.test(url)) {
|
||
this._addLog(url + " 不是以http://https://开头，或者不是网址, 已经自动修改");
|
||
this.serverRootDir = "http://" + this.serverRootDir;
|
||
this._getRemoteServerVersion();
|
||
}
|
||
} else {
|
||
// 更新服务器版本
|
||
this._getRemoteServerVersion();
|
||
}
|
||
this._addHotAddress(this.serverRootDir);
|
||
this._updateShowUseAddrBtn();
|
||
this._saveConfig();
|
||
},
|
||
// 获取远程资源服务器的版本号
|
||
_getRemoteServerVersion() {
|
||
if (this.serverRootDir.length <= 0) {
|
||
console.log("远程资源服务器URL错误: " + this.serverRootDir);
|
||
return;
|
||
}
|
||
// TODO 浏览器缓存会导致版本号获取失败
|
||
this.isShowRemoteServerVersion = false;
|
||
this.remoteServerVersion = null;
|
||
let versionUrl = this.serverRootDir + "/version.manifest";
|
||
|
||
let xhr = new XMLHttpRequest();
|
||
xhr.onreadystatechange = function () {
|
||
if (xhr.readyState === 4 && ((xhr.status >= 200 && xhr.status < 400))) {
|
||
let text = xhr.responseText;
|
||
// console.log("版本文件内容\n" + versionUrl + "\n" + text);
|
||
let json = null;
|
||
try {
|
||
json = JSON.parse(text);
|
||
} catch (e) {
|
||
console.log(e);
|
||
this._addLog("获取远程版本号失败!");
|
||
return;
|
||
}
|
||
this.isShowRemoteServerVersion = true;
|
||
this.remoteServerVersion = json.version;
|
||
} else if (xhr.status === 404) {
|
||
// console.log("404");
|
||
}
|
||
}.bind(this);
|
||
xhr.open('get', versionUrl, true);
|
||
xhr.setRequestHeader("If-Modified-Since", "0");// 不缓存
|
||
xhr.send();
|
||
},
|
||
onTestUrl() {
|
||
let url = this.serverRootDir;
|
||
if (url.length > 0) {
|
||
this._isUrlAvilable(url, function (code) {
|
||
this._addLog(url + " 响应: " + code);
|
||
}.bind(this));
|
||
} else {
|
||
this._addLog("请填写 [资源服务器url] ");
|
||
}
|
||
},
|
||
_isUrlAvilable(url, callback) {
|
||
let http = require("http");
|
||
try {
|
||
http.get(url, function (res) {
|
||
if (callback) {
|
||
callback(res.statusCode);
|
||
}
|
||
//let text;
|
||
//res.setEncoding('utf8');
|
||
//res.on('data', function (chunk) {
|
||
// text += chunk;
|
||
// console.log(text);
|
||
//});
|
||
}.bind(this));
|
||
} catch (e) {
|
||
callback(-1);
|
||
}
|
||
},
|
||
// 访问测试网站
|
||
onOpenUrl(event) {
|
||
let url = this.serverRootDir;
|
||
if (url.length > 0) {
|
||
Electron.shell.openExternal(url);
|
||
} else {
|
||
this._addLog("未填写参数");
|
||
}
|
||
},
|
||
userLocalIP() {
|
||
let ip = "";
|
||
let os = require('os');
|
||
let network = os.networkInterfaces();
|
||
for (let i = 0; i < network.WLAN.length; i++) {
|
||
let json = network.WLAN[i];
|
||
if (json.family === 'IPv4') {
|
||
ip = json.address;
|
||
}
|
||
}
|
||
console.log(ip);
|
||
if (ip.length > 0) {
|
||
this.serverRootDir = "http://" + ip;
|
||
this.onInPutUrlOver(null);
|
||
}
|
||
},
|
||
// 选择资源文件目录
|
||
onSelectSrcDir(event) {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择Src目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
callback: function (fileNames) {
|
||
|
||
},
|
||
});
|
||
if (res !== -1) {
|
||
this.srcDirPath = res[0];
|
||
this._saveConfig();
|
||
}
|
||
},
|
||
onSelectResDir() {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择Res目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
});
|
||
if (res !== -1) {
|
||
this.resDirPath = res[0];
|
||
this._saveConfig();
|
||
}
|
||
},
|
||
// 选择projManifest文件
|
||
onOpenResourceDir() {
|
||
if (!fs.existsSync(this.resourceRootDir)) {
|
||
this._addLog("目录不存在：" + this.resourceRootDir);
|
||
return;
|
||
}
|
||
Electron.shell.showItemInFolder(this.resourceRootDir);
|
||
Electron.shell.beep();
|
||
},
|
||
onOpenManifestDir() {
|
||
if (!fs.existsSync(this.genManifestDir)) {
|
||
this._addLog("目录不存在：" + this.genManifestDir);
|
||
return;
|
||
}
|
||
Electron.shell.showItemInFolder(this.genManifestDir);
|
||
Electron.shell.beep();
|
||
},
|
||
onOpenLocalServer() {
|
||
if (!fs.existsSync(this.genManifestDir)) {
|
||
this._addLog("目录不存在：" + this.localServerPath);
|
||
return;
|
||
}
|
||
Electron.shell.showItemInFolder(this.localServerPath);
|
||
Electron.shell.beep();
|
||
},
|
||
// 选择生成Manifest的目录
|
||
onSelectGenManifestDir() {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择生成Manifest目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
});
|
||
if (res !== -1) {
|
||
this.genManifestDir = res[0];
|
||
this._saveConfig();
|
||
}
|
||
},
|
||
onSelectGenServerRootDir() {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择部署的服务器根目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
});
|
||
if (res !== -1) {
|
||
this.serverRootDir = res[0];
|
||
this._saveConfig();
|
||
}
|
||
},
|
||
onSelectResourceRootDir() {
|
||
let res = Editor.Dialog.openFile({
|
||
title: "选择构建后的根目录",
|
||
defaultPath: Editor.projectInfo.path,
|
||
properties: ['openDirectory'],
|
||
});
|
||
if (res !== -1) {
|
||
let dir = res[0];
|
||
if (this._checkResourceRootDir(dir)) {
|
||
this.resourceRootDir = dir;
|
||
this._saveConfig();
|
||
}
|
||
}
|
||
},
|
||
onCleanSimRemoteRes() {
|
||
let path = require("fire-path");
|
||
let simPath = path.join(__dirname, "../cocos2d-x/simulator/win32");
|
||
let remoteAsset = path.join(simPath, "remote-asset");
|
||
if (!fs.existsSync(remoteAsset)) {
|
||
console.log(remoteAsset);
|
||
this._addLog("[清理热更缓存] 目录不存在: " + remoteAsset);
|
||
} else {
|
||
FileUtil.emptyDir(remoteAsset);
|
||
this._addLog("[清理热更缓存] 清空目录 " + remoteAsset + " 成功.");
|
||
}
|
||
},
|
||
onOpenLocalGameManifestDir() {
|
||
let strArr = this.localGameProjectManifest.split("project.manifest");
|
||
let dir = strArr[0];
|
||
|
||
if (!fs.existsSync(dir)) {
|
||
this._addLog("目录不存在：" + dir);
|
||
return;
|
||
}
|
||
Electron.shell.showItemInFolder(dir);
|
||
Electron.shell.beep();
|
||
},
|
||
onTestZip() {
|
||
let zip = require("node-native-zip");
|
||
},
|
||
//
|
||
onTestSelect() {
|
||
let ip = Math.random() * 100;
|
||
this.hotAddressArray.push(ip.toFixed(2));
|
||
selectionLast(this.hotAddressArray.length - 1);
|
||
},
|
||
onIpSelectChange(event) {
|
||
console.log("index:%d, text:%s, value:%s ", event.detail.index, event.detail.text, event.detail.value);
|
||
},
|
||
onLogIp() {
|
||
// getSelectIp();
|
||
Editor.Ipc.sendToMain('hot-update-tools:test', 'Hello, this is simple panel');
|
||
// let relativePath = path.relative(__dirname, path.join(Editor.projectInfo.path, 'assets'));
|
||
// console.log(relativePath);
|
||
},
|
||
onTestEnvChange(event) {
|
||
// let children = event.target.$select.children;
|
||
// for (let i = 0; i < children.length; i++) {
|
||
// let item = children[i];
|
||
// if (item.value === "0") {
|
||
// item.selected = true;
|
||
// } else {
|
||
// item.selected = false;
|
||
// }
|
||
// }
|
||
let selectValue = event.target.value;
|
||
this.testEnvALi = false;
|
||
this.testEnvLocal = false;
|
||
this.testEnvEmail = false;
|
||
if (selectValue === "0") {// 本地测试环境
|
||
this.testEnvLocal = true;
|
||
} else if (selectValue === "1") {//阿里云测试环境
|
||
this.testEnvALi = true;
|
||
} else if (selectValue === "2") {
|
||
this.testEnvEmail = true;
|
||
}
|
||
},
|
||
}
|
||
});
|
||
},
|
||
|
||
|
||
messages: {
|
||
'hot-update-tools:onBuildFinished'(event, time) {
|
||
window.plugin.onBuildFinished(time);
|
||
},
|
||
|
||
}
|
||
|
||
}); |