public void PrepareStart(string caller_trace)
{
InitializeRequest initializeRequest = new InitializeRequest();
initializeRequest.arguments.clientID = "vscode";
initializeRequest.arguments.clientName = "Visual Studio Code";
initializeRequest.arguments.adapterID = "coreclr";
initializeRequest.arguments.pathFormat = "path";
initializeRequest.arguments.linesStartAt1 = true;
initializeRequest.arguments.columnsStartAt1 = true;
initializeRequest.arguments.supportsVariableType = true;
initializeRequest.arguments.supportsVariablePaging = true;
initializeRequest.arguments.supportsRunInTerminalRequest = true;
initializeRequest.arguments.locale = "en-us";
Assert.True(VSCodeDebugger.Request(initializeRequest).Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
Process testProcess = new Process();
testProcess.StartInfo.UseShellExecute = false;
testProcess.StartInfo.FileName = ControlInfo.CorerunPath;
testProcess.StartInfo.Arguments = ControlInfo.TargetAssemblyPath;
testProcess.StartInfo.CreateNoWindow = true;
Assert.True(testProcess.Start(), @"__FILE__:__LINE__" + "\n" + caller_trace);
AttachRequest attachRequest = new AttachRequest();
attachRequest.arguments.processId = testProcess.Id;
Assert.True(VSCodeDebugger.Request(attachRequest).Success, @"__FILE__:__LINE__" + "\n" + caller_trace);
}
public override Task <InitializeResponse> Initialize(InitializeRequest request, ServerCallContext context)
{
Program.WriteLine("Initialize");
// NOTE: This is currently happening in `Create()`;
// connector.InitializeConnection();
return(Task.FromResult(new InitializeResponse()));
}
void StartDebugAgent()
{
var startInfo = new ProcessStartInfo(Path.Combine(Path.GetDirectoryName(typeof(VSCodeDebuggerSession).Assembly.Location), "CoreClrAdaptor", "OpenDebugAD7"));
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardInput = true;
startInfo.StandardOutputEncoding = Encoding.UTF8;
startInfo.StandardOutputEncoding = Encoding.UTF8;
startInfo.UseShellExecute = false;
startInfo.EnvironmentVariables["PATH"] = "/usr/local/share/dotnet:" + Environment.GetEnvironmentVariable("PATH");
debugAgentProcess = Process.Start(startInfo);
protocolClient = new ProtocolClient();
protocolClient.OnEvent += HandleAction;
protocolClient.Start(debugAgentProcess.StandardOutput.BaseStream, debugAgentProcess.StandardInput.BaseStream)
.ContinueWith((task) => {
if (task.IsFaulted)
{
Console.WriteLine(task.Exception);
}
});
var initRequest = new InitializeRequest(new InitializeRequestArguments()
{
adapterID = "coreclr",
linesStartAt1 = true,
columnsStartAt1 = true,
pathFormat = "path"
});
Capabilities = protocolClient.SendRequestAsync(initRequest).Result;
}
public void PrepareStart(string caller_trace)
{
InitializeRequest initializeRequest = new InitializeRequest();
initializeRequest.arguments.clientID = "vscode";
initializeRequest.arguments.clientName = "Visual Studio Code";
initializeRequest.arguments.adapterID = "coreclr";
initializeRequest.arguments.pathFormat = "path";
initializeRequest.arguments.linesStartAt1 = true;
initializeRequest.arguments.columnsStartAt1 = true;
initializeRequest.arguments.supportsVariableType = true;
initializeRequest.arguments.supportsVariablePaging = true;
initializeRequest.arguments.supportsRunInTerminalRequest = true;
initializeRequest.arguments.locale = "en-us";
Assert.True(VSCodeDebugger.Request(initializeRequest).Success,
@"__FILE__:__LINE__" + "\n" + caller_trace);
LaunchRequest launchRequest = new LaunchRequest();
launchRequest.arguments.name = ".NET Core Launch (console) with pipeline";
launchRequest.arguments.type = "coreclr";
launchRequest.arguments.preLaunchTask = "build";
launchRequest.arguments.program = ControlInfo.TargetAssemblyPath;
launchRequest.arguments.cwd = "";
launchRequest.arguments.console = "internalConsole";
launchRequest.arguments.stopAtEntry = true;
launchRequest.arguments.internalConsoleOptions = "openOnSessionStart";
launchRequest.arguments.__sessionId = Guid.NewGuid().ToString();
Assert.True(VSCodeDebugger.Request(launchRequest).Success,
@"__FILE__:__LINE__" + "\n" + caller_trace);
}
public async Task Initialize_Succeeds()
{
using (var test = await PluginTest.CreateAsync())
{
Assert.Equal(PluginProtocolConstants.CurrentVersion, test.Plugin.Connection.ProtocolVersion);
// Send canned response
var responseSenderTask = Task.Run(() => test.ResponseSender.StartSendingAsync(test.CancellationToken));
await test.ResponseSender.SendAsync(
MessageType.Response,
MessageMethod.Initialize,
new InitializeResponse(MessageResponseCode.Success));
var clientVersion = MinClientVersionUtility.GetNuGetClientVersion().ToNormalizedString();
var culture = CultureInfo.CurrentCulture.Name;
var payload = new InitializeRequest(
clientVersion,
culture,
PluginConstants.RequestTimeout);
var response = await test.Plugin.Connection.SendRequestAndReceiveResponseAsync <InitializeRequest, InitializeResponse>(
MessageMethod.Initialize,
payload,
test.CancellationToken);
Assert.NotNull(response);
Assert.Equal(MessageResponseCode.Success, response.ResponseCode);
}
}
protected async Task HandleInitializeRequest(
InitializeRequest initializeParams,
RequestContext <InitializeResult> requestContext)
{
// Grab the workspace path from the parameters
editorSession.Workspace.WorkspacePath = initializeParams.RootPath;
await requestContext.SendResult(
new InitializeResult
{
Capabilities = new ServerCapabilities
{
TextDocumentSync = TextDocumentSyncKind.Incremental,
DefinitionProvider = true,
ReferencesProvider = true,
DocumentHighlightProvider = true,
DocumentSymbolProvider = true,
WorkspaceSymbolProvider = true,
HoverProvider = true,
CompletionProvider = new CompletionOptions
{
ResolveProvider = true,
TriggerCharacters = new string[] { ".", "-", ":", "\\" }
},
SignatureHelpProvider = new SignatureHelpOptions
{
TriggerCharacters = new string[] { " " } // TODO: Other characters here?
}
}
});
}
public async Task Handle(InitializeRequest <WorkItemQueryWidget> request, CancellationToken cancellationToken)
{
var api = new AzureDevOpsApi(request.DataContext.ConnectionSettings);
var workItemQueries =
await api.GetWorkItemQueriesAsync(request.DataContext.Project, request.DataContext.Query, 1,
cancellationToken).ConfigureAwait(false);
if (workItemQueries.Count == 0)
{
request.DataContext.State = State.Unknown;
request.DataContext.QueryId = string.Empty;
request.DataContext.URL = string.Empty;
_uiAction.Invoke(request.DataContext.Clear);
request.DataContext.Clear();
_logger.Error($"Work item query {request.DataContext.Query} was not found.");
}
else
{
var query = workItemQueries.Value.First();
request.DataContext.QueryId = query.Id;
request.DataContext.URL = query.Links["html"]["href"];
}
}
protected async Task HandleInitializeRequest(
InitializeRequest initializeParams,
RequestContext<InitializeResult> requestContext)
{
// Grab the workspace path from the parameters
editorSession.Workspace.WorkspacePath = initializeParams.RootPath;
await requestContext.SendResult(
new InitializeResult
{
Capabilities = new ServerCapabilities
{
TextDocumentSync = TextDocumentSyncKind.Incremental,
DefinitionProvider = true,
ReferencesProvider = true,
DocumentHighlightProvider = true,
DocumentSymbolProvider = true,
WorkspaceSymbolProvider = true,
HoverProvider = true,
CompletionProvider = new CompletionOptions
{
ResolveProvider = true,
TriggerCharacters = new string[] { ".", "-", ":", "\\" }
},
SignatureHelpProvider = new SignatureHelpOptions
{
TriggerCharacters = new string[] { " " } // TODO: Other characters here?
}
}
});
}
public static void PrepareStart()
{
InitializeRequest initializeRequest = new InitializeRequest();
initializeRequest.arguments.clientID = "vscode";
initializeRequest.arguments.clientName = "Visual Studio Code";
initializeRequest.arguments.adapterID = "coreclr";
initializeRequest.arguments.pathFormat = "path";
initializeRequest.arguments.linesStartAt1 = true;
initializeRequest.arguments.columnsStartAt1 = true;
initializeRequest.arguments.supportsVariableType = true;
initializeRequest.arguments.supportsVariablePaging = true;
initializeRequest.arguments.supportsRunInTerminalRequest = true;
initializeRequest.arguments.locale = "en-us";
Assert.True(VSCodeDebugger.Request(initializeRequest).Success);
LaunchRequest launchRequest = new LaunchRequest();
launchRequest.arguments.name = ".NET Core Launch (console) with pipeline";
launchRequest.arguments.type = "coreclr";
launchRequest.arguments.preLaunchTask = "build";
launchRequest.arguments.program = DebuggeeInfo.TargetAssemblyPath;
// NOTE this code works only with one source file
launchRequest.arguments.cwd = Directory.GetParent(DebuggeeInfo.SourceFilesPath).FullName;
launchRequest.arguments.console = "internalConsole";
launchRequest.arguments.stopAtEntry = true;
launchRequest.arguments.internalConsoleOptions = "openOnSessionStart";
launchRequest.arguments.__sessionId = Guid.NewGuid().ToString();
Assert.True(VSCodeDebugger.Request(launchRequest).Success);
}
void StartDebugAgent()
{
var startInfo = new ProcessStartInfo(GetDebugAdapterPath(), GetDebugAdapterArguments());
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardInput = true;
startInfo.StandardOutputEncoding = Encoding.UTF8;
startInfo.StandardOutputEncoding = Encoding.UTF8;
startInfo.UseShellExecute = false;
if (!MonoDevelop.Core.Platform.IsWindows)
{
startInfo.EnvironmentVariables ["PATH"] = Environment.GetEnvironmentVariable("PATH") + ":/usr/local/share/dotnet/";
}
debugAgentProcess = Process.Start(startInfo);
debugAgentProcess.EnableRaisingEvents = true;
debugAgentProcess.Exited += DebugAgentProcess_Exited;
protocolClient = new DebugProtocolHost(debugAgentProcess.StandardInput.BaseStream, debugAgentProcess.StandardOutput.BaseStream);
protocolClient.RequestReceived += OnDebugAdaptorRequestReceived;
protocolClient.Run();
protocolClient.TraceCallback = (obj) => {
Debug.WriteLine(obj);
};
protocolClient.EventReceived += HandleEvent;
InitializeRequest initRequest = CreateInitRequest();
Capabilities = protocolClient.SendRequestSync(initRequest);
}
private static async Task InitializePluginAsync(
IPlugin plugin,
TimeSpan requestTimeout,
CancellationToken cancellationToken)
{
var clientVersion = MinClientVersionUtility.GetNuGetClientVersion().ToNormalizedString();
var culture = GetCurrentCultureName();
var payload = new InitializeRequest(
clientVersion,
culture,
requestTimeout);
var response = await plugin.Connection.SendRequestAndReceiveResponseAsync <InitializeRequest, InitializeResponse>(
MessageMethod.Initialize,
payload,
cancellationToken);
if (response != null && response.ResponseCode != MessageResponseCode.Success)
{
throw new PluginException(Strings.Plugin_InitializationFailed);
}
plugin.Connection.Options.SetRequestTimeout(requestTimeout);
}
public async Task InitializeAsync_WhenUsernameIsNotSet_DefaultIsNull()
{
var firstClickCell = _fixture.Create <CellCoordinates>();
var columns = 5;
var rows = 5;
var mines = 3;
var board = _fixture.Create <Board>();
var request = new InitializeRequest
{
InitialClickCell = firstClickCell,
Columns = columns,
Rows = rows,
Mines = mines
};
A.CallTo(() => _service.InitializeAsync(A <Cell> ._, A <string> ._, A <int> ._, A <int> ._, A <int> ._))
.Returns(board);
A.CallTo(() => _mapper.Map <Cell>(A <CellCoordinates> ._))
.Returns(new Cell {
Column = firstClickCell.Column, Row = firstClickCell.Row
});
var result = await _controller.InitializeAsync(request) as SuccessResponse <Board>;
A.CallTo(() => _service.InitializeAsync(
A <Cell> .That.Matches(i => i.Column == firstClickCell.Column && i.Row == firstClickCell.Row),
A <string> .That.Matches(i => i == null),
A <int> .That.Matches(i => i == columns),
A <int> .That.Matches(i => i == rows),
A <int> .That.Matches(i => i == mines))
).MustHaveHappenedOnceExactly();
}
public TransactionResponse InitializeTransaction(InitializeRequest payload)
{
string url = _appSettings.BaseUrl + "transaction/initialize";
string seckey = _appSettings.SecKey;
return(CallRestAction <TransactionResponse, InitializeRequest>(payload, url, seckey));
}
public override async Task <InitializeResponse> Initialize(InitializeRequest request, ServerCallContext context)
{
if (IsInitialized)
{
return new InitializeResponse
{
IsSuccess = false
}
}
;
await TimeCatDB.Instance.Initialize(Environment.Database);
IsInitialized = true;
Log.Information("TimeCat {AppVersion} initialized", request.AppVersion);
return(new InitializeResponse
{
IsSuccess = true,
OsInformation = new OSInformation
{
Platform = RuntimeInformationUtility.OSPlatform.ToRpc(),
Architecture = RuntimeInformation.OSArchitecture.ToRpc(),
Description = RuntimeInformation.OSDescription
}
});
}
public InitializeResponse InitializePayment(InitializeRequest initializerequest)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
var request = new RestRequest(Constants.Routes.InitializeTransaction, Method.POST);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddHeader("authorization", "Bearer " + Paystack_SECRET_KEY);
request.AddJsonBody(initializerequest);
try
{
var response = client.Execute <InitializeResponse>(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var result = JsonConvert.DeserializeObject <InitializeResponse>(response.Content);
return(result);
}
return(null);
}
catch
{
return(null);
}
}
/// <summary>
/// Handles the initialization request
/// </summary>
/// <param name="initializeParams"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
private async Task HandleInitializeRequest(InitializeRequest initializeParams, RequestContext <InitializeResult> requestContext)
{
// Call all tasks that registered on the initialize request
var initializeTasks = initializeCallbacks.Select(t => t(initializeParams, requestContext));
await Task.WhenAll(initializeTasks);
// TODO: Figure out where this needs to go to be agnostic of the language
// Send back what this server can do
await requestContext.SendResult(
new InitializeResult
{
Capabilities = new ServerCapabilities
{
TextDocumentSync = TextDocumentSyncKind.Incremental,
DefinitionProvider = true,
ReferencesProvider = false,
DocumentHighlightProvider = false,
HoverProvider = true,
CompletionProvider = new CompletionOptions
{
ResolveProvider = true,
TriggerCharacters = new string[] { ".", "-", ":", "\\", "[" }
},
SignatureHelpProvider = new SignatureHelpOptions
{
TriggerCharacters = new string[] { " ", "," }
}
}
});
}
/// <summary>
/// Handles the initialization request
/// </summary>
/// <param name="initializeParams"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
protected async Task HandleInitializeRequest(InitializeRequest initializeParams, RequestContext <InitializeResponse> requestContext)
{
Logger.Write(LogLevel.Normal, "HandleInitializeRequest");
// Call all tasks that registered on the initialize request
var initializeTasks = initializeCallbacks.Select(t => t(initializeParams, requestContext));
await Task.WhenAll(initializeTasks);
}
public async Task API_InitializeTest()
{
var widget = new TestWidget();
var handler = new Initializer();
var request = InitializeRequest.Create(widget);
await handler.Handle(request, CancellationToken.None);
}
protected override InitializeRequest CreateInitRequest()
{
var result = new InitializeRequest();
result.Args.ClientID = "monodevelop";
result.Args.AdapterID = "dotnetcore";
return(result);
}
public InitializeResponse InitializeTransaction(InitializeRequest payload)
{
string url = _configManager.BaseUrl + "transaction/initialize";
string seckey = _configManager.SecKey;
var _client = new RestActions(_contentRootPath);
return(_client.CallPostAction <InitializeResponse, InitializeRequest>(payload, url, seckey));
}
public async Task <InitializeResponse> InitializePayment(InitializeRequest request)
{
RestSharpCaller ApiCaller = new RestSharpCaller();
ApiCaller.Paystack_SECRET_KEY = _payStackSecretKey;
return(ApiCaller.InitializePayment(request));
}
public void Constructor_InitializesProperties()
{
var request = new InitializeRequest(
clientVersion: "a",
culture: "b",
requestTimeout: _requestTimeout);
Assert.Equal("a", request.ClientVersion);
Assert.Equal("b", request.Culture);
Assert.Equal(_requestTimeout, request.RequestTimeout);
}
public void JsonSerialization_ReturnsCorrectJson()
{
var request = new InitializeRequest(
clientVersion: "a",
culture: "b",
requestTimeout: _requestTimeout);
var actualJson = TestUtilities.Serialize(request);
var expectedJson = "{\"ClientVersion\":\"a\",\"Culture\":\"b\",\"RequestTimeout\":\"1.02:03:04.0050000\"}";
Assert.Equal(expectedJson, actualJson);
}
protected override Task OnConnect()
{
// Send the 'initialize' request and wait for the response
var initializeRequest = new InitializeRequest
{
RootPath = "",
Capabilities = new ClientCapabilities()
};
return(this.SendRequest(
InitializeRequest.Type,
initializeRequest));
}
public async Task Handle(InitializeRequest <PullRequestsWidget> request, CancellationToken cancellationToken)
{
var api = new AzureDevOpsApi(request.DataContext.ConnectionSettings);
var repository = await api.GetRepositoryAsync(request.DataContext.Project, request.DataContext.Repository, cancellationToken).ConfigureAwait(false);
if (string.IsNullOrEmpty(repository.Id))
{
request.DataContext.State = State.Unknown;
}
else
{
request.DataContext.RepositoryId = repository.Id;
}
}
public async Task InitializeRequestTest()
{
using (TestServiceDriverProvider testService = new TestServiceDriverProvider())
{
InitializeRequest initializeRequest = new InitializeRequest()
{
RootPath = Path.GetTempPath(),
Capabilities = new ClientCapabilities()
};
InitializeResult result = await testService.Driver.SendRequest(InitializeRequest.Type, initializeRequest);
Assert.NotNull(result);
}
}
public async Task Handle(InitializeRequest <BuildWidget> request, CancellationToken cancellationToken)
{
var api = new AzureDevOpsApi(request.DataContext.ConnectionSettings);
var response = await api.GetBuildDefinitionsAsync(request.DataContext.Project, request.DataContext.Definition, 1, cancellationToken).ConfigureAwait(false);
var buildDefinition = response.Value.FirstOrDefault();
if (buildDefinition == null)
{
throw new Exception($"Build definition \"{request.DataContext.Definition}\" was not found.");
}
request.DataContext.DefinitionId = buildDefinition.Id;
request.DataContext.URL = buildDefinition.Links["web"]["href"];
}
public void Start(Stream inputStream, Stream outputStream)
{
this.outputStream = outputStream;
/*debugAgentProcess =
* debugAgentProcess.EnableRaisingEvents = true;
* debugAgentProcess.Exited += DebugAgentProcess_Exited;*/
protocolClient = new DebugProtocolHost(inputStream, outputStream);
protocolClient.Run();
protocolClient.EventReceived += HandleEvent;
OnTargetOutput(false, "Running");
InitializeRequest initRequest = CreateInitRequest();
Capabilities = protocolClient.SendRequestSync(initRequest);
OnTargetOutput(false, "Running");
}
protected override async Task Initialize()
{
// Add handlers for common events
this.SetEventHandler(PublishDiagnosticsNotification.Type, HandlePublishDiagnosticsEvent);
// Send the 'initialize' request and wait for the response
var initializeRequest = new InitializeRequest
{
RootPath = "",
Capabilities = new ClientCapabilities()
};
await this.SendRequest(
InitializeRequest.Type,
initializeRequest);
}
protected override void BeforeInitialize(
PostProcessPaymentRequest postProcessPaymentRequest, InitializeRequest request)
{
// In m-commerce flow, the customer may want to use a different number other than that on the order.
// Since we don't know which flow, it's safer to not specify however less convenient for desktop users.
// If the number is not Swish enabled, we immediately get ThirdPartyError=Payer not Enrolled.
// Additionally, the number must contain country code or else we get "Invalid parameter:MSISDN" in Initialize.
//request.MobilePhoneNumber = postProcessPaymentRequest.Order.BillingAddress?.FaxNumber
// Description Can be 160 characters long, except when the payment method is iDEAL or Swish, then the limit is 35 characters (iDEAL)
// and 50 characters (Swish). For Swish, allowed characters are restricted to [a-öA-Ö0-9:;.,?!()”].
request.Description = Regex.Replace(request.Description, @"[^a-öA-Ö0-9:;\.,\?\!\(\)"" ]", "");
if (request.Description.Length > 50)
{
request.Description = request.Description.PadLeft(50);
}
}
//[TestMethod]
public async Task BuildHealthCheckTest()
{
var widget = new BuildWidget
{
Project = "AnyStatus",
Definition = "Master",
ConnectionSettings = new AzureDevOpsConnectionSettings
{
Organization = "production",
PersonalAccessToken = ""
}
};
await new InitializeBuild().Handle(InitializeRequest.Create(widget), CancellationToken.None).ConfigureAwait(false);
await new BuildHealthCheck().Handle(HealthCheckRequest.Create(widget), CancellationToken.None).ConfigureAwait(false);
}
public BaseResponse Post(InitializeRequest request)
{
_log.StartLog(request);
try
{
_authProvider.Initialize(request.UserName, request.Password);
return new BaseResponse();
}
catch (Exception e)
{
_log.Fatal("error", e);
Errors.Add(e.Message + " " + e.StackTrace);
return new BaseResponse { Errors = Errors };
}
}
public BinaryMessage Initialize (InitializeRequest msg)
{
WatchProcess (msg.IdeProcessId);
SetCulture (CultureInfo.GetCultureInfo (msg.CultureName));
SetGlobalProperties (msg.GlobalProperties);
return msg.CreateResponse ();
}
