public ExecuteResponse Execute(ExecuteRequest request)
{
ExecuteResponse response = new ExecuteResponse();
List <Header> headers = new List <Header>();
for (int i = 0; i < 4; i++)
{
Header header = new Header();
header.Title = $"T{i + 1}";
headers.Add(header);
}
response.HeaderList = headers;
List <List <string> > rows = new List <List <string> >();
for (int i = 0; i < 68; i++)
{
List <string> row = new List <string>();
for (int ij = 0; ij < 4; ij++)
{
row.Add($"C-{i}-{ij}");
}
rows.Add(row);
}
response.RowList = rows;
response.Message = request.Command;
response.Status = 1;
return(response);
}
private void SetHeaders <TResponse>(ExecuteRequest <TResponse> info) where TResponse : class, IResponseResult
{
foreach (var value in info.Headers)
{
_client.DefaultRequestHeaders.Add(value.Key, value.Value);
}
}
private void CleanHeaders <TResponse>(ExecuteRequest <TResponse> info) where TResponse : class, IResponseResult
{
foreach (var value in info.Headers)
{
_client.DefaultRequestHeaders.Remove(value.Key);
}
}
public void Execute_Prepared_With_Param_Test()
{
using (var connection = CreateConnection())
{
connection.Open().Wait();
var prepareRequest = new PrepareRequest(GetSerializer(), "SELECT * FROM system.local WHERE key = ?", null, null);
var task = connection.Send(prepareRequest);
var prepareOutput = ValidateResult <OutputPrepared>(task.Result);
var options = new QueryProtocolOptions(ConsistencyLevel.One, new object[] { "local" }, false, 100, null, ConsistencyLevel.Any);
var executeRequest = new ExecuteRequest(
GetSerializer(),
prepareOutput.QueryId,
null,
new ResultMetadata(prepareOutput.ResultMetadataId, prepareOutput.ResultRowsMetadata),
options,
false,
null);
task = connection.Send(executeRequest);
var output = ValidateResult <OutputRows>(task.Result);
var rows = output.RowSet.ToList();
Assert.Greater(rows.Count, 0);
Assert.NotNull(rows[0].GetValue <string>("key"), "It should contain a key column value");
}
}
public void RunScript()
{
LogIn();
var executeRequest = new ExecuteRequest();
executeRequest.Code = Code;
if (InputParameters.Count != 0)
{
executeRequest.InputParameters = InputParameters;
}
if (OutputParameters.Count != 0)
{
executeRequest.OutputParameters = OutputParameters;
}
var executeResponse = Client.ExecuteCode(Response.SessionId, executeRequest);
if (executeResponse.Success.Value)
{
PopulateResults(executeResponse);
LogOut();
}
else
{
LogOut();
throw new Exception(executeResponse.ErrorMessage);
}
}
public void Execute_Prepared_Test()
{
using (var connection = CreateConnection())
{
connection.Open().Wait();
//Prepare a query
var prepareRequest = new PrepareRequest(GetSerializer(), BasicQuery, null, null);
var task = connection.Send(prepareRequest);
var prepareOutput = ValidateResult <OutputPrepared>(task.Result);
//Execute the prepared query
var executeRequest = new ExecuteRequest(
GetSerializer(),
prepareOutput.QueryId,
null,
new ResultMetadata(prepareOutput.ResultMetadataId, prepareOutput.ResultRowsMetadata),
QueryProtocolOptions.Default,
false,
null);
task = connection.Send(executeRequest);
var output = ValidateResult <OutputRows>(task.Result);
var rs = output.RowSet;
var rows = rs.ToList();
Assert.Greater(rows.Count, 0);
Assert.True(rows[0].GetValue <string>("key") != null, "It should contain a key column");
}
}
public async Task GetRawResult_ValidRequestGiven_ShouldReturnResult()
{
const string expectedResultXml = "<wps:LiteralValue xmlns:wps=\"http://www.opengis.net/wps/2.0\" dataType=\"https://www.w3.org/2001/XMLSchema-datatypes#string\">150</wps:LiteralValue>";
var request = new ExecuteRequest
{
Inputs = new[]
{
new DataInput
{
Data = new LiteralDataValue {
Value = "test"
}
}
},
ExecutionMode = ExecutionMode.Synchronous,
ResponseType = ResponseType.Raw
};
var expectedRequestXml = new XmlSerializationService().Serialize(request);
var wpsClient = new WpsClient(new HttpClient(GetMockedMessageHandlerForResponse(expectedResultXml, HttpStatusCode.OK, expectedRequestXml)), new XmlSerializationService());
var result = await wpsClient.GetRawResult(MockUri, request);
result.Should().Be(expectedResultXml);
}
public async Task AsyncGetDocumentedResult_ValidRequestGiven_ShouldReturnResult(string expectedHttpResponse)
{
var request = new ExecuteRequest
{
Identifier = "org.n52.javaps.test.EchoProcess",
Inputs = new[]
{
new DataInput
{
Data = new LiteralDataValue {
Value = "test"
}
}
},
Outputs = new []
{
new DataOutput
{
MimeType = "text/xml"
}
},
ExecutionMode = ExecutionMode.Asynchronous,
ResponseType = ResponseType.Document
};
var expectedRequestXml = new XmlSerializationService().Serialize(request);
var wpsClient = new WpsClient(new HttpClient(GetMockedMessageHandlerForResponse(expectedHttpResponse, HttpStatusCode.OK, expectedRequestXml)), new XmlSerializationService());
var session = await wpsClient.AsyncGetDocumentResultAs <LiteralDataValue>(MockUri, request);
session.Should().NotBeNull();
session.JobId.Should().Be("test-job-id");
}
private void EventLoop(NetMQSocket socket)
{
this.logger.LogDebug("Starting shell server event loop at {Address}.", socket);
while (alive)
{
try
{
// Start by pulling off the next <action>_request message
// from the client.
var nextMessage = socket.ReceiveMessage(context);
logger.LogDebug(
$"Received new message:\n" +
$"\t{JsonConvert.SerializeObject(nextMessage.Header)}\n" +
$"\t{JsonConvert.SerializeObject(nextMessage.ParentHeader)}\n" +
$"\t{JsonConvert.SerializeObject(nextMessage.Metadata)}\n" +
$"\t{JsonConvert.SerializeObject(nextMessage.Content)}"
);
// If this is our first message, we need to set the session
// id.
if (session == null)
{
session = nextMessage.Header.Session;
}
// Get a service that can handle the message type and
// dispatch.
switch (nextMessage.Header.MessageType)
{
case "kernel_info_request":
KernelInfoRequest?.Invoke(nextMessage);
break;
case "execute_request":
ExecuteRequest?.Invoke(nextMessage);
break;
case "shutdown_request":
ShutdownRequest?.Invoke(nextMessage);
break;
}
}
catch (ProtocolViolationException ex)
{
logger.LogCritical(ex, $"Protocol violation when trying to receive next ZeroMQ message.");
}
catch (ThreadInterruptedException)
{
if (alive)
{
continue;
}
else
{
return;
}
}
}
}
public override Task <GenericResponse> Execute(ExecuteRequest request, ServerCallContext context)
{
Process.Start(request.Path);
return(Task.FromResult(new GenericResponse {
Succeeded = true
}));
}
public OpenRequest(JupyterRequestContext context, ExecuteRequest executeRequest, int executionCount, Guid id, Dictionary <string, object> transient)
{
Context = context;
ExecuteRequest = executeRequest;
ExecutionCount = executionCount;
Id = id;
Transient = transient;
}
private ExecuteResponse.Builder GetAccountDigest(ExecuteRequest request)
{
ExecuteResponse.Builder builder = ExecuteResponse.CreateBuilder();
foreach (OperationResult result in request.OperationsList.Select(operation => CreateOperationResult(operation, 1, AccountDigest.ToByteString())))
{
builder.AddResults(result);
}
return(builder);
}
private string CreateEndpoint <TResponse>(ExecuteRequest <TResponse> info) where TResponse : class, IResponseResult
{
if (_options.IsTest)
{
return($"{info.EndPointPath}{(info.EndPointPath.Contains("?") ? "&test=1" : "?test=1")}");
}
return(info.EndPointPath);
}
public void Build_ReturnDeliveryRequest()
{
var context = new Mock <Context>().Object;
var execute = new ExecuteRequest();
var prefetch = new PrefetchRequest();
var notifications = new List <Notification>();
var customerIds = new List <CustomerId>();
var property = new Property("testToken");
var telemetry = new Telemetry();
var trace = new Trace("testAuthToken");
var expCloud = new ExperienceCloud();
var qaMode = new QAMode();
var request = new TargetDeliveryRequest.Builder()
.SetTntId(tntId)
.SetMarketingCloudVisitorId(marketingCloudVisitorId)
.SetThirdPartyId(thirdPartyId)
.SetContext(context)
.SetExecute(execute)
.SetPrefetch(prefetch)
.SetNotifications(notifications)
.SetProperty(property)
.SetTelemetry(telemetry)
.SetTrace(trace)
.SetExperienceCloud(expCloud)
.SetEnvironmentId(environmentId)
.SetImpressionId(impressionId)
.SetQaMode(qaMode)
.SetLocationHint(locationHint)
.SetRequestId(requestId)
.SetSessionId(sessionId)
.SetTargetCustomerIds(customerIds)
.SetDecisioningMethod(DecisioningMethod.Hybrid)
.Build();
Assert.Equal(tntId, request.DeliveryRequest.Id.TntId);
Assert.Equal(marketingCloudVisitorId, request.DeliveryRequest.Id.MarketingCloudVisitorId);
Assert.Equal(thirdPartyId, request.DeliveryRequest.Id.ThirdPartyId);
Assert.Equal(customerIds, request.DeliveryRequest.Id.CustomerIds);
Assert.Equal(context, request.DeliveryRequest.Context);
Assert.Equal(execute, request.DeliveryRequest.Execute);
Assert.Equal(prefetch, request.DeliveryRequest.Prefetch);
Assert.Equal(notifications, request.DeliveryRequest.Notifications);
Assert.Equal(property, request.DeliveryRequest.Property);
Assert.Equal(telemetry, request.DeliveryRequest.Telemetry);
Assert.Equal(trace, request.DeliveryRequest.Trace);
Assert.Equal(expCloud, request.DeliveryRequest.ExperienceCloud);
Assert.Equal(qaMode, request.DeliveryRequest.QaMode);
Assert.Equal(environmentId, request.DeliveryRequest.EnvironmentId);
Assert.Equal(impressionId, request.DeliveryRequest.ImpressionId);
Assert.Equal(requestId, request.DeliveryRequest.RequestId);
Assert.Equal(locationHint, request.LocationHint);
Assert.Equal(sessionId, request.SessionId);
Assert.Equal(DecisioningMethod.Hybrid, request.DecisioningMethod);
}
public override ExecuteResponse Execute(ExecuteRequest request, Action <ExecuteStream> stream)
{
StringBuilder message = new StringBuilder();
message.AppendFormat("Execute:\n Executable: {0}", request.Executable);
if (request.__isset.arguments)
{
message.AppendFormat("\n Arguments: {0}", request.Arguments);
}
if (request.__isset.timeout)
{
message.AppendFormat("\n Timeout: {0} seconds", request.Timeout);
}
if (request.__isset.workingDirectory)
{
message.AppendFormat("\n WorkingDirectory: {0}", request.WorkingDirectory);
}
if (request.__isset.environmentVariables)
{
message.Append("\n EnvironmentVariables:");
foreach (KeyValuePair <string, string> entry in request.EnvironmentVariables)
{
message.AppendFormat("\n {0}={1}", entry.Key, entry.Value);
}
}
log.Info(message.ToString());
int exitCode;
try
{
exitCode = ProcessUtil.Execute(request.Executable,
request.__isset.arguments ? request.Arguments : "",
request.__isset.workingDirectory ? request.WorkingDirectory : null,
request.__isset.environmentVariables ? request.EnvironmentVariables : null,
line => stream(new ExecuteStream()
{
StdoutLine = line
}),
line => stream(new ExecuteStream()
{
StderrLine = line
}),
request.__isset.timeout ? TimeSpan.FromSeconds(request.Timeout) : (TimeSpan?)null);
}
catch (Exception ex)
{
throw OperationFailed(string.Format("Failed to execute process '{0}'.", request.Executable), ex.Message);
}
return(new ExecuteResponse()
{
ExitCode = exitCode
});
}
public string LogExceptionReport(string jobId, ExecuteRequest request, Exception ex)
{
var serializer = new XmlSerializationService();
var report = new ErrorReport
{
JobId = jobId,
ExceptionMessage = ex.ToString(),
ExecuteRequest = request
};
return(Save(report));
}
ExecuteResponse Iface.Execute(ExecuteRequest request)
{
TProtocol oprot = CurrentOutputProtocol;
int seqId = CurrentSeqId;
return(Execute(request, stream =>
{
oprot.WriteMessageBegin(new TMessage("Execute", StreamMessageType, seqId));
stream.Write(oprot);
oprot.WriteMessageEnd();
}));
}
private async Task <TResponse> CreateResult <TResponse>(ExecuteRequest <TResponse> info, HttpResponseMessage request) where TResponse : class, IResponseResult
{
if (request.IsSuccessStatusCode)
{
var content = await request.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <TResponse>(content));
}
var errorContent = await request.Content.ReadAsStringAsync();
throw ApiErrorException.Create(errorContent);
}
public override Task <ExecuteResponse> Execute(ExecuteRequest request,
ServerCallContext context)
{
ExecuteResponse executeResponse = new ExecuteResponse();
mutex.WaitOne();
executeResponse.Latencies.Add(latencies);
executeResponse.ReceivedMessages.Add(received_messages);
latencies.Clear();
received_messages.Clear();
mutex.ReleaseMutex();
return(Task.FromResult(executeResponse));
}
public void HandleMessage(Message message, RouterSocket serverSocket, PublisherSocket ioPub)
{
this.logger.Debug(string.Format("Message Content {0}", message.Content));
ExecuteRequest executeRequest = JsonSerializer.Deserialize <ExecuteRequest>(message.Content);
this.logger.Info(string.Format("Execute Request received with code {0}", executeRequest.Code));
// 1: Send Busy status on IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Busy);
// 2: Send execute input on IOPub
this.SendInputMessageToIOPub(message, ioPub, executeRequest.Code);
// 3: Evaluate the C# code
IOPubConsole ioPubConsole = new IOPubConsole(message, ioPub, this.messageSender, this.executionCount, this.logger);
ioPubConsole.RedirectConsole();
string code = executeRequest.Code;
ExecutionResult results = this.replEngine.Execute(code);
ioPubConsole.CancelRedirect();
string codeOutput = this.GetCodeOutput(results);
string codeHtmlOutput = this.GetCodeHtmlOutput(results);
Dictionary <string, object> data = new Dictionary <string, object>()
{
{ "text/plain", codeOutput },
{ "text/html", codeHtmlOutput }
};
DisplayData displayData = new DisplayData()
{
Data = data,
};
// 4: Send execute reply to shell socket
this.SendExecuteReplyMessage(message, serverSocket);
// 5: Send execute result message to IOPub
if (results.OutputResultWithColorInformation.Any())
{
this.SendOutputMessageToIOPub(message, ioPub, displayData);
}
// 6: Send IDLE status message to IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Idle);
this.executionCount += 1;
}
private static ExecuteResponse.Builder GetHeroDigest(ExecuteRequest request)
{
var results = new List<OperationResult>();
foreach (Operation operation in request.OperationsList)
{
//var toonDigest = ToonHandle.ParseFrom(operation.RowId.Hash.ToByteArray().Skip(2).ToArray());
OperationResult.Builder operationResult = OperationResult.CreateBuilder().SetTableId(operation.TableId);
var value = new EntityId.Builder
{
IdHigh = 0x300016200004433,
IdLow = 2
};
operationResult.AddData(
Cell.CreateBuilder()
.SetColumnId(operation.ColumnId)
.SetRowId(operation.RowId)
.SetVersion(1)
.SetData(D3.Hero.Digest.CreateBuilder().SetVersion(891)
.SetHeroId(value)
.SetHeroName("hazzik")
.SetGbidClass(0)
.SetPlayerFlags(0)
.SetLevel(1)
.SetVisualEquipment(new VisualEquipment.Builder().Build())
.SetLastPlayedAct(0)
.SetHighestUnlockedAct(0)
.SetLastPlayedDifficulty(0)
.SetHighestUnlockedDifficulty(0)
.SetLastPlayedQuest(-1)
.SetLastPlayedQuestStep(-1)
.SetTimePlayed(0)
.Build()
.ToByteString())
.Build()
);
results.Add(operationResult.Build());
}
ExecuteResponse.Builder builder = ExecuteResponse.CreateBuilder();
foreach (OperationResult result in results)
{
builder.AddResults(result);
}
return builder;
}
public ShellServer(
ILogger <ShellServer> logger,
IOptions <KernelContext> context,
IServiceProvider provider,
IShellRouter router
)
{
this.logger = logger;
this.context = context.Value;
this.provider = provider;
this.router = router;
router.RegisterHandler("kernel_info_request", message => KernelInfoRequest?.Invoke(message));
router.RegisterHandler("execute_request", message => ExecuteRequest?.Invoke(message));
router.RegisterHandler("shutdown_request", message => ShutdownRequest?.Invoke(message));
}
public void SerializeExecuteRequest_ValidRequestGiven_ShouldPass()
{
const string expectedXml = @"<?xml version=""1.0"" encoding=""utf-8""?><wps:Execute xmlns:ows=""http://www.opengis.net/ows/2.0"" xmlns:xli=""http://www.w3.org/1999/xlink"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" service=""WPS"" version=""2.0.0"" mode=""sync"" response=""document"" xmlns:wps=""http://www.opengis.net/wps/2.0""><ows:Identifier>org.n52.wps.server.algorithm.SimpleBufferAlgorithm</ows:Identifier><wps:Input id=""data""><wps:Reference xmlns:ows=""http://www.opengis.net/ows/2.0"" xmlns:xli=""http://www.w3.org/1999/xlink"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xli:href=""http://geoprocessing.demo.52north.org:8080/geoserver/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=topp:tasmania_roads&SRS=EPSG:4326&OUTPUTFORMAT=GML3"" schema=""http://schemas.opengis.net/gml/3.1.1/base/feature.xsd"" xmlns:wps=""http://www.opengis.net/wps/2.0"" /></wps:Input><wps:Input id=""width""><wps:Data><LiteralValue xmlns=""http://www.opengis.net/wps/2.0"">0.05</LiteralValue></wps:Data></wps:Input><wps:Output transmission=""value"" id=""result"" /></wps:Execute>";
// Remove white spaces and new line characters for XML comparison.
var trimmedExpectedXml = Regex.Replace(expectedXml, @"\s+", string.Empty);
var executeRequest = new ExecuteRequest
{
Identifier = "org.n52.wps.server.algorithm.SimpleBufferAlgorithm",
ExecutionMode = ExecutionMode.Synchronous,
ResponseType = ResponseType.Document,
Inputs = new[]
{
new DataInput
{
Identifier = "data",
Reference = new ResourceReference
{
Href = "http://geoprocessing.demo.52north.org:8080/geoserver/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=topp:tasmania_roads&SRS=EPSG:4326&OUTPUTFORMAT=GML3",
Schema = "http://schemas.opengis.net/gml/3.1.1/base/feature.xsd"
}
},
new DataInput
{
Identifier = "width",
Data = new LiteralDataValue
{
Value = 0.05f.ToString(CultureInfo.InvariantCulture)
}
}
},
Outputs = new[]
{
new DataOutput
{
Identifier = "result",
Transmission = TransmissionMode.Value
}
}
};
var resultXml = _serializer.Serialize(executeRequest);
var trimmedResult = Regex.Replace(resultXml, @"\s+", string.Empty);
trimmedResult.Should().Be(trimmedExpectedXml);
}
private static ExecuteResponse.Builder GetHeroDigest(ExecuteRequest request)
{
var results = new List <OperationResult>();
foreach (Operation operation in request.OperationsList)
{
//var toonDigest = ToonHandle.ParseFrom(operation.RowId.Hash.ToByteArray().Skip(2).ToArray());
OperationResult.Builder operationResult = OperationResult.CreateBuilder().SetTableId(operation.TableId);
var value = new EntityId.Builder
{
IdHigh = 0x300016200004433,
IdLow = 2
};
operationResult.AddData(
Cell.CreateBuilder()
.SetColumnId(operation.ColumnId)
.SetRowId(operation.RowId)
.SetVersion(1)
.SetData(D3.Hero.Digest.CreateBuilder().SetVersion(891)
.SetHeroId(value)
.SetHeroName("hazzik")
.SetGbidClass(0)
.SetPlayerFlags(0)
.SetLevel(1)
.SetVisualEquipment(new VisualEquipment.Builder().Build())
.SetLastPlayedAct(0)
.SetHighestUnlockedAct(0)
.SetLastPlayedDifficulty(0)
.SetHighestUnlockedDifficulty(0)
.SetLastPlayedQuest(-1)
.SetLastPlayedQuestStep(-1)
.SetTimePlayed(0)
.Build()
.ToByteString())
.Build()
);
results.Add(operationResult.Build());
}
ExecuteResponse.Builder builder = ExecuteResponse.CreateBuilder();
foreach (OperationResult result in results)
{
builder.AddResults(result);
}
return(builder);
}
public void HandleMessage(Message message, RouterSocket serverSocket, PublisherSocket ioPub)
{
this.logger.LogDebug(string.Format("Message Content {0}", message.Content));
ExecuteRequest executeRequest = JsonConvert.DeserializeObject <ExecuteRequest>(message.Content);
this.logger.LogInformation(string.Format("Execute Request received with code {0}", executeRequest.Code));
// 1: Send Busy status on IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Busy);
// 2: Send execute input on IOPub
this.SendInputMessageToIOPub(message, ioPub, executeRequest.Code);
// 3: Evaluate the C# code
string code = executeRequest.Code;
var results = this.replEngine.Execute(code);
DisplayData displayData = results.GetDisplayData();
// 4: Send execute reply to shell socket
this.SendExecuteReplyMessage(message, serverSocket);
// 5: Send execute result message to IOPub
if (results.Output.Any())
{
this.SendOutputMessageToIOPub(message, ioPub, displayData);
}
if (results.Exceptions.Any())
{
this.SendExecuteErrorMessage(message, serverSocket);
foreach (var ex in results.Exceptions)
{
this.SendErrorToIOPub(message, ioPub, ex);
}
}
// 6: Send IDLE status message to IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Idle);
if (executeRequest.StoreHistory)
{
this.executionCount += 1;
}
}
private async Task <TResponse> ExecutePostAsync <TResponse>(ExecuteRequest <TResponse> info) where TResponse : class, IResponseResult
{
var json = string.Empty;
if (info.Data != null)
{
json = JsonConvert.SerializeObject(info.Data);
}
var buffer = Encoding.UTF8.GetBytes(json);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var request = await _client.PostAsync(CreateEndpoint(info), byteContent);
return(await CreateResult(info, request));
}
public ExecuteResponse Execute(ExecuteRequest executeRequest)
{
Contract.Requires(executeRequest != null);
Contract.Requires(executeRequest.Command != null);
Contract.Ensures(Contract.Result <ExecuteResponse>() != null);
Contract.EnsuresOnThrow <FaultException <CommandWebServiceFault> >(Contract.Result <ExecuteResponse>() == null);
try
{
_service.Execute(executeRequest.Command);
return(new ExecuteResponse());
}
catch (Exception ex)
{
throw new FaultException <CommandWebServiceFault>(
new CommandWebServiceFault(executeRequest.Command, ex), "An exception occured while trying to execute the command");
}
}
private void executeCode(string code)
{
try
{
ExecuteRequest request = new ExecuteRequest();
request.Code = code;
var response = mrsServer.ExecuteCode(sessionId, request);
if (response.Success == false)
{
throw new Exception(response.ErrorMessage);
}
}
catch (Exception e)
{
throw new Exception("Execute Code Failed : " + e.Message);
}
}
protected ActionResult ExecuteRequestAndHandle(ExecuteRequest executeRequest, int responseCode)
{
try
{
return(RestErrorHandler.Handle(() =>
{
Log.Info(string.Format("Entering {0} method", executeRequest.Method));
executeRequest.Invoke();
var response = this.StatusCode(responseCode);
Log.Info(string.Format("Leaving {0} method", executeRequest.Method));
return response;
}));
}
catch (Exception ex)
{
return(this.ProcessException(ex));
}
}
public void Service_Execute_Zorgtoeslag_From_Url()
{
APIServiceController controller = new APIServiceController(InitMoqLogger(), new YamlScriptController(), InitMoqRoutingController());
var executeRequest = new ExecuteRequest()
{
Config = YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"),
Parameters = new ParametersCollection()
{
new ClientParameter("alleenstaande", "ja", TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy")
}
};
var payload = JsonConvert.SerializeObject(executeRequest);
var result = controller.Execute(executeRequest).Result;
Assert.True(result.Questions.Parameters.Count == 1);
Assert.True(result.Questions.Parameters[0].Name == "woonland");
}
public async Task <ActionResult <BoolResult> > Execute([FromBody] ExecuteRequest request)
{
if (!await _authManager.HasAppPermissionsAsync(DatabaseManager.PermissionsExecute))
{
return(Unauthorized());
}
if (request.SecurityKey != _settingsManager.SecurityKey)
{
return(this.Error("SecurityKey 输入错误！"));
}
await _databaseManager.ExecuteAsync(request.Execute);
return(new BoolResult
{
Value = true
});
}
public override void Execute(IRpcController controller, ExecuteRequest request, Action<ExecuteResponse> done)
{
ExecuteResponse.Builder response;
switch (request.QueryName)
{
case "QueryAccountDigest":
response = GetAccountDigest(request);
break;
case "LoadAccountDigest":
response = LoadAccountDigest(request);
break;
case "GetHeroDigests":
response = GetHeroDigest(request);
break;
default:
response = new ExecuteResponse.Builder();
break;
}
done(response.Build());
}
public ExecuteResponse Execute(ExecuteRequest request, Action<ExecuteStream> handleStream)
{
send_Execute(request);
for (; ; )
{
TMessage msg = iprot_.ReadMessageBegin();
if (msg.Type == TMessageType.Exception)
{
TApplicationException x = TApplicationException.Read(iprot_);
iprot_.ReadMessageEnd();
throw x;
}
if (msg.Type == StreamMessageType)
{
ExecuteStream stream = new ExecuteStream();
stream.Read(iprot_);
iprot_.ReadMessageEnd();
handleStream(stream);
continue;
}
Execute_result result = new Execute_result();
result.Read(iprot_);
iprot_.ReadMessageEnd();
if (result.__isset.success)
{
return result.Success;
}
if (result.__isset.ex)
{
throw result.Ex;
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "Execute failed: unknown result");
}
}
public override ExecuteResponse Execute(ExecuteRequest request, Action<ExecuteStream> stream)
{
StringBuilder message = new StringBuilder();
message.AppendFormat("Execute:\n Executable: {0}", request.Executable);
if (request.__isset.arguments)
message.AppendFormat("\n Arguments: {0}", request.Arguments);
if (request.__isset.timeout)
message.AppendFormat("\n Timeout: {0} seconds", request.Timeout);
if (request.__isset.workingDirectory)
message.AppendFormat("\n WorkingDirectory: {0}", request.WorkingDirectory);
if (request.__isset.environmentVariables)
{
message.Append("\n EnvironmentVariables:");
foreach (KeyValuePair<string, string> entry in request.EnvironmentVariables)
message.AppendFormat("\n {0}={1}", entry.Key, entry.Value);
}
log.Info(message.ToString());
int exitCode;
try
{
exitCode = ProcessUtil.Execute(request.Executable,
request.__isset.arguments ? request.Arguments : "",
request.__isset.workingDirectory ? request.WorkingDirectory : null,
request.__isset.environmentVariables ? request.EnvironmentVariables : null,
line => stream(new ExecuteStream() { StdoutLine = line }),
line => stream(new ExecuteStream() { StderrLine = line }),
request.__isset.timeout ? TimeSpan.FromSeconds(request.Timeout) : (TimeSpan?) null);
}
catch (Exception ex)
{
throw OperationFailed(string.Format("Failed to execute process '{0}'.", request.Executable), ex.Message);
}
return new ExecuteResponse() { ExitCode = exitCode };
}
public override void Execute(IRpcController controller, ExecuteRequest request, Action<ExecuteResponse> done)
{
ProtoOutputBuffer.Write(request.GetType(), request.ToString());
}
public int Execute(string executable, string arguments, string workingDirectory,
IDictionary<string, string> environmentVariables,
LineHandler stdoutHandler, LineHandler stderrHandler, TimeSpan? timeout)
{
CheckProfileCanResolveSlave();
StringBuilder message = new StringBuilder();
message.AppendLine("Executing remote command: ");
message.AppendFormat(" Executable : {0}\n", executable);
message.AppendFormat(" Arguments : {0}\n", arguments);
if (workingDirectory != null)
message.AppendFormat(" Directory : {0}\n", workingDirectory);
if (environmentVariables != null)
{
message.AppendLine(" Environment :");
foreach (KeyValuePair<string, string> entry in environmentVariables)
message.AppendFormat(" {0}={1}\n", entry.Key, entry.Value);
}
Log(message.ToString());
ExecuteRequest request = new ExecuteRequest();
request.Executable = executable;
if (arguments.Length != 0)
request.Arguments = arguments;
if (workingDirectory != null)
request.WorkingDirectory = workingDirectory;
if (environmentVariables != null)
request.EnvironmentVariables = new Dictionary<string, string>(environmentVariables);
if (timeout.HasValue)
request.Timeout = (int) timeout.Value.TotalSeconds;
ExecuteResponse response = GetSlaveClient().Execute(request,
stream =>
{
if (stream.__isset.stdoutLine)
stdoutHandler(stream.StdoutLine);
if (stream.__isset.stderrLine)
stderrHandler(stream.StderrLine);
});
return response.ExitCode;
}
public abstract ExecuteResponse Execute(ExecuteRequest request, Action<ExecuteStream> sendStream);
private ExecuteResponse.Builder GetAccountDigest(ExecuteRequest request)
{
ExecuteResponse.Builder builder = ExecuteResponse.CreateBuilder();
foreach (OperationResult result in request.OperationsList.Select(operation => CreateOperationResult(operation, 1, AccountDigest.ToByteString())))
{
builder.AddResults(result);
}
return builder;
}
public override void Execute(Google.ProtocolBuffers.IRpcController controller, ExecuteRequest request, Action<ExecuteResponse> done) {
var response = ExecuteResponse.CreateBuilder();
foreach (var op in request.OperationsList) {
var result = OperationResult.CreateBuilder();
result.SetTableId(op.TableId);
var data = Cell.CreateBuilder();
data.SetColumnId(op.ColumnId);
data.SetRowId(op.RowId);
result.SetErrorCode(1);
if (request.QueryName == "GetGameAccountSettings") {
result.SetErrorCode(4);
} else if (request.QueryName == "GetHeroDigests") {
var hero_digest = D3.Hero.Digest.CreateBuilder();
hero_digest.SetVersion(891);
hero_digest.SetHeroId(D3.OnlineService.EntityId.CreateBuilder().SetIdHigh(216174302532224051).SetIdLow(2345959482769161802));
hero_digest.SetHeroName("poop");
hero_digest.SetGbidClass(-930376119);
hero_digest.SetLevel(1);
hero_digest.SetPlayerFlags(0);
var eq = VisualEquipment.CreateBuilder();
for (int i = 0; i < 8; i++) {
eq.AddVisualItem(VisualItem.CreateBuilder().SetEffectLevel(0));
}
hero_digest.SetVisualEquipment(eq);
//hero_digest.SetQuestHistory(QuestHistoryEntry
hero_digest.SetLastPlayedAct(0);
hero_digest.SetHighestUnlockedAct(0);
hero_digest.SetLastPlayedQuest(-1);
hero_digest.SetLastPlayedQuestStep(-1);
hero_digest.SetLastPlayedDifficulty(0);
hero_digest.SetTimePlayed(0);
hero_digest.SetHighestUnlockedDifficulty(0);
data.SetData(hero_digest.Build().ToByteString());
} else if (request.QueryName == "LoadAccountDigest") {
var account_digest = D3.Account.Digest.CreateBuilder();
account_digest.SetVersion(1);
// no last played hero
var last_played = D3.OnlineService.EntityId.CreateBuilder();
last_played.SetIdHigh(216174302532224051);
last_played.SetIdLow(2345959482769161802);
account_digest.SetLastPlayedHeroId(last_played);
// default banner
var banner = D3.Account.BannerConfiguration.CreateBuilder();
banner.SetBannerIndex(0).SetSigilMain(0).SetSigilAccent(0).SetPatternColorIndex(0).SetBackgroundColorIndex(0).SetSigilColorIndex(0)
.SetPlacementIndex(0).SetPattern(0).SetUseSigilVariant(false);
account_digest.SetBannerConfiguration(banner);
// default flags
account_digest.SetFlags((uint)D3.Account.Digest.Types.Flags.HARDCORE_HERO_UNLOCKED);
data.SetData(account_digest.Build().ToByteString());
} else if (request.QueryName == "GetToonSettings") {
//response.SetErrorCode(4);
} else {
throw new ArgumentException("Invalid query name: " + request.QueryName);
}
result.AddData(data);
response.AddResults(result);
}
done(response.Build());
}
/// <summary>
/// This request is used to execute a PreparedStatement, optionally with values to bind to the parameters in the Statement.
/// </summary>
public async Task<ExecuteResponse> ExecuteRequestAsync(StatementHandle statementHandle, pbc::RepeatedField<TypedValue> parameterValues, ulong firstFrameMaxSize, bool hasParameterValues, RequestOptions options)
{
ExecuteRequest req = new ExecuteRequest
{
StatementHandle = statementHandle,
ParameterValues = parameterValues,
FirstFrameMaxSize = firstFrameMaxSize,
HasParameterValues = hasParameterValues
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
statementHandle.ConnectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
ExecuteResponse Iface.Execute(ExecuteRequest request)
{
TProtocol oprot = CurrentOutputProtocol;
int seqId = CurrentSeqId;
return Execute(request, stream =>
{
oprot.WriteMessageBegin(new TMessage("Execute", StreamMessageType, seqId));
stream.Write(oprot);
oprot.WriteMessageEnd();
});
}
