private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Welcome.txt"));
if (config.Root["?", "h", "help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Help.txt"));
return;
}
if (!config.Root.AttrByIndex(0).Exists)
{
throw new Exception("Assembly is missing");
}
var afn = config.Root.AttrByIndex(0).Value;
if (string.IsNullOrWhiteSpace(afn))
{
throw new Exception("Assembly empty path");
}
afn = Path.GetFullPath(afn);
ConsoleUtils.Info("Trying to load assembly: " + afn);
var asm = Assembly.LoadFile(afn);
ConsoleUtils.Info("Assembly file loaded OK");
var tcompiler = typeof(CSharpGluecCompiler);
var tcname = config.Root["c", "compiler"].AttrByIndex(0).Value;
if (!string.IsNullOrWhiteSpace(tcname))
{
tcompiler = Type.GetType(tcname, true);
}
var compiler = Activator.CreateInstance(tcompiler, new object[] { asm }) as GluecCompiler;
if (compiler == null)
{
throw new Exception("Could not create compiler type");
}
compiler.OutPath = Path.GetDirectoryName(afn);
compiler.FilePerContract = true;
compiler.NamespaceFilter = config.Root["f", "flt", "filter"].AttrByIndex(0).Value;
ConfigAttribute.Apply(compiler, config.Root["o", "opt", "options"]);
ConsoleUtils.Info("Namespace filter: " + compiler.NamespaceFilter);
compiler.Compile();
}
static int Main(string[] args)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
App.Current.OnExecute(async() =>
await Watch(CommandArgsConfiguration.Parse(App.Current, args))
);
return(App.Current.Execute(args));
}
static void Main(string[] str_args)
{
Console.WriteLine("NFX License Block Updater");
Console.WriteLine(" Usage:");
Console.WriteLine(" licupd path lfile [-pat pattern] [-insert]");
Console.WriteLine(" path - path to code base");
Console.WriteLine(" lfile - path to license file");
Console.WriteLine(" [-pat pattern] - optional pattern search such as '-pat *.txt'. Assumes '*.cs' if omitted");
Console.WriteLine(" [-insert] - optional switch that causes license block insertion when missing");
var args = new CommandArgsConfiguration(str_args);
var path = args.Root.AttrByIndex(0).ValueAsString(string.Empty);
var license = File.ReadAllText(args.Root.AttrByIndex(1).ValueAsString(string.Empty));
var fpat = args.Root["pat"].AttrByIndex(0).ValueAsString("*.cs");
var insert = args.Root["insert"].Exists;
var regexp = new Regex(
@"/\*<FILE_LICENSE>[\s*|\S*]{0,}</FILE_LICENSE>\*/"
);
var replaced = 0;
var inserted = 0;
foreach (var fn in path.AllFileNamesThatMatch(fpat, true))
{
var content = File.ReadAllText(fn);
if (regexp.Match(content).Success)
{
Console.Write("Matched: " + fn);
File.WriteAllText(fn, regexp.Replace(content, license));
Console.WriteLine(" Replaced.");
replaced++;
}
else
if (insert)
{
content = license + Environment.NewLine + content;
File.WriteAllText(fn, content);
Console.WriteLine("Inserted: " + fn);
inserted++;
}
}//freach file
Console.WriteLine(string.Format("Total Replaced: {0} Inserted: {1}", replaced, inserted));
Console.WriteLine("Strike <enter>");
Console.ReadLine();
}
private void btnCommandArgs_Click(object sender, EventArgs e)
{
try
{
var args = this.txtCommandArgs.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var conf = new CommandArgsConfiguration(args);
this.resultCommandArgs.Text = conf.ToLaconicString();
}
catch (Exception ex)
{
this.resultCommandArgs.Text = ex.ToMessageWithType();
}
}
static void Main(string[] args)
{
Configuration argsConfig = new CommandArgsConfiguration(args);
if (argsConfig.Root[CommonApplicationLogic.CONFIG_SWITCH].Exists)
{
using (new ServiceBaseApplication(args, null))
run(App.ConfigRoot, true);
}
else
{
run(argsConfig.Root, false);
}
}
private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Welcome.txt"));
if (config.Root["?", "h", "help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Help.txt"));
return;
}
var asmFileName = config.Root.AttrByIndex(0).Value;
var path = config.Root.AttrByIndex(1).Value;
if (asmFileName.IsNullOrWhiteSpace())
{
throw new Exception("Assembly missing");
}
if (path.IsNullOrWhiteSpace())
{
throw new Exception("Output path is missing");
}
if (!File.Exists(asmFileName))
{
throw new Exception("Assembly file does not exist");
}
if (!Directory.Exists(path))
{
throw new Exception("Output path does not exist");
}
var assembly = Assembly.LoadFrom(asmFileName);
using (var generator = new CodeGenerator())
{
generator.RootPath = path;
generator.CodeSegregation = config.Root["c", "code"].ValueAsEnum(CodeGenerator.GeneratedCodeSegregation.FilePerNamespace);
generator.Generate(assembly);
}
}
//perform the core construction of app instance,
//this is a method because of C# inability to control ctor chaining sequence
//this is framework internal code, developers do not call
protected void Constructor(bool allowNesting,
string[] cmdLineArgs,
ConfigSectionNode rootConfig,
IApplicationDependencyInjectorImplementation defaultDI = null)
{
m_AllowNesting = allowNesting;
if (cmdLineArgs != null && cmdLineArgs.Length > 0)
{
var acfg = new CommandArgsConfiguration(cmdLineArgs)
{
Application = this
};
m_CommandArgs = acfg.Root;
}
else
{
var acfg = new MemoryConfiguration {
Application = this
};
m_CommandArgs = acfg.Root;
}
m_ConfigRoot = rootConfig ?? GetConfiguration().Root;
m_Singletons = new ApplicationSingletonManager();
m_NOPApplicationSingletonManager = new NOPApplicationSingletonManager();
m_DefaultDependencyInjector = defaultDI ?? new ApplicationDependencyInjector(this);
m_Realm = new ApplicationRealmBase(this);
m_NOPLog = new NOPLog(this);
m_NOPModule = new NOPModule(this);
m_NOPInstrumentation = new NOPInstrumentation(this);
m_NOPDataStore = new NOPDataStore(this);
m_NOPObjectStore = new NOPObjectStore(this);
m_NOPGlue = new NOPGlue(this);
m_NOPSecurityManager = new NOPSecurityManager(this);
m_DefaultTimeSource = new DefaultTimeSource(this);
m_NOPEventTimer = new NOPEventTimer(this);
}
/// <summary>
/// Takes optional args[] and root configuration. If configuration is null then
/// application is configured from a file co-located with entry-point assembly and
/// called the same name as assembly with '.config' extension, unless args are specified and "/config file"
/// switch is used in which case 'file' has to be locatable and readable.
/// </summary>
public ServiceBaseApplication(string[] args, ConfigSectionNode rootConfig)
{
lock (typeof(ServiceBaseApplication))
{
if (s_Instance != null)
{
throw new NFXException(StringConsts.SVCAPP_INSTANCE_ALREADY_CREATED_ERROR);
}
try
{
Configuration argsConfig;
if (args != null)
{
argsConfig = new CommandArgsConfiguration(args);
}
else
{
argsConfig = new MemoryConfiguration();
}
m_CommandArgs = argsConfig.Root;
m_ConfigRoot = rootConfig ?? GetConfiguration().Root;
InitApplication();
s_Instance = this;
}
catch
{
Destructor();
throw;
}
}
}
private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
if (config.Root["?"].Exists ||
config.Root["h"].Exists ||
config.Root["help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(Program).GetText("Help.txt"));
return;
}
if (!config.Root.AttrByIndex(0).Exists)
{
Console.WriteLine("Specify ';'-delimited assembly list");
return;
}
var manager = new InventorizationManager(config.Root.AttrByIndex(0).Value);
var fnode = config.Root["f"];
if (!fnode.Exists)
{
fnode = config.Root["filter"];
}
if (fnode.Exists)
{
ConfigAttribute.Apply(manager, fnode);
}
foreach (var n in config.Root.Children.Where(chi => chi.IsSameName("s") || chi.IsSameName("strat") || chi.IsSameName("strategy")))
{
var tname = n.AttrByIndex(0).Value ?? "<unspecified>";
Type t = Type.GetType(tname);
if (t == null)
{
throw new NFXException("Can not create strategy type: " + tname);
}
var strategy = Activator.CreateInstance(t) as IInventorization;
if (strategy == null)
{
throw new NFXException("The supplied type is not strategy: " + tname);
}
manager.Strategies.Add(strategy);
}
if (manager.Strategies.Count == 0)
{
manager.Strategies.Add(new BasicInventorization());
}
// if (config.Root["any"].Exists)
// manager.OnlyAttributed = false;
var result = new XMLConfiguration();
result.Create("inventory");
manager.Run(result.Root);
Console.WriteLine(result.SaveToString());
}
private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Welcome.txt"));
if (config.Root["?", "h", "help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Help.txt"));
return;
}
if (!config.Root.AttrByIndex(0).Exists)
{
throw new Exception("Schema file missing");
}
var schemaFileName = config.Root.AttrByIndex(0).Value;
if (string.IsNullOrWhiteSpace(schemaFileName))
{
throw new Exception("Schema empty path");
}
schemaFileName = Path.GetFullPath(schemaFileName);
ConsoleUtils.Info("Trying to load schema: " + schemaFileName);
var schema = new Schema(schemaFileName, new string[] { Path.GetDirectoryName(schemaFileName) });
ConsoleUtils.Info("Schema file loaded OK");
var tcompiler = typeof(MsSqlCompiler);
var tcname = config.Root["c", "compiler"].AttrByIndex(0).Value;
if (!string.IsNullOrWhiteSpace(tcname))
{
tcompiler = Type.GetType(tcname, true);
}
var compiler = Activator.CreateInstance(tcompiler, new object[] { schema }) as Compiler;
if (compiler == null)
{
throw new Exception("Could not create compiler type");
}
compiler.OutputPath = Path.GetDirectoryName(schemaFileName);
var options = config.Root["o", "opt", "options"];
if (options.Exists)
{
compiler.Configure(options);
}
ConsoleUtils.Info("Compiler information:");
Console.WriteLine(" Type={0}\n Name={1}\n Target={2}".Args(compiler.GetType().FullName, compiler.Name, compiler.Target));
if (compiler is RDBMSCompiler)
{
Console.WriteLine(" DomainsSearchPath={0}".Args(((RDBMSCompiler)compiler).DomainSearchPaths));
}
Console.WriteLine(" OutPath={0}".Args(compiler.OutputPath));
Console.WriteLine(" OutPrefix={0}".Args(compiler.OutputPrefix));
Console.WriteLine(" CaseSensitivity={0}".Args(compiler.NameCaseSensitivity));
compiler.Compile();
foreach (var error in compiler.CompileErrors)
{
ConsoleUtils.Error(error.ToMessageWithType());
}
if (compiler.CompileException != null)
{
ConsoleUtils.Warning("Compile exception thrown");
throw compiler.CompileException;
}
}
private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Welcome.txt"));
if (config.Root["?"].Exists ||
config.Root["h"].Exists ||
config.Root["help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Help.txt"));
return;
}
if (!config.Root.AttrByIndex(0).Exists)
{
ConsoleUtils.Error("Template source path is missing");
return;
}
var files = getFiles(config.Root);
var ctypename = config.Root["c"].AttrByIndex(0).Value ?? config.Root["compiler"].AttrByIndex(0).Value;
var ctype = string.IsNullOrWhiteSpace(ctypename)? typeof(Azos.Templatization.TextCSTemplateCompiler) : Type.GetType(ctypename);
if (ctype == null)
{
throw new AzosException("Can not create compiler type: " + (ctypename ?? "<none>"));
}
var compiler = Activator.CreateInstance(ctype) as TemplateCompiler;
var onode = config.Root["options"];
if (!onode.Exists)
{
onode = config.Root["o"];
}
if (onode.Exists)
{
ConfigAttribute.Apply(compiler, onode);
var asms = onode.AttrByName("ref").ValueAsString(string.Empty).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var asm in asms)
{
compiler.ReferenceAssembly(asm);
}
}
showOptions(compiler);
foreach (var f in files)
{
var src = new FileTemplateStringContentSource(f);
ConsoleUtils.Info("Included: " + src.GetName(50));
compiler.IncludeTemplateSource(src);
}
compiler.Compile();
if (compiler.HasErrors)
{
showErrors(compiler, config.Root);
return;
}
if (config.Root["src"].Exists)
{
writeToDiskCompiledSourceFiles(compiler, config.Root);
}
}
private static void run(string[] args)
{
var config = new CommandArgsConfiguration(args);
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Welcome.txt"));
if (config.Root["?", "h", "help"].Exists)
{
ConsoleUtils.WriteMarkupContent(typeof(ProgramBody).GetText("Help.txt"));
return;
}
var asmFileName = config.Root.AttrByIndex(0).Value;
var path = config.Root.AttrByIndex(1).Value;
if (asmFileName.IsNullOrWhiteSpace())
{
throw new Exception("Assembly missing");
}
if (path.IsNullOrWhiteSpace())
{
throw new Exception("Output path is missing");
}
if (!File.Exists(asmFileName))
{
throw new Exception("Assembly file does not exist");
}
if (!Directory.Exists(path))
{
throw new Exception("Output path does not exist");
}
//20191106 DKh
//var assembly = Assembly.LoadFrom(asmFileName);
Assembly assembly;
try
{
assembly = Assembly.LoadFrom(asmFileName);
var allTypes = CodeGenerator.DefaultScanForAllRowTypes(assembly);
//this throws on invalid loader exception as
var schemas = allTypes.Select(t => Schema.GetForTypedDoc(t)).ToArray();//it touches all type/schemas because of .ToArray()
ConsoleUtils.Info("Assembly contains {0} data document schemas".Args(schemas.Length));
}
catch (Exception asmerror)
{
ConsoleUtils.Error("Could not load assembly: `{0}`".Args(asmFileName));
ConsoleUtils.Warning("Exception: ");
ConsoleUtils.Warning(asmerror.ToMessageWithType());
Console.WriteLine();
ConsoleUtils.Warning(new WrappedExceptionData(asmerror).ToJson(JsonWritingOptions.PrettyPrintASCII));
throw;
}
using (var generator = new CodeGenerator())
{
generator.RootPath = path;
generator.CodeSegregation = config.Root["c", "code"].AttrByIndex(0).ValueAsEnum(CodeGenerator.GeneratedCodeSegregation.FilePerNamespace);
generator.HeaderDetailLevel = config.Root["hdr", "header", "hl"].AttrByIndex(0).ValueAsInt(255);
generator.Generate(assembly);
}
}
