public static bool IsEnabled(Type featureType)
{
bool defaultEnabled = !typeof(FeatureDisabled).IsAssignableFrom(featureType);
return(DebugOptions.GetOption(GetFeatureName(featureType),
defaultEnabled ? DebugOptions.ENABLED : DebugOptions.FEATURE_DISABLED_DEFAULT));
}
private void CreateDebugOptions(out UserSettings settings, out DebugOptions debugOptions, out SshDeltaCopy.Options options)
{
ThreadHelper.ThrowIfNotOnUIThread();
var allDeviceSettings = UserSettingsManager.Instance.Load();
settings = allDeviceSettings.CurrentUserSettings;
if (settings.UseDeployPathFromProjectFileIfExists)
{
try
{
_monoExtension.OverwriteWithProjectSettingsFromStartupProject(ref settings);
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
debugOptions = _monoExtension.CreateDebugOptions(settings);
options = new SshDeltaCopy.Options()
{
Host = settings.SSHHostIP,
Port = settings.SSHPort,
Username = settings.SSHUsername,
Password = settings.SSHPassword,
PrivateKeyFile = settings.SSHPrivateKeyFile,
SourceDirectory = debugOptions.OutputDirectory,
DestinationDirectory = settings.SSHDeployPath,
RemoveOldFiles = true,
PrintTimings = true,
RemoveTempDeleteListFile = true,
};
}
static int RunDebug(DebugOptions options)
{
var engine = new DesktopEngine();
var midiAccess = MidiAccessManager.Default;
Console.WriteLine("MIDI Inputs");
Console.WriteLine("-----------");
Console.WriteLine("");
Console.WriteLine($"\tId\tName");
Console.WriteLine($"-----------------------------------");
foreach (var input in midiAccess.Inputs)
{
Console.WriteLine($"\t{input.Id}\t{input.Name}");
}
Console.WriteLine();
Console.WriteLine("MIDI Outputs");
Console.WriteLine("------------");
Console.WriteLine("");
Console.WriteLine($"\tId\tName");
Console.WriteLine($"-----------------------------------");
foreach (var output in midiAccess.Outputs)
{
Console.WriteLine($"\t{output.Id}\t{output.Name}");
}
return(0);
}
private void Clone(object source, EventArgs args)
{
var container = Model.Container;
var current = container.Current;
var cloned = new DebugOptions(container)
{
HostAddress = current.HostAddress,
DebugPort = current.DebugPort,
RunAsDebugServer = current.RunAsDebugServer,
MaxConnectionAttempts = current.MaxConnectionAttempts,
TimeBetweenConnectionAttemptsMs = current.TimeBetweenConnectionAttemptsMs
};
var idx = 1;
var name = current.AppName + " Clone ";
while (container.Profiles.Any(p => p.AppName == name.Trim()))
{
name = $"{name.Substring(0, name.Length-(idx.ToString().Length)).Trim()} {idx++}";
}
cloned.AppName = name.Trim();
container.Profiles.Add(cloned);
container.SelectedName = cloned.AppName;
}
public DebugOptions CreateDebugOptions(UserSettings settings, bool useSSH = false)
{
ThreadHelper.ThrowIfNotOnUIThread();
var startupAssemblyPath = GetStartupAssemblyPath();
var targetExeFileName = Path.GetFileName(startupAssemblyPath);
var outputDirectory = Path.GetDirectoryName(startupAssemblyPath);
var startArguments = GetStartArguments();
var preDebugScript = settings.PreDebugScriptWithParameters
.Replace(settings.MONO_DEBUG_PORT, settings.SSHMonoDebugPort.ToString())
.Replace(settings.TARGET_EXE_FILENAME, targetExeFileName)
.Replace(settings.START_ARGUMENTS, startArguments)
.Replace("\r\n", "\n");
var debugScript = settings.DebugScriptWithParameters
.Replace(settings.MONO_DEBUG_PORT, settings.SSHMonoDebugPort.ToString())
.Replace(settings.TARGET_EXE_FILENAME, targetExeFileName)
.Replace(settings.START_ARGUMENTS, startArguments)
.Replace("\r\n", "\n");
var debugOptions = new DebugOptions()
{
UseSSH = useSSH,
StartupAssemblyPath = startupAssemblyPath,
UserSettings = settings,
OutputDirectory = outputDirectory,
TargetExeFileName = targetExeFileName,
StartArguments = startArguments,
PreDebugScript = preDebugScript,
DebugScript = debugScript,
};
return(debugOptions);
}
void updateAll()
{
if (inputManager.InputAccept())
{
if (currentSelection == 0)
{
currentSelection = 0;
maxSelection = 2;
currentOption = DebugOptions.Display;
}
else if (currentSelection == 1)
{
currentSelection = 0;
maxSelection = 4;
currentOption = DebugOptions.Score;
}
else if (currentSelection == 2)
{
currentSelection = 0;
maxSelection = 7;
currentOption = DebugOptions.Player;
}
else if (currentSelection == 3)
{
currentSelection = 0;
maxSelection = 2;
currentOption = DebugOptions.Save;
}
}
}
//public static string ComputeHash(string file)
//{
// using (FileStream stream = File.OpenRead(file))
// {
// var sha = new SHA256Managed();
// byte[] checksum = sha.ComputeHash(stream);
// return BitConverter.ToString(checksum).Replace("-", string.Empty);
// }
//}
private IntPtr GetDebugInfo(DebugOptions debugOptions)//string args, int debugPort, string targetExe, string outputDirectory)
{
var info = new VsDebugTargetInfo()
{
//cbSize = (uint)Marshal.SizeOf(info),
dlo = DEBUG_LAUNCH_OPERATION.DLO_CreateProcess,
bstrExe = debugOptions.StartupAssemblyPath,
bstrCurDir = debugOptions.OutputDirectory,
bstrArg = debugOptions.StartArguments,
bstrRemoteMachine = null, // debug locally
grfLaunch = (uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_StopDebuggingOnEnd, // When this process ends, debugging is stopped.
//grfLaunch = (uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_DetachOnStop, // Detaches instead of terminating when debugging stopped.
fSendStdoutToOutputWindow = 0,
clsidCustom = DebugEngineGuids.EngineGuid,
//bstrEnv = "",
bstrOptions = debugOptions.SerializeToJson() // add debug engine options
};
if (DebugEngineGuids.UseAD7Engine == EngineType.XamarinEngine)
{
info.bstrPortName = "Mono";
info.clsidPortSupplier = DebugEngineGuids.ProgramProviderGuid;
}
info.cbSize = (uint)Marshal.SizeOf(info);
IntPtr pInfo = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, pInfo, false);
return(pInfo);
}
public DebugOptions CreateDebugOptions(UserSettings settings)
{
NLogService.TraceEnteringMethod();
ThreadHelper.ThrowIfNotOnUIThread();
var startupAssemblyPath = GetStartupAssemblyPath();
var targetExeFileName = Path.GetFileName(startupAssemblyPath);
var outputDirectory = Path.GetDirectoryName(startupAssemblyPath);
var startArguments = GetStartArguments();
var preDebugScript = settings.DeployAndDebugOnLocalWindowsSystem ? settings.PreDebugScriptWithParametersWindows : settings.PreDebugScriptWithParameters;
preDebugScript = ReplaceDebugParameters(preDebugScript, settings, targetExeFileName, startArguments, "\n");
var debugScript = settings.DeployAndDebugOnLocalWindowsSystem ? settings.DebugScriptWithParametersWindows : settings.DebugScriptWithParameters;
debugScript = ReplaceDebugParameters(debugScript, settings, targetExeFileName, startArguments, "\n");
var debugOptions = new DebugOptions()
{
StartupAssemblyPath = startupAssemblyPath,
UserSettings = settings,
OutputDirectory = outputDirectory,
TargetExeFileName = targetExeFileName,
StartArguments = startArguments,
PreDebugScript = preDebugScript,
DebugScript = debugScript,
};
return(debugOptions);
}
private IntPtr GetDebugInfo(DebugOptions debugOptions)
{
ThreadHelper.ThrowIfNotOnUIThread();
var startupAssemblyPath = GetStartupAssemblyPath();
var targetExeFileName = Path.GetFileName(startupAssemblyPath);
var outputDirectory = Path.GetDirectoryName(startupAssemblyPath);
var info = new VsDebugTargetInfo()
{
//cbSize = (uint)Marshal.SizeOf(info),
dlo = DEBUG_LAUNCH_OPERATION.DLO_CreateProcess,
bstrExe = targetExeFileName,
bstrCurDir = outputDirectory,
bstrArg = GetStartArguments(),
bstrRemoteMachine = null, // debug locally
grfLaunch = (uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_StopDebuggingOnEnd, // When this process ends, debugging is stopped.
//grfLaunch = (uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_DetachOnStop, // Detaches instead of terminating when debugging stopped.
fSendStdoutToOutputWindow = 0,
clsidCustom = DebugEngineGuids.EngineGuid,
//bstrEnv = "",
bstrOptions = debugOptions.SerializeToJson(), // add debug engine options
bstrPortName = "Mono",
clsidPortSupplier = DebugEngineGuids.ProgramProviderGuid
};
info.cbSize = (uint)Marshal.SizeOf(info);
IntPtr pInfo = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, pInfo, false);
return(pInfo);
}
public void WatchItems <TypedItem>(IFolder folder, TypedItemEventHandler <TypedItem> handler, bool reportExisting)
where TypedItem : IItem
{
if (!DebugOptions.GetOption(null, DebugOptions.WATCHER_ENABLED))
{
return;
}
// Must have a ZPush folder to watch events.
ZPushFolder zPushFolder = folder.ZPush;
// Register the handlers
ItemsWatcher watcher = zPushFolder.ItemsWatcher();
watcher.ItemEvent += (item) =>
{
if (item is TypedItem)
{
handler((TypedItem)item);
}
};
// Report existing if requested
if (reportExisting)
{
zPushFolder.ReportExistingItems(handler);
}
}
private static int Debug(DebugOptions options)
{
BaseliningTester tester = new BaseliningTester();
tester.RunSeries(Path.Combine(options.TestRootPath, BaseliningTester.InputFolderName, options.DebugSeriesPath), options.DebugSeriesPath, options.DebugLogIndex, options.DebugResultIndex);
return(0);
}
public MainDialog(IDialogFactory dialogFactory, ICrmService crmService, string personId,
DebugOptions debugOptions = DebugOptions.None)
{
this.dialogFactory = dialogFactory;
this.crmService = crmService;
this.personId = personId;
this.debugOptions = debugOptions;
}
internal async Task AttachDebugger(DebugOptions debugOptions)
{
string appHash = ComputeHash(debugOptions.StartupAssemblyPath);
Project startup = GetStartupProject();
bool isWeb = ((object[])startup.ExtenderNames).Any(x => x.ToString() == "WebApplication");
ApplicationType appType = isWeb ? ApplicationType.Webapplication : ApplicationType.Desktopapplication;
if (appType == ApplicationType.Webapplication)
{
debugOptions.OutputDirectory += @"\..\..\";
}
var client = new DebugClient(appType, debugOptions.TargetExeFileName, debugOptions.StartArguments, debugOptions.OutputDirectory, appHash);
DebugSession session = await client.ConnectToServerAsync(debugOptions.UserSettings.LastIp);
var debugSessionStarted = await session.RestartDebuggingAsync(debugOptions.UserSettings.LastTimeout);
if (!debugSessionStarted)
{
await session.TransferFilesAsync();
await session.WaitForAnswerAsync(debugOptions.UserSettings.LastTimeout);
}
IntPtr pInfo = GetDebugInfo(debugOptions);
var sp = new ServiceProvider((IServiceProvider)_dte);
try
{
var dbg = (IVsDebugger)sp.GetService(typeof(SVsShellDebugger));
int hr = dbg.LaunchDebugTargets(1, pInfo);
Marshal.ThrowExceptionForHR(hr);
DebuggedProcess.Instance.AssociateDebugSession(session);
}
catch (Exception ex)
{
logger.Error(ex);
string msg;
var sh = (IVsUIShell)sp.GetService(typeof(SVsUIShell));
sh.GetErrorInfo(out msg);
if (!string.IsNullOrWhiteSpace(msg))
{
logger.Error(msg);
}
throw;
}
finally
{
if (pInfo != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(pInfo);
}
}
}
public MessageContextDispatcher(
ILogger <MessageContextDispatcher> logger,
IMessageContextFactory factory,
IOptions <DebugOptions> debugOptions)
{
_logger = logger;
_factory = factory;
_debugOptions = debugOptions.Value;
}
void Awake()
{
SceneManager.sceneLoaded += OnSceneLoaded;
_debugOptions = GetComponent <DebugOptions>();
_debugOptions.Options.AddRange(_options);
ApplyCurrentSettings();
}
public static void DebugOn()
{
Debug = new DebugOptions
{
AssertsWithStacks = false, DrawGraphEdges = false, DrawGraphNodes = false, DrawBogiePhysics = true,
DrawBendyPhysics = false, DrawSwitchControllers = true, DrawBogieEdges = true, DrawGradingShapes = true
};
DebugCommit();
}
private string SerializeDebuggerOptions(string jsonDebugOptions)
{
try
{
NLogService.TraceEnteringMethod(Logger);
var debugOptions = DebugOptions.DeserializeFromJson(jsonDebugOptions);
_session = new MonoDebugSession();
LogMonoDebuggerAssemblyPaths();
if (debugOptions.UserSettings.EnableVerboseDebugLogging)
{
RegisterEventHandlers();
}
var connectionTimeout = 30000;
var evaluationTimeout = 30000;
var startupProject = StartupProject;
XamarinEngine.DebugOptions = debugOptions;
var softDebuggerConnectArgs = new SoftDebuggerConnectArgs(debugOptions.TargetExeFileName, debugOptions.GetHostIP(), debugOptions.GetMonoDebugPort());
// TODO implement programm output via stream
//softDebuggerConnectArgs.RedirectOutput = true;
//softDebuggerConnectArgs.OutputPort = ???;
//_session.VirtualMachine.StandardOutput ???
softDebuggerConnectArgs.TimeBetweenConnectionAttempts = (int)debugOptions.UserSettings.TimeBetweenConnectionAttemptsInMs;
softDebuggerConnectArgs.MaxConnectionAttempts = (int)debugOptions.UserSettings.MaxConnectionAttempts;
_startInfo = new StartInfo(
softDebuggerConnectArgs,
new DebuggingOptions()
{
EvaluationTimeout = evaluationTimeout,
MemberEvaluationTimeout = evaluationTimeout,
ModificationTimeout = evaluationTimeout,
SocketTimeout = connectionTimeout
},
startupProject
);
SessionMarshalling sessionMarshalling = new SessionMarshalling(_session, _startInfo);
using (MemoryStream ms = new MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
ObjRef oref = RemotingServices.Marshal(sessionMarshalling);
bf.Serialize(ms, oref);
return(Convert.ToBase64String(ms.ToArray()));
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
// Start is called before the first frame update
new void Start()
{
debugOptions = FindObjectOfType <DebugOptions>();
attackRigidbody = attack.GetComponent <Rigidbody2D>();
if (!attackRigidbody)
{
Debug.LogError("No rigidbody found on attack, did you forget to give the enemy an attack?");
}
base.Start();
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(string))
{
// Show full registry string
Feature feature = value as Feature;
return(DebugOptions.GetOptions(feature?.Name));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public MapperOptions()
{
Strictness = new MapperStrictnessOptions
{
ThrowWithoutCorrespondingSourceMember = false
};
Conventions = new MapperConventionOptions
{
CallToStringWhenDestinationIsString = true,
AutomaticallyFlattenHierarchies = true,
MakeCloneIfDestinationIsTheSameAsSource = true,
IgnoreMemberAttributeShouldBeRespected = true,
ReuseNonNullComplexMembersOnDestination = true,
IgnoreCaseWhenFindingMatch = true,
IgnoreMembersWithNullValueOnSource = false,
PreserveDestinationListContents = true,
MaxDepth = null
};
Safety = new MapperSafetyOptions
{
PerformNullChecksOnCustomMappings = true,
IfSourceIsNull = SourceObjectNullOptions.ReturnNullWhenSourceIsNull,
IfRecursiveRelationshipIsDetected = RecursivePropertyOptions.IgnoreRecursiveProperties,
ThrowIfDestinationIsNull = true,
EnsureCollectionIsNotArrayType = true,
UseDefaultValueForMissingVariable = true
};
Compilation = new CompilationOptions
{
CompileToDynamicAssembly = true
};
Projection = new ProjectionOptions
{
MapCollectionMembers = true
};
Cloning = new CloneOptions
{
MaxCloneDepth = 2,
};
Debug = new DebugOptions
{
#if DEBUG
DebugInformationEnabled = true
#else
DebugInformationEnabled = false
#endif
};
}
}
private void Start()
{
deathBehaviors = GetComponents <DeathBehavior>();
debugOptions = FindObjectOfType <DebugOptions>();
if (GetComponent <MainCharacter>())
{
MaximumHealth = FindObjectOfType <GameSession>().currentMaximumHealth;
}
CurrentHealth = MaximumHealth;
SetGameStatId(GameStats.STAT_HEALTH);
}
public bool Start(string filename, string cmdLine, string cwd, BreakProcessKind breakKind)
{
var options = new DebugOptions {
Filename = filename,
CommandLine = cmdLine,
CurrentDirectory = cwd,
BreakProcessKind = breakKind,
};
return(Start(options));
}
public DebugMenu(SpriteFont fnt, InputManager im, SaveData sd, Level lvl)
{
font = fnt;
inputManager = im;
saveData = sd;
level = lvl;
currentOption = DebugOptions.All;
currentSelection = 0;
maxSelection = 4;
}
public static DebugOptions GetInstance()
{
if(h_Instance == null)
{
h_Instance = GameObject.FindObjectOfType<DebugOptions>();
if (h_Instance == null)
Debug.LogWarning("DebugOptions instance is being requested, but no object has been found using it");
}
return h_Instance;
}
public static DBG.DebugProcessOptions Convert(DebugOptions options, IDebuggerSettings settings, DBG.CLRTypeDebugInfo info) {
if (options == null)
throw new ArgumentNullException();
var o = new DBG.DebugProcessOptions(info);
o.Filename = options.Filename;
o.CommandLine = options.CommandLine;
o.CurrentDirectory = options.CurrentDirectory;
o.DebugMessageDispatcher = WpfDebugMessageDispatcher.Instance;
o.BreakProcessKind = Convert(options.BreakProcessKind);
o.DebugOptions.IgnoreBreakInstructions = settings.IgnoreBreakInstructions;
return o;
}
public static DebugOptions GetInstance()
{
if (h_Instance == null)
{
h_Instance = GameObject.FindObjectOfType <DebugOptions>();
if (h_Instance == null)
{
Debug.LogWarning("DebugOptions instance is being requested, but no object has been found using it");
}
}
return(h_Instance);
}
public DebugProcessOptions CopyTo(DebugProcessOptions other)
{
other.CLRTypeDebugInfo = CLRTypeDebugInfo.Clone();
other.Filename = Filename;
other.CommandLine = CommandLine;
other.CurrentDirectory = CurrentDirectory;
other.InheritHandles = InheritHandles;
other.ProcessCreationFlags = ProcessCreationFlags;
other.DebugMessageDispatcher = DebugMessageDispatcher;
other.DebugOptions = DebugOptions == null ? null : DebugOptions.Clone();
other.BreakProcessKind = BreakProcessKind;
return(other);
}
public GridXZ(int width, int height, float cellSize, Vector3 gridOrigin = default, T startingValue = default, bool debug = false, DebugOptions?debugOptions = null)
{
this.width = width;
this.height = height;
this.cellSize = cellSize;
this.gridOrigin = gridOrigin;
grid = new T[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
grid[x, y] = startingValue;
}
}
if (!debug)
{
return;
}
if (debugOptions == null)
{
debugOptions = new DebugOptions();
}
Quaternion rotation = Quaternion.Euler(90, 0, 0);
if (debugOptions.Value.ShowText)
{
debugText = new TextMeshPro[width, height];
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Debug.DrawLine(GetWorldCoordinates(x, y), GetWorldCoordinates(x, y + 1), Color.white, debugOptions.Value.LineDuration, false);
Debug.DrawLine(GetWorldCoordinates(x, y), GetWorldCoordinates(x + 1, y), Color.white, debugOptions.Value.LineDuration, false);
if (debugOptions.Value.ShowText)
{
debugText[x, y] = Utils.CreateWorldText(grid[x, y].ToString(), position: GetWorldCoordinates(x, y) + new Vector3(cellSize, cellSize) * 0.5f,
fontSize: debugOptions.Value.FontSize, rotation: rotation, horizontalAlignment: HorizontalAlignmentOptions.Center,
verticalAlignment: VerticalAlignmentOptions.Middle);
}
}
}
Debug.DrawLine(GetWorldCoordinates(0, height), GetWorldCoordinates(width, height), Color.white, debugOptions.Value.LineDuration, false);
Debug.DrawLine(GetWorldCoordinates(width, 0), GetWorldCoordinates(width, height), Color.white, debugOptions.Value.LineDuration, false);
OnGridValueChanged += args => { debugText[args.X, args.Y].text = args.NewValue.ToString(); };
}
internal static void AttachDebugger(DebugOptions options)
{
if (options == DebugOptions.No)
{
return;
}
#if DEBUG
if (!Debugger.IsAttached)
{
if (options == DebugOptions.Prompt)
{
var response = Prompt.GetYesNo(
"Do you wish to debug? Attach now or press [Y] and [ENTER] to attach. Press [N] or [ENTER] to continue.",
defaultAnswer: false,
promptColor: ConsoleColor.Cyan);
options = response ? DebugOptions.Yes : DebugOptions.No;
}
if (options == DebugOptions.Yes || options == DebugOptions.YesSilent)
{
var vsProcess =
VisualStudioAttacher.GetVisualStudioForSolutions(
new List <string> {
"AudioAnalysis.sln"
});
if (vsProcess != null)
{
VisualStudioAttacher.AttachVisualStudioToProcess(vsProcess, Process.GetCurrentProcess());
}
else
{
// try and attach the old fashioned way
Debugger.Launch();
}
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (Debugger.IsAttached)
{
if (options != DebugOptions.YesSilent)
{
LoggedConsole.WriteLine("\t>>> Attach sucessful");
LoggedConsole.WriteLine();
}
}
}
#endif
}
private void CreateDebugOptions(out UserSettings settings, out DebugOptions debugOptions, out SshDeltaCopy.Options options)
{
ThreadHelper.ThrowIfNotOnUIThread();
var allDeviceSettings = UserSettingsManager.Instance.Load();
settings = allDeviceSettings.CurrentUserSettings;
if (settings.UseDeployPathFromProjectFileIfExists)
{
try
{
var localProjectConfig = _monoExtension.GetProjectSettingsFromStartupProject();
if (localProjectConfig.HasValue)
{
if (!string.IsNullOrWhiteSpace(localProjectConfig.Value.SSHDeployPath))
{
Logger.Info($"SSHDeployPath = {settings.SSHDeployPath} was overwritten with local *.VSMonoDebugger.config: {localProjectConfig.Value.SSHDeployPath}");
settings.SSHDeployPath = localProjectConfig.Value.SSHDeployPath;
}
if (!string.IsNullOrWhiteSpace(localProjectConfig.Value.WindowsDeployPath))
{
Logger.Info($"WindowsDeployPath = {settings.WindowsDeployPath} was overwritten with local *.VSMonoDebugger.config: {localProjectConfig.Value.WindowsDeployPath}");
settings.WindowsDeployPath = localProjectConfig.Value.WindowsDeployPath;
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
debugOptions = _monoExtension.CreateDebugOptions(settings);
options = new SshDeltaCopy.Options()
{
Host = settings.SSHHostIP,
Port = settings.SSHPort,
Username = settings.SSHUsername,
Password = settings.SSHPassword,
PrivateKeyFile = settings.SSHPrivateKeyFile,
SourceDirectory = debugOptions.OutputDirectory,
DestinationDirectory = settings.SSHDeployPath,
RemoveOldFiles = true,
PrintTimings = true,
RemoveTempDeleteListFile = true,
};
}
public void AttachDebuggerToRunningProcess(DebugOptions debugOptions)
{
NLogService.TraceEnteringMethod();
ThreadHelper.ThrowIfNotOnUIThread();
if (DebugEngineGuids.UseAD7Engine == EngineType.XamarinEngine)
{
// Workaround to get StartProject
XamarinEngine.StartupProject = GetStartupProject();
}
IntPtr pInfo = GetDebugInfo(debugOptions);
var sp = new ServiceProvider((IServiceProvider)_dte);
try
{
var dbg = sp.GetService(typeof(SVsShellDebugger)) as IVsDebugger;
if (dbg == null)
{
logger.Error($"GetService did not returned SVsShellDebugger");
}
int hr = dbg.LaunchDebugTargets(1, pInfo);
Marshal.ThrowExceptionForHR(hr);
}
catch (Exception ex)
{
logger.Error(ex);
string msg = null;
var sh = sp.GetService(typeof(SVsUIShell)) as IVsUIShell;
if (sh != null)
{
sh.GetErrorInfo(out msg);
}
if (!string.IsNullOrWhiteSpace(msg))
{
logger.Error(msg);
}
throw;
}
finally
{
if (pInfo != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(pInfo);
}
}
}
public static DBG.DebugProcessOptions Convert(DebugOptions options, IDebuggerSettings settings, DBG.CLRTypeDebugInfo info)
{
if (options == null)
{
throw new ArgumentNullException();
}
var o = new DBG.DebugProcessOptions(info);
o.Filename = options.Filename;
o.CommandLine = options.CommandLine;
o.CurrentDirectory = options.CurrentDirectory;
o.DebugMessageDispatcher = WpfDebugMessageDispatcher.Instance;
o.BreakProcessKind = Convert(options.BreakProcessKind);
o.DebugOptions.IgnoreBreakInstructions = settings.IgnoreBreakInstructions;
return(o);
}
public bool Start(DebugOptions options) => dispatcher.UI(() => debugService.Value.DebugAssembly(Utils.Convert(options, debugService.Value.DebuggerSettings, new DBG.DesktopCLRTypeDebugInfo())));
public AttachProcessOptions() {
this.DebugOptions = new DebugOptions();
}
public DebugProcessOptions(CLRTypeDebugInfo info) {
CLRTypeDebugInfo = info;
DebugOptions = new DebugOptions();
BreakProcessKind = BreakProcessKind.None;
}
/// <summary>
/// Constructor
/// </summary>
public CoreCLRDebugOptions() {
Options = new DebugOptions();
}
public AttachProcessOptions(CLRTypeAttachInfo info) {
this.DebugOptions = new DebugOptions();
this.CLRTypeAttachInfo = info;
}
/// <summary>
/// Calls CRYPTO_dbg_set_options()
/// </summary>
/// <param name="options"></param>
public static void SetDebugOptions(DebugOptions options)
{
Native.CRYPTO_dbg_set_options((int)options);
}
public bool Start(string filename, string cmdLine, string cwd, BreakProcessKind breakKind) {
var options = new DebugOptions {
Filename = filename,
CommandLine = cmdLine,
CurrentDirectory = cwd,
BreakProcessKind = breakKind,
};
return Start(options);
}
