public InvokeResponse Invoke(InvokeRequest request)
{
InvokeResponse response = new InvokeResponse();
if (!string.IsNullOrEmpty(request.ComponentType))
{
IServiceComponentManager componentManager = Container.Resolve<IServiceComponentManager>();
IServiceComponent component = componentManager.ServiceComponents.FirstOrDefault(c => c != null && c.GetType().GetInterface(request.ComponentType) != null);
if (component != null)
{
MethodInfo operation =
component.GetType().GetMethod(request.OperationName,
request.OperationParameters.Select(op => DataContractUtility.GetType(op.AssemblyQualifiedTypeName, op.TypeName, op.IsEnumerable)).ToArray());
if (operation != null)
{
try
{
List<object> parameters = new List<object>();
foreach (InvokeParameter parameter in request.OperationParameters)
parameters.Add(DataContractUtility.Deserialize(DataContractUtility.GetType(parameter.AssemblyQualifiedTypeName, parameter.TypeName, parameter.IsEnumerable),
parameter.SerializedParameter));
object result;
try
{
result = operation.Invoke(component, parameters.ToArray());
if (result != null)
response.OperationResult = DataContractUtility.Serialize(result.GetType(), result);
}
catch (Exception ex)
{
response.Error = new Exception("An exception occurred trying to invoke operation.", ex);
}
}
catch (Exception ex)
{
response.Error = new InvalidRequestException("An exception occurred trying to deserialize operation parameters.", ex);
}
}
else
response.Error = new InvalidRequestException("Operation not found.");
}
else
response.Error = new InvalidRequestException("Component not found.");
}
else
response.Error = new InvalidRequestException("Component type not provided.");
return response;
}
public void BodyDoesntHideBase()
{
var sut = new InvokeResponse <SomeType>
{
Status = 200,
Body = new SomeType
{
Id = "200",
Value = "blah"
}
};
// Assert that the Body property is not hidden when using InvokeResponse or InvokeResponse<T>.
var sutAsInvokeResponse = (InvokeResponse)sut;
Assert.NotNull(sutAsInvokeResponse.Body);
Assert.Same(sut.Body, sutAsInvokeResponse.Body);
Assert.Equal(sut.Body.Id, ((SomeType)sutAsInvokeResponse.Body).Id);
Assert.Equal(sut.Body.Value, ((SomeType)sutAsInvokeResponse.Body).Value);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
InvokeResponse response = new InvokeResponse();
var ms = new MemoryStream();
Amazon.Util.AWSSDKUtils.CopyStream(context.Stream, ms);
ms.Seek(0, SeekOrigin.Begin);
response.Payload = ms;
if (context.ResponseData.IsHeaderPresent("X-Amz-Function-Error"))
{
response.FunctionError = context.ResponseData.GetHeaderValue("X-Amz-Function-Error");
}
if (context.ResponseData.IsHeaderPresent("X-Amz-Log-Result"))
{
response.LogResult = context.ResponseData.GetHeaderValue("X-Amz-Log-Result");
}
response.StatusCode = (int)context.ResponseData.StatusCode;
return(response);
}
public override async Task <InvokeResponse> OnInvoke(InvokeRequest request, ServerCallContext context)
{
var response = new InvokeResponse();
switch (request.Method)
{
case "createuser":
var user = JsonSerializer.Deserialize <User>(System.Text.Encoding.UTF8.GetString(request.Data.Value.Memory.ToArray()));
await CreateUserAsync(user);
break;
case "sendmessage":
var message = JsonSerializer.Deserialize <Message>(System.Text.Encoding.UTF8.GetString(request.Data.Value.Memory.ToArray()));
await SendMessageAsync(message);
break;
}
return(await Task.FromResult(response));
}
public async Task <string> HandleIncomingCall(TwilioIncomingCall twilioCallDetails, ILambdaContext context)
{
string stage = System.Environment.GetEnvironmentVariable("STAGE");
string region = System.Environment.GetEnvironmentVariable("AWS_REGION");
string functionName = $"telephonist-csharp-{stage}-GetDetailsForCurrentOnCallOperator";
LambdaLogger.Log($"REQUEST: {twilioCallDetails}");
LambdaLogger.Log($"PARAM: stage={stage}");
LambdaLogger.Log($"PARAM: region={region}");
LambdaLogger.Log($"functionName: {functionName}");
using (AmazonLambdaClient client = new AmazonLambdaClient(RegionEndpoint.GetBySystemName(region)))
{
InvokeRequest request = new InvokeRequest()
{
FunctionName = functionName
};
InvokeResponse response = await client.InvokeAsync(request);
using (StreamReader reader = new StreamReader(response.Payload))
{
string result = reader.ReadToEnd();
LambdaLogger.Log($"Lambda result: {result}");
OnCallOperatorDetails engineer = WebHelpers.ParseJSON <OnCallOperatorDetails>(result);
string justName = engineer.Name.Split(' ')[0];
TimeZoneInfo localTimeZone = WebHelpers.OlsonTimeZoneToTimeZoneInfo(engineer.TimeZone);
DateTime localTime = TimeZoneInfo.ConvertTime(DateTime.Now, localTimeZone);
string localTimeString = localTime.ToString("hh:mm tt", CultureInfo.InvariantCulture);
return(String.Format(CultureInfo.InvariantCulture, ResponseTwiML, justName, localTimeString, engineer.PhoneNumber));
}
}
}
public async Task OnTurnAsync(ITurnContext turnCtx, CancellationToken cancellationToken)
{
try
{
if (turnCtx.Activity != null && turnCtx.Activity.Type != null && turnCtx.Activity.Type == ActivityTypes.Invoke)
{
ITeamsContext teamsContext = turnCtx.TurnState.Get <ITeamsContext>();
MessagingExtensionQuery meQuery = null;
if (teamsContext.IsRequestMessagingExtensionQuery())
{
meQuery = teamsContext.GetMessagingExtensionQueryData();
}
InvokeResponse ir = new InvokeResponse
{
Body = new MessagingExtensionResponse
{
ComposeExtension = await searchHandler.GetSearchResultAsync(meQuery.Parameters[0].Value.ToString())
},
Status = 200,
};
await turnCtx.SendActivityAsync(
new Activity
{
Value = ir,
Type = ActivityTypesEx.InvokeResponse,
}).ConfigureAwait(false);
}
else
{
await turnCtx.SendActivityAsync(string.Format("Sorry! As of now I'm only support an invoke command, but you're trying to execute {0}", (turnCtx.Activity != null && turnCtx.Activity.Type != null) ? turnCtx.Activity.Type.ToString() : "empty activity"));
}
}
catch (Exception ex)
{
await turnCtx.SendActivityAsync($"Oppps, seems like an error: {ex.InnerException}. Try again or contact your IT admin");
}
}
public async Task InvokeMethodGrpcAsync_CanInvokeMethodWithNoReturnTypeAndData_ThrowsErrorNonSuccess()
{
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = Any.Pack(data),
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.Build();
const string rpcExceptionMessage = "RPC exception";
const StatusCode rpcStatusCode = StatusCode.Unavailable;
const string rpcStatusDetail = "Non success";
var rpcStatus = new Status(rpcStatusCode, rpcStatusDetail);
var rpcException = new RpcException(rpcStatus, new Metadata(), rpcExceptionMessage);
// Setup the mock client to throw an Rpc Exception with the expected details info
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Throws(rpcException);
var ex = await Assert.ThrowsAsync <InvocationException>(async() =>
{
await client.DaprClient.InvokeMethodGrpcAsync <Request>("test", "test", new Request()
{
RequestParameter = "Hello "
});
});
Assert.Same(rpcException, ex.InnerException);
}
public void record_with_one_pdf_resource_test()
{
var record = new Record().With(r =>
{
r.Id = Helpers.AddCollection("0545c14b-e7fd-472d-8575-5bb75034945f");
r.Gemini = Library.Example();
r.Resources = new List <Resource>
{
new Resource
{
Name = "A pdf resource",
Path = "C:\\work\\test.pdf",
PublishedUrl = "http://data.jncc.gov.uk/data/0545c14b-e7fd-472d-8575-5bb75034945f/test.pdf"
}
};
});
var lambdaClientMock = new Mock <ILambdaClient>();
var s3ClientMock = new Mock <IS3Client>();
var fileHelperMock = new Mock <IFileHelper>();
var hubService = new HubService(env, lambdaClientMock.Object, s3ClientMock.Object, fileHelperMock.Object);
fileHelperMock.Setup(x => x.IsPdfFile(It.IsAny <string>())).Returns(true);
fileHelperMock.Setup(x => x.GetFileSizeInBytes(It.IsAny <string>())).Returns(100);
fileHelperMock.Setup(x => x.GetBase64String(It.IsAny <string>())).Returns("base 64 string");
fileHelperMock.Setup(x => x.GetFileExtensionWithoutDot(It.IsAny <string>())).Returns("pdf");
var s3Response = new PutObjectResponse();
s3Response.HttpStatusCode = HttpStatusCode.OK;
s3ClientMock.Setup(x => x.SaveToS3(It.IsAny <string>(), It.IsAny <string>())).Returns(s3Response);
var lambdaResponse = new InvokeResponse();
lambdaResponse.StatusCode = 200;
lambdaClientMock.Setup(x => x.SendToHub(It.IsAny <string>())).Returns(lambdaResponse);
hubService.Publish(record);
s3ClientMock.Verify(x => x.SaveToS3(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
lambdaClientMock.Verify(x => x.SendToHub(It.IsAny <string>()), Times.Once);
}
public string PostData(LambdaResourceType lambdaResourceType, string postData)
{
postData = @"{
""resource"": ""/" + (lambdaResourceType == LambdaResourceType.listings ? "listings" : "areas") + @""",
""body"": " + postData + @"
}";
InvokeRequest ir = new InvokeRequest
{
FunctionName = "rasterizer",
InvocationType = InvocationType.RequestResponse,
Payload = postData
};
InvokeResponse response = this.lambdaClient.InvokeAsync(ir).Result;
string sr = new StreamReader(response.Payload).ReadToEnd();
return(sr.Substring(sr.IndexOf("\"") + 1).Substring(0, sr.LastIndexOf("\"") - 1).Replace("\\", ""));
//WebRequest request = WebRequest.Create(url);
//request.Method = "POST";
//byte[] byteArray = Encoding.UTF8.GetBytes(postData);
//request.ContentType = "application/x-www-form-urlencoded";
//request.ContentLength = byteArray.Length;
//Stream dataStream = request.GetRequestStream();
//dataStream.Write(byteArray, 0, byteArray.Length);
//dataStream.Close();
//WebResponse response = request.GetResponse();
//dataStream = response.GetResponseStream();
//StreamReader reader = new StreamReader(dataStream);
//string responseFromServer = reader.ReadToEnd();
//reader.Close();
//dataStream.Close();
//response.Close();
//return responseFromServer;
}
public override Task <InvokeResponse> InvokeService(InvokeServiceRequest request, ServerCallContext context)
{
switch (request.Message.Method)
{
case "SayHello":
Console.WriteLine("Inside DaprImpl! InvokeService");
var response = new InvokeResponse()
{
Data = new Any()
{
Value = ByteString.CopyFrom(
Encoding.UTF8.GetBytes($"Hello from {request.Message?.Data?.Value?.ToStringUtf8()}"))
}
};
return(Task.FromResult(response));
default:
throw new Exception($"Unknown method invocation {request.Message.Method}");
}
}
public async Task <InvokeResponse> ServiceInvokeMethod(InvokeRequest parameters)
{
InvokeResponse res = null;
try
{
res = await InvokeMethod(parameters);
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
res = new InvokeResponse {
result = null,
error = new ErrorInfo(ex.GetFullMessage(), ex.GetType().Name)
};
_OnError(ex);
}
return(res);
}
public void testGetResultForInvoke()
{
XooaClient xooaClient = new XooaClient();
xooaClient.setApiToken(XooaConstants.API_TOKEN);
string resultId = "63dc6290-053d-4469-8461-dcdf705d0943";
try {
InvokeResponse invokeResponse = xooaClient.getResultForInvoke(resultId);
Assert.IsNotEmpty(invokeResponse.getPayload());
Assert.IsNotEmpty(invokeResponse.getTxnId());
} catch (XooaRequestTimeoutException xrte) {
Assert.IsNotEmpty(xrte.getResultUrl());
Assert.IsNotEmpty(xrte.getResultId());
Assert.AreEqual(resultId, xrte.getResultId());
}
}
static void Main(string[] args)
{
AmazonLambdaClient client = new AmazonLambdaClient("key", "key", RegionEndpoint.USWest1);
InvokeRequest ir = new InvokeRequest
{
FunctionName = "MyHelloWorld",
InvocationType = InvocationType.RequestResponse,
Payload = "\"Ramesh\""
};
InvokeResponse response = client.Invoke(ir);
var sr = new StreamReader(response.Payload);
JsonReader reader = new JsonTextReader(sr);
var serilizer = new JsonSerializer();
var op = serilizer.Deserialize(reader);
Console.WriteLine(op);
Console.ReadLine();
}
// GET: Register
public ActionResult Register()
{
AmazonLambdaClient client = new AmazonLambdaClient("", "", RegionEndpoint.USEast1);
InvokeRequest ir = new InvokeRequest
{
FunctionName = "RandomNumber",
InvocationType = InvocationType.RequestResponse
};
InvokeResponse response = client.Invoke(ir);
var sr = new StreamReader(response.Payload);
JsonReader reader = new JsonTextReader(sr);
var serilizer = new JsonSerializer();
var op = serilizer.Deserialize(reader);
ViewData["number"] = op;
return(View());
}
public void testInvoke()
{
string functionName = "set";
string[] args = { "args1", "9000" };
XooaClient xooaClient = new XooaClient();
xooaClient.setApiToken(XooaConstants.API_TOKEN);
try {
InvokeResponse invokeResponse = xooaClient.invoke(functionName, args);
Assert.IsNotEmpty(invokeResponse.getTxnId());
Assert.IsNotEmpty(invokeResponse.getPayload());
} catch (XooaRequestTimeoutException xrte) {
Assert.IsNotEmpty(xrte.getResultId());
Assert.IsNotEmpty(xrte.getResultUrl());
}
}
static T InvokeMethodCore <T>(
JsiiMethodAttribute methodAttribute,
object[] arguments,
Func <IClient, object[], BeginResponse> beginFunc,
Func <IClient, object[], InvokeResponse> invokeFunc
)
{
IServiceProvider serviceProvider = ServiceContainer.ServiceProvider;
IClient client = serviceProvider.GetRequiredService <IClient>();
IJsiiToFrameworkConverter converter = serviceProvider.GetRequiredService <IJsiiToFrameworkConverter>();
IReferenceMap referenceMap = serviceProvider.GetRequiredService <IReferenceMap>();
object result = GetResult();
if (!converter.TryConvert(methodAttribute.Returns, typeof(T), referenceMap, result, out object frameworkValue))
{
throw new ArgumentException($"Could not convert result '{result}' for method '{methodAttribute.Name}'", nameof(result));
}
return((T)frameworkValue);
object GetResult()
{
object[] args = ConvertArguments(methodAttribute.Parameters, arguments);
if (methodAttribute.IsAsync)
{
BeginResponse beginResponse = beginFunc(client, args);
InvokeCallbacks();
return(client.End(beginResponse.PromiseId).Result);
}
InvokeResponse invokeResponse = invokeFunc(client, args);
return(invokeResponse.Result);
}
}
public async Task InvokeMethodAsync_CanInvokeMethodWithResponse_CalleeSideHttp()
{
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = TypeConverters.ToAny(data)
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.AddHeader("dapr-http-status", "200")
.Build();
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Returns(response);
var body = new Request()
{
RequestParameter = "Hello "
};
var task = client.DaprClient.InvokeMethodWithResponseAsync <Request, Response>("test", "testMethod", body);
// Validate Response
var invokedResponse = await task;
invokedResponse.Body.Name.Should().Be("Look, I was invoked!");
invokedResponse.Headers.ContainsKey("dapr-http-status").Should().BeTrue();
invokedResponse.ContentType.Should().Be(Constants.ContentTypeApplicationJson);
invokedResponse.GrpcStatusInfo.Should().BeNull();
invokedResponse.HttpStatusCode.Should().NotBeNull();
invokedResponse.HttpStatusCode.Should().Be(HttpStatusCode.OK);
}
public async Task <InvokeResponse> HandleAppBasedLinkQueryAsync(
ITurnContext <IInvokeActivity> turnContext,
AppBasedLinkQuery query,
CancellationToken cancellationToken)
{
var url = query?.Url?.Trim() ?? string.Empty;
var result = new InvokeResponse {
Status = (int)HttpStatusCode.OK
};
if (url.Contains("OpenPositionsPersonalTab"))
{
var positionIdParam = HttpUtility.ParseQueryString(new Uri(url).Query).Get("positionId");
if (int.TryParse(positionIdParam, out var positionId))
{
result = await PositionMessagingExtensionResponse(turnContext, positionId);
}
}
return(result);
}
private async Task <string> Recognize(IFormFile file)
{
var lambdaRequest = new OcrLambdaRequest(this.ConvertImageToBase64(file));
var payload = JsonConvert.SerializeObject(lambdaRequest, new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
});
InvokeRequest ir = new InvokeRequest
{
FunctionName = "x1",
InvocationType = InvocationType.RequestResponse,
Payload = payload
};
InvokeResponse response = await this.awsLambdaClient.InvokeAsync(ir);
using (var sr = new StreamReader(response.Payload))
{
JsonReader reader = new JsonTextReader(sr);
var serilizer = new JsonSerializer();
var op = serilizer.Deserialize(reader);
var text = op as string;
//TODO add proper error handling
if (text != null)
{
return(text);
}
else
{
throw new Exception("Something went wrong!");
}
}
}
public override Task <InvokeResponse <T> > PostActivityAsync <T>(string fromBotId, string toBotId, Uri toUrl, Uri serviceUrl, string conversationId, Activity activity, CancellationToken cancellationToken = default)
{
var responseActivity = activity;
if (activity.Text.Contains("skill"))
{
responseActivity = new Activity()
{
Type = "message",
Text = "This is the skill talking: hello"
};
}
if (activity.Text.Contains("end"))
{
responseActivity = new Activity()
{
Type = "endOfConversation"
};
}
var response = new InvokeResponse <ExpectedReplies>()
{
Status = 200,
Body = new ExpectedReplies
{
Activities = new List <Activity>()
{
responseActivity
}
}
};
var casted = (InvokeResponse <T>)Convert.ChangeType(response, typeof(InvokeResponse <T>), new System.Globalization.CultureInfo("en-US"));
var result = Task.FromResult(casted);
return(result);
}
public void invoke()
{
AmazonLambdaClient client = new AmazonLambdaClient("AKIAJHTR2OYL3LKMA7TA", "FugS3+bephKimPa9orSL7Ox2+mv1RreS4IFPK0oJ"
, RegionEndpoint.USWest2);
InvokeRequest ir = new InvokeRequest
{
FunctionName = "myfirstfunction",
InvocationType = InvocationType.RequestResponse,
Payload = "\"Hello Du\""
};
InvokeResponse response = client.InvokeAsync(ir).Result;
var sr = new StreamReader(response.Payload);
JsonReader reader = new JsonTextReader(sr);
var serilizer = new JsonSerializer();
var op = serilizer.Deserialize(reader);
Console.WriteLine(op);
}
private static string PostPredicitionViaInvokeRequest(string serializedPrediction)
{
AmazonLambdaClient client = new AmazonLambdaClient("awsaccessKeyID", "awsSecreteAccessKey", RegionEndpoint.USWest1);
InvokeRequest ir = new InvokeRequest
{
FunctionName = "HelloLambdaWorld",
InvocationType = InvocationType.RequestResponse,
Payload = "\"Vikram\""
};
InvokeResponse response = null; // client.Invoke(ir);
var sr = new StreamReader(response.Payload);
JsonReader reader = new JsonTextReader(sr);
var serilizer = new JsonSerializer();
var op = serilizer.Deserialize(reader);
Console.WriteLine(op);
Console.ReadLine();
return(serializedPrediction);
}
/// <summary>
/// Primary adapter method for processing activities sent from calling bot.
/// </summary>
/// <param name="activity">The activity to process.</param>
/// <param name="callback">The BotCallBackHandler to call on completion.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>The response to the activity.</returns>
public async Task <InvokeResponse> ProcessActivityAsync(Activity activity, BotCallbackHandler callback, CancellationToken cancellationToken)
{
// Ensure the Activity has been retrieved from the HTTP POST
BotAssert.ActivityNotNull(activity);
_botTelemetryClient.TrackTrace($"SkillHttpBotAdapter: Received an incoming activity. Activity id: {activity.Id}", Severity.Information, null);
// Process the Activity through the Middleware and the Bot, this will generate Activities which we need to send back.
using (var context = new TurnContext(this, activity))
{
await RunPipelineAsync(context, callback, default(CancellationToken));
}
_botTelemetryClient.TrackTrace($"SkillHttpBotAdapter: Batching activities in the response. ReplyToId: {activity.ReplyToId}", Severity.Information, null);
// Any Activity responses are now available (via SendActivitiesAsync) so we need to pass back for the response
var response = new InvokeResponse
{
Status = (int)HttpStatusCode.OK,
Body = GetReplies(),
};
return(response);
}
public override async Task <InvokeResponse> OnInvoke(InvokeRequest request, ServerCallContext context)
{
Console.WriteLine($"Method {request.Method}");
var response = new InvokeResponse();
switch (request.Method)
{
case "reserve":
var input = request.Data.Unpack <Generated.Item>();
var output = await Task.FromResult <Generated.Item>(new Generated.Item()
{
SKU = input.SKU, Quantity = -input.Quantity
});
response.Data = Any.Pack(output);
break;
default:
Console.WriteLine("Method not supported");
break;
}
return(response);
}
protected override async Task <InvokeResponse> OnInvokeActivityAsync(ITurnContext <IInvokeActivity> turnContext, CancellationToken cancellationToken)
{
JObject valueObject = JObject.FromObject(turnContext.Activity.Value);
if (valueObject["authentication"] != null)
{
JObject authenticationObject = JObject.FromObject(valueObject["authentication"]);
if (authenticationObject["token"] != null)
{
//If the token is NOT exchangeable, then return 412 to require user consent
if (await TokenIsExchangeable(turnContext, cancellationToken))
{
return(await base.OnInvokeActivityAsync(turnContext, cancellationToken).ConfigureAwait(false));
}
else
{
var response = new InvokeResponse();
response.Status = 412;
return(response);
}
}
}
return(await base.OnInvokeActivityAsync(turnContext, cancellationToken).ConfigureAwait(false));
}
public async Task InvokeMethodAsync_CanInvokeMethodWithReturnTypeAndData_ThrowsExceptionForNonSuccess()
{
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse
{
Data = TypeConverters.ToAny(data)
};
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.Build();
const string rpcExceptionMessage = "RPC exception";
const StatusCode rpcStatusCode = StatusCode.Unavailable;
const string rpcStatusDetail = "Non success";
var rpcStatus = new Status(rpcStatusCode, rpcStatusDetail);
var rpcException = new RpcException(rpcStatus, new Metadata(), rpcExceptionMessage);
// Setup the mock client to throw an Rpc Exception with the expected details info
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Throws(rpcException);
await FluentActions.Awaiting(async() => await client.DaprClient.InvokeMethodAsync <Request, Response>("test", "test", new Request()
{
RequestParameter = "Hello "
}))
.Should().ThrowAsync <InvocationException>();
}
public override async Task <InvokeResponse> OnInvoke(InvokeRequest request, ServerCallContext context)
{
var response = new InvokeResponse();
using var scope = _serviceLoader.CreateScope();
var service = _serviceLoader.Create(request.Method, scope);
var method = _serviceLoader.GetMethod(request.Method, service);
try
{
var requestData = GetRequestData(request.Data, method.GetParameters()[0].ParameterType);
var task = (Task)method.Invoke(service, new[] { requestData }) !;
await task !.ConfigureAwait(false);
var resultProperty = task.GetType().GetProperty("Result");
response.Data = Any.Pack((IMessage)resultProperty !.GetValue(task) !);
}
catch (System.Exception e)
{
throw;
}
return(response);
}
public IResponse Request(IRequest request, IRecipientCallback callback)
{
try
{
switch (request)
{
case GetBindingDescriptionsRequest getBindingsReq:
var getBindingsResp = new GetBindingDescriptionsResponse();
foreach (var obj in _registeredObjects)
{
getBindingsResp.bindings.Add(obj.Key, obj.Value.Description);
}
return(getBindingsResp);
case SubscribeRequest subscribeReq:
var subscribeObj = _registeredObjects[subscribeReq.objectId];
subscribeObj.Subscribe(subscribeReq.eventId, callback);
var subscribeResponse = new SubscribeResponse()
{
objectId = subscribeReq.objectId,
eventId = subscribeReq.eventId
};
return(subscribeResponse);
case UnsubscribeRequest unsubscribeReq:
var unsubscribeObj = _registeredObjects[unsubscribeReq.objectId];
unsubscribeObj.Unsubscribe(unsubscribeReq.eventId, callback);
var unsubscribeResponse = new UnsubscribeResponse()
{
objectId = unsubscribeReq.objectId,
eventId = unsubscribeReq.eventId
};
return(unsubscribeResponse);
case PropertyGetRequest propertyGetReq:
var propertyGetObj = _registeredObjects[propertyGetReq.objectId];
object propertyGetValue = propertyGetObj.GetValue(propertyGetReq.propertyId);
var propertyGetResponse = new PropertyGetResponse()
{
objectId = propertyGetReq.objectId,
propertyId = propertyGetReq.propertyId,
value = propertyGetValue
};
return(propertyGetResponse);
case PropertySetRequest propertySetReq:
var propertySetObj = _registeredObjects[propertySetReq.objectId];
propertySetObj.SetValue(propertySetReq.propertyId, propertySetReq.value);
var propertySetResponse = new PropertySetResponse()
{
objectId = propertySetReq.objectId,
propertyId = propertySetReq.propertyId
};
return(propertySetResponse);
case InvokeRequest invokeReq:
var invokeObj = _registeredObjects[invokeReq.objectId];
object invokeResult = invokeObj.Invoke(invokeReq.methodId, invokeReq.methodArgs);
var invokeResponse = new InvokeResponse()
{
objectId = invokeReq.objectId,
methodId = invokeReq.methodId,
result = invokeResult
};
return(invokeResponse);
default:
if (request != null)
{
throw new RecipientBindingException($"Unsupported request type: {request.requestType}");
}
else
{
throw new RecipientBindingException($"Request failed to deserialize.");
}
}
}
catch (RecipientBindingException ex)
{
var exceptionResponse = new ExceptionResponse()
{
exception = ex
};
#pragma warning disable EA003 // Catch block swallows an exception
return(exceptionResponse);
}
#pragma warning restore EA003 // Catch block swallows an exception
}
private bool Invoke(Invocation invocation, InvokeResponse invokeResponse)
{
if (invocation.M == null || invocation.I == null || invocation.V == null)
{
throw new ArgumentException();
}
var obj = this.session.Instantiate(invocation.I);
if (obj == null)
{
invokeResponse.AddMissingError(invocation.I);
return(true);
}
var composite = (Composite)obj.Strategy.Class;
var methodTypes = composite.WorkspaceMethodTypes;
var methodType = methodTypes.FirstOrDefault(x => x.Name.Equals(invocation.M));
if (methodType == null)
{
throw new Exception("Method " + invocation.M + " not found.");
}
if (!invocation.V.Equals(obj.Strategy.ObjectVersion.ToString()))
{
invokeResponse.AddVersionError(obj);
return(true);
}
var acl = new AccessControlList(obj, this.user);
if (!acl.CanExecute(methodType))
{
invokeResponse.AddAccessError(obj);
return(true);
}
var method = obj.GetType().GetMethod(methodType.Name, new Type[] { });
try
{
method.Invoke(obj, null);
}
catch (Exception e)
{
var innerException = e;
while (innerException.InnerException != null)
{
innerException = innerException.InnerException;
}
invokeResponse.ErrorMessage = innerException.Message;
return(true);
}
var validation = this.session.Derive(false);
if (validation.HasErrors)
{
invokeResponse.AddDerivationErrors(validation);
return(true);
}
return(false);
}
public InvokeResponse Build()
{
var invokeResponse = new InvokeResponse();
if (this.isolated)
{
foreach (var invocation in this.invocations)
{
var error = this.Invoke(invocation, invokeResponse);
if (!error)
{
var validation = this.session.Derive(false);
if (validation.HasErrors)
{
error = true;
invokeResponse.AddDerivationErrors(validation);
}
}
if (error)
{
this.session.Rollback();
if (!this.continueOnError)
{
break;
}
}
else
{
this.session.Commit();
}
}
}
else
{
var error = false;
foreach (var invocation in this.invocations)
{
error = this.Invoke(invocation, invokeResponse);
if (error)
{
break;
}
}
if (error)
{
this.session.Rollback();
}
else
{
var validation = this.session.Derive(false);
if (validation.HasErrors)
{
invokeResponse.AddDerivationErrors(validation);
}
else
{
this.session.Commit();
}
}
}
return(invokeResponse);
}
public InvokeResponse Build()
{
if (this.invokeRequest.M == null || this.invokeRequest.I == null || this.invokeRequest.V == null)
{
throw new ArgumentException();
}
var obj = this.session.Instantiate(this.invokeRequest.I);
var composite = (Composite)obj.Strategy.Class;
var methodTypes = composite.MethodTypesByGroup[this.@group];
var methodType = methodTypes.FirstOrDefault(x => x.Name.Equals(this.invokeRequest.M));
if (methodType == null)
{
throw new Exception("Method " + this.invokeRequest.M + " not found.");
}
var invokeResponse = new InvokeResponse();
if (!this.invokeRequest.V.Equals(obj.Strategy.ObjectVersion.ToString()))
{
invokeResponse.AddVersionError(obj);
}
else
{
var acl = new AccessControlList(obj, this.user);
if (acl.CanExecute(methodType))
{
var method = obj.GetType().GetMethod(methodType.Name, new Type[] { });
try
{
method.Invoke(obj, null);
}
catch (Exception e)
{
var innerException = e;
while (innerException.InnerException != null)
{
innerException = innerException.InnerException;
}
invokeResponse.ErrorMessage = innerException.Message;
}
var validation = this.session.Derive();
if (!validation.HasErrors)
{
this.session.Commit();
}
else
{
invokeResponse.AddDerivationErrors(validation);
}
}
else
{
invokeResponse.AddAccessError(obj);
}
}
return(invokeResponse);
}
