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] }; }