public RemoteDebugPort(RemoteDebugPortSupplier supplier, IDebugPortRequest2 request, string portName)
{
this.guidId = Guid.NewGuid();
this.supplier = supplier;
this.request = request;
this.portName = portName;
} // ctor
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string name;
pRequest.GetPortName(out name);
Match m = _portNameRegex.Match(name);
if (!m.Success) {
return Marshal.GetHRForException(new FormatException());
}
string secret = m.Groups["secret"].Value;
string hostName = m.Groups["hostName"].Value;
ushort portNum = _defaultPort;
if (m.Groups["portNum"].Success) {
if (!ushort.TryParse(m.Groups["portNum"].Value, out portNum)) {
return Marshal.GetHRForException(new FormatException());
}
}
var port = new JRemoteDebugPort(this, hostName, portNum, secret, _useSsl);
ppPort = port;
return 0;
}
//string pname;
public SquirrelPort(SquirrelPortSupplier supplier, IDebugPortRequest2 req)
{
// string pname;
//req.GetPortName(out pname);
this.req = req;
this.supplier = supplier;
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string name;
pRequest.GetPortName(out name);
Match m = _portNameRegex.Match(name);
if (!m.Success)
{
return(Marshal.GetHRForException(new FormatException()));
}
string secret = m.Groups["secret"].Value;
string hostName = m.Groups["hostName"].Value;
ushort portNum = _defaultPort;
if (m.Groups["portNum"].Success)
{
if (!ushort.TryParse(m.Groups["portNum"].Value, out portNum))
{
return(Marshal.GetHRForException(new FormatException()));
}
}
var port = new LuaRemoteDebugPort(this, hostName, portNum, secret, _useSsl);
ppPort = port;
return(0);
}
public DebugPort(RDebugPortSupplier supplier, IDebugPortRequest2 request) {
_supplier = supplier;
_request = request;
var compModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
compModel.DefaultCompositionService.SatisfyImportsOnce(this);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected int CreatePort(IDebugPortRequest2 portRequest, out IDebugPort2 port)
{
LoggingUtils.PrintFunction();
try
{
string requestPortName;
LoggingUtils.RequireOk(portRequest.GetPortName(out requestPortName));
if (string.IsNullOrWhiteSpace(requestPortName))
{
throw new InvalidOperationException("Invalid/empty port name");
}
AndroidDevice device = AndroidAdb.GetConnectedDeviceById(requestPortName);
if (device == null)
{
throw new InvalidOperationException("Failed to find a device with the name: " + requestPortName);
}
port = new DebuggeePort(this, device);
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
port = null;
return(Constants.E_FAIL);
}
}
public PythonRemoteDebugPort(PythonRemoteDebugPortSupplier supplier, IDebugPortRequest2 request, Uri uri, TextWriter debugLog)
{
_supplier = supplier;
_request = request;
_uri = uri;
_debugLog = debugLog ?? new DebugTextWriter();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#region IDebugPortSupplier2 Members
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
//
// Attempt to find a port matching the requested name, otherwise one is created.
//
LoggingUtils.PrintFunction();
try
{
LoggingUtils.RequireOk(CanAddPort());
LoggingUtils.RequireOk(pRequest.GetPortName(out string requestPortName));
if (string.IsNullOrWhiteSpace(requestPortName))
{
throw new InvalidOperationException("Invalid/empty port name");
}
ppPort = null;
foreach (KeyValuePair <Guid, IDebugPort2> keyPair in m_registeredPorts)
{
IDebugPort2 registeredPort = keyPair.Value;
LoggingUtils.RequireOk(registeredPort.GetPortName(out string portName));
if (portName.Equals(requestPortName))
{
ppPort = registeredPort;
break;
}
}
if (ppPort == null)
{
//
// Create and track a new port for this request.
//
LoggingUtils.RequireOk(CreatePort(pRequest, out ppPort));
LoggingUtils.RequireOk(ppPort.GetPortId(out Guid portId));
m_registeredPorts.Add(portId, ppPort);
}
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
ppPort = null;
return(Constants.E_FAIL);
}
}
/// <inheritdoc />
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string portName;
var result = pRequest.GetPortName(out portName);
ppPort = null;
return(VSConstants.S_OK);
}
public DebugPort(RDebugPortSupplier supplier, IDebugPortRequest2 request)
{
_supplier = supplier;
_request = request;
var compModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
compModel.DefaultCompositionService.SatisfyImportsOnce(this);
}
/// <summary>
/// Adds a port. (http://msdn.microsoft.com/en-ca/library/bb161980.aspx)
/// </summary>
/// <param name="pRequest"> An IDebugPortRequest2 object that describes the port to be added. </param>
/// <param name="ppPort"> Returns an IDebugPort2 object that represents the port. </param>
/// <returns> VSConstants.S_OK. </returns>
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
AD7PortRequest port_request = (AD7PortRequest)pRequest;
var port = CreatePort(port_request);
m_ports.Add(port.m_guid, port);
ppPort = port;
return(VSConstants.S_OK);
}
public AD7Port(AD7PortSupplier supplier, IDebugPortRequest2 request)
{
this.supplier = supplier;
this.request = request;
request.GetPortName(out portName);
AD7Process p = new AD7Process(this);
processes.Add(p);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#region IDebugPortSupplier2 Members
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
//
// Attempt to find a port matching the requested name, refreshes and iterates updated ports via EnumPorts.
//
LoggingUtils.PrintFunction();
try
{
string requestPortName;
LoggingUtils.RequireOk(CanAddPort());
LoggingUtils.RequireOk(pRequest.GetPortName(out requestPortName));
ppPort = null;
foreach (KeyValuePair <Guid, IDebugPort2> keyPair in m_registeredPorts)
{
string portName;
IDebugPort2 registeredPort = keyPair.Value;
LoggingUtils.RequireOk(registeredPort.GetPortName(out portName));
if (portName.Equals(requestPortName))
{
ppPort = registeredPort;
break;
}
}
if (ppPort == null)
{
Guid portId;
ppPort = CreatePort(pRequest);
LoggingUtils.RequireOk(ppPort.GetPortId(out portId));
m_registeredPorts.Add(portId, ppPort);
}
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
ppPort = null;
return(Constants.E_FAIL);
}
}
/// <summary>
/// Add a port.
/// </summary>
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPortSupplier.AddPort");
string name;
ErrorHandler.ThrowOnFailure(pRequest.GetPortName(out name));
var port = new DebugPort(this, pRequest);
ports[name] = port;
ppPort = port;
return VSConstants.S_OK;
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string pName;
pRequest.GetPortName(out pName);
ppPort = new RemoteDebugPort(this, pRequest, pName);
return(VSConstants.S_OK);
}
// Qualifier for our transport has one of the following formats:
//
// tcp[s]://[secret@]hostname[:port]
// ws[s]://[secret@]hostname[:port][/path]
// [secret@]hostname[:port]
//
// 'tcp' and 'tcps' are for connecting directly to ptvsd; 'ws' and 'wss' are for connecting through WebSocketProxy.
// The versions ending with '...s' use SSL to secure the connection. If no scheme is specified, 'tcp' is the default.
// If port is not specified, it defaults to 5678 for 'tcp' and 'tcps', 80 for 'ws' and 443 for 'wss'.
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string name;
pRequest.GetPortName(out name);
// Support old-style 'hostname:port' format, as well.
if (!name.Contains("://"))
{
name = "tcp://" + name;
}
var uri = new Uri(name, UriKind.Absolute);
var transport = DebuggerTransportFactory.Get(uri);
if (transport == null)
{
MessageBox.Show(
Strings.RemoteUnrecognizedDebuggingTransport.FormatUI(uri.Scheme),
Strings.ProductTitle,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
return(VSConstants.E_FAIL);
}
var validationError = transport.Validate(uri);
if (validationError != null)
{
return(validationError.HResult);
}
var port = new PythonRemoteDebugPort(this, pRequest, uri, DebugLog);
if (PythonDebugOptionsServiceHelper.Options.UseLegacyDebugger)
{
// Validate connection early. Debugger automation (DTE) objects are not consistent in error checking from this
// point on, so errors reported from EnumProcesses and further calls may be ignored and treated as successes
// (with empty result). Reporting an error here works around that.
int hr = port.EnumProcesses(out IEnumDebugProcesses2 processes);
if (hr < 0)
{
return(hr);
}
}
ppPort = port;
_ports.Add(port);
return(VSConstants.S_OK);
}
/// <summary>
/// Add a port.
/// </summary>
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPortSupplier.AddPort");
string name;
ErrorHandler.ThrowOnFailure(pRequest.GetPortName(out name));
var port = new DebugPort(this, pRequest);
ports[name] = port;
ppPort = port;
return(VSConstants.S_OK);
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort) {
string name;
Marshal.ThrowExceptionForHR(pRequest.GetPortName(out name));
if (name != PortName) {
ppPort = null;
return VSConstants.E_INVALIDARG;
}
ppPort = new DebugPort(this, pRequest);
return VSConstants.S_OK;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int GetPortRequest(out IDebugPortRequest2 ppRequest)
{
//
// Gets the description of a port that was previously used to create the port (if available).
//
LoggingUtils.PrintFunction();
ppRequest = null;
return(Constants.E_PORT_NO_REQUEST);
}
int IDebugPortSupplier2.AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string portName;
if (ErrorHandler.Succeeded(pRequest.GetPortName(out portName)))
{
ppPort = new RemoteDebugPort(this, pRequest, portName);
return(VSConstants.S_OK);
}
ppPort = null;
return(VSConstants.E_NOTIMPL);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected DebuggeePort CreatePort(IDebugPortRequest2 portRequest)
{
AndroidAdb.Refresh();
string requestPortName;
LoggingUtils.RequireOk(portRequest.GetPortName(out requestPortName));
AndroidDevice device = AndroidAdb.GetConnectedDeviceById(requestPortName);
return(new DebuggeePort(this, device));
}
new public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string name;
pRequest.GetPortName(out name);
ppPort = FindPort(name);
if (ppPort != null)
{
return(COM_HResults.S_OK);
}
return(COM_HResults.E_FAIL);
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string name;
Marshal.ThrowExceptionForHR(pRequest.GetPortName(out name));
if (name != PortName)
{
ppPort = null;
return(VSConstants.E_INVALIDARG);
}
ppPort = new DebugPort(this, pRequest);
return(VSConstants.S_OK);
}
public int AddPort(IDebugPortRequest2 request, out IDebugPort2 port)
{
string name;
HR.Check(request.GetPortName(out name));
AD7Port newPort = new AD7Port(this, name, isInAddPort: true);
if (newPort.IsConnected)
{
port = newPort;
return HR.S_OK;
}
port = null;
return HR.E_REMOTE_CONNECT_USER_CANCELED;
}
// Qualifier for our transport is parsed either as a tcp://, ws:// or ws:// URI,
// or as 'hostname:port', where ':port' is optional.
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string name;
pRequest.GetPortName(out name);
// Support old-style 'hostname:port' format, as well.
if (!name.Contains("://"))
{
name = "tcp://" + name;
}
var uri = new Uri(name, UriKind.Absolute);
switch (uri.Scheme)
{
case "tcp":
// tcp:// URI should only specify host and optionally port, path has no meaning and is invalid.
if (uri.PathAndQuery != "/")
{
return(new FormatException().HResult);
}
// Set default port if not specified.
if (uri.Port < 0)
{
uri = new UriBuilder(uri)
{
Port = NodejsConstants.DefaultDebuggerPort
}.Uri;
}
break;
case "ws":
case "wss":
// WebSocket URIs are used as is
break;
default:
// Anything else is not a valid debugger endpoint
return(new FormatException().HResult);
}
ppPort = new NodeRemoteDebugPort(this, pRequest, uri);
return(VSConstants.S_OK);
}
public int AddPort(IDebugPortRequest2 request, out IDebugPort2 port)
{
string name;
HR.Check(request.GetPortName(out name));
AD7Port newPort = new AD7Port(this, name, isInAddPort: true);
if (newPort.IsConnected)
{
port = newPort;
return(HR.S_OK);
}
port = null;
return(HR.E_REMOTE_CONNECT_USER_CANCELED);
}
// Qualifier for our transport has one of the following formats:
//
// tcp[s]://[secret@]hostname[:port]
// ws[s]://[secret@]hostname[:port][/path]
// [secret@]hostname[:port]
//
// 'tcp' and 'tcps' are for connecting directly to ptvsd; 'ws' and 'wss' are for connecting through WebSocketProxy.
// The versions ending with '...s' use SSL to secure the connection. If no scheme is specified, 'tcp' is the default.
// If port is not specified, it defaults to 5678 for 'tcp' and 'tcps', 80 for 'ws' and 443 for 'wss'.
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
ppPort = null;
string name;
pRequest.GetPortName(out name);
// Support old-style 'hostname:port' format, as well.
if (!name.Contains("://"))
{
name = "tcp://" + name;
}
var uri = new Uri(name, UriKind.Absolute);
var transport = DebuggerTransportFactory.Get(uri);
if (transport == null)
{
MessageBox.Show(
Strings.RemoteUnrecognizedDebuggingTransport.FormatUI(uri.Scheme),
Strings.ProductTitle,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
return(VSConstants.E_FAIL);
}
var validationError = transport.Validate(uri);
if (validationError != null)
{
return(validationError.HResult);
}
var port = new PythonRemoteDebugPort(this, pRequest, uri, DebugLog);
ppPort = port;
_ports.Add(port);
return(VSConstants.S_OK);
}
public override int AddPort(IDebugPortRequest2 request, out IDebugPort2 port)
{
string name;
HR.Check(request.GetPortName(out name));
if (!string.IsNullOrWhiteSpace(name))
{
AD7Port newPort = new DockerPort(this, name, isInAddPort: true);
if (newPort.IsConnected)
{
port = newPort;
return(HR.S_OK);
}
}
port = null;
return(HR.E_REMOTE_CONNECT_USER_CANCELED);
}
new public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string name;
pRequest.GetPortName(out name);
ppPort = FindPort(name);
if (ppPort == null)
{
DebugPort port = _ports[(int)PortFilter.TcpIp];
//hack, hack. Abusing the Attach to dialog box to force the NetworkDevice port to
//look for a nanoCLR process
if (port.TryAddProcess(name) != null)
{
ppPort = port;
}
}
return(COM_HResults.BOOL_TO_HRESULT_FAIL(ppPort != null));
}
public int AddPort(IDebugPortRequest2 request, out IDebugPort2 port)
{
var debugSessionMetrics = new DebugSessionMetrics(_metrics);
debugSessionMetrics.UseNewDebugSessionId();
var actionRecorder = new ActionRecorder(debugSessionMetrics);
port = null;
if (request.GetPortName(out string gameletIdOrName) != VSConstants.S_OK)
{
return(VSConstants.E_FAIL);
}
var action = actionRecorder.CreateToolAction(ActionType.GameletGet);
var gameletClient = _gameletClientFactory.Create(_cloudRunner.Intercept(action));
var gameletTask = _cancelableTaskFactory.Create(
"Querying instance...",
async() => await gameletClient.LoadByNameOrIdAsync(gameletIdOrName));
try
{
gameletTask.RunAndRecord(action);
}
catch (CloudException e)
{
Trace.WriteLine(e.ToString());
_dialogUtil.ShowError(e.Message);
return(VSConstants.S_OK);
}
var debugPort = _debugPortFactory.Create(gameletTask.Result, this,
debugSessionMetrics.DebugSessionId);
_ports.Add(debugPort);
port = debugPort;
return(VSConstants.S_OK);
}
// Qualifier for our transport has one of the following formats:
//
// tcp[s]://[secret@]hostname[:port]
// ws[s]://[secret@]hostname[:port][/path]
// [secret@]hostname[:port]
//
// 'tcp' and 'tcps' are for connecting directly to ptvsd; 'ws' and 'wss' are for connecting through WebSocketProxy.
// The versions ending with '...s' use SSL to secure the connection. If no scheme is specified, 'tcp' is the default.
// If port is not specified, it defaults to 5678 for 'tcp' and 'tcps', 80 for 'ws' and 443 for 'wss'.
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort) {
ppPort = null;
string name;
pRequest.GetPortName(out name);
// Support old-style 'hostname:port' format, as well.
if (!name.Contains("://")) {
name = "tcp://" + name;
}
var uri = new Uri(name, UriKind.Absolute);
var transport = DebuggerTransportFactory.Get(uri);
if (transport == null) {
MessageBox.Show(string.Format("Unrecognized remote debugging transport '{0}'.", uri.Scheme), null, MessageBoxButtons.OK, MessageBoxIcon.Error);
return VSConstants.E_FAIL;
}
var validationError = transport.Validate(uri);
if (validationError != null) {
return validationError.HResult;
}
var port = new PythonRemoteDebugPort(this, pRequest, uri);
// Validate connection early. Debugger automation (DTE) objects are not consistent in error checking from this
// point on, so errors reported from EnumProcesses and further calls may be ignored and treated as successes
// (with empty result). Reporting an error here works around that.
IEnumDebugProcesses2 processes;
int hr = port.EnumProcesses(out processes);
if (hr < 0) {
return hr;
}
ppPort = port;
return VSConstants.S_OK;
}
// Qualifier for our transport is parsed either as a tcp://, ws:// or ws:// URI,
// or as 'hostname:port', where ':port' is optional.
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort) {
ppPort = null;
string name;
pRequest.GetPortName(out name);
// Support old-style 'hostname:port' format, as well.
if (!name.Contains("://")) {
name = "tcp://" + name;
}
var uri = new Uri(name, UriKind.Absolute);
switch (uri.Scheme) {
case "tcp":
// tcp:// URI should only specify host and optionally port, path has no meaning and is invalid.
if (uri.PathAndQuery != "/") {
return new FormatException().HResult;
}
// Set default port if not specified.
if (uri.Port < 0) {
uri = new UriBuilder(uri) { Port = NodejsConstants.DefaultDebuggerPort }.Uri;
}
break;
case "ws":
case "wss":
// WebSocket URIs are used as is
break;
default:
// Anything else is not a valid debugger endpoint
return new FormatException().HResult;
}
ppPort = new NodeRemoteDebugPort(this, pRequest, uri);
return VSConstants.S_OK;
}
int Microsoft.VisualStudio.Debugger.Interop.IDebugPort2.GetPortRequest(out IDebugPortRequest2 ppRequest)
{
ppRequest = null;
return Utility.COM_HResults.E_NOTIMPL;
}
/// <summary>
/// Adds a port. (http://msdn.microsoft.com/en-ca/library/bb161980.aspx)
/// </summary>
/// <param name="pRequest"> An IDebugPortRequest2 object that describes the port to be added. </param>
/// <param name="ppPort"> Returns an IDebugPort2 object that represents the port. </param>
/// <returns> VSConstants.S_OK. </returns>
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
bool sucess = true;
AD7PortRequest port_request = null;
AD7Port port = null;
try
{
port_request = (AD7PortRequest)pRequest;
}
catch
{
sucess = false;
string portRequestName;
AD7Port defaultPort = null;
pRequest.GetPortName(out portRequestName);
string search = "";
if (portRequestName.ToLower().Contains("device"))
search = "device";
else if (portRequestName.ToLower().Contains("simulator"))
search = "simulator";
else
{
search = portRequestName.ToLower();
}
foreach (var p in m_ports)
{
AD7Port tempPort = p.Value;
if (defaultPort == null)
defaultPort = tempPort;
string tempPortName = "";
tempPort.GetPortName(out tempPortName);
if (tempPortName.ToLower().Contains(search))
{
port = tempPort;
break;
}
else
{
string IP = search;
do
{
int pos = IP.LastIndexOf('.');
if (pos != -1)
{
IP = IP.Remove(pos);
if (tempPortName.Contains(IP))
{
port = tempPort;
break;
}
}
else
IP = "";
} while (IP != "");
if (IP != "")
break;
}
}
if (port == null)
{
if (defaultPort != null)
{
port = defaultPort;
}
else
port = new AD7Port(this, port_request, Guid.NewGuid(), "", "", true, "");
}
}
if (sucess)
{
port = CreatePort(port_request);
Guid portGuid;
port.GetPortId(out portGuid);
m_ports.Add(portGuid, port);
}
ppPort = port;
return VSConstants.S_OK;
}
public int GetPortRequest(out IDebugPortRequest2 ppRequest)
{
ppRequest = _request;
return(VSConstants.S_OK);
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort) {
ppPort = new DebugPort(this, pRequest);
return VSConstants.S_OK;
}
int IDebugPortSupplier2.AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
throw new NotImplementedException();
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
throw new NotImplementedException();
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
thePort = new SquirrelPort(this, pRequest);
ppPort = (IDebugPort2)thePort;
return(Microsoft.VisualStudio.VSConstants.S_OK);
}
/// <summary>
/// Adds a port. (http://msdn.microsoft.com/en-ca/library/bb161980.aspx)
/// </summary>
/// <param name="pRequest"> An IDebugPortRequest2 object that describes the port to be added. </param>
/// <param name="ppPort"> Returns an IDebugPort2 object that represents the port. </param>
/// <returns> VSConstants.S_OK. </returns>
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
AD7PortRequest port_request = (AD7PortRequest)pRequest;
var port = CreatePort(port_request);
m_ports.Add(port.m_guid, port);
ppPort = port;
return VSConstants.S_OK;
}
public int GetPortRequest(out IDebugPortRequest2 ppRequest) {
ppRequest = _request;
return VSConstants.S_OK;
}
/// <summary>
/// Adds a port.
/// </summary>
/// <param name="pRequest">An IDebugPortRequest2 object that describes the port to be added.</param>
/// <param name="ppPort">Returns an IDebugPort2 object that represents the port.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>
/// This method actually creates the requested port as well as adding it to the port supplier's internal list of active ports. The IDebugPortSupplier2::CanAddPort method can be called first to avoid possible time-consuming delays.
/// </remarks>
public virtual int AddPort( IDebugPortRequest2 pRequest, out IDebugPort2 ppPort )
{
Logger.Debug( string.Empty );
ppPort = null;
return VSConstants.E_NOTIMPL;
}
/// <summary>
/// Gets the description of a port that was previously used to create the port (if available).
/// </summary>
public int GetPortRequest(out IDebugPortRequest2 ppRequest)
{
DLog.Debug(DContext.VSDebuggerComCall, "DebugPort.GetPortRequest");
ppRequest = request;
return VSConstants.S_OK;
}
/// <summary>
/// Gets the description of a port that was previously used to create the port (if available).
/// </summary>
/// <param name="ppRequest">Returns an IDebugPortRequest2 object representing the request that was used to create the port.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code. Returns E_PORT_NO_REQUEST if a port was not created using an IDebugPortRequest2 port request.</returns>
public virtual int GetPortRequest( out IDebugPortRequest2 ppRequest )
{
Logger.Debug( string.Empty );
ppRequest = null;
return VSConstants.E_NOTIMPL;
}
public PythonRemoteDebugPort(PythonRemoteDebugPortSupplier supplier, IDebugPortRequest2 request, Uri uri) {
_supplier = supplier;
_request = request;
_uri = uri;
}
new public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
string name;
pRequest.GetPortName(out name);
ppPort = FindPort(name);
if (ppPort == null)
{
DebugPort port = m_ports[(int)PortFilter.TcpIp];
//hack, hack. Abusing the Attach to dialog box to force the NetworkDevice port to
//look for a TinyCLR process
if (port.TryAddProcess(name) != null)
{
ppPort = port;
}
}
return Utility.COM_HResults.BOOL_TO_HRESULT_FAIL( ppPort != null );
}
/// <summary>
/// Default ctor
/// </summary>
internal DebugPort(DebugPortSupplier supplier, IDebugPortRequest2 request)
{
this.supplier = supplier;
this.request = request;
guid = Guid.NewGuid();
}
public int GetPortRequest(out IDebugPortRequest2 ppRequest)
{
throw new NotImplementedException();
}
public int AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
return s_portSupplier.AddPort(pRequest, out ppPort);
}
int IDebugPortSupplier2.AddPort(IDebugPortRequest2 pRequest, out IDebugPort2 ppPort)
{
throw new NotImplementedException();
}
public int GetPortRequest(out IDebugPortRequest2 ppRequest)
{
throw new NotImplementedException();
}