public override void Execute()
{
base.Execute();
if (string.IsNullOrEmpty(Output) || !Directory.Exists(Output))
{
Logger.Instance.WriteError("Output Path '{0}' does not exist", Output);
return;
}
string design = PathHelper.GetFullPath(Design);
Logger.Instance.WriteVerbose("Selected NCD '{0}'", Design);
OutputPath location = new OutputPath();
location.OutputDirectory = PathHelper.GetFullPath(Output);
location.TemporaryDirectory = SystemHelper.GetTemporaryDirectory();
location.WorkingDirectory = Environment.CurrentDirectory;
location.LogDirectory = location.OutputDirectory;
Logger.Instance.WriteVerbose("Starting Build");
BitstreamGenerator generator = new BitstreamGenerator(XilinxHelper.GetCurrentXilinxToolchain(), location, design);
if (generator.Build())
{
Logger.Instance.WriteInfo("Build Complete");
}
else
{
Logger.Instance.WriteError("Build Failed");
}
Logger.Instance.WriteVerbose("Cleaning temporary directory");
Directory.Delete(location.TemporaryDirectory, true);
}
public override void Execute()
{
base.Execute();
if (string.IsNullOrEmpty(Output) || !Directory.Exists(Output))
{
Logger.Instance.WriteError("Output Path '{0}' does not exist", Output);
return;
}
string design = PathHelper.GetFullPath(Design);
Logger.Instance.WriteVerbose("Selected NCD '{0}'", Design);
OutputPath location = new OutputPath();
location.OutputDirectory = PathHelper.GetFullPath(Output);
location.TemporaryDirectory = SystemHelper.GetTemporaryDirectory();
location.WorkingDirectory = Environment.CurrentDirectory;
location.LogDirectory = location.OutputDirectory;
Logger.Instance.WriteVerbose("Starting Generation");
BlockMemoryMapGenerator bmmGenerator = new BlockMemoryMapGenerator(location);
bmmGenerator.NCDFile = design;
if (bmmGenerator.Build())
{
Logger.Instance.WriteInfo("Generation Complete");
}
else
{
Logger.Instance.WriteError("Generation Failed");
}
Logger.Instance.WriteVerbose("Cleaning temporary directory");
Directory.Delete(location.TemporaryDirectory, true);
}
public override void Execute()
{
base.Execute();
if (string.IsNullOrEmpty(Output) || !Directory.Exists(Output))
{
Logger.Instance.WriteError("Output Path '{0}' does not exist", Output);
return;
}
string netlist = PathHelper.GetFullPath(NetList);
string constraints = PathHelper.GetFullPath(Constraints);
Logger.Instance.WriteVerbose("Selected NetList '{0}'", netlist);
Logger.Instance.WriteVerbose("Selected Constraints '{0}'", constraints);
// Search for Part
DevicePartSpeed device = DeviceHelper.FindDeviceByName(Device);
if (device == null)
{
Logger.Instance.WriteError("Cannot Find Device '{0}'", Device);
return;
}
Logger.Instance.WriteVerbose("Selected device '{0}'", device.Name);
OutputPath location = new OutputPath();
location.OutputDirectory = PathHelper.GetFullPath(Output);
location.TemporaryDirectory = SystemHelper.GetTemporaryDirectory();
location.WorkingDirectory = Environment.CurrentDirectory;
location.LogDirectory = location.OutputDirectory;
Logger.Instance.WriteVerbose("Starting Build");
GenericImplementationConfiguration config = new GenericImplementationConfiguration();
config.Constraints = constraints;
config.NetList = netlist;
config.TargetDevice = device;
IImplementor implementor = XilinxHelper.GetCurrentXilinxToolchain().Implementors.FirstOrDefault();
if (implementor != null)
{
using (IImplementorInstance instance = implementor.Create(location, config))
{
if (instance.Build())
{
Logger.Instance.WriteInfo("Build Complete");
}
else
{
Logger.Instance.WriteError("Build Failed");
}
}
}
Logger.Instance.WriteVerbose("Cleaning temporary directory");
Directory.Delete(location.TemporaryDirectory, true);
}
public override void Execute()
{
base.Execute();
if (string.IsNullOrEmpty(Output) || !Directory.Exists(Output))
{
Logger.Instance.WriteError("Output Path '{0}' does not exist", Output);
return;
}
string bmmfile = PathHelper.GetFullPath(BlockMemoryMap);
string bitfile = PathHelper.GetFullPath(Bitstream);
string binary = PathHelper.GetFullPath(Binary);
Logger.Instance.WriteVerbose("Selected BMM '{0}'", bmmfile);
Logger.Instance.WriteVerbose("Selected Bitstream '{0}'", bitfile);
Logger.Instance.WriteVerbose("Selected Binary '{0}'", binary);
OutputPath location = new OutputPath();
location.OutputDirectory = PathHelper.GetFullPath(Output);
location.TemporaryDirectory = SystemHelper.GetTemporaryDirectory();
location.WorkingDirectory = Environment.CurrentDirectory;
location.LogDirectory = location.OutputDirectory;
Logger.Instance.WriteVerbose("Starting Injection");
BitstreamDataInjector bitInjector = new BitstreamDataInjector(location);
bitInjector.BMMDescription = bmmfile;
bitInjector.Bitstream = bitfile;
bitInjector.BinaryFile = binary;
if (bitInjector.Build())
{
Logger.Instance.WriteInfo("Injection Complete");
}
else
{
Logger.Instance.WriteError("Injection Failed");
}
Logger.Instance.WriteVerbose("Cleaning temporary directory");
Directory.Delete(location.TemporaryDirectory, true);
}
public BlockMemoryMapGenerator(OutputPath output)
{
OutputLocation = output;
}
/// <summary>
///
/// </summary>
/// <param name="numberOfThreads"></param>
public void RunSimulations(int numberOfThreads = -1)
{
int noCoresToUse = numberOfThreads;
int noCores = Environment.ProcessorCount;
if (noCoresToUse <= 0)
{
noCoresToUse += noCores;
}
//Set up outputs (on main thread)
if (OutputType == OutputType.CSVOutput)
{
FileInfo hlkFile = new FileInfo(FileName);
if (OutputPath == null)
{
OutputPath = hlkFile.Directory.FullName.Replace("\\", "/");
}
if (!OutputPath.Contains(":") || OutputPath.Contains("./"))
{
DirectoryInfo outDir = new DirectoryInfo(Path.Combine(hlkFile.Directory.FullName, OutputPath));
if (!outDir.Exists)
{
outDir.Create();
}
OutputPath = outDir.FullName;
}
}
else if (OutputType == OutputType.SQLiteOutput)
{
if (OutputPath == null)
{
OutputPath = FileName.Replace(".hlk", ".sqlite");
OutputPath = OutputPath.Replace("\\", "/");
}
//if (DBContext == null)
//{
// DBContext = new HLDBContext(new SQLiteConnection("data source=" + OutputPath + ";foreign keys=false"), true);
// DBContext.Configuration.AutoDetectChangesEnabled = false;
// DBContext.Configuration.ValidateOnSaveEnabled = false;
// //DBContext.SaveChanges();
//}
//List<string> OutputIndicies = new List<string>();
//for(int i = 0; i < OutputDataElements.Count; i++)
//{
// OutputIndicies.Add("x" + (i + 1).ToString());
//}
if (SQLConn != null && SQLConn.State == System.Data.ConnectionState.Open)
{
SQLConn.Close();
}
if (File.Exists(OutputPath))
{
File.Delete(OutputPath);
}
SQLiteConnection.CreateFile(OutputPath);
SQLConn = new SQLiteConnection("Data Source=" + OutputPath + ";Version=3;");
SQLConn.Open();
//Will need to create tables
//Data
string sql = "create table data (SimId int, Day int," + String.Join(" double,", OutputDataElements.Where(j => j.IsSelected == true).Select(x => x.Name)) + " double)";
// sql = "create table data (SimId int, Day int," + String.Join(" double,", OutputIndicies) + " double)";
SQLiteCommand command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
//Annual sum data
sql = "create table annualdata (SimId int, Year int," + String.Join(" double,", OutputDataElements.Where(j => j.IsSelected == true).Select(x => x.Name)) + " double)";
// sql = "create table annualdata (SimId int, Year int," + String.Join(" double,", OutputIndicies) + " double)";
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
//Annual sum average data
sql = "create table annualaveragedata (SimId int," + String.Join(" double,", OutputDataElements.Where(j => j.IsSelected == true).Select(x => x.Name)) + " double)";
// sql = "create table annualaveragedata (SimId int," + String.Join(" double,", OutputIndicies) + " double)";
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
//Outputs
sql = "create table outputs (Name string, Description string, Units string, Controller string)";
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
StringBuilder sb = new StringBuilder();
sb.Append("INSERT INTO OUTPUTS (Name, Description , Units, Controller) VALUES ");
foreach (OutputDataElement ode in OutputDataElements)
{
string comma = ",";
if (ode == OutputDataElements.First())
{
comma = "";
}
sb.Append(comma + "(\"" + ode.Name + "\",\"" + ode.Output.Description + "\",\"" + ode.Output.Unit + "\",\"" + ode.HLController.GetType().Name + "\")");
}
sql = sb.ToString();
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
//Simulations
sql = "create table simulations (Id int, Name string, StartDate DATETIME, EndDate DATETIME)";
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
//Models
sql = "create table models (SimId int, Name string, InputType string, LongName string)";
command = new SQLiteCommand(sql, SQLConn);
command.ExecuteNonQuery();
}
else if (OutputType == OutputType.NetCDF)
{
//if (HLNC == null)
//{
// // HLNC = new HLNCFile(this, this.Simulations[0].StartDate, this.Simulations[0].EndDate, FileName.Replace(".hlk", ".nc"));
//}
}
//SQLite
//Reset the counters
CurrentSimIndex = 0;
NoSimsComplete = 0;
StartRunTime = DateTime.Now;
//Create a list of background workers
BackgroundWorkers = new List <HLBackGroundWorker>(noCoresToUse);
//Populate the Background workers and run
for (int i = 0; i < noCoresToUse; i++)
{
BackgroundWorkers.Add(new HLBackGroundWorker());
BackgroundWorkers[i].DoWork += HLBackgroundWorker_DoWork;
BackgroundWorkers[i].RunWorkerCompleted += HLBackgroundWorker_RunWorkerCompleted;
BackgroundWorkers[i].WorkerReportsProgress = true;
BackgroundWorkers[i].WorkerSupportsCancellation = true;
Simulation sim = GetSimulationElement();
if (sim != null)
{
BackgroundWorkers[i].Sim = sim;
// BackgroundWorkers[i].RunWorkerAsync(new List<object>(new object[] { xe, handler }));
//BackgroundWorkers[i].RunWorkerAsync(new List<object>(new object[] { sim }));
BackgroundWorkers[i].RunWorkerAsync();
}
}
if (HasOwnExecutableSpace)
{
while (NoSimsComplete < Simulations.Count)
{
System.Threading.Thread.Sleep(500);
}
}
}
//---------------------------------------------------------------------
public static string ReplaceTemplateVars(string template,
int timestep)
{
varValues[TimestepVar] = timestep.ToString();
return(OutputPath.ReplaceTemplateVars(template, varValues));
}
public XilinxSynthesisConfiguration(OutputPath output)
{
OutputLocation = output;
}
public override void Execute()
{
base.Execute();
if (string.IsNullOrEmpty(Output) || !Directory.Exists(Output))
{
Logger.Instance.WriteError("Output Path '{0}' does not exist", Output);
return;
}
GenericSynthesisConfiguration configuration = new GenericSynthesisConfiguration();
configuration.Module = Program.Repository.FindModuleByName(Module);
configuration.TargetDevice = DeviceHelper.FindDeviceByName(Device);
if (configuration.Module == null)
{
Logger.Instance.WriteError("Cannot Find Module '{0}'", Module);
return;
}
Logger.Instance.WriteVerbose("Selected module '{0}' in library '{1}'", configuration.Module.Name, configuration.Module.Parent.Name);
if (configuration.TargetDevice == null)
{
Logger.Instance.WriteError("Cannot Find Device '{0}'", Device);
return;
}
Logger.Instance.WriteVerbose("Selected device '{0}'", configuration.TargetDevice.Name);
OutputPath location = new OutputPath();
location.OutputDirectory = PathHelper.GetFullPath(Output);
location.TemporaryDirectory = SystemHelper.GetTemporaryDirectory();
location.WorkingDirectory = Environment.CurrentDirectory;
location.LogDirectory = location.OutputDirectory;
Logger.Instance.WriteVerbose("Starting Build");
bool successful = false;
ISynthesizer synthesizer = XilinxHelper.GetCurrentXilinxToolchain().Synthesizers.FirstOrDefault();
if (synthesizer != null)
{
Logger.Instance.WriteDebug("Using '{0}' Synthesizer from '{1}' toolchain", synthesizer.GetType().Name, synthesizer.Toolchain.GetType().Name);
using (ISynthesizerInstance instance = synthesizer.Create(location, configuration))
{
successful = instance.Build();
}
}
if (successful)
{
Logger.Instance.WriteInfo("Build Complete");
}
else
{
Logger.Instance.WriteError("Build Failed");
}
Logger.Instance.WriteVerbose("Cleaning temporary directory");
Directory.Delete(location.TemporaryDirectory, true);
}
public override int GetHashCode()
{
return(Items.GetHashCode() ^ OutputPath.GetHashCode() ^ ProgressReporter.GetHashCode());
}
public IDictionary <string, string> to_token_dictionary()
{
var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(AfterMigrationFolderName), AfterMigrationFolderName.to_string() },
{ nameof(AlterDatabaseFolderName), AlterDatabaseFolderName.to_string() },
{ nameof(Baseline), Baseline.to_string() },
{ nameof(BeforeMigrationFolderName), BeforeMigrationFolderName.to_string() },
{ nameof(CommandTimeout), CommandTimeout.to_string() },
{ nameof(CommandTimeoutAdmin), CommandTimeoutAdmin.to_string() },
{ nameof(ConfigurationFile), ConfigurationFile.to_string() },
{ nameof(ConnectionString), ConnectionString.to_string() },
{ nameof(ConnectionStringAdmin), ConnectionStringAdmin.to_string() },
{ nameof(CreateDatabaseCustomScript), CreateDatabaseCustomScript.to_string() },
{ nameof(DatabaseName), DatabaseName.to_string() },
{ nameof(DatabaseType), DatabaseType.to_string() },
{ nameof(Debug), Debug.to_string() },
{ nameof(DisableOutput), DisableOutput.to_string() },
{ nameof(DisableTokenReplacement), DisableTokenReplacement.to_string() },
{ nameof(DoNotAlterDatabase), DoNotAlterDatabase.to_string() },
{ nameof(DoNotCreateDatabase), DoNotCreateDatabase.to_string() },
{ nameof(DoNotStoreScriptsRunText), DoNotStoreScriptsRunText.to_string() },
{ nameof(DownFolderName), DownFolderName.to_string() },
{ nameof(Drop), Drop.to_string() },
{ nameof(DryRun), DryRun.to_string() },
#pragma warning disable 618
{ nameof(EnvironmentName), string.Join(",", EnvironmentNames) },
#pragma warning restore 618
{ nameof(EnvironmentNames), string.Join(",", EnvironmentNames) },
{ nameof(FunctionsFolderName), FunctionsFolderName.to_string() },
{ nameof(IndexesFolderName), IndexesFolderName.to_string() },
{ nameof(Initialize), Initialize.to_string() },
{ nameof(OutputPath), OutputPath.to_string() },
{ nameof(PermissionsFolderName), PermissionsFolderName.to_string() },
{ nameof(RecoveryMode), RecoveryMode.to_string() },
{ nameof(RepositoryPath), RepositoryPath.to_string() },
{ nameof(Restore), Restore.to_string() },
{ nameof(RestoreCustomOptions), RestoreCustomOptions.to_string() },
{ nameof(RestoreFromPath), RestoreFromPath.to_string() },
{ nameof(RestoreTimeout), RestoreTimeout.to_string() },
{ nameof(RunAfterCreateDatabaseFolderName), RunAfterCreateDatabaseFolderName.to_string() },
{ nameof(RunAfterOtherAnyTimeScriptsFolderName), RunAfterOtherAnyTimeScriptsFolderName.to_string() },
{ nameof(RunAllAnyTimeScripts), RunAllAnyTimeScripts.to_string() },
{ nameof(RunBeforeUpFolderName), RunBeforeUpFolderName.to_string() },
{ nameof(RunFirstAfterUpFolderName), RunFirstAfterUpFolderName.to_string() },
{ nameof(SchemaName), SchemaName.to_string() },
{ nameof(ScriptsRunErrorsTableName), ScriptsRunErrorsTableName.to_string() },
{ nameof(ScriptsRunTableName), ScriptsRunTableName.to_string() },
{ nameof(SearchAllSubdirectoriesInsteadOfTraverse), SearchAllSubdirectoriesInsteadOfTraverse.to_string() },
{ nameof(ServerName), ServerName.to_string() },
{ nameof(Silent), Silent.to_string() },
{ nameof(SprocsFolderName), SprocsFolderName.to_string() },
{ nameof(SqlFilesDirectory), SqlFilesDirectory.to_string() },
{ nameof(TriggersFolderName), TriggersFolderName.to_string() },
{ nameof(UpFolderName), UpFolderName.to_string() },
{ nameof(Version), Version.to_string() },
{ nameof(VersionFile), VersionFile.to_string() },
{ nameof(VersionTableName), VersionTableName.to_string() },
{ nameof(VersionXPath), VersionXPath.to_string() },
{ nameof(ViewsFolderName), ViewsFolderName.to_string() },
{ nameof(WarnAndIgnoreOnOneTimeScriptChanges), WarnAndIgnoreOnOneTimeScriptChanges.to_string() },
{ nameof(WarnOnOneTimeScriptChanges), WarnOnOneTimeScriptChanges.to_string() },
{ nameof(WithTransaction), WithTransaction.to_string() },
};
if (UserTokens != null)
{
foreach (var t in UserTokens)
{
tokens[t.Key] = t.Value;
}
}
return(tokens);
}
public override bool Execute()
{
if (string.IsNullOrWhiteSpace(UnchangedFiles))
{
Log.LogCommandLine("WARNING: UnchangedFiles must be set.");
return(true);
}
if (string.IsNullOrWhiteSpace(OutputPath))
{
Log.LogCommandLine("WARNING: OutputPath must be set.");
return(true);
}
Log.LogCommandLine("! CullFilesFromProject Task !");
Log.LogCommandLine("OutputPath: " + OutputPath);
Log.LogCommandLine("UnchangedFiles: " + UnchangedFiles);
var normalizedFiles = File.ReadAllLines(UnchangedFiles).Select(i => i.Replace("/", @"\")).ToArray();
var normalizedOutputDir = (OutputPath?.Replace("\\\\", "\\")).TrimEnd('\\');
foreach (var file in Directory.EnumerateFiles(normalizedOutputDir, "*.*", SearchOption.AllDirectories))
{
// do not delete config files or xml files as they may be transformed
if (file.EndsWith(".config") || file.EndsWith(".xml"))
{
continue;
}
// need to search /bin for *.dll files
if (file.EndsWith(".dll"))
{
var dllOnly = file.Split('\\').Last();
if (!normalizedFiles.Any(i => i.EndsWith(dllOnly)))
{
continue;
}
File.Delete(file);
Log.LogCommandLine("CullFilesFromProject :: Deleted file: " + file);
continue;
}
var relativeFilePath = file.Replace(normalizedOutputDir, "");
if (!normalizedFiles.Any(i => i.EndsWith(relativeFilePath)))
{
continue;
}
File.Delete(file);
Log.LogCommandLine("CullFilesFromProject :: Deleted file: " + file);
}
foreach (var directory in Directory.EnumerateDirectories(normalizedOutputDir, "*", SearchOption.AllDirectories).OrderByDescending(i => i.Length))
{
if (Directory.GetFiles(directory).Length != 0 || Directory.GetDirectories(directory).Length != 0)
{
continue;
}
Directory.Delete(directory, false);
Log.LogCommandLine("CullFilesFromProject :: Deleted empty directory: " + directory);
}
return(true);
}
public BitstreamDataInjector(OutputPath output)
{
OutputLocation = output;
}
public override bool Start()
{
#region Set exe files path
if (this.IsNodeInPath)
{
this.NodeJsPath = FindInPath.Find("node.exe", MainWindow.WorkingDirectory, false);
}
if (this.IsCoffeeGlobal)
{
CoffeePath = FindInPath.Find("coffee", MainWindow.WorkingDirectory, true, false);
if (CoffeePath.EndsWith(".bat", StringComparison.OrdinalIgnoreCase) || CoffeePath.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase) || CoffeePath.EndsWith(".com", StringComparison.OrdinalIgnoreCase))
{
HashSet <string> possibleCoffeeLocations = FindPathInfo.InBat("%~dp0\\.\\", "coffee", CoffeePath);
if (possibleCoffeeLocations != null)
{
foreach (string possibleCoffeeLocation in possibleCoffeeLocations)
{
string temp = possibleCoffeeLocation.Replace("%~dp0\\.\\", string.Empty);
string tempFullPath = Path.GetDirectoryName(CoffeePath) + Path.DirectorySeparatorChar + temp;
if (File.Exists(tempFullPath))
{
CoffeePath = tempFullPath;
break;
}
}
}
}
;
}
fileName = this.NodeJsPath;
arguments = "\"" + PathConverter.ConvertWinToUnix(this.CoffeePath) + "\"";
#endregion
#region Merge paths
InputPath = !String.IsNullOrEmpty(InputPath) ? PathConverter.ConvertUnixToWin(InputPath) : ".";
if (Directory.Exists(InputPath))
{
if (InputPath[InputPath.Length - 1] != '\\')
{
InputPath += '\\';
}
}
if (Directory.Exists(OutputPath))
{
if (OutputPath[OutputPath.Length - 1] != '\\')
{
OutputPath += '\\';
}
}
if (String.IsNullOrEmpty(OutputPath))
{
workingDirectory = Path.GetDirectoryName(InputPath);
InputPath = PathConverter.ConvertWinToUnix(Path.GetFileName(InputPath));
OutputPath = PathConverter.ConvertWinToUnix(Path.GetFileName(OutputPath));
}
else
{
workingDirectory = ComparePath.Compare(InputPath, OutputPath, '\\');
int headerIndex = workingDirectory.Length;
InputPath = PathConverter.ConvertWinToUnix(InputPath.Substring(headerIndex));
OutputPath = PathConverter.ConvertWinToUnix(OutputPath.Substring(headerIndex));
}
if (String.IsNullOrEmpty(InputPath))
{
InputPath = ".";
}
if (String.IsNullOrEmpty(OutputPath))
{
OutputPath = ".";
}
#endregion
#region Set arguments
arguments += " " + this.AddParams;
if (this.IsBare)
{
arguments += " --bare";
}
if (this.IsWatch)
{
arguments += " --watch";
}
arguments += " --compile";
if (!String.IsNullOrEmpty(OutputPath))
{
arguments += " --output " + this.OutputPath;
}
arguments += " " + this.InputPath;
#endregion
#region Set process properties
setupInfo(fileName, arguments, workingDirectory);
return(run());
#endregion
}
/// <summary>
/// Start processing the compositions.
/// </summary>
/// <returns>Number of successful conversions</returns>
public int Process()
{
if (Compositions == null || FFmpegPath == null)
{
return(0);
}
int finished = 0;
failures = new StringBuilder();
foreach (string composition in Compositions)
{
if (!File.Exists(composition))
{
continue;
}
string title = Finder.GetCPLTitle(composition);
OnStatusUpdate?.Invoke($"Processing {title}...");
string finalOutput = OutputPath, sourceFolder = composition.Substring(0, composition.LastIndexOf('\\'));
if (!string.IsNullOrEmpty(OutputPath) && OutputPath.Equals(parentMarker))
{
int index = sourceFolder.LastIndexOf('\\');
if (index < 0)
{
failures.AppendLine("Drive root is an invalid directory: " + title);
continue;
}
finalOutput = sourceFolder.Substring(0, index);
}
CompositionProcessor processor = new CompositionProcessor(FFmpegPath, composition)
{
ForcePath = finalOutput,
Overwrite = Overwrite,
VideoFormat = VideoFormat,
ChromaSubsampling = ChromaSubsampling,
CRF = CRF,
CRF3D = CRF3D,
StereoMode = StereoMode,
AudioFormat = AudioFormat
};
if (processor.ProcessComposition(Force2K))
{
++finished;
if (ZipAfter)
{
OnStatusUpdate?.Invoke($"Zipping {title}...");
Finder.ZipAssets(sourceFolder, $"{finalOutput}\\{title}.zip", textOut => OnStatusUpdate(textOut));
}
if (DeleteAfter)
{
Finder.DeleteAssets(sourceFolder);
}
}
else
{
failures.AppendLine("Conversion error: " + title);
}
}
OnStatusUpdate?.Invoke("Finished!");
OnCompletion?.Invoke(finished);
return(finished);
}
public FPGAImplementorInstance(FPGAImplementor implementor, OutputPath output, IImplementationConfiguration config)
{
Implementor = implementor;
OutputLocation = output;
Configuration = config;
}
/// <summary>
/// 执行制定生成
/// </summary>
/// <param name="op"></param>
public void Run(string op)
{
if (AppPath == null)
{
return;
}
var path = Path.Combine(OutputPath, CurrentOption + ".cs");
if (File.Exists(path))
{
File.Delete(path);
}
System.Diagnostics.Process p = new System.Diagnostics.Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.UseShellExecute = false; //是否使用操作系统shell启动
p.StartInfo.RedirectStandardInput = true; //接受来自调用程序的输入信息
p.StartInfo.RedirectStandardOutput = true; //由调用程序获取输出信息
p.StartInfo.RedirectStandardError = true; //重定向标准错误输出
p.StartInfo.CreateNoWindow = true; //不显示程序窗口
p.Start(); //启动程序
//向cmd窗口发送输入信息
p.StandardInput.WriteLine(AppPath.Replace("\\", "/") + " --csharp_out=\"" + OutputPath.Replace("\\", "/") + "/\" --proto_path=\"" + SourcesPath.Replace("\\", "/") + "/\" " + op + ".proto" + "&exit");
p.StandardInput.AutoFlush = true;
var ans = p.WaitForExit(1000);
p.Close();
if (!ans)
{
GenerateText.Text = "";
return;
}
//Log(op + "生成完成." );
path = Path.Combine(OutputPath, CurrentOption + ".cs");
if (File.Exists(path))
{
var text = File.ReadAllText(path);
var index = GenerateText.CaretOffset;
GenerateText.Text = text.Replace("global::Google.Protobuf", "global::Secode.Protobuf");
GenerateText.CaretOffset = index;
File.WriteAllText(path, GenerateText.Text);
}
}
public override bool Execute()
{
OutputPath = OutputPath.Replace('\\', '/');
Directory.CreateDirectory(Path.GetDirectoryName(OutputPath));
DependencyVersionsFile depsFile;
if (File.Exists(OutputPath))
{
if (!DependencyVersionsFile.TryLoad(OutputPath, out depsFile))
{
depsFile = DependencyVersionsFile.Create(AddOverrideImport, AdditionalImports);
Log.LogWarning($"Could not load the existing deps file from {OutputPath}. This file will be overwritten.");
}
}
else
{
depsFile = DependencyVersionsFile.Create(AddOverrideImport, AdditionalImports);
}
var varNames = new HashSet <string>();
foreach (var pkg in Packages)
{
var packageVersion = pkg.GetMetadata("Version");
if (string.IsNullOrEmpty(packageVersion))
{
Log.LogError("Package {0} is missing the Version metadata", pkg.ItemSpec);
continue;
}
string packageVarName;
if (!string.IsNullOrEmpty(pkg.GetMetadata("VariableName")))
{
packageVarName = pkg.GetMetadata("VariableName");
if (!packageVarName.EndsWith("Version", StringComparison.Ordinal))
{
Log.LogError("VariableName for {0} must end in 'Version'", pkg.ItemSpec);
continue;
}
}
else
{
packageVarName = DependencyVersionsFile.GetVariableName(pkg.ItemSpec);
}
if (varNames.Contains(packageVarName))
{
Log.LogError("Multiple packages would produce {0} in the generated dependencies.props file. Set VariableName to differentiate the packages manually", packageVarName);
continue;
}
var item = depsFile.Update(packageVarName, packageVersion);
if (!SuppressVariableLabels)
{
item.SetLabel(pkg.ItemSpec);
}
}
depsFile.Save(OutputPath);
Log.LogMessage(MessageImportance.Normal, $"Generated {OutputPath}");
return(!Log.HasLoggedErrors);
}
/// <summary>
/// Run the predictor with given args and check if it adds up
/// </summary>
protected void Run(RunContext ctx)
{
Contracts.Assert(IsActive);
List <string> args = new List <string>();
if (ctx.Command != Cmd.Test)
{
AddIfNotEmpty(args, ctx.Predictor.Trainer, "tr");
}
string dataName = ctx.Command == Cmd.Test ? ctx.Dataset.testFilename : ctx.Dataset.trainFilename;
AddIfNotEmpty(args, GetDataPath(dataName), "data");
AddIfNotEmpty(args, 1, "seed");
//AddIfNotEmpty(args, false, "threads");
Log("Running '{0}' on '{1}'", ctx.Predictor.Trainer.Kind, ctx.Dataset.name);
string dir = ctx.BaselineDir;
if (ctx.Command == Cmd.TrainTest)
{
AddIfNotEmpty(args, GetDataPath(ctx.Dataset.testFilename), "test");
}
if (ctx.Command == Cmd.TrainTest || ctx.Command == Cmd.Train)
{
AddIfNotEmpty(args, GetDataPath(ctx.Dataset.validFilename), "valid");
}
// Add in the loader args, and keep a location so we can backtrack and remove it later.
int loaderArgIndex = -1;
string loaderArgs = GetLoaderTransformSettings(ctx.Dataset);
if (!string.IsNullOrWhiteSpace(loaderArgs))
{
loaderArgIndex = args.Count;
args.Add(loaderArgs);
}
// Add in the dataset transforms. These need to come before the predictor imposed transforms.
if (ctx.Dataset.mamlExtraSettings != null)
{
args.AddRange(ctx.Dataset.mamlExtraSettings);
}
// Model file output, used only for train/traintest.
var modelPath = ctx.Command == Cmd.Train || ctx.Command == Cmd.TrainTest ? ctx.ModelPath() : null;
AddIfNotEmpty(args, modelPath, "out");
string basePrefix = ctx.BaselineNamePrefix;
// Predictions output, for all types of commands except train.
OutputPath predOutPath = ctx.Command == Cmd.Train ? null : ctx.InitPath(".txt");
AddIfNotEmpty(args, predOutPath, "dout");
if (ctx.Predictor.MamlArgs != null)
{
args.AddRange(ctx.Predictor.MamlArgs);
}
// If CV, do not run the CV in multiple threads.
if (ctx.Command == Cmd.CV)
{
args.Add("threads-");
}
if (ctx.ExtraArgs != null)
{
foreach (string arg in ctx.ExtraArgs)
{
args.Add(arg);
}
}
AddIfNotEmpty(args, ctx.Predictor.Scorer, "scorer");
if (ctx.Command != Cmd.Test)
{
AddIfNotEmpty(args, ctx.Predictor.Tester, "eval");
}
else
{
AddIfNotEmpty(args, ctx.ModelOverride.Path, "in");
}
string runcmd = string.Join(" ", args.Where(a => !string.IsNullOrWhiteSpace(a)));
Log(" Running as: {0} {1}", ctx.Command, runcmd);
int res;
if (basePrefix == null)
{
// Not capturing into a specific log.
Log("*** Start raw predictor output");
res = MainForTest(Env, LogWriter, string.Join(" ", ctx.Command, runcmd), ctx.BaselineProgress);
Log("*** End raw predictor output, return={0}", res);
return;
}
var consOutPath = ctx.StdoutPath();
TestCore(ctx, ctx.Command.ToString(), runcmd);
bool matched = consOutPath.CheckEqualityNormalized();
if (modelPath != null && (ctx.Summary || ctx.SaveAsIni))
{
// Save the predictor summary and compare it to baseline.
string str = string.Format("SavePredictorAs in={{{0}}}", modelPath.Path);
List <string> files = new List <string>();
if (ctx.Summary)
{
var summaryName = basePrefix + "-summary.txt";
files.Add(summaryName);
var summaryPath = DeleteOutputPath(dir, summaryName);
str += string.Format(" sum={{{0}}}", summaryPath);
Log(" Saving summary with: {0}", str);
}
if (ctx.SaveAsIni)
{
var iniName = basePrefix + ".ini";
files.Add(iniName);
var iniPath = DeleteOutputPath(dir, iniName);
str += string.Format(" ini={{{0}}}", iniPath);
Log(" Saving ini file: {0}", str);
}
MainForTest(Env, LogWriter, str);
files.ForEach(file => CheckEqualityNormalized(dir, file));
}
if (ctx.Command == Cmd.Train || ctx.Command == Cmd.Test || ctx.ExpectedToFail)
{
return;
}
// ResultProcessor output
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // -rp.txt files are not getting generated for Non-Windows Os
{
string rpName = basePrefix + "-rp.txt";
string rpOutPath = DeleteOutputPath(dir, rpName);
string[] rpArgs = null;
if (ctx.Command == Cmd.CV && ctx.ExtraArgs != null && ctx.ExtraArgs.Any(arg => arg.Contains("opf+")))
{
rpArgs = new string[] { "opf+" }
}
;
// Run result processor on the console output.
RunResultProcessorTest(new string[] { consOutPath.Path }, rpOutPath, rpArgs);
CheckEqualityNormalized(dir, rpName);
}
// Check the prediction output against its baseline.
Contracts.Assert(predOutPath != null);
predOutPath.CheckEquality();
if (ctx.Command == Cmd.TrainTest)
{
// Adjust the args so that we no longer have the loader and transform
// arguments in there.
if (loaderArgIndex >= 0)
{
args.RemoveAt(loaderArgIndex);
}
bool foundOut = false;
List <int> toRemove = new List <int>();
HashSet <string> removeArgs = new HashSet <string>();
removeArgs.Add("tr=");
removeArgs.Add("data=");
removeArgs.Add("valid=");
removeArgs.Add("norm=");
removeArgs.Add("cali=");
removeArgs.Add("numcali=");
removeArgs.Add("xf=");
removeArgs.Add("cache-");
removeArgs.Add("sf=");
for (int i = 0; i < args.Count; ++i)
{
if (string.IsNullOrWhiteSpace(args[i]))
{
continue;
}
if (removeArgs.Any(x => args[i].StartsWith(x)))
{
toRemove.Add(i);
}
if (args[i].StartsWith("out="))
{
args[i] = string.Format("in={0}", args[i].Substring(4));
}
if (args[i].StartsWith("test="))
{
args[i] = string.Format("data={0}", args[i].Substring(5));
}
foundOut = true;
}
Contracts.Assert(foundOut);
toRemove.Reverse();
foreach (int i in toRemove)
{
args.RemoveAt(i);
}
runcmd = string.Join(" ", args.Where(a => !string.IsNullOrWhiteSpace(a)));
// Redirect output to the individual log and run the test.
var ctx2 = ctx.TestCtx();
OutputPath consOutPath2 = ctx2.StdoutPath();
TestCore(ctx2, "Test", runcmd);
if (CheckTestOutputMatchesTrainTest(consOutPath.Path, consOutPath2.Path, 1))
{
File.Delete(consOutPath2.Path);
}
else if (matched)
{
// The TrainTest output matched the baseline, but the SaveLoadTest output did not, so
// append some stuff to the .txt output so comparing output to baselines in BeyondCompare
// will show the issue.
using (var writer = OpenWriter(consOutPath.Path, true))
{
writer.WriteLine("*** Unit Test Failure! ***");
writer.WriteLine("Loaded predictor test results differ! Compare baseline with {0}", consOutPath2.Path);
writer.WriteLine("*** Unit Test Failure! ***");
}
}
// REVIEW: There is nothing analogous to the old predictor output comparison here.
// The MAML command does not "export" the result of its training programmatically, that would
// allow us to compare it to the loaded model. To verify that the result of the trained model
// is the same as its programmatic
}
}
public IImplementorInstance Create(OutputPath output, IImplementationConfiguration configuration)
{
return new FPGAImplementorInstance(this, output, configuration);
}
public override bool Execute()
{
if (!Enum.TryParse(OutputType, true, out m_OutputType))
{
Log.LogError("Unrecognized OutputType {0}", OutputType);
return(false);
}
if (!Enum.TryParse(Platform, true, out m_Platform))
{
Log.LogError("Unrecognized Platform {0}", Platform);
return(false);
}
m_responseFile = Path.GetTempFileName();
List <string> argv = new List <string>();
argv.Add("-nologo");
argv.Add("-version:1.8");
argv.Add("-w4");
switch (m_OutputType)
{
case ParsedOutputType.Exe:
argv.Add("-target:exe");
break;
case ParsedOutputType.WinExe:
argv.Add("-target:winexe");
break;
case ParsedOutputType.Library:
argv.Add("-target:library");
break;
}
switch (m_Platform)
{
case ParsedPlatform.AnyCpu:
argv.Add("-platform:anycpu");
break;
case ParsedPlatform.AnyCpuPrefer32Bit:
argv.Add("-platform:anycpu32bitpreferred");
break;
case ParsedPlatform.ARM:
argv.Add("-platform:arm");
break;
case ParsedPlatform.x64:
argv.Add("-platform:x64");
break;
case ParsedPlatform.x86:
argv.Add("-platform:x86");
break;
}
if (!string.IsNullOrEmpty(Version))
{
argv.Add("-version:" + Version);
}
if (!string.IsNullOrEmpty(FileVersion))
{
argv.Add("-fileversion:" + FileVersion);
}
if (!string.IsNullOrEmpty(ApplicationIcon))
{
argv.Add("-win32icon:" + ApplicationIcon);
}
if (!string.IsNullOrEmpty(Win32Manifest))
{
argv.Add("-win32manifest:" + Win32Manifest);
}
argv.AddRange(NoWarn.Select(x => "-nowarn:" + x));
if (CompressResources)
{
argv.Add("-compressresources");
}
if (StrictFieldSemantics)
{
argv.Add("-strictfinalfieldsemantics");
}
if (RemoveAssertions)
{
argv.Add("-removeassertions");
}
if (SharedClassLoader)
{
argv.Add("-sharedclassloader");
}
if (SuppressParameterReflection)
{
argv.Add("-noparameterreflection");
}
argv.AddRange(ExtraArguments ?? Enumerable.Empty <string>());
argv.Add("-highentropyva"); // for security
argv.Add("-out:" + OutputPath.GetMetadata("FullPath"));
// Don't use FullPath here, as some of these might be bare filenames, and those must be preserved.
argv.AddRange(References?.Select(x => "-r:" + x.ItemSpec) ?? Enumerable.Empty <string>());
argv.AddRange(ClassFiles?.Select(x => x.GetMetadata("FullPath")) ?? Enumerable.Empty <string>());
File.WriteAllLines(m_responseFile, argv);
bool taskSuccess = base.Execute();
if (taskSuccess)
{
DeleteTempFile(m_responseFile);
}
else
{
Log.LogMessage(MessageImportance.High, "Migrator arguments can be found here: {0}", m_responseFile);
}
return(taskSuccess);
}
private protected IDisposable TemporarySetPackageVersion(SVersion version, bool targetOutputPath = false)
{
return(TempFileTextModification.TemporaryReplacePackageVersion(!targetOutputPath ? PackageJson.JsonFilePath : OutputPath.AppendPart("package.json"), version));
}
public IDictionary <string, string> to_token_dictionary()
{
var tokens = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
tokens["AfterMigrationFolderName"] = AfterMigrationFolderName.to_string();
tokens["AlterDatabaseFolderName"] = AlterDatabaseFolderName.to_string();
tokens["Baseline"] = Baseline.to_string();
tokens["BeforeMigrationFolderName"] = BeforeMigrationFolderName.to_string();
tokens["CommandTimeout"] = CommandTimeout.to_string();
tokens["CommandTimeoutAdmin"] = CommandTimeoutAdmin.to_string();
tokens["ConfigurationFile"] = ConfigurationFile.to_string();
tokens["ConnectionString"] = ConnectionString.to_string();
tokens["ConnectionStringAdmin"] = ConnectionStringAdmin.to_string();
tokens["CreateDatabaseCustomScript"] = CreateDatabaseCustomScript.to_string();
tokens["DatabaseName"] = DatabaseName.to_string();
tokens["DatabaseType"] = DatabaseType.to_string();
tokens["Debug"] = Debug.to_string();
tokens["DisableOutput"] = DisableOutput.to_string();
tokens["DisableTokenReplacement"] = DisableTokenReplacement.to_string();
tokens["DoNotAlterDatabase"] = DoNotAlterDatabase.to_string();
tokens["DoNotCreateDatabase"] = DoNotCreateDatabase.to_string();
tokens["DoNotStoreScriptsRunText"] = DoNotStoreScriptsRunText.to_string();
tokens["DownFolderName"] = DownFolderName.to_string();
tokens["Drop"] = Drop.to_string();
tokens["DryRun"] = DryRun.to_string();
tokens["EnvironmentName"] = string.Join(",", EnvironmentNames);
tokens["EnvironmentNames"] = string.Join(",", EnvironmentNames);
tokens["FunctionsFolderName"] = FunctionsFolderName.to_string();
tokens["IndexesFolderName"] = IndexesFolderName.to_string();
tokens["Initialize"] = Initialize.to_string();
tokens["OutputPath"] = OutputPath.to_string();
tokens["PermissionsFolderName"] = PermissionsFolderName.to_string();
tokens["RecoveryMode"] = RecoveryMode.to_string();
tokens["RepositoryPath"] = RepositoryPath.to_string();
tokens["Restore"] = Restore.to_string();
tokens["RestoreCustomOptions"] = RestoreCustomOptions.to_string();
tokens["RestoreFromPath"] = RestoreFromPath.to_string();
tokens["RestoreTimeout"] = RestoreTimeout.to_string();
tokens["RunAfterCreateDatabaseFolderName"] = RunAfterCreateDatabaseFolderName.to_string();
tokens["RunAfterOtherAnyTimeScriptsFolderName"] = RunAfterOtherAnyTimeScriptsFolderName.to_string();
tokens["RunAllAnyTimeScripts"] = RunAllAnyTimeScripts.to_string();
tokens["RunBeforeUpFolderName"] = RunBeforeUpFolderName.to_string();
tokens["RunFirstAfterUpFolderName"] = RunFirstAfterUpFolderName.to_string();
tokens["SchemaName"] = SchemaName.to_string();
tokens["ScriptsRunErrorsTableName"] = ScriptsRunErrorsTableName.to_string();
tokens["ScriptsRunTableName"] = ScriptsRunTableName.to_string();
tokens["SearchAllSubdirectoriesInsteadOfTraverse"] = SearchAllSubdirectoriesInsteadOfTraverse.to_string();
tokens["ServerName"] = ServerName.to_string();
tokens["Silent"] = Silent.to_string();
tokens["SprocsFolderName"] = SprocsFolderName.to_string();
tokens["SqlFilesDirectory"] = SqlFilesDirectory.to_string();
tokens["TriggersFolderName"] = TriggersFolderName.to_string();
tokens["UpFolderName"] = UpFolderName.to_string();
tokens["Version"] = Version.to_string();
tokens["VersionFile"] = VersionFile.to_string();
tokens["VersionTableName"] = VersionTableName.to_string();
tokens["VersionXPath"] = VersionXPath.to_string();
tokens["ViewsFolderName"] = ViewsFolderName.to_string();
tokens["WarnAndIgnoreOnOneTimeScriptChanges"] = WarnAndIgnoreOnOneTimeScriptChanges.to_string();
tokens["WarnOnOneTimeScriptChanges"] = WarnOnOneTimeScriptChanges.to_string();
tokens["WithTransaction"] = WithTransaction.to_string();
if (UserTokens != null)
{
foreach (var t in UserTokens)
{
tokens[t.Key] = t.Value;
}
}
return(tokens);
}
private protected IDisposable TemporaryPrePack(SVersion version, Action <JObject> packageJsonPreProcessor, bool ckliLocalFeedMode)
{
return(TempFileTextModification.TemporaryReplaceDependenciesVersion(NpmSolution, OutputPath.AppendPart("package.json"), ckliLocalFeedMode, version, packageJsonPreProcessor));
}
private void CopyValidFilesToOutFolder(string basePath, string outFolder, IEnumerable <ValidFileContents> validFileContents)
{
var outputPath = new OutputPath(basePath, outFolder);
_validFileContentsWriter.WriteValidFileContents(outputPath, validFileContents);
}
public BitstreamGenerator(XilinxToolchain toolchain, OutputPath output, string ncd)
{
Toolchain = toolchain;
OutputLocation = output;
NCDFile = ncd;
}
//---------------------------------------------------------------------
public static string ReplaceTemplateVars(string template,
string agentName)
{
varValues[AgentNameVar] = agentName;
return(OutputPath.ReplaceTemplateVars(template, varValues));
}
public NGDBuilder(XilinxToolchain toolchain, OutputPath output)
{
Toolchain = toolchain;
OutputLocation = output;
}
//---------------------------------------------------------------------
public static string ReplaceTemplateVars(string template,
string insectName)
{
varValues[InsectNameVar] = insectName;
return(OutputPath.ReplaceTemplateVars(template, varValues));
}
internal bool Run(out string errors)
{
errors = null;
if (RawMarkdown != null)
{
RawMarkdown = RawMarkdown.Replace("\\r\\n", "\\n").Replace("\\n", "\n");
var f = RawMarkdown.ToHtml();
//if this.OutputPath != null
if (!DryRun)
{
Console.WriteLine(f);
}
else
{
Console.WriteLine("(dryrun)" + f);
}
return(true);
}
if (FileName != null)
{
return(Generate(FileName, OutputPath, InputPath, NoTemplate, DefaultTemplate, DryRun, out errors));
}
if (InputPath != null)
{
foreach (var f in Directory.EnumerateFiles(InputPath, "*.*", Recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
{
if (Path.GetExtension(f).ToLowerInvariant() == ".md")
{
var result = Generate(f, OutputPath, InputPath, NoTemplate, DefaultTemplate, DryRun, out errors);
if (!result)
{
return(false);
}
}
else if ( //todo:linux case sensitive, todo: configurable set
!f.Contains("\\.git\\") && //todo:linux path separator
Path.GetExtension(f).ToLowerInvariant() != ".html" &&
Path.GetExtension(f).ToLowerInvariant() != ".clowncar" &&
Path.GetExtension(f).ToLowerInvariant() != ".clowntent" &&
Path.GetExtension(f).ToLowerInvariant() != ".gitignore" &&
Path.GetExtension(f).ToLowerInvariant() != ".pre" &&
Path.GetExtension(f).ToLowerInvariant() != ".ok" &&
Path.GetExtension(f).ToLowerInvariant() != ".ps1")
{
if (!string.IsNullOrWhiteSpace(OutputPath))
{
var inputFilePath = Path.GetDirectoryName(f);
var relativePath = Path.GetRelativePath(InputPath, inputFilePath);
var targetFileName = Path.Combine(OutputPath, relativePath, Path.GetFileName(f));
// don't copy anything FROM the output path.....
//TODO: depends if OS is case-insensitive
if (inputFilePath.ToLowerInvariant().StartsWith(OutputPath.ToLowerInvariant() + "/"))
{
Console.WriteLine("sub-site:");
continue;
}
if (!DryRun)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"++> {Path.Combine(relativePath, targetFileName)}");
Console.ResetColor();
File.Copy(f, targetFileName, true);
}
else
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"(dryrun)++> {Path.Combine(relativePath, targetFileName)}");
Console.ResetColor();
}
}
}
else
{
var inputFilePath = Path.GetDirectoryName(f);
var relativePath = Path.GetRelativePath(InputPath, inputFilePath);
var targetFileName = Path.Combine(OutputPath, relativePath, Path.GetFileName(f));
Console.ForegroundColor = ConsoleColor.Yellow;
if (!DryRun)
{
Console.WriteLine($"xx> (skipped) {Path.Combine(relativePath, targetFileName)}");
}
else
{
Console.WriteLine($"(dryrun)xx> (skipped) {Path.Combine(relativePath, targetFileName)}");
}
Console.ResetColor();
}
}
}
return(true);
}
public void AddPorcelain <ApiClient>(CommandLineApplication app, IClientFactory <ApiClient> clientFactory)
{
var properties = clientFactory.GetProperties();
properties.ToList().ForEach(prop =>
{
var groupType = prop.PropertyType;
var groupName = groupType.Name.Substring(0, groupType.Name.Length - 3).Substring(1);
var methods = groupType.GetMethods();
methods.ToList().ForEach(m =>
{
var methodName = m.Name;
var commandName = $"{methodName}".ToKebabCase();
if (commandName.EndsWith("-"))
{
commandName = commandName.Substring(0, commandName.Length - 1);
}
var parameters = m.GetParameters().Where(param => !param.Name.ToLower().Equals("useragent"));
app.Command(commandName, (command) =>
{
command.Description = $"Porcelain command for {methodName.ToText()} Api";
command.HelpOption("-?|-h|--help");
// standard options
var apiToken = new Token();
var apiTokenOption = command.Option(apiToken.Template,
apiToken.Description,
apiToken.OptionType);
var indent = new Indent();
command.Option(indent.Template,
indent.Description,
indent.OptionType);
var outputPath = new OutputPath();
command.Option(outputPath.Template,
outputPath.Description,
outputPath.OptionType);
var filter = new Filter();
command.Option(filter.Template,
filter.Description,
filter.OptionType);
var options = new List <CommandOption>();
parameters.ToList().ForEach(param =>
{
var paramName = $"--{param.Name}";
var paramDesc = $"The {param.Name}";
var option = command.Option(paramName, paramDesc, CommandOptionType.SingleValue);
options.Add(option);
});
command.OnExecute(() =>
{
return(command.Run(
app,
() =>
{
var client = clientFactory.GetClient(apiTokenOption.Value());
var api = GetApi(client, prop);
var method = api.GetType().GetMethod(m.Name);
List <object> args = CompileRequestArgs <ApiClient>(app, clientFactory, options);
return InvokeRequest(api, method, args);
}
));
});
});
});
});
}
private Boolean Validate()
{
String outputDirectory = OutputPath.Substring(0, OutputPath.LastIndexOf('\\') == -1 ? 0:OutputPath.LastIndexOf('\\'));
return(File.Exists(InputPath) && Directory.Exists(outputDirectory) && SelectedType != -1);
}
//---------------------------------------------------------------------
public static string ReplaceTemplateVars(string template,
string speciesMapName)
{
varValues[SpeciesNameVar] = speciesMapName;
return(OutputPath.ReplaceTemplateVars(template, varValues));
}
private static string AutoGenerateFilename(OutputPath outputPathType, string path, string filename)
{
// Create folder
string fileFolder = string.Empty;
if (outputPathType == OutputPath.RelativeToProject)
{
string projectFolder = System.IO.Path.GetFullPath(System.IO.Path.Combine(Application.dataPath, ".."));
fileFolder = System.IO.Path.Combine(projectFolder, path);
}
else if (outputPathType == OutputPath.Absolute)
{
fileFolder = path;
}
// Combine path and filename
return System.IO.Path.Combine(fileFolder, filename);
}
//---------------------------------------------------------------------
public static void CheckTemplateVars(string template)
{
OutputPath.CheckTemplateVars(template, knownVars);
}
public FileWriter(OutputPath outputPath)
{
_outputPath = outputPath;
}
public ISynthesizerInstance Create(OutputPath output, ISynthesisConfiguration configuration)
{
return new XSTInstance(this, output, configuration);
}
public PlaceAndRouter(XilinxToolchain toolchain, OutputPath output)
{
Toolchain = toolchain;
OutputLocation = output;
}
private static string ManualGenerateFilename(OutputPath outputPathType, string path, string filename)
{
string result = filename;
if (outputPathType == OutputPath.RelativeToProject)
{
if (!System.IO.Path.IsPathRooted(filename) && !System.IO.Path.IsPathRooted(path))
{
string projectFolder = System.IO.Path.GetFullPath(System.IO.Path.Combine(Application.dataPath, ".."));
result = System.IO.Path.Combine(System.IO.Path.Combine(projectFolder, path), filename);
}
}
else if (outputPathType == OutputPath.Absolute)
{
if (!System.IO.Path.IsPathRooted(filename))
{
result = System.IO.Path.Combine(path, filename);
}
}
return result;
}
public override bool Execute()
{
if (!Directory.Exists(OutputPath))
{
Log.LogError($"OutputPath not found: {OutputPath}");
return(false);
}
var modInfoPath = Path.Combine(OutputPath, "info.json");
if (!File.Exists(modInfoPath))
{
// Unix FS is case sensitive
modInfoPath = Path.Combine(OutputPath, "Info.json");
if (!File.Exists(modInfoPath))
{
Log.LogError($"Mod Info.json not found: {modInfoPath}");
return(false);
}
}
ModInfo modInfo = null;
try
{
modInfo = JsonConvert.DeserializeObject <ModInfo>(File.ReadAllText(modInfoPath));
modInfo.Validate();
}
catch
{
Log.LogError($"Error parsing {modInfoPath}");
return(false);
}
var modSettingsPath = Path.Combine(OutputPath, "settings.xml");
if (File.Exists(modSettingsPath))
{
XDocument modSettings = null;
try
{
modSettings = XDocument.Load(modSettingsPath);
}
catch
{
Log.LogError($"Error parsing {modSettingsPath}");
return(false);
}
}
var modDir = Path.Combine(PublishPath, modInfo.DisplayName);
var zipFilePath = Path.Combine(modDir, $"{modInfo.Id}.zip");
EnsureParentDirExists(zipFilePath);
// Patch info.json
modInfo.Repository = $"https://{HostSiteDomain}/{Uri.EscapeDataString(modInfo.DisplayName)}/{RepositoryJsonFileName}";
if (string.IsNullOrEmpty(modInfo.HomePage))
{
modInfo.HomePage = $"https://{HostSiteDomain}/{Uri.EscapeDataString(modInfo.DisplayName)}/";
}
// Copy readme files
foreach (var readmeFilePath in Directory.EnumerateFiles(OutputPath, "*.md", SearchOption.TopDirectoryOnly))
{
var publishPath = Path.Combine(modDir, Path.GetFileName(readmeFilePath));
File.Copy(readmeFilePath, publishPath, overwrite: true);
}
File.WriteAllText(modInfoPath, JsonConvert.SerializeObject(modInfo, _jsonSerializerSettings));
{
using var zipFileStream = File.Create(zipFilePath);
using var outStream = new ZipOutputStream(zipFileStream);
foreach (var filePath in Directory.EnumerateFiles(OutputPath, "*", SearchOption.AllDirectories))
{
var relativeRootIndex = OutputPath.TrimEnd(Path.DirectorySeparatorChar).Length + 1;
outStream.PutNextEntry(new ZipEntry($"{modInfo.Id}/{filePath.Substring(relativeRootIndex).Replace('\\', '/')}"));
using var entryFs = File.OpenRead(filePath);
entryFs.CopyTo(outStream);
}
}
var repositoryJsonPath = Path.Combine(modDir, RepositoryJsonFileName);
EnsureParentDirExists(repositoryJsonPath);
var repo = new Repository
{
Releases = new Release[]
{
new Release
{
Id = modInfo.Id,
Version = modInfo.Version,
DownloadUrl = $"https://{HostSiteDomain}/{Uri.EscapeDataString(modInfo.DisplayName)}/{Uri.EscapeDataString(modInfo.Id)}.zip",
}
},
};
File.WriteAllText(repositoryJsonPath, JsonConvert.SerializeObject(repo, _jsonSerializerSettings));
return(true);
}
