protected override void ParseProgramArgs()
{
//get and test the cmd line arg key\values
var argHash = ConsoleCmd.ArgHash(_args);
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting("NoFuture.ToolsCustomTools.InvokeNfTypeName");
if (argHash.ContainsKey(AssemblyAnalysis.GET_TOKEN_IDS_PORT_CMD_SWITCH))
{
_getTokenIdsCmdPort = ResolveInt(argHash[AssemblyAnalysis.GET_TOKEN_IDS_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.GET_TOKEN_NAMES_PORT_CMD_SWITCH))
{
_getTokenNamesCmdPort = ResolveInt(argHash[AssemblyAnalysis.GET_TOKEN_NAMES_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.GET_ASM_INDICES_PORT_CMD_SWITCH))
{
_getasmIndicesCmdPort = ResolveInt(argHash[AssemblyAnalysis.GET_ASM_INDICES_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.GET_TOKEN_TYPES_PORT_CMD_SWITCH))
{
_getTokenTypesCmdPort = ResolveInt(argHash[AssemblyAnalysis.GET_TOKEN_TYPES_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.GET_TOKEN_PAGE_RANK_PORT_CMD_SWITCH))
{
_getTokenPageRankCmdPort = ResolveInt(argHash[AssemblyAnalysis.GET_TOKEN_PAGE_RANK_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.REASSIGN_TOKEN_NAMES_PORT_CMD_SWITCH))
{
_reassignTokenNamesCmdPort = ResolveInt(argHash[AssemblyAnalysis.REASSIGN_TOKEN_NAMES_PORT_CMD_SWITCH].ToString());
}
if (argHash.ContainsKey(AssemblyAnalysis.RESOLVE_GAC_ASM_SWITCH))
{
_resolveGacAsms = ResolveBool(argHash[AssemblyAnalysis.RESOLVE_GAC_ASM_SWITCH].ToString());
}
}
/// <summary>
/// Creates a new wrapper around the remote process.
/// </summary>
/// <param name="ports"></param>
/// <remarks>
/// See the detailed notes on its sister type <see cref="AssemblyAnalysis"/> ctor.
/// While not exact in terms of what its doing - it is exact in terms of how it does it.
/// </remarks>
public Flatten(params int[] ports)
{
if (string.IsNullOrWhiteSpace(NfConfig.CustomTools.InvokeFlatten) || !File.Exists(NfConfig.CustomTools.InvokeFlatten))
{
throw new ItsDeadJim("Don't know where to locate the NoFuture.Util.Tokens.InvokeFlatten.exe, assign " +
"the global variable at NoFuture.Tools.CustomTools.InvokeFlatten.");
}
var args = string.Empty;
var getFlatAsmPort = DefaultPort;
if (ports != null && ports.Length > 0)
{
getFlatAsmPort = ports[0];
args = ConsoleCmd.ConstructCmdLineArgs(GET_FLAT_ASM_PORT_CMD_SWITCH,
getFlatAsmPort.ToString(CultureInfo.InvariantCulture));
}
MyProcess = StartRemoteProcess(NfConfig.CustomTools.InvokeFlatten, args);
_invokeGetFlattenAssemblyCmd = new InvokeGetFlattenAssembly()
{
ProcessId = MyProcess.Id,
SocketPort = getFlatAsmPort
};
}
/// <summary>
/// The ctor both instantiates this type and launches the remote process which does
/// the actual parsing.
/// </summary>
/// <param name="port"></param>
public NfTypeNameProcess(int?port)
{
//is there one already running?
MyProcess =
System.Diagnostics.Process.GetProcessesByName("NoFuture.Tokens.InvokeNfTypeName").FirstOrDefault();
if (MyProcess != null)
{
_invokeCmd = new InvokeGetNfTypeName
{
ProcessId = MyProcess.Id,
SocketPort = port.GetValueOrDefault(DefaultPort)
};
return;
}
if (string.IsNullOrWhiteSpace(NfConfig.CustomTools.InvokeNfTypeName) || !File.Exists(NfConfig.CustomTools.InvokeNfTypeName))
{
throw new ItsDeadJim("Don't know where to locate the NoFuture.Tokens.InvokeNfTypeName.exe, assign " +
"the global variable at NoFuture.Tools.CustomTools.InvokeNfTypeName.");
}
var cmdPort = port.GetValueOrDefault(DefaultPort);
var args = ConsoleCmd.ConstructCmdLineArgs(GET_NF_TYPE_NAME_CMD_SWITCH, cmdPort.ToString());
MyProcess = StartRemoteProcess(NfConfig.CustomTools.InvokeNfTypeName, args);
_invokeCmd = new InvokeGetNfTypeName
{
ProcessId = MyProcess.Id,
SocketPort = cmdPort
};
}
/// <summary>
/// Runs <see cref="AsmDiagram"/> to generate a diagram
/// on another process to keep the loaded assemblies isolated from the invoking app domain.
/// </summary>
/// <param name="assemblyPath"></param>
/// <returns>This output is JSON and not GraphViz syntax</returns>
public static string RunIsolatedAsmAdjGraph(string assemblyPath)
{
var argPath = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_ASM_PATH_SWITCH, assemblyPath);
var diagramType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DIAGRAM_TYPE,
Settings.ASM_ADJ_GRAPH);
return(RunGraphViz(argPath, null, diagramType, 60));
}
public void TestParseArgsToKeyValueHash()
{
var testcmd = "-connStr=Server=localhost;Database=ApexQA01;Trusted_Connection=True;";
var testResult = ConsoleCmd.ParseArgKey2StringHash(testcmd);
Assert.IsNotNull(testResult);
Console.WriteLine(testResult.Value.Value);
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
if (argHash.ContainsKey(NfTypeNameProcess.GET_NF_TYPE_NAME_CMD_SWITCH))
{
_getNfTypeNamePort = ResolveInt(argHash[NfTypeNameProcess.GET_NF_TYPE_NAME_CMD_SWITCH].ToString());
}
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting("NoFuture.ToolsCustomTools.InvokeNfTypeName");
if (argHash.ContainsKey(Flatten.GET_FLAT_ASM_PORT_CMD_SWITCH))
{
_getFlattenAssemblyCmdPort = ResolveInt(argHash[Flatten.GET_FLAT_ASM_PORT_CMD_SWITCH].ToString());
}
}
/// <summary>
/// Run its counterpart <see cref="GetClassDiagram"/> in an isolated process
/// </summary>
public static string RunIsolatedGetClassDiagram(string assemblyPath, string typeFullName, bool displayEnums, int maxWaitInSeconds = 60)
{
var argPath = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_ASM_PATH_SWITCH, assemblyPath);
var argType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_FULL_TYPE_NAME_SWITCH, typeFullName);
var diagramType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DIAGRAM_TYPE,
Settings.CLASS_DIAGRAM);
var argEn = displayEnums
? ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DISPLAY_ENUMS, null)
: null;
return(RunGraphViz(argPath, argType, diagramType, maxWaitInSeconds, argEn));
}
/// <summary>
/// Runs <see cref="AsmDiagram"/> to generate a diagram
/// on another process to keep the loaded assemblies isolated from the invoking app domain.
/// </summary>
/// <param name="assemblyPath"></param>
/// <param name="withNamespaceSubgraphs"></param>
/// <returns></returns>
public static string RunIsolatedAsmDiagram(string assemblyPath, bool withNamespaceSubgraphs = false)
{
var argPath = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_ASM_PATH_SWITCH, assemblyPath);
var diagramType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DIAGRAM_TYPE,
Settings.ASM_OBJ_GRAPH_DIAGRAM);
if (withNamespaceSubgraphs)
{
var withNsOutlines = ConsoleCmd.ConstructCmdLineArgs(Settings.ASM_OBJ_OUTLINE_NS, null);
return(RunGraphViz(argPath, null, diagramType, 60, withNsOutlines));
}
return(RunGraphViz(argPath, null, diagramType, 60));
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
GetFileCmdArgs(argHash);
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting("NoFuture.ToolsCustomTools.InvokeNfTypeName");
if (MyFileParameters.FileCommand == InvokeKind.HostSjcl)
{
return;
}
GetHostSjclCmdArgs(argHash);
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting("NoFuture.ToolsCustomTools.InvokeNfTypeName");
if (!argHash.ContainsKey(Dpx.BIN_DIR) ||
argHash[Dpx.BIN_DIR] == null)
{
throw new RahRowRagee(
$"the switch '{Dpx.BIN_DIR}' could not be " +
$"parsed from cmd line arg \n{string.Join(" ", _args)}");
}
BinDir = argHash[Dpx.BIN_DIR].ToString();
}
public void TestArgHash()
{
var testCmd = new[]
{
"-connStr=Server=localhost;Database=ApexQA01;Trusted_Connection=True;",
@"-spmFilePath=C:\ProgramFiles (x86)\Somepath\SomeFile.bin",
"-mySwitchHere"
};
var testResult = ConsoleCmd.ArgHash(testCmd);
Assert.IsNotNull(testResult);
foreach (var k in testResult.Keys)
{
Console.WriteLine(string.Format("{0}\n\t\t{1}", k, testResult[k]));
}
}
/// <summary>
/// A helper function used to draft the entire command line switch (s)
/// which are passed to the NoFuture.Hbm.InvokeStoredProc.exe process.
///
/// The function handles wrapping values in double quotes when said value
/// contains a space. When the args are assigned to a <see cref="System.Diagnostics.ProcessStartInfo"/>
/// as a single string and, in turn, received by a console's Main statement as a
/// string array the values are being split on the space char (0x20) and the double-quotes
/// are removed.
/// </summary>
/// <param name="spItem"></param>
/// <param name="connectionString"></param>
/// <returns></returns>
public static string ConstructCmdLineArgs(StoredProcMetadata spItem, string connectionString)
{
var cmdArg = new StringBuilder();
cmdArg.Append(ConsoleCmd.ConstructCmdLineArgs(CONNECTION_STR_SWITCH, connectionString));
cmdArg.Append(" ");
cmdArg.Append(ConsoleCmd.ConstructCmdLineArgs(FILE_PATH_SWITCH, spItem.BinFilePath));
cmdArg.Append(" ");
cmdArg.Append(ConsoleCmd.ConstructCmdLineArgs(HBM_STORED_PROX_DIR_SWITCH, Settings.HbmStoredProcsDirectory));
cmdArg.Append(" ");
cmdArg.Append(ConsoleCmd.ConstructCmdLineArgs(SEND_MESSAGES_BACK_ON_SOCKET, Boolean.TrueString));
return(cmdArg.ToString());
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
if (!argHash.ContainsKey(Settings.INVOKE_ASM_PATH_SWITCH) ||
argHash[Settings.INVOKE_ASM_PATH_SWITCH] == null)
{
throw new RahRowRagee(
$"the switch '{Settings.INVOKE_ASM_PATH_SWITCH}' could not be " +
$"parsed from cmd line arg \n{string.Join(" ", _args)}");
}
if (!argHash.ContainsKey(Settings.INVOKE_FULL_TYPE_NAME_SWITCH) ||
argHash[Settings.INVOKE_FULL_TYPE_NAME_SWITCH] == null)
{
throw new RahRowRagee(
$"the switch '{Settings.INVOKE_FULL_TYPE_NAME_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}");
}
ResolveDependencies = argHash.ContainsKey(Settings.INVOKE_RESOLVE_ALL_DEPENDENCIES) &&
string.Equals(argHash[Settings.INVOKE_RESOLVE_ALL_DEPENDENCIES].ToString(),
bool.TrueString,
StringComparison.OrdinalIgnoreCase);
AsmPath = argHash[Settings.INVOKE_ASM_PATH_SWITCH].ToString();
if (!File.Exists(AsmPath))
{
throw new RahRowRagee($"There is no assembly at '{AsmPath}'.");
}
NfConfig.AssemblySearchPaths.Add(Path.GetDirectoryName(AsmPath));
Assembly = NfConfig.UseReflectionOnlyLoad
? Asm.NfReflectionOnlyLoadFrom(AsmPath)
: Asm.NfLoadFrom(AsmPath);
if (Assembly == null)
{
throw new RahRowRagee(
$"The assembly at '{AsmPath}' could not be loaded, " +
$"see the log at '{Asm.ResolveAsmLog}' for more info.");
}
TypeName = argHash[Settings.INVOKE_FULL_TYPE_NAME_SWITCH].ToString();
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting("NoFuture.ToolsCustomTools.InvokeNfTypeName");
}
/// <summary>
/// Runs <see cref="Flatten"/>
/// </summary>
/// <param name="assemblyPath"></param>
/// <param name="typeFullName"></param>
/// <param name="maxDepth">The max recursive depth.</param>
/// <param name="onlyPrimitivesNamed"></param>
/// <param name="displayEnums"></param>
/// <param name="maxWaitInSeconds"></param>
/// <returns></returns>
public static string RunIsolatedFlattenTypeDiagram(string assemblyPath, string typeFullName,
string onlyPrimitivesNamed, bool displayEnums, int maxDepth = FlattenLineArgs.MAX_DEPTH, int maxWaitInSeconds = 60)
{
var argPath = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_ASM_PATH_SWITCH, assemblyPath);
var argType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_FULL_TYPE_NAME_SWITCH, typeFullName);
var diagramType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DIAGRAM_TYPE,
Settings.FLATTENED_DIAGRAM);
var argP = !string.IsNullOrWhiteSpace(onlyPrimitivesNamed)
? ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_FLATTENED_LIMIT_TYPE, onlyPrimitivesNamed)
: null;
var argEn = displayEnums
? ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_DISPLAY_ENUMS, null)
: null;
var argMaxDepth = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_GRAPHVIZ_FLATTEN_MAX_DEPTH,
maxDepth.ToString());
return(RunGraphViz(argPath, argType, diagramType, maxWaitInSeconds, argP, argEn, argMaxDepth));
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
MyParameters = new DomainParameters
{
AppDomain = argHash.ContainsKey(Engine.APP_DOMAIN_SWITCH) ? $"{argHash[Engine.APP_DOMAIN_SWITCH]}"
: ConfigFileAppDomain,
AspListenerPrefix = argHash.ContainsKey(Engine.ASP_LISTENER_SWITCH) ?
$"{argHash[Engine.ASP_LISTENER_SWITCH]}"
: ConfigFileAspHttp
};
if (string.IsNullOrWhiteSpace(MyParameters.AppDomain) || !System.IO.Directory.Exists(MyParameters.AppDomain))
{
throw new ItsDeadJim($"The '{Engine.APP_DOMAIN_SWITCH}' value is missing or invalid.");
}
if (string.IsNullOrWhiteSpace(MyParameters.AspListenerPrefix))
{
throw new ItsDeadJim($"The '{Engine.ASP_LISTENER_SWITCH}' value is missing or invalid");
}
}
public Dpx(string binDir)
{
if (string.IsNullOrWhiteSpace(binDir) || !Directory.Exists(binDir))
{
throw new ItsDeadJim($"The {binDir} directory was not found");
}
if (string.IsNullOrWhiteSpace(NfConfig.CustomTools.InvokeDpx) || !File.Exists(NfConfig.CustomTools.InvokeDpx))
{
throw new ItsDeadJim("Don't know where to locate the NoFuture.Tokens.DotNetMeta.InvokeDpx, assign " +
"the global variable at NoFuture.CustomTools.InvokeDpx.");
}
var args = string.Join(" ", ConsoleCmd.ConstructCmdLineArgs(BIN_DIR, binDir));
_si = new ProcessStartInfo
{
FileName = NfConfig.CustomTools.InvokeDpx,
Arguments = args,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true
};
}
protected override void ParseProgramArgs()
{
//get and test the cmd line arg key\values
var argHash = ConsoleCmd.ArgHash(_args);
if (argHash == null || argHash.Keys.Count <= 0)
{
throw new RahRowRagee($"could not parse cmd line arg \n{string.Join(" ", _args)}");
}
if (!argHash.ContainsKey(Settings.INVOKE_ASM_PATH_SWITCH) ||
argHash[Settings.INVOKE_ASM_PATH_SWITCH] == null)
{
throw new RahRowRagee(
$"the switch '{Settings.INVOKE_ASM_PATH_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}");
}
AsmPath = argHash[Settings.INVOKE_ASM_PATH_SWITCH].ToString();
if (!File.Exists(AsmPath))
{
throw new RahRowRagee($"There is no assembly at '{AsmPath}'.");
}
NfConfig.AssemblySearchPaths.Add(Path.GetDirectoryName(AsmPath));
Assembly = NfConfig.UseReflectionOnlyLoad
? Asm.NfReflectionOnlyLoadFrom(AsmPath)
: Asm.NfLoadFrom(AsmPath);
GraphText = string.Empty;
OutputFileName = string.Empty;
if (Assembly == null)
{
throw new RahRowRagee(
$"The assembly at '{AsmPath}' could not " +
$"be loaded, see the log at '{Asm.ResolveAsmLog}' for more info.");
}
LimitOn = argHash[Settings.INVOKE_GRAPHVIZ_FLATTENED_LIMIT_TYPE];
DisplayEnums = argHash.ContainsKey(Settings.INVOKE_GRAPHVIZ_DISPLAY_ENUMS);
DiagramType = argHash[Settings.INVOKE_GRAPHVIZ_DIAGRAM_TYPE].ToString();
if (DiagramType == Settings.ASM_OBJ_GRAPH_DIAGRAM || DiagramType == Settings.ASM_ADJ_GRAPH)
{
WithNamespaceOutlines = argHash.ContainsKey(Settings.ASM_OBJ_OUTLINE_NS);
return;
}
if (!argHash.ContainsKey(Settings.INVOKE_FULL_TYPE_NAME_SWITCH) ||
argHash[Settings.INVOKE_FULL_TYPE_NAME_SWITCH] == null)
{
throw new RahRowRagee(
$"the switch '{Settings.INVOKE_FULL_TYPE_NAME_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}");
}
TypeName = argHash[Settings.INVOKE_FULL_TYPE_NAME_SWITCH].ToString();
MaxDepth = argHash.ContainsKey(Settings.INVOKE_GRAPHVIZ_FLATTEN_MAX_DEPTH)
? ResolveInt(argHash.ContainsKey(Settings.INVOKE_GRAPHVIZ_FLATTEN_MAX_DEPTH).ToString())
.GetValueOrDefault(FlattenLineArgs.MAX_DEPTH)
: FlattenLineArgs.MAX_DEPTH;
if (string.IsNullOrWhiteSpace(DiagramType) || !_implementedDiagrams.Contains(DiagramType))
{
throw new RahRowRagee("choose a valid type of diagram listed in the help ");
}
}
/// <summary>
/// Runs its counterpart <see cref="GetCgOfType"/> in an isolated process.
/// </summary>
/// <param name="assemblyPath"></param>
/// <param name="typeFullName"></param>
/// <param name="resolveDependencies"></param>
/// <param name="maxWaitInSeconds"></param>
/// <returns></returns>
public static CgType GetIsolatedCgOfType(string assemblyPath, string typeFullName,
bool resolveDependencies = false, int maxWaitInSeconds = 60)
{
var tempDebug = NfConfig.TempDirectories.Debug;
if (string.IsNullOrWhiteSpace(tempDebug) || !Directory.Exists(tempDebug))
{
throw new RahRowRagee("The constant value at " +
"'NoFuture.Shared.Cfg.NfConfig.TempDirectories.Debug' is not assigned.");
}
var invokeGetCgTypePath = NfConfig.CustomTools.InvokeGetCgType;
if (string.IsNullOrWhiteSpace(typeFullName))
{
throw new ArgumentNullException(nameof(typeFullName));
}
if (string.IsNullOrWhiteSpace(invokeGetCgTypePath))
{
throw new RahRowRagee("The constants value at " +
"'NoFuture.Shared.Cfg.NfConfig.CustomTools.InvokeGetCgType' is not assigned.");
}
if (!File.Exists(invokeGetCgTypePath))
{
throw new ItsDeadJim(
$"The binary 'NoFuture.Gen.InvokeGetCgOfType.exe' is not at '{invokeGetCgTypePath}'.");
}
var argPath = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_ASM_PATH_SWITCH, assemblyPath);
var argType = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_FULL_TYPE_NAME_SWITCH, typeFullName);
var argResolve = ConsoleCmd.ConstructCmdLineArgs(Settings.INVOKE_RESOLVE_ALL_DEPENDENCIES,
resolveDependencies.ToString());
string buffer = null;
using (var invokeGetCgType = new Process
{
StartInfo = new ProcessStartInfo(invokeGetCgTypePath)
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
Arguments = string.Join(" ", new[] { argPath, argType, argResolve })
}
})
{
invokeGetCgType.Start();
buffer = invokeGetCgType.StandardOutput.ReadToEnd();
invokeGetCgType.WaitForExit(maxWaitInSeconds);
if (!invokeGetCgType.HasExited)
{
invokeGetCgType.Kill();
throw new ItsDeadJim(
"The 'NoFuture.Gen.InvokeGetCgOfType.exe' ran " +
$"longer than '{maxWaitInSeconds}' seconds and was shut down.");
}
}
if (string.IsNullOrWhiteSpace(buffer))
{
throw new ItsDeadJim("The invocation to 'NoFuture.Gen.InvokeGetCgOfType.exe' didn't " +
"return anything on its standard output.");
}
File.WriteAllBytes(Path.Combine(tempDebug, "GetIsolatedCgType.json"),
Encoding.UTF8.GetBytes(buffer));
var dcs = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(CgType));
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(buffer)))
{
var cgTypeOut = dcs.ReadObject(ms) as CgType;
if (cgTypeOut == null)
{
throw new ItsDeadJim(
$"Could not deserialize into a CgType from the standard output text of\n {buffer}");
}
return(cgTypeOut);
}
}
/// <summary>
/// Handles a specific set of formatted runtime commands as printed in <see cref="RuntimeHelp"/>
/// </summary>
/// <param name="ut">User entered text</param>
protected internal void RtCommands(string ut)
{
try
{
if (string.IsNullOrWhiteSpace(ut))
{
return;
}
if (!ut.StartsWith(NfConfig.CmdLineArgSwitch))
{
return;
}
var cmds = ut.Split(' ');
var rtArgHash = ConsoleCmd.ArgHash(cmds);
if (rtArgHash.ContainsKey(ASSIGN_REGEX_PATTERN_RT_CMD))
{
var regexPattern = rtArgHash[ASSIGN_REGEX_PATTERN_RT_CMD];
if (string.IsNullOrWhiteSpace(regexPattern?.ToString()))
{
return;
}
AssemblyNameRegexPattern = regexPattern.ToString().Trim();
PrintToConsole($"AssemblyNameRegexPattern = {AssemblyNameRegexPattern}");
}
if (rtArgHash.ContainsKey(RESOLVE_TOKEN_ID_CMD))
{
var tokenCmd = rtArgHash[RESOLVE_TOKEN_ID_CMD];
if (string.IsNullOrWhiteSpace(tokenCmd?.ToString()))
{
return;
}
var tokenCmdStr = tokenCmd.ToString().Trim();
if (!Regex.IsMatch(tokenCmdStr, @"^[0-9]\.([0-9]+|0x[0-9a-fA-F]+)$"))
{
return;
}
var asmIdxStr = tokenCmdStr.Split('.')[0];
var tokenIdStr = tokenCmdStr.Split('.')[1];
int tokenId;
int asmIdx;
if (!int.TryParse(asmIdxStr, out asmIdx))
{
return;
}
if (Regex.IsMatch(tokenIdStr, "0x[0-9a-fA-F]+"))
{
tokenIdStr = tokenIdStr.Substring(2);
if (!int.TryParse(tokenIdStr, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out tokenId))
{
return;
}
}
else
{
if (!int.TryParse(tokenIdStr, out tokenId))
{
return;
}
}
var mdt = new MetadataTokenId {
Id = tokenId, RslvAsmIdx = asmIdx
};
MetadataTokenName tokenName;
if (!_utilityMethods.ResolveSingleTokenName(mdt, out tokenName))
{
PrintToConsole($"could not resolve name {ut}");
return;
}
PrintToConsole(tokenName.Name);
if (!tokenName.IsMethodName())
{
return;
}
var resolveDepth = 0;
var st = new Stack <MetadataTokenId>();
var msg = new StringBuilder();
var tTokensIds = new GetTokenIds(this);
tTokensIds.ResolveCallOfCall(mdt, ref resolveDepth, st, msg);
if (mdt.Items == null || mdt.Items.Length <= 0)
{
PrintToConsole("ResolveCallOfCall returned nothing");
PrintToConsole(msg.ToString(), false);
return;
}
Console.WriteLine();
PrintToConsole(MetadataTokenId.Print(mdt), false);
}
}
catch (Exception ex)
{
PrintToConsole("console entry error");
PrintToConsole(ex);
}
}
protected override void ParseProgramArgs()
{
var argHash = ConsoleCmd.ArgHash(_args);
if (argHash == null || argHash.Keys.Count <= 0)
{
var msg = $"could not parse cmd line arg \n{string.Join(" ", _args)}";
throw new ItsDeadJim(msg);
}
NfConfig.CustomTools.InvokeNfTypeName = SysCfg.GetAppCfgSetting(AppSettingKeyNames.NF_TYPE_NAME_EXE);
if (!argHash.ContainsKey(InvokeStoredProcManager.HBM_STORED_PROX_DIR_SWITCH) ||
argHash[InvokeStoredProcManager.HBM_STORED_PROX_DIR_SWITCH] == null)
{
var msg =
$"the switch '{InvokeStoredProcManager.HBM_STORED_PROX_DIR_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}";
throw new ItsDeadJim(msg);
}
Settings.HbmStoredProcsDirectory = argHash[InvokeStoredProcManager.HBM_STORED_PROX_DIR_SWITCH].ToString();
if (!argHash.ContainsKey(InvokeStoredProcManager.CONNECTION_STR_SWITCH) ||
argHash[InvokeStoredProcManager.CONNECTION_STR_SWITCH] == null)
{
var msg =
$"the switch '{InvokeStoredProcManager.CONNECTION_STR_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
if (!argHash.ContainsKey(InvokeStoredProcManager.FILE_PATH_SWITCH) ||
argHash[InvokeStoredProcManager.FILE_PATH_SWITCH] == null)
{
var msg =
$"the switch '{InvokeStoredProcManager.FILE_PATH_SWITCH}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
if (!argHash.ContainsKey(InvokeStoredProcManager.SEND_MESSAGES_BACK_ON_SOCKET) ||
argHash[InvokeStoredProcManager.SEND_MESSAGES_BACK_ON_SOCKET] == null)
{
var msg =
$"the switch '{InvokeStoredProcManager.SEND_MESSAGES_BACK_ON_SOCKET}' could not " +
$"be parsed from cmd line arg \n{string.Join(" ", _args)}";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
if (
!bool.TryParse(argHash[InvokeStoredProcManager.SEND_MESSAGES_BACK_ON_SOCKET].ToString(),
out _sendSocketMessages))
{
var msg =
"could not parse the value 'True' nor 'False' from " +
$"the '{InvokeStoredProcManager.SEND_MESSAGES_BACK_ON_SOCKET}' switch " +
$"using the cmd line arg \n{string.Join(" ", _args)}";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
ConnectionString = argHash[InvokeStoredProcManager.CONNECTION_STR_SWITCH].ToString();
SpmFilePath = argHash[InvokeStoredProcManager.FILE_PATH_SWITCH].ToString();
if (!File.Exists(SpmFilePath))
{
var msg = $"bad path or file name '{SpmFilePath}'";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
if (!SortingContainers.StoredProcMetadata.TryDeserializeFromDisk(SpmFilePath, out _myProcMetadata))
{
var msg =
$"could not deserialize the file \n'{SpmFilePath}' " +
$"into the type \n'{typeof(SortingContainers.StoredProcMetadata).FullName}'";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
if (string.IsNullOrWhiteSpace(_myProcMetadata.ProcName))
{
var msg = "there isn't a stored proc name in " +
$"the deserialized file at \n'{SpmFilePath}'";
Settings.WriteToStoredProcLog(msg);
throw new ItsDeadJim(msg);
}
}
/// <summary>
/// Launches the NoFuture.Tokens.Gia.InvokeAssemblyAnalysis.exe
/// </summary>
/// <param name="resolveGacAsmNames"></param>
/// <param name="ports">
/// Optional, allows caller to specify the ports used - will use defaults
/// otherwise.
/// </param>
/// <returns></returns>
/// <remarks>
/// The ports used are <see cref="DefaultPort"/> to <see cref="DefaultPort"/> + 5.
/// </remarks>
/// <remarks>
/// <![CDATA[
/// +------------------------------------------------------------------------------------------------------------+
/// | Using AssemblyAnalysis |
/// ||+--operating-context(1)--+|+-----new-instance(2)----+|+------remote-exe(3)-----+|+---target-assembly(4)---+|
/// || new instance of | | | |
/// || ................> | | |
/// || | start new process | | |
/// || | provide assembly name | | |
/// || | ................> | |
/// || | | launch sockets | |
/// || | | get asm names on manifest| |
/// || | | ................> |
/// || | |send AsmIndicies on socket| |
/// || | <................ | |
/// || | receive AsmIndices | | |
/// || | save to disk | | |
/// || | assign to prop | | |
/// || <................ | | |
/// || invoke GetTokenIds with | | | |
/// || regex | | | |
/// || ................> | | |
/// || | send GetTokenIdsCriteria | | |
/// || | on socket | | |
/// || | ................> | |
/// || | | get types as tokens | |
/// || | | ................> |
/// || | | get members as tokens | |
/// || | | ................> |
/// || | | get callvirts as tokens | |
/// || | | ................> |
/// || | | get tokens-of-tokens(a) | |
/// || | | ................> |
/// || | |send TokenIds on socket(b)| |
/// || | <................ | |
/// || | get TokenIds | | |
/// || | save to disk | | |
/// || | return TokenIds | | |
/// || <................ | | |
/// || flatten the TokenIds | | | |
/// || invoke GetTokenNames | | | |
/// || ................> | | |
/// || | send MetadataTokenId[] on| | |
/// || | socket | | |
/// || | ................> | |
/// || | | resolve each to a runtime| |
/// || | | type | |
/// || | | ................> |
/// || | | send TokenNames on socket| |
/// || | <................ | |
/// || | receive TokenNames | | |
/// || | save to disk | | |
/// || | return TokenNames | | |
/// || <................ | | |
/// ||+------------------------+|+------------------------+|+------------------------+|+------------------------+|
///
/// (1) assume PowerShell
/// (2) new instance of NoFuture.Tokens.DotNetMeta.AssemblyAnalysis
/// (3) new process NoFuture.Tokens.DotNetMeta.InvokeAssemblyAnalysis.exe
/// (4) the assembly whose tokens we want
///
/// (a) The top-level types already had all thier members resolved to tokens and every virtcall found within the body of those members.
/// This is now starting it all over again as if the types found on the callvirts in the body of these members were themselves the top-level types.
/// This will continue until we end up on a type which is contained in an assembly whose name doesn't match our regex pattern.
/// (b) This is a tree data-struct. Each token has itself a collection of tokens and so on.
/// ]]>
/// </remarks>
/// <example>
/// <![CDATA[
/// # will launch a console
/// $myAsmAly = New-Object NoFuture.Tokens.DotNetMeta.AssemblyAnalysis($false)
///
/// # this is assembly-name-to-index used to reduce the size of socket payloads
/// $myAsmIndices = $myAsmAly.GetAsmIndices($AssemblyPath)
///
/// # this is all the types in a similar form
/// $myTokenTypes = $myAsmAly.GetTokenTypes("NoFuture.*")
///
/// # this will represent the call-stack-tree in terms of just metadata token ids
/// $myTokensIds = $myAsmAly.GetTokenIds(0, "NoFuture.*")
///
/// # translates the metadata token ids into a token name (e.g. type, method, field, etc.)
/// $myTokenNames = $myAsmAly.GetTokenNames($myTokensIds.GetAsRoot().SelectDistinct(), $true)
/// ]]>
/// </example>
/// <example>
/// <![CDATA[
/// # example using analysis results
/// # say, some app with three layers: web, logic and data
/// # have already run the analysis and have all the results on file as JSON
/// $myAsmAly = New-Object NoFuture.Tokens.DotNetMeta.AssemblyAnalysis($false)
///
/// # web layer uses types from logic layer as interfaces
/// $myWebTokens = ([NoFuture.Tokens.DotNetMeta.TokenName.TokenNameResponse]::ReadFromFile($webTokensFile)).GetAsRoot()
/// $myWebTypes = ([NoFuture.Tokens.DotNetMeta.TokenType.TokenTypeResponse]::ReadFromFile($webTypesFile)).GetAsRoot()
/// $myWebAssemblies = [NoFuture.Tokens.DotNetMeta.TokenAsm.TAsmIndexResponse]::ReadFromFile($webAssemblyFile)
///
/// #logic layer uses types from data layer, likewise, as interfaces
/// $myLogicTokens = ([NoFuture.Tokens.DotNetMeta.TokenName.TokenNameResponse]::ReadFromFile($logicTokensFile)).GetAsRoot()
/// $myLogicTypes = ([NoFuture.Tokens.DotNetMeta.TokenType.TokenTypeResponse]::ReadFromFile($logicTypesFile)).GetAsRoot()
///
/// #data layer is as far down as we want to go
/// $myDataTokens = ([NoFuture.Tokens.DotNetMeta.TokenName.TokenNameResponse]::ReadFromFile($dataTokensFile)).GetAsRoot()
/// $myDataTypes = ([NoFuture.Tokens.DotNetMeta.TokenType.TokenTypeResponse]::ReadFromFile($dataTypesFile)).GetAsRoot()
///
/// #expand logic layer with data layer's concrete types
/// $myLogicTokens = $myAsmAly.ReassignTokenNames($myLogicTokens, $myDataTokens, $myDataTypes).GetAsRoot()
///
/// #expand web layer with expanded logic layer's concrete types
/// $myWebTokens = $myAsmAly.ReassignTokenNames($myWebTokens, $myLogicTokens, $myLogicTypes).GetAsRoot()
///
/// #get all token names in logic layer as a Set instead of a Data-Tree
/// $myFlatLogicTokens = $myLogicTokens.SelectDistinct()
///
/// #do likewise for the web layer - get tokens as a Set
/// $myFlatWebTokens = $myWebTokens.SelectDistinct()
///
/// #now normal Set-Operations can be applied
/// #say, want to find orphaned methods in logic layer no longer used by web layer
/// $myOrphanedLogicTokens = $myFlatWebTokens.GetRightSetDiff($myFlatLogicTokens)
///
/// #this would tell us all the types with at least one orphaned member
/// $orphanedTypes = $myOrphanedLogicTokens.GetUniqueTypeNames() | Sort-Object
///
/// #using NoFuture.Gen, we could remove these systematically if we know where to find the assemblies with .pdb's
/// $searchDirs = @(
/// "C:\Projects\MyProj\Web\bin",
/// "C:\Projects\MyProj\Logic\debug\bin",
/// "C:\Projects\MyProj\Data\debug\bin")
///
///
/// #(in actual practice, you would want to perform null-checks, skipped here for brevity)
/// $orphanedTypes | % {
/// $typeName = $_
///
/// $tokenType = $myWebTypes.Items | ? {$_.Name -eq $typeName}
///
/// #PDB data will not be found for interface type def's
/// if($tokenType.IsInterfaceType()){
/// $tokenType = $tokenTypes.GetFirstInterfaceImplementor($tokenType)
/// }
///
/// #need to go backwards from a type name to some path to some assembly on the drive
/// $asmPath = [NoFuture.Tokens.DotNetMeta.TokenAsm.AsmIndexResponse]::GetAssemblyPathFromRoot($typeName, $myWebAssemblies, $tokenType, $searchDirs)
///
/// #now get this as a NoFuture.Gen code-gen type (assuming .NET code file was C#)
/// $nfCgType = New-Object NoFuture.Gen.CgTypeCsSrcCode($asmPath,$typeName)
///
/// #collect up all the orphaned members now as NoFuture.Gen.CgMember's
/// $nfCgMems = New-Object "System.Collections.Generic.List[NoFuture.Gen.CgMember]"
/// $orphanedMembersByType = $myOrphanedLogicTokens.SelectTypeNamesThatEndWith(([string[]]@($typeName)))
/// $orphanedMembersByType | % {
///
/// #NoFuture.Gen directly transforms a MetadataTokenName into a CgMember
/// $nfCgMems.Add($nfCgType.CgType.FindCgMemberByTokenName($_))
/// }
///
/// #blow away the orphaned members from the original source code file(s)
/// [NoFuture.Gen.RefactorExtensions]::RemoveMembers($nfCgMems, $true)
/// }
/// ]]>
/// </example>
public AssemblyAnalysis(bool resolveGacAsmNames, params int[] ports)
{
if (string.IsNullOrWhiteSpace(NfConfig.CustomTools.InvokeAssemblyAnalysis) || !File.Exists(NfConfig.CustomTools.InvokeAssemblyAnalysis))
{
throw new ItsDeadJim("Don't know where to locate the NoFuture.Tokens.DotNetMeta.InvokeAssemblyAnalysis, assign " +
"the global variable at NoFuture.Shared.Cfg.NfConfig.CustomTools.InvokeAssemblyAnalysis.");
}
var np = DefaultPort;
var usePorts = new int[6];
for (var i = 0; i < usePorts.Length; i++)
{
usePorts[i] = ports != null && ports.Length >= i + 1 ? ports[i] : np + i;
}
var args = string.Join(" ",
ConsoleCmd.ConstructCmdLineArgs(GET_ASM_INDICES_PORT_CMD_SWITCH,
usePorts[0].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(GET_TOKEN_IDS_PORT_CMD_SWITCH,
usePorts[1].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(GET_TOKEN_NAMES_PORT_CMD_SWITCH,
usePorts[2].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(GET_TOKEN_PAGE_RANK_PORT_CMD_SWITCH,
usePorts[3].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(GET_TOKEN_TYPES_PORT_CMD_SWITCH,
usePorts[4].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(REASSIGN_TOKEN_NAMES_PORT_CMD_SWITCH,
usePorts[5].ToString(CultureInfo.InvariantCulture)),
ConsoleCmd.ConstructCmdLineArgs(RESOLVE_GAC_ASM_SWITCH, resolveGacAsmNames.ToString()));
MyProcess = StartRemoteProcess(NfConfig.CustomTools.InvokeAssemblyAnalysis, args);
_getAsmIndiciesCmd = new InvokeGetAsmIndicies
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[0]
};
_getTokenIdsCmd = new InvokeGetTokenIds
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[1]
};
_getTokenNamesCmd = new InvokeGetTokenNames
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[2]
};
_getTokenPageRankCmd = new InvokeGetTokenPageRank
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[3]
};
_getTokenTypesCmd = new InvokeGetTokenTypes
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[4]
};
_reassignTokenNamesCmd = new InvokeReassignTokenNames
{
ProcessId = MyProcess.Id,
SocketPort = usePorts[5]
};
}
