/// <summary>
/// Initializes a new instance of the <see cref="DeploySettings" /> class.
/// </summary>
public DeploySettings()
{
_PublishUrl = "";
_AgentType = RemoteAgent.None;
_NTLM = null;
_AllowUntrusted = true;
_ComputerName = "localhost";
_Port = DeployUtils.DefaultPort;
_SiteName = "";
_Username = "";
_Password = "";
_TraceLevel = TraceLevel.Info;
_Delete = true;
_WhatIf = false;
_UseChecksum = false;
_SourcePath = null;
_DestinationPath = null;
_ParametersFilePath = null;
_Parameters = new Dictionary <string, string>();
_DeploymentSkipRules = new List <SkipRule>();
_UseAppOffline = false;
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
#if DEBUG
//if (args.Contains("--launch-debugger"))
// Debugger.Launch();
#endif
string url = string.Empty;
string id = string.Empty;
for (int i = 0; i < args.Length; i++)
{
var item = args[i];
if (item == "-url")
{
url = args[i + 1];
}
else if (item == "-id")
{
id = args[i + 1];
}
else
{
continue;
}
}
RemoteAgent.Regist(id, url);
Console.WriteLine("#" + id + " agent ready.");
Console.Read();
}
public static DeploySettings UseAgentType(this DeploySettings settings, RemoteAgent agentType)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
settings.AgentType = agentType;
return(settings);
}
public CfgDefLoader(RemoteAgent agent) : base(agent)
{
RegisterRootDefineHandler("service", AddService);
RegisterRootDefineHandler("group", AddGroup);
RegisterModuleDefineHandler("table", AddTable);
IsBeanFieldMustDefineId = false;
}
/// <summary>
/// Sets the type of remote agent to connect to
/// </summary>
/// <param name="settings">The publish settings.</param>
/// <param name="agentType">The type of remote agent</param>
/// <returns>The same <see cref="DeploySettings"/> instance so that multiple calls can be chained.</returns>
public static DeploySettings UseAgentType(this DeploySettings settings, RemoteAgent agentType)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
settings.AgentType = agentType;
return settings;
}
public RemoteRubyMiniTestExecutionHandler(AutomationJob job2Run, string rootResultPath)
{
Project project = AutomationJob.GetProjectOfJobByJobId(job2Run.JobId);
this.RootResultPath = rootResultPath;
this.Job2Run = job2Run;
this.environment = TestEnvironment.GetEnvironmentById(job2Run.TestAgentEnvironmentId.Value);
this.vcsRootPath = project.VCSRootPath;
this.remote = GetRemoteTestAgent(this.environment);
this.executionCommand = GetExecutionCommand(job2Run);
}
protected CommonDefLoader(RemoteAgent agent)
{
Agent = agent;
_rootDefineHandlers.Add("topmodule", SetTopModule);
_moduleDefineHandlers.Add("module", AddModule);
_moduleDefineHandlers.Add("const", AddConst);
_moduleDefineHandlers.Add("enum", AddEnum);
_moduleDefineHandlers.Add("bean", AddBean);
}
public RemoteAgent GetRemoteTestAgent(TestEnvironment environment)
{
TestEnvironmentConfigHelper config = new TestEnvironmentConfigHelper(environment.Config);
string domainAdmin = config.SUTConfiguration.SUTDomainConfig.Adminstrator;
string domainAdminPassword = config.SUTConfiguration.SUTDomainConfig.Password;
RemoteAgent r = new RemoteAgent();
foreach (Machine m in config.SUTConfiguration.Machines)
{
if (m.Roles.FindAll(role => role.Key == Core.AgentType.RemoteAgent).Count() > 0)
{
r.Admin = string.IsNullOrEmpty(m.Administrator) ? domainAdmin : m.Administrator;
r.Password = string.IsNullOrEmpty(m.Password) ? domainAdminPassword : m.Password;
r.Server = m.ExternalIP;
return r;
}
}
return null;
}
public PublishSettings()
{
_PublishUrl = "";
_AgentType = RemoteAgent.None;
_NTLM = null;
_AllowUntrusted = true;
_ComputerName = "localhost";
_Port = DeployUtils.DefaultPort;
_SiteName = "";
_Username = "";
_Password = "";
_TraceLevel = TraceLevel.Info;
_Delete = true;
_WhatIf = false;
_SourcePath = null;
_DestinationPath = null;
}
private async Task LoadCfgDataAsync(RemoteAgent agent, DefAssembly ass, string dataDir, bool exportTestData)
{
var ctx = agent;
List <DefTable> exportTables = ass.Types.Values.Where(t => t is DefTable ct && ct.NeedExport).Select(t => (DefTable)t).ToList();
var genDataTasks = new List <Task>();
var outputDataFiles = new ConcurrentBag <FileInfo>();
long genDataStartTime = TimeUtil.NowMillis;
foreach (DefTable c in exportTables)
{
genDataTasks.Add(Task.Run(async() =>
{
long beginTime = TimeUtil.NowMillis;
await LoadTableAsync(agent, c, dataDir, exportTestData);
long endTime = TimeUtil.NowMillis;
if (endTime - beginTime > 100)
{
ctx.Info("====== load {0} cost {1} ms ======", c.FullName, (endTime - beginTime));
}
}));
}
await Task.WhenAll(genDataTasks.ToArray());
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string outputCodeDir = args.OutputCodeDir;
timer.StartPhase("build defines");
var loader = new DbDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
var ass = new DefAssembly();
ass.Load(rawDefines, agent, args);
List <DefTypeBase> exportTypes = ass.GetExportTypes();
var tasks = new List <Task>();
var genCodeFiles = new ConcurrentBag <FileInfo>();
var genScatteredFiles = new ConcurrentBag <FileInfo>();
var genType = args.GenType;
switch (genType)
{
case "cs":
{
ass.CurrentLanguage = ELanguage.CS;
var render = new AsyncCsRender();
foreach (var c in ass.Types.Values)
{
tasks.Add(Task.Run(() =>
{
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), Common.ELanguage.CS);
var file = RenderFileUtil.GetDefTypePath(c.FullName, Common.ELanguage.CS);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
}
tasks.Add(Task.Run(() =>
{
var module = ass.TopModule;
var name = "Tables";
var content = FileHeaderUtil.ConcatAutoGenerationHeader(
render.RenderTables(name, module,
ass.Types.Values.Where(t => t is DefTable).Select(t => (DefTable)t).ToList()),
Common.ELanguage.CS);
var file = RenderFileUtil.GetDefTypePath(name, Common.ELanguage.CS);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
case "typescript":
{
ass.CurrentLanguage = ELanguage.TYPESCRIPT;
var render = new TypescriptRender();
var brightRequirePath = args.TypescriptBrightRequirePath;
var brightPackageName = args.TypescriptBrightPackageName;
tasks.Add(Task.Run(() =>
{
var fileContent = new List <string>();
fileContent.Add(TypescriptStringTemplate.GetByteBufImports(brightRequirePath, brightPackageName));
fileContent.Add(TypescriptStringTemplate.GetSerializeImports(brightRequirePath, brightPackageName));
fileContent.Add(TypescriptStringTemplate.GetProtocolImports(brightRequirePath, brightPackageName));
fileContent.Add(TypescriptStringTemplate.GetVectorImports(brightRequirePath, brightPackageName));
if (!string.IsNullOrEmpty(brightRequirePath))
{
fileContent.Add($"import {{FieldLogger, FieldLoggerGeneric1, FieldLoggerGeneric2}} from '{brightRequirePath}/transaction/FieldLogger'");
fileContent.Add($"import TxnBeanBase from '{brightRequirePath}/transaction/TxnBeanBase'");
fileContent.Add($"import {{TxnTable, TxnTableGeneric}} from '{brightRequirePath}/transaction/TxnTable'");
fileContent.Add($"import TransactionContext from '{brightRequirePath}/transaction/TransactionContext'");
fileContent.Add($"import {{FieldTag}} from '{brightRequirePath}/serialization/FieldTag'");
fileContent.Add($"import TKey from '{brightRequirePath}/storage/TKey'");
fileContent.Add($"import PList from '{brightRequirePath}/transaction/collections/PList'");
fileContent.Add($"import PList1 from '{brightRequirePath}/transaction/collections/PList1'");
fileContent.Add($"import PList2 from '{brightRequirePath}/transaction/collections/PList2'");
fileContent.Add($"import PSet from '{brightRequirePath}/transaction/collections/PSet'");
fileContent.Add($"import PMap from '{brightRequirePath}/transaction/collections/PMap'");
fileContent.Add($"import PMap1 from '{brightRequirePath}/transaction/collections/PMap1'");
fileContent.Add($"import PMap2 from '{brightRequirePath}/transaction/collections/PMap2'");
fileContent.Add($"import SerializeFactory from '{brightRequirePath}/serialization/SerializeFactory'");
}
else
{
fileContent.Add($"import {{FieldLogger, FieldLoggerGeneric1, FieldLoggerGeneric2}} from '{brightPackageName}'");
fileContent.Add($"import {{TxnBeanBase}} from '{brightPackageName}'");
fileContent.Add($"import {{TxnTable, TxnTableGeneric}} from '{brightPackageName}'");
fileContent.Add($"import {{TransactionContext}} from '{brightPackageName}'");
fileContent.Add($"import {{FieldTag}} from '{brightPackageName}'");
fileContent.Add($"import {{TKey}} from '{brightPackageName}'");
fileContent.Add($"import {{PList}} from '{brightPackageName}'");
fileContent.Add($"import {{PList1}} from '{brightPackageName}'");
fileContent.Add($"import {{PList2}} from '{brightPackageName}'");
fileContent.Add($"import {{PSet}} from '{brightPackageName}'");
fileContent.Add($"import {{PMap}} from '{brightPackageName}'");
fileContent.Add($"import {{PMap1}} from '{brightPackageName}'");
fileContent.Add($"import {{PMap2}} from '{brightPackageName}'");
fileContent.Add($"import {{SerializeFactory}} from '{brightPackageName}'");
}
fileContent.Add($"export namespace {ass.TopModule} {{");
foreach (var type in exportTypes)
{
fileContent.Add(render.RenderAny(type));
}
var tables = ass.Types.Values.Where(t => t is DefTable).Select(t => (DefTable)t).ToList();
fileContent.Add(render.RenderTables("Tables", ass.TopModule, tables));
fileContent.Add("}"); // end of topmodule
var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.TYPESCRIPT);
var file = "Types.ts";
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
default:
{
throw new NotSupportedException($"not support gen type:{genType}");
}
}
await Task.WhenAll(tasks.ToArray());
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFiles.ToList()
});
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = $"{e.Message} \n {e.StackTrace}";
}
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
public void Load(Defines defines, RemoteAgent agent, GenArgs args)
{
LoadCommon(defines, agent, args);
foreach (var e in defines.Enums)
{
AddType(new DefEnum(e));
}
foreach (var b in defines.Beans)
{
AddType(new DefBean(b));
}
foreach (var p in defines.Protos)
{
AddType(new DefProto(p));
}
foreach (var r in defines.Rpcs)
{
AddType(new DefRpc(r));
}
foreach (var type in Types.Values)
{
type.AssemblyBase = this;
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("precompile type:{0} begin", type.FullName);
type.PreCompile();
s_logger.Trace("precompile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("precompile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("compile type:{0} begin", type.FullName);
type.Compile();
s_logger.Trace("compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("compile type:{0} error", type.FullName);
s_logger.Error("compile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("post compile type:{0} begin", type.FullName);
type.PostCompile();
s_logger.Trace("post compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("post compile type:{0} error", type.FullName);
s_logger.Error("post compile type:{0} error", type.FullName);
throw;
}
}
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string outputCodeDir = args.OutputCodeDir;
timer.StartPhase("build defines");
var loader = new DbDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
var ass = new DefAssembly();
ass.Load(rawDefines, agent);
List <DefTypeBase> exportTypes = ass.GetExportTypes();
var tasks = new List <Task>();
var genCodeFiles = new ConcurrentBag <FileInfo>();
var genType = args.GenType;
switch (genType)
{
case "cs":
{
var render = new SyncCsRender();
foreach (var c in ass.Types.Values)
{
tasks.Add(Task.Run(() =>
{
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), Common.ELanguage.CS);
var file = RenderFileUtil.GetDefTypePath(c.FullName, Common.ELanguage.CS);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
}
tasks.Add(Task.Run(() =>
{
var module = ass.TopModule;
var name = "Tables";
var content = FileHeaderUtil.ConcatAutoGenerationHeader(
render.RenderTables(name, module,
ass.Types.Values.Where(t => t is DefTable).Select(t => (DefTable)t).ToList()),
Common.ELanguage.CS);
var file = RenderFileUtil.GetDefTypePath(name, Common.ELanguage.CS);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
default:
{
throw new NotSupportedException($"not support gen type:{genType}");
}
}
await Task.WhenAll(tasks.ToArray());
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFiles.ToList()
});
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = $"{e.Message} \n {e.StackTrace}";
}
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string outputCodeDir = args.OutputCodeDir;
timer.StartPhase("build defines");
var loader = new ProtoDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
var ass = new DefAssembly();
ass.Load(rawDefines, agent, args);
var targetService = args.Service;
List <DefTypeBase> exportTypes = ass.GetExportTypes();
var tasks = new List <Task>();
var genCodeFiles = new ConcurrentBag <FileInfo>();
var genScatteredFiles = new ConcurrentBag <FileInfo>();
var genType = args.GenType;
var render = RenderFactory.CreateRender(genType);
if (render == null)
{
throw new NotSupportedException($"not support gen type:{genType}");
}
ass.CurrentLanguage = RenderFileUtil.GetLanguage(genType);
render.Render(new GenContext()
{
GenArgs = args,
Assembly = ass,
Lan = ass.CurrentLanguage,
GenType = genType,
Render = render,
Tasks = tasks,
ExportTypes = exportTypes,
GenCodeFilesInOutputCodeDir = genCodeFiles,
GenScatteredFiles = genScatteredFiles,
});
await Task.WhenAll(tasks.ToArray());
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFiles.ToList()
});
res.ScatteredFiles.AddRange(genScatteredFiles);
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = ExceptionUtil.ExtractMessage(e);
res.StackTrace = e.StackTrace;
}
DefAssemblyBase.LocalAssebmly = null;
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
public ProtoDefLoader(RemoteAgent agent) : base(agent)
{
RegisterRootDefineHandler("service", AddService);
RegisterModuleDefineHandler("proto", AddProto);
RegisterModuleDefineHandler("rpc", AddRpc);
}
public DbDefLoader(RemoteAgent agent) : base(agent)
{
RegisterModuleDefineHandler("table", AddTable);
}
public void Load(Defines defines, RemoteAgent agent)
{
this.Agent = agent;
TopModule = defines.TopModule;
foreach (var c in defines.Consts)
{
AddType(new DefConst(c));
}
foreach (var e in defines.Enums)
{
AddType(new DefEnum(e));
}
foreach (var b in defines.Beans)
{
AddType(new DefBean(b));
}
foreach (var p in defines.DbTables)
{
AddType(new DefTable(p));
}
foreach (var type in Types.Values)
{
type.AssemblyBase = this;
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("precompile type:{0} begin", type.FullName);
type.PreCompile();
s_logger.Trace("precompile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("precompile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("compile type:{0} begin", type.FullName);
type.Compile();
s_logger.Trace("compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("compile type:{0} error", type.FullName);
s_logger.Error("compile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("post compile type:{0} begin", type.FullName);
type.PostCompile();
s_logger.Trace("post compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("post compile type:{0} error", type.FullName);
s_logger.Error("post compile type:{0} error", type.FullName);
throw;
}
}
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string inputDataDir = args.InputDataDir;
string outputCodeDir = args.OutputCodeDir;
string outputDataDir = args.OutputDataDir;
var genTypes = args.GenType.Split(',').Select(s => s.Trim()).ToList();
timer.StartPhase("build defines");
var loader = new CfgDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
await loader.LoadDefinesFromFileAsync(inputDataDir);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
TimeZoneInfo timeZoneInfo = string.IsNullOrEmpty(args.L10nTimeZone) ? null : TimeZoneInfo.FindSystemTimeZoneById(args.L10nTimeZone);
var excludeTags = args.OutputExcludeTags.Split(',').Select(t => t.Trim().ToLowerInvariant()).Where(t => !string.IsNullOrEmpty(t)).ToList();
var ass = new DefAssembly(args.L10nPatchName, timeZoneInfo, excludeTags, agent);
ass.Load(rawDefines, agent, args);
List <DefTable> exportTables = ass.GetExportTables();
List <DefTypeBase> exportTypes = ass.GetExportTypes();
bool hasLoadCfgData = false;
bool needL10NTextConvert = !string.IsNullOrWhiteSpace(args.L10nInputTextTableFiles);
async Task CheckLoadCfgDataAsync()
{
if (!hasLoadCfgData)
{
hasLoadCfgData = true;
var timer = new ProfileTimer();
timer.StartPhase("load config data");
await DataLoaderUtil.LoadCfgDataAsync(agent, ass, args.InputDataDir, args.L10nPatchName, args.L10nPatchInputDataDir, args.InputConvertDataDir);
timer.EndPhaseAndLog();
if (needL10NTextConvert)
{
ass.InitL10n(args.L10nTextValueFieldName);
await DataLoaderUtil.LoadTextTablesAsync(agent, ass, ".", args.L10nInputTextTableFiles);
}
timer.StartPhase("validate");
var validateCtx = new ValidatorContext(ass, args.ValidateRootDir);
await validateCtx.ValidateTables(ass.GetAllTables());
timer.EndPhaseAndLog();
}
}
var tasks = new List <Task>();
var genCodeFilesInOutputCodeDir = new ConcurrentBag <FileInfo>();
var genDataFilesInOutputDataDir = new ConcurrentBag <FileInfo>();
var genScatteredFiles = new ConcurrentBag <FileInfo>();
foreach (var genType in genTypes)
{
var ctx = new GenContext()
{
GenType = genType,
Assembly = ass,
GenArgs = args,
ExportTypes = exportTypes,
ExportTables = exportTables,
GenCodeFilesInOutputCodeDir = genCodeFilesInOutputCodeDir,
GenDataFilesInOutputDataDir = genDataFilesInOutputDataDir,
GenScatteredFiles = genScatteredFiles,
Tasks = tasks,
DataLoader = CheckLoadCfgDataAsync,
};
GenContext.Ctx = ctx;
var render = RenderFactory.CreateRender(genType);
if (render == null)
{
throw new Exception($"unknown gentype:{genType}");
}
if (render is DataRenderBase)
{
await CheckLoadCfgDataAsync();
}
render.Render(ctx);
GenContext.Ctx = null;
}
await Task.WhenAll(tasks.ToArray());
if (needL10NTextConvert)
{
var notConvertTextList = DataExporterUtil.GenNotConvertTextList(ass.NotConvertTextSet);
var md5 = FileUtil.CalcMD5(notConvertTextList);
string outputNotConvertTextFile = args.L10nOutputNotTranslatedTextFile;
CacheManager.Ins.AddCache(outputNotConvertTextFile, md5, notConvertTextList);
genScatteredFiles.Add(new FileInfo()
{
FilePath = outputNotConvertTextFile, MD5 = md5
});
}
if (!genCodeFilesInOutputCodeDir.IsEmpty)
{
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFilesInOutputCodeDir.ToList()
});
}
if (!genDataFilesInOutputDataDir.IsEmpty)
{
res.FileGroups.Add(new FileGroup()
{
Dir = outputDataDir, Files = genDataFilesInOutputDataDir.ToList()
});
}
if (!genScatteredFiles.IsEmpty)
{
res.ScatteredFiles.AddRange(genScatteredFiles);
}
}
catch (DataCreateException e)
{
res.ErrCode = Luban.Common.EErrorCode.DATA_PARSE_ERROR;
res.ErrMsg = $@"
=======================================================================
解析失败!
文件: {e.OriginDataLocation}
错误位置: {e.DataLocationInFile}
Err: {e.OriginErrorMsg}
字段: {e.VariableFullPathStr}
=======================================================================
";
res.StackTrace = e.OriginStackTrace;
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = $@"
=======================================================================
{ExceptionUtil.ExtractMessage(e)}
=======================================================================
";
res.StackTrace = e.StackTrace;
}
DefAssemblyBase.LocalAssebmly = null;
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
public void Load(string outputService, Defines defines, RemoteAgent agent)
{
this.Agent = agent;
SupportDatetimeType = true;
TopModule = defines.TopModule;
CfgTargetService = defines.Services.Find(s => s.Name == outputService);
if (CfgTargetService == null)
{
throw new ArgumentException($"service:{outputService} not exists");
}
foreach (var c in defines.Consts)
{
AddType(new DefConst(c));
}
foreach (var e in defines.Enums)
{
AddType(new DefEnum(e));
}
foreach (var b in defines.Beans)
{
AddType(new DefBean((CfgBean)b));
}
foreach (var p in defines.Tables)
{
var table = new DefTable(p);
AddType(table);
AddCfgTable(table);
}
_cfgServices.AddRange(defines.Services);
foreach (var type in Types.Values)
{
type.AssemblyBase = this;
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("precompile type:{0} begin", type.FullName);
type.PreCompile();
s_logger.Trace("precompile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("precompile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("compile type:{0} begin", type.FullName);
type.Compile();
s_logger.Trace("compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("compile type:{0} error", type.FullName);
s_logger.Error("compile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("post compile type:{0} begin", type.FullName);
type.PostCompile();
s_logger.Trace("post compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("post compile type:{0} error", type.FullName);
s_logger.Error("post compile type:{0} error", type.FullName);
throw;
}
}
// 丑陋. 怎么写更好？
// 递归 设置DefBean及DefField 的 IsMultiRow
var multiRowBeans = new HashSet <DefBean>();
for (bool anyMark = true; anyMark;)
{
anyMark = false;
foreach (var type in this.Types.Values)
{
if (type is DefBean beanType && !beanType.IsMultiRow)
{
bool isMultiRows;
if (beanType.IsNotAbstractType)
{
isMultiRows = beanType.HierarchyFields.Any(f => ((DefField)f).ComputeIsMultiRow());
}
else
{
isMultiRows = beanType.HierarchyNotAbstractChildren.Any(c => ((DefBean)c).IsMultiRow);
}
if (isMultiRows)
{
beanType.IsMultiRow = true;
//s_logger.Info("bean:{bean} is multi row", beanType.FullName);
anyMark = true;
}
}
}
}
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string inputDataDir = args.InputDataDir;
string outputCodeDir = args.OutputCodeDir;
string outputDataDir = args.OutputDataDir;
var genTypes = args.GenType.Split(',').Select(s => s.Trim()).ToList();
timer.StartPhase("build defines");
var loader = new CfgDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
TimeZoneInfo timeZoneInfo = string.IsNullOrEmpty(args.TimeZone) ? TimeZoneInfo.Local : TimeZoneInfo.FindSystemTimeZoneById(args.TimeZone);
var ass = new DefAssembly(timeZoneInfo);
ass.Load(args.Service, rawDefines, agent);
var targetService = ass.CfgTargetService;
List <DefTable> exportTables = ass.GetExportTables();
List <DefTypeBase> exportTypes = ass.GetExportTypes();
bool hasLoadCfgData = false;
async Task CheckLoadCfgDataAsync()
{
if (!hasLoadCfgData)
{
hasLoadCfgData = true;
var timer = new ProfileTimer();
timer.StartPhase("load config data");
await LoadCfgDataAsync(agent, ass, args.InputDataDir, args.ExportTestData);
timer.EndPhaseAndLog();
timer.StartPhase("validate");
var validateCtx = new ValidatorContext(ass, args.ValidateRootDir);
await validateCtx.ValidateTables(exportTables);
timer.EndPhaseAndLog();
}
}
var tasks = new List <Task>();
var genCodeFiles = new ConcurrentBag <FileInfo>();
var genDataFiles = new ConcurrentBag <FileInfo>();
foreach (var genType in genTypes)
{
switch (genType)
{
case "code_cs_bin":
case "code_cs_json":
case "code_java_bin":
{
ICodeRender render = CreateCodeRender(genType);
ELanguage lan = GetLanguage(genType);
foreach (var c in exportTypes)
{
tasks.Add(Task.Run(() =>
{
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), lan);
var file = RenderFileUtil.GetDefTypePath(c.FullName, lan);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
}
tasks.Add(Task.Run(() =>
{
var module = ass.TopModule;
var name = targetService.Manager;
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderService(name, module, exportTables), lan);
var file = RenderFileUtil.GetDefTypePath(name, lan);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
case "code_lua_bin":
{
tasks.Add(Task.Run(() =>
{
var render = new LuaRender();
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAll(ass.Types.Values.ToList()), ELanguage.LUA);
var file = "Types.lua";
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
case "code_go_bin":
{
var render = new GoCodeRender();
foreach (var c in exportTypes)
{
tasks.Add(Task.Run(() =>
{
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.GO);
var file = RenderFileUtil.GetDefTypePath(c.FullName, ELanguage.GO);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
}
tasks.Add(Task.Run(() =>
{
var module = ass.TopModule;
var name = targetService.Manager;
var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderService(name, module, exportTables), ELanguage.GO);
var file = RenderFileUtil.GetDefTypePath(name, ELanguage.GO);
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
break;
}
case "code_cpp_bin":
{
var render = new CppBinCodeRender();
// 将所有 头文件定义 生成到一个文件
// 按照 const,enum,bean,table, service 的顺序生成
tasks.Add(Task.Run(() =>
{
var headerFileContent = new List <string>
{
@$ "
#pragma once
#include <functional>
#include " "bright/serialization/ByteBuf.h" "
#include " "bright/CfgBean.hpp" "
using ByteBuf = bright::serialization::ByteBuf;
namespace {ass.TopModule}
{{
"
};
foreach (var type in exportTypes)
{
if (type is DefEnum e)
{
headerFileContent.Add(render.Render(e));
}
}
foreach (var type in exportTypes)
{
if (type is DefConst c)
{
headerFileContent.Add(render.Render(c));
}
}
foreach (var type in exportTypes)
{
if (type is DefBean e)
{
headerFileContent.Add(render.RenderForwardDefine(e));
}
}
foreach (var type in exportTypes)
{
if (type is DefBean e)
{
headerFileContent.Add(render.Render(e));
}
}
foreach (var type in exportTables)
{
headerFileContent.Add(render.Render(type));
}
headerFileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));
headerFileContent.Add("}"); // end of topmodule
var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', headerFileContent), ELanguage.CPP);
var file = "gen_types.h";
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
var beanTypes = exportTypes.Where(c => c is DefBean).ToList();
int TYPE_PER_STUB_FILE = 100;
for (int i = 0, n = (beanTypes.Count + TYPE_PER_STUB_FILE - 1) / TYPE_PER_STUB_FILE; i < n; i++)
{
int index = i;
tasks.Add(Task.Run(() =>
{
int startIndex = index * TYPE_PER_STUB_FILE;
var content = FileHeaderUtil.ConcatAutoGenerationHeader(
render.RenderStub(ass.TopModule, beanTypes.GetRange(startIndex, Math.Min(TYPE_PER_STUB_FILE, beanTypes.Count - startIndex))),
ELanguage.CPP);
var file = $"gen_stub_{index}.cpp";
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
}
break;
}
case "code_typescript_json":
{
var render = new TypeScriptJsonCodeRender();
tasks.Add(Task.Run(() =>
{
var fileContent = new List <string>
{
@$ "
export namespace {ass.TopModule} {{
",
@"
export class Vector2 {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
static fromJson(_json_: any): Vector2 {
let x = _json_['x'];
let y = _json_['y'];
if (x == null || y == null) {
throw new Error();
}
return new Vector2(x, y);
}
}
export class Vector3 {
x: number;
y: number;
z: number;
constructor(x: number, y: number, z: number) {
this.x = x;
this.y = y;
this.z = z;
}
static fromJson(_json_: any): Vector3 {
let x = _json_['x'];
let y = _json_['y'];
let z = _json_['z'];
if (x == null || y == null || z == null) {
throw new Error();
}
return new Vector3(x, y, z);
}
}
export class Vector4 {
x: number;
y: number;
z: number;
w: number;
constructor(x: number, y: number, z: number, w: number) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
static fromJson(_json_: any): Vector4 {
let x = _json_['x'];
let y = _json_['y'];
let z = _json_['z'];
let w = _json_['w'];
if (x == null || y == null || z == null || w == null) {
throw new Error();
}
return new Vector4(x, y, z, w);
}
}
"
};
foreach (var type in exportTypes)
{
if (type is DefEnum e)
{
fileContent.Add(render.Render(e));
}
}
foreach (var type in exportTypes)
{
if (type is DefConst c)
{
fileContent.Add(render.Render(c));
}
}
foreach (var type in exportTypes)
{
if (type is DefBean e)
{
fileContent.Add(render.Render(e));
}
}
foreach (var type in exportTables)
{
fileContent.Add(render.Render(type));
}
fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));
fileContent.Add("}"); // end of topmodule
var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.TYPESCRIPT);
var file = "Types.ts";
var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
genCodeFiles.Add(new FileInfo()
{
FilePath = file, MD5 = md5
});
}));
private void ConnectProfiler()
{
_agent = _internalDevice.GetRemoteAgent(_remoteAgentGuid);
_agent.Start("");
_devicePacketStream = _agent.CreatePacketStream(_remoteServiceId);
}
private void ConnectProfiler()
{
_agent = _internalDevice.GetRemoteAgent(_remoteAgentGuid);
_agent.Start("");
_devicePacketStream = _agent.CreatePacketStream(_remoteServiceId);
}
