public async Task <ActionResult <bool> > Call([FromBody] CallRequest request)
{
if (request == null)
{
return(BadRequest());
}
log.Info($"Request to Call. SipAddress={request.SipAddress} Callee={request.Callee} Profile={request.ProfileName} DeviceEncoder={request.DeviceEncoder}");
var caller = new SipUri(request.SipAddress).UserAtHost;
// Could be a SIP-uri or phone number that lacks domain
string callee = request.Callee;
if (!callee.IsNumeric())
{
// Sip-address.
callee = new SipUri(callee).UserAtHost;
}
string callWithDeviceEncoder = string.IsNullOrEmpty(request.DeviceEncoder) ? "Program" : request.DeviceEncoder;
return(await Execute(caller,
async (codecApi, codecInformation) => await codecApi.CallAsync(codecInformation.Ip, callee, request.ProfileName, callWithDeviceEncoder)));
}
internal async Task <object[]> CallMethodAsync(UaItem item, object[] inputArguments)
{
var session = Session;
if (session != null && session.Connected)
{
try
{
var callRequest = new CallRequest {
MethodsToCall = { new CallMethodRequest {
ObjectId = item.StartNodeId, MethodId = item.ResolvedNodeId, InputArguments = inputArguments.Select(a => new Variant(a)).ToArray()
} }
};
var callResponse = await session.CallAsync(callRequest).ConfigureAwait(false);
for (int i = 0; i < callResponse.Results.Count; i++)
{
if (StatusCode.IsNotGood(callResponse.Results[i].StatusCode))
{
Trace.TraceError("Error calling method with MethodId {0} : {1}", callRequest.MethodsToCall[i].MethodId, callResponse.Results[i].StatusCode);
}
}
return(callResponse.Results[0].OutputArguments.Select(a => a.Value).ToArray());
}
catch (Exception ex)
{
Trace.TraceError("Error calling method with MethodId {0} : {1}", item.ResolvedNodeId, ex.Message);
}
}
else
{
Trace.TraceError("Error calling method with MethodId {0} : {1}", item.ResolvedNodeId, "Session is null or not connected");
}
return(null);
}
public CallAnswer HandleCallRequest(CallRequest callRequest)
{
CallAnswer result = null;
MethodInfo methodInfo;
methodInfos.TryGetValue(callRequest.MethodInfoId, out methodInfo);
if (methodInfo != null)
{
callRequest.Target = GetRealObject(callRequest.Target);
object[] paramValues = callRequest.ParameterValues;
for (int i = 0; i < paramValues.Length; i++)
{
paramValues[i] = GetRealObject(paramValues[i]);
}
result = new CallAnswer();
try
{
object returnValue = methodInfo.Invoke(callRequest.Target, paramValues);
result.ReturnValue = GetObjectId(returnValue);
//foreach()
}
catch (Exception ex)
{
result.ExceptionMessage = ex.Message;
}
}
return(result);
}
public static LogEntry For(CallRequest request)
{
LogEntry entry = new LogEntry("CallRequest");
entry.Add("RequestHeader", For(request.RequestHeader));
entry.Add("MethodsToCall", For(request.MethodsToCall));
return(entry);
}
public ActionResult New(CallRequest request)
{
return(TwiML(response => response
.Say("Thanks for calling the All Knowing Magical 8 Ball.")
.Say("Ask a Question after the Beep.")
.Say("Press Pound when done.")
.Record(Url.Action("Question"))));
}
public void ProcessCall(CallRequest request)
{
foreach (var employee in _employees)
{
if (employee.CanHandleTheCall())
{
employee.ProcessCall(request);
}
}
}
public void Write(CallRequest <T> value, IMsgPackWriter writer)
{
writer.WriteMapHeader(2);
_keyConverter.Write(Key.FunctionName, writer);
_stringConverter.Write(value.FunctionName, writer);
_keyConverter.Write(Key.Tuple, writer);
_tupleConverter.Write(value.Tuple, writer);
}
public ActionResult MakeCall([FromBody] CallRequest callRequest)
{
if (LoginStatus.LoggedIn != LoginManager.Instance.CurrentLoginStatus)
{
return(GetErrInfo(Constants.ErrorCode.NOT_LOGGED_IN));
}
callDialOut.StartVideoCall(false, false, callRequest.callee, callRequest.displayName, callRequest.password);
return(Content(""));
}
public void TimeOver(CallRequest unhappyCustomer)
{
print("Time over, you lazy fool");
requestEnds.Remove(unhappyCustomer);
if (rand.Next(0, 1000) == 69)
{
GameOver("You have died of dysentery");
}
GameOver("You ran out of time. Martha couldn't order her pizza and starved to death.");
}
private void CreatePlugGoal()
{
var goalPlug = new PlugEnds();
print("Okay, now connect " + goalPlug.first.CoordString() + " to " + goalPlug.second.CoordString());
GameObject newCallPanel = Instantiate(callPanelPrefab, commandPanel.transform);
CallRequest call = newCallPanel.GetComponent <CallRequest>();
call.StartRequest(goalPlug, colSyms, rowSyms, 20f);
requestEnds.Add(call);
}
private void HandleCall(IPEndPoint remote, int index, CallRequest request)
{
var status = StatusCode.Success;
var reason = string.Empty;
IUser target = null;
ICallSession session = null;
if (!_users.TryGet(remote, out IUser source))
{
status = StatusCode.NotAuthorized;
reason = "User is not logged in";
}
else if (!_users.TryGet(request.Target, out target))
{
status = StatusCode.UserNotFound;
reason = "Target not found";
}
else if (source == target)
{
status = StatusCode.Failure;
reason = "Don't target at yourself";
}
else if (!_callController.TryGetOrAdd(source.Name, request.Target, out session))
{
status = StatusCode.CallDuplicate;
reason = "Call exists";
}
else if (!ushort.TryParse(request.RoutePort.ToString(), out _) || request.RoutePort == ushort.MinValue)
{
status = StatusCode.Failure;
reason = $"Invalid parameters: {nameof(CallRequest.RoutePort)}";
}
_core.Send(new MessageResult {
Status = status, Reason = reason
}, remote, index);
if (status != StatusCode.Success)
{
return;
}
session.AppendOrUpdate(source, request.RoutePort);
session.AppendOrUpdate(target);
_core.Send(new CallResponse {
SessionId = session.Id, RouteId = session.RouteId
}, remote, index);
session.RaiseState();
}
public async Task CallAsync()
{
var response = new CallResponse();
var request = new CallRequest();
var channel = new TestRequestChannel(response);
var ret = await channel.CallAsync(request);
ret
.Should().BeSameAs(response);
channel.Request
.Should().BeSameAs(request);
}
public virtual Response <object> Call(CallRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.Call");
scope.Start();
try
{
return(RestClient.Call(body, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <object> > CallAsync(CallRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.Call");
scope.Start();
try
{
return(await RestClient.CallAsync(body, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <CallResponse> CallAsync(CallRequest request)
{
// For now, we'll route both Invoke and Call through IMocks.CallAsync.
var args = ToDictionary(request.Args);
var result = await _mocks.CallAsync(new MockCallArgs
{
Token = request.Tok,
Args = args,
Provider = request.Provider,
})
.ConfigureAwait(false);
return(new CallResponse {
Return = await SerializeAsync(result).ConfigureAwait(false)
});
}
public async Task VectorAdd()
{
var channel = new UaTcpSessionChannel(
this.localDescription,
this.certificateStore,
new AnonymousIdentity(),
"opc.tcp://*****:*****@" ------------------");
Console.WriteLine($" {result}");
Console.WriteLine($"Closing session '{channel.SessionId}'.");
await channel.CloseAsync();
result.Z
.Should().Be(6.0);
}
public void Request(CallRequest request)
{
if (!IsMoving)
{
if (CurrentFloor == request.Floor.Number)
{
OpenDoors();
return;
}
request.RequestServedEvent += RequestServed;
request.Execute(this);
}
else
{
request.RequestServedEvent += RequestServed;
RequestQueue.Enqueue(request);
}
}
private static void TestMessageSerialization()
{
CallRequest msg1 = new CallRequest();
msg1.MethodInfoId = Guid.NewGuid();
msg1.Target = Guid.NewGuid();
msg1.ParameterValues = new object[] { 1, 2, 3 };
byte[] data = msg1.ToBytes();
CallRequest msg2 = (CallRequest)MessageManager.Create(msg1.Id, data);
Debug.Assert(msg2.Id == msg1.Id);
Debug.Assert(object.Equals(msg1.Target, msg2.Target));
Debug.Assert(msg1.ParameterValues.Length == msg2.ParameterValues.Length);
CallRequest msg3;
using (MemoryStream ms = new MemoryStream())
{
msg1.BeginWrite(ms);
Thread.Sleep(100);
ms.Position = 0;
var ar = AMessage.BeginRead(ms);
Thread.Sleep(100);
msg3 = ar.GetMessage() as CallRequest;
}
Debug.Assert(msg1.Id == msg3.Id);
Debug.Assert(object.Equals(msg1.Target, msg3.Target));
Debug.Assert(msg1.ParameterValues.Length == msg3.ParameterValues.Length);
var mainMethodInfo = typeof(Program).GetMethod("Main", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
MethodInfoAnswer miAnswer1 = new MethodInfoAnswer();
miAnswer1.MethodInfoId = Guid.NewGuid();
miAnswer1.MethodInfo = mainMethodInfo;
byte[] miAnswerBytes = miAnswer1.ToBytes();
MethodInfoAnswer miAnswer2 = (MethodInfoAnswer)AMessage.Create(miAnswer1.Id, miAnswerBytes);
Debug.Assert(miAnswer1.MethodInfo == miAnswer2.MethodInfo);
}
public Call Call(CallRequest request)
{
Request call_req;
Call call;
call_req = PrepareCallRequest(request, out call);
call.AccountSid = request.AccountSid;
fsInbound.CallRequest[call.Sid] = call_req;
if (fsInbound.Originate(call.Sid))
{
//save call back to database
try
{
_callService.AddCallLog(call);
}
catch (Exception ex)
{
}
}
return(call);
}
public async Task <CallResponse> CallAsync(CallRequest callRequest)
{
UpdateRequestHeader(callRequest, true, "Call");
CallResponse callResponse = null;
try
{
if (UseTransportChannel)
{
var serviceResponse = await Task <IServiceResponse> .Factory.FromAsync(TransportChannel.BeginSendRequest, TransportChannel.EndSendRequest, callRequest, null).ConfigureAwait(false);
if (serviceResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(serviceResponse.ResponseHeader);
callResponse = (CallResponse)serviceResponse;
}
else
{
var callResponseMessage = await Task <CallResponseMessage> .Factory.FromAsync(InnerChannel.BeginCall, InnerChannel.EndCall, new CallMessage(callRequest), null).ConfigureAwait(false);
if (callResponseMessage == null || callResponseMessage.CallResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
callResponse = callResponseMessage.CallResponse;
ValidateResponse(callResponse.ResponseHeader);
}
}
finally
{
RequestCompleted(callRequest, callResponse, "Call");
}
return(callResponse);
}
public AMessage GetResponse(AMessage message)
{
if (message == null)
{
return(null);
}
AMessage result = null;
switch (message.Id)
{
// ---- Call ----
case MessageId.CallRequest:
CallRequest callRequest = (CallRequest)message;
result = callHandler.HandleCallRequest(callRequest);
if (result == null)
{
lock (sync)
{
// Add the call request to the queue
pendingRequests.Add(callRequest);
}
// Send a method info request
MethodInfoRequest methodInfoRequest = new MethodInfoRequest();
methodInfoRequest.MethodInfoId = callRequest.MethodInfoId;
result = methodInfoRequest;
}
break;
case MessageId.CallAnswer:
callHandler.HandleCallAnswer((CallAnswer)message);
break;
// ---- MethodInfo ----
case MessageId.MethodInfoRequest:
result = callHandler.HandleMethodInfoRequest((MethodInfoRequest)message);
break;
case MessageId.MethodInfoAnswer:
MethodInfoAnswer methodInfoAnswer = (MethodInfoAnswer)message;
callHandler.HandleMethodInfoAnswer(methodInfoAnswer);
CallRequest pendingCallRequest = null;
lock (sync)
{
for (int i = 0; i < pendingRequests.Count; i++)
{
if (pendingRequests[i].MethodInfoId == methodInfoAnswer.MethodInfoId)
{
// We got the answer for a method info
pendingCallRequest = pendingRequests[i];
pendingRequests.RemoveAt(i);
}
}
}
if (pendingCallRequest != null)
{
result = callHandler.HandleCallRequest(pendingCallRequest);
}
break;
// ---- ConnectionInfo ----
case MessageId.ConnectionInfoRequest:
result = HandleConnectionInfoRequest((ConnectionInfoRequest)message);
break;
case MessageId.ConnectionInfoAnswer:
HandleConnectionInfoAnswer((ConnectionInfoAnswer)message);
break;
default:
string errorMsg = string.Format("Messages of Id={0} and type={1} are not supported", message.Id, message.GetType());
throw new NotSupportedException(errorMsg);
}
return(result);
}
private Employee GetCallHandler(CallRequest callRequst)
{
var availableFresher = freshers.FirstOrDefault(e => e.IsFree());
if (availableFresher.CanHandleACall(callRequst)) return availableFresher;
else if (teamLead.CanHandleACall(callRequst)) return teamLead;
else return projectManager;
}
private Request PrepareCallRequest(CallRequest request, out Call call)
{
call = new Call()
{
AccountSid = request.AccountSid, CallTo = request.To, AnswerUrl = request.AnswerUrl, Direction = "outbound-api", CallerId = request.From, Timeout = request.TimeLimit
};
Queue <DialString> dialStrings = new Queue <DialString>();
System.Text.StringBuilder args_list = new System.Text.StringBuilder();
string sched_hangup_id = string.Empty;
// don't allow "|" and "," in 'to' (destination) to avoid call injection
request.To = request.To.Split(',', '|')[0];
//set hangup_on_ring
int hangup = 0;
if (!int.TryParse(request.HangupOnRing, out hangup))
{
hangup = -1;
}
if (hangup == 0)
{
args_list.Append("execute_on_ring='hangup ORIGINATOR_CANCEL',");
}
else if (hangup > 0)
{
args_list.Append(string.Format("execute_on_ring='sched_hangup +{0} ORIGINATOR_CANCEL',", hangup));
}
// set send_digits
if (!string.IsNullOrEmpty(request.SendDigits))
{
args_list.Append(string.Format("execute_on_answer='send_dtmf {0}',", request.SendDigits));
}
//set time_limit
int time = 0;
if (!int.TryParse(request.TimeLimit, out time))
{
time = -1;
}
if (time > 0)
{
//create sched_hangup_id
sched_hangup_id = System.Guid.NewGuid().ToString();
args_list.Append(string.Format("api_on_answer='sched_api {0} +{1} hupall ALLOTTED_TIMEOUT agbara_callSid {2}',", sched_hangup_id, request.TimeLimit, call.Sid));
args_list.Append(string.Format("agbara_sched_hangup_id={0}", sched_hangup_id));
}
if (!string.IsNullOrEmpty(request.StatusCallbackUrl))
{
args_list.Append(string.Format("agbara_statuscallback_url={0},", request.StatusCallbackUrl));
args_list.Append(string.Format("agbara_statuscallbackmethod={0},", request.StatusCallbackMethod));
}
if (!string.IsNullOrEmpty(request.FallbackUrl))
{
args_list.Append(string.Format("agbara_fallbackrul={0},", request.FallbackUrl));
args_list.Append(string.Format("agbara_fallbackmethod={0},", request.FallbackMethod));
}
if (!string.IsNullOrEmpty(request.ApplicationSid))
{
args_list.Append(string.Format("agbara_applicationsid={0},", request.ApplicationSid));
}
args_list.Append(string.Format("agbara_callsid={0},", call.Sid));
args_list.Append(string.Format("agbara_accountsid={0},", call.AccountSid));
args_list.Append(string.Format("agbara_answer_url={0},", request.AnswerUrl));
args_list.Append(string.Format("origination_caller_id_number={0},", request.From));
//session_heartbeat
args_list.Append(string.Format("enable_heartbeat_events={0},", 60));
//Set Direction
args_list.Append(string.Format("agbara_call_direction={0}", CallDirection.outboundapi));
foreach (Gateway gate in _fsService.GetGatewaysForNumber(call.CallTo, FS.Sid))
{
for (int i = 1; i < int.Parse(gate.GatewayRetry); i++)
{
DialString dialString = new DialString(call.Sid, request.To, gate.GatewayString, gate.GatewayCodec, gate.GatewayTimeout.ToString(), args_list.ToString());
dialStrings.Enqueue(dialString);
}
}
Request call_req = new Request(call.Sid, dialStrings, request.AnswerUrl, request.StatusCallbackUrl, request.StatusCallbackMethod);
return(call_req);
}
public async Task ReadHistoryRawValues()
{
// describe this client application.
var clientDescription = new ApplicationDescription
{
ApplicationName = "Workstation.UaClient.FeatureTests",
ApplicationUri = $"urn:{System.Net.Dns.GetHostName()}:Workstation.UaClient.FeatureTests",
ApplicationType = ApplicationType.Client
};
// place to store certificates
var certificateStore = new DirectoryStore("./pki");
// create a 'UaTcpSessionChannel', a client-side channel that opens a 'session' with the server.
var channel = new UaTcpSessionChannel(
clientDescription,
certificateStore,
new AnonymousIdentity(), // the anonymous identity
"opc.tcp://localhost:48010"); // the endpoint of Unified Automation's UaCPPServer.
try
{
// try opening a session and reading a few nodes.
await channel.OpenAsync();
Console.WriteLine($"Opened session with endpoint '{channel.RemoteEndpoint.EndpointUrl}'.");
Console.WriteLine($"SecurityPolicy: '{channel.RemoteEndpoint.SecurityPolicyUri}'.");
Console.WriteLine($"SecurityMode: '{channel.RemoteEndpoint.SecurityMode}'.");
Console.WriteLine($"UserIdentityToken: '{channel.UserIdentity}'.");
Console.WriteLine("\nCheck if DataLogger active.");
// check if DataLoggerActive is true. If not, then call method StartLogging.
var req = new ReadRequest
{
NodesToRead = new[] {
new ReadValueId {
NodeId = NodeId.Parse("ns=2;s=Demo.History.DataLoggerActive"), AttributeId = AttributeIds.Value
}
},
};
var res = await channel.ReadAsync(req);
if (StatusCode.IsBad(res.Results[0].StatusCode))
{
throw new InvalidOperationException("Error reading 'Demo.History.DataLoggerActive'. ");
}
var isActive = res.Results[0].GetValueOrDefault <bool>();
if (!isActive)
{
Console.WriteLine("Activating DataLogger.");
var req1 = new CallRequest
{
MethodsToCall = new[] {
new CallMethodRequest {
ObjectId = NodeId.Parse("ns=2;s=Demo.History"), // parent node
MethodId = NodeId.Parse("ns=2;s=Demo.History.StartLogging")
},
},
};
var res1 = await channel.CallAsync(req1);
if (StatusCode.IsBad(res1.Results[0].StatusCode))
{
throw new InvalidOperationException("Error calling method 'Demo.History.StartLogging'.");
}
Console.WriteLine("Note: Datalogger has just been activated, so there will be little or no history data to read.");
Console.WriteLine(" Try again in 1 minute.");
}
Console.WriteLine("\nReading history for last 1 minute(s).");
// A continuation point is returned if there are more values to return than the
// limit set by parameter NumValuesPerNode. A client should continue calling HistoryRead
// until the continuation point returns null.
byte[] cp = null;
do
{
var req2 = new HistoryReadRequest
{
HistoryReadDetails = new ReadRawModifiedDetails
{
StartTime = DateTime.UtcNow.Add(TimeSpan.FromSeconds(-60)), // set start time to 1 minute ago
EndTime = DateTime.UtcNow,
NumValuesPerNode = 100, // sets limit. if there are more values to return then a continuation point is returned.
ReturnBounds = false, // set true to return interpolated values for the start and end times
},
TimestampsToReturn = TimestampsToReturn.Both,
ReleaseContinuationPoints = false, // set true to abandon returning any remaining values from this interval
NodesToRead = new[] {
new HistoryReadValueId {
NodeId = NodeId.Parse("ns=2;s=Demo.History.DoubleWithHistory"), ContinuationPoint = cp
},
},
};
var res2 = await channel.HistoryReadAsync(req2);
if (StatusCode.IsGood(res2.Results[0].StatusCode))
{
var historyData = res2.Results[0].HistoryData as HistoryData;
Console.WriteLine($"Found {historyData.DataValues.Length} value(s) for node '{req2.NodesToRead[0].NodeId}':");
foreach (var dv in historyData.DataValues)
{
Console.WriteLine($"Read {dv.Value}, q: {dv.StatusCode}, ts: {dv.SourceTimestamp}");
}
cp = res2.Results[0].ContinuationPoint;
// if ContinuationPoint is null, then there is no more data to return.
if (cp == null)
{
break;
}
}
else
{
Console.WriteLine($"HistoryRead return statuscode: {res2.Results[0].StatusCode}");
break;
}
} while (cp != null); // loop while ContinuationPoint is not null.
Console.WriteLine($"\nClosing session '{channel.SessionId}'.");
await channel.CloseAsync();
}
catch (Exception ex)
{
await channel.AbortAsync();
Console.WriteLine(ex.Message);
}
}
private void TaskAudioPlayback(Logger logger, CancellationToken cancelToken, BlockingCollection <IMsgPackTypeName> queue)
{
while (!cancelToken.IsCancellationRequested)
{
if (queue.TryTake(out IMsgPackTypeName data, 500))
{
switch (data.GetType().Name)
{
case nameof(AudioRxDto):
{
var dto = (AudioRxDto)data;
soundcardSampleProvider.AddOpusSamples(dto, dto.Transceivers);
if (logger.IsTraceEnabled)
{
logger.Trace(dto.ToDebugString());
}
break;
}
case nameof(CallRequestDto):
{
var dto = (CallRequestDto)data;
if (incomingCallRequest != null)
{
Connection.VoiceServerTransmitQueue.Add(new CallResponseDto()
{
Request = dto, Event = CallResponseEvent.Busy
});
}
else
{
incomingCallRequest = dto;
soundcardSampleProvider.LandLineRing(true);
CallRequest?.Invoke(this, new CallRequestEventArgs()
{
Callsign = dto.FromCallsign
});
}
break;
}
case nameof(CallResponseDto):
{
var dto = (CallResponseDto)data;
switch (dto.Event)
{
// Server events
case CallResponseEvent.Routed:
soundcardSampleProvider.LandLineRing(true);
CallResponse?.Invoke(this, new CallResponseEventArgs()
{
Callsign = dto.Request.ToCallsign, Event = CallResponseEvent.Routed
}); //Our request was routed
break;
case CallResponseEvent.NoRoute:
CallResponse?.Invoke(this, new CallResponseEventArgs()
{
Callsign = dto.Request.ToCallsign, Event = CallResponseEvent.NoRoute
}); //Our request was not routed
break;
//Remote party events
case CallResponseEvent.Busy:
soundcardSampleProvider.LandLineRing(false);
//Play busy tone
CallResponse?.Invoke(this, new CallResponseEventArgs()
{
Callsign = dto.Request.ToCallsign, Event = CallResponseEvent.Busy
});
break;
case CallResponseEvent.Accept:
soundcardSampleProvider.LandLineRing(false);
CallResponse?.Invoke(this, new CallResponseEventArgs()
{
Callsign = dto.Request.ToCallsign, Event = CallResponseEvent.Accept
});
break;
case CallResponseEvent.Reject:
soundcardSampleProvider.LandLineRing(false);
//Play reject tone
CallResponse?.Invoke(this, new CallResponseEventArgs()
{
Callsign = dto.Request.ToCallsign, Event = CallResponseEvent.Reject
});
break;
}
break;
}
}
}
}
}
public async Task <CallResponse> CallAsync(CallRequest request) => await this._client.CallAsync(request);
public CallControl(CallRequest callRequest)
{
InitializeComponent();
CallRequest = callRequest;
}
/// <summary>Performs a CALL request.</summary>
/// <param name="callRequest">The call request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The <see cref="Task" /> with MessagePackObject as result.</returns>
public async Task <MessagePackObject> CallAsync(CallRequest callRequest, CancellationToken cancellationToken)
{
return(await RequestAsync(callRequest, cancellationToken).ConfigureAwait(false));
}
public CallRequestBuilder(CallRequest callRequest) : base(callRequest)
{
_callRequest = callRequest;
}
public bool CanHandleACall(CallRequest callRequest)
{
return false;
}
public void ProcessCall(CallRequest request)
{
//Some logic
}
/// <summary>
/// Begins an asynchronous invocation of the Call service.
/// </summary>
public IAsyncResult BeginCall(
RequestHeader requestHeader,
CallMethodRequestCollection methodsToCall,
AsyncCallback callback,
object asyncState)
{
CallRequest request = new CallRequest();
request.RequestHeader = requestHeader;
request.MethodsToCall = methodsToCall;
UpdateRequestHeader(request, requestHeader == null, "Call");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginCall(new CallMessage(request), callback, asyncState);
}
/// <summary>
/// Example testing DAPI endpoints using Classes
/// </summary>
public DAPIResponse runDAPICall(string method, Dictionary<string, string> args, UserToken userToken = null, AppToken appToken = null, string stringToken = null)
{
Uri u = new Uri("https://api.zynga.com");
TTransport transport = new THttpModClient(u);
TProtocol protocol = new TDAPIProtocol(transport);
DAPI.Client client = new DAPI.Client(protocol);
transport.Open();
List<CallRequest> dapiCalls = new List<CallRequest>();
CallRequest callRequest = new CallRequest();
callRequest.Method = method;
callRequest.Argz = args;
dapiCalls.Add(callRequest);
DAPIRequest dapiRequest = new DAPIRequest();
dapiRequest.Calls = dapiCalls;
dapiRequest.UserToken = userToken;
dapiRequest.AppToken = appToken;
dapiRequest.StringToken = stringToken;
DAPIResponse dapiResponse = client.call(dapiRequest);
transport.Close();
return dapiResponse;
}
public void Call(
OperationContext context,
IList<CallMethodRequest> methodsToCall,
IList<CallMethodResult> results,
IList<ServiceResult> errors)
{
if (context == null) throw new ArgumentNullException("context");
if (methodsToCall == null) throw new ArgumentNullException("methodsToCall");
if (results == null) throw new ArgumentNullException("results");
if (errors == null) throw new ArgumentNullException("errors");
#if LEGACY_CORENODEMANAGER
List<CallRequest> callables = new List<CallRequest>();
#endif
lock (m_lock)
{
for (int ii = 0; ii < methodsToCall.Count; ii++)
{
CallMethodRequest methodToCall = methodsToCall[ii];
// skip items that have already been processed.
if (methodToCall.Processed)
{
continue;
}
// look up the node.
ILocalNode node = GetLocalNode(methodToCall.ObjectId) as ILocalNode;
if (node == null)
{
continue;
}
methodToCall.Processed = true;
// look up the method.
ILocalNode method = GetLocalNode(methodToCall.MethodId) as ILocalNode;
if (method == null)
{
errors[ii] = ServiceResult.Create(StatusCodes.BadMethodInvalid, "Method is not in the address space.");
continue;
}
// check that the method is defined for the object.
if (!node.References.Exists(ReferenceTypeIds.HasComponent, false, methodToCall.MethodId, true, m_server.TypeTree))
{
errors[ii] = ServiceResult.Create(StatusCodes.BadMethodInvalid, "Method is not a component of the Object.");
continue;
}
#if LEGACY_CORENODEMANAGER
// find object to call.
ICallable callable = method as ICallable;
SourceHandle handle = method.Handle as SourceHandle;
if (handle != null)
{
callable = handle.Source as ICallable;
}
if (callable == null)
{
errors[ii] = ServiceResult.Create(StatusCodes.BadNotImplemented, "Method does not have a source registered.");
continue;
}
// get the input arguments.
IVariable argumentNode = GetLocalNode(method.NodeId, ReferenceTypes.HasProperty, false, false, BrowseNames.InputArguments) as IVariable;
// extract the arguments from the node.
Argument[] arguments = null;
if (argumentNode != null)
{
Array value = argumentNode.Value as Array;
if (value != null)
{
arguments = ExtensionObject.ToArray(value, typeof(Argument)) as Argument[];
}
}
// validate the input arguments.
bool argumentError = false;
List<ServiceResult> argumentErrors = new List<ServiceResult>();
object[] validatedArguments = new object[methodToCall.InputArguments.Count];
// check if the argument is expected.
if ((arguments == null && methodToCall.InputArguments.Count > 0) || (methodToCall.InputArguments.Count != arguments.Length))
{
errors[ii] = StatusCodes.BadArgumentsMissing;
continue;
}
for (int jj = 0; jj < methodToCall.InputArguments.Count; jj++)
{
// can't do anything if the argument definition is missing.
Argument argumentDefinition = arguments[jj];
if (argumentDefinition == null)
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadConfigurationError, "Server does not have a defintion for argument."));
argumentError = true;
continue;
}
// a null value can be used for optional arguments.
object argumentValue = methodToCall.InputArguments[jj].Value;
if (argumentValue == null)
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadInvalidArgument, "Argument cannot be null."));
argumentError = true;
continue;
}
// get the datatype.
if (!m_server.TypeTree.IsEncodingFor(argumentDefinition.DataType, argumentValue))
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadTypeMismatch, "Expecting value with datatype '{0}'.", argumentDefinition.DataType));
argumentError = true;
continue;
}
// check the array size.
Array array = argumentValue as Array;
if (array != null)
{
if (argumentDefinition.ValueRank == ValueRanks.Scalar)
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadTypeMismatch, "Expecting a scalar value."));
argumentError = true;
continue;
}
if (argumentDefinition.ValueRank > 0 && array.Length != argumentDefinition.ValueRank)
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadTypeMismatch, "Expecting an array with length {0}.", argumentDefinition.ValueRank));
argumentError = true;
continue;
}
}
else
{
if (argumentDefinition.ValueRank >= 0)
{
argumentErrors.Add(ServiceResult.Create(StatusCodes.BadTypeMismatch, "Expecting an array value."));
argumentError = true;
continue;
}
}
// argument passed initial validation.
validatedArguments[jj] = argumentValue;
argumentErrors.Add(null);
}
#else
errors[ii] = StatusCodes.BadNotImplemented;
#endif
#if LEGACY_CORENODEMANAGER
CallRequest request = new CallRequest();
request.Callable = callable;
request.Index = ii;
request.MethodId = method.NodeId;
request.MethodHandle = (handle != null)?handle.Handle:null;
request.ObjectId = node.NodeId;
request.InputArguments = validatedArguments;
request.ArgumentErrors = argumentErrors;
request.HasInvalidArgument = argumentError;
callables.Add(request);
#endif
}
}
#if LEGACY_CORENODEMANAGER
// check if nothing to do.
if (callables.Count == 0)
{
return;
}
// call the methods.
foreach (CallRequest callable in callables)
{
// call method if no errors occurred.
List<object> outputArguments = new List<object>();
if (!callable.HasInvalidArgument)
{
try
{
errors[callable.Index] = callable.Callable.Call(
context,
callable.MethodId,
callable.MethodHandle,
callable.ObjectId,
callable.InputArguments,
callable.ArgumentErrors,
outputArguments);
}
catch (Exception e)
{
errors[callable.Index] = ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Error occurred invoking method.");
}
}
else
{
errors[callable.Index] = ServiceResult.Create(StatusCodes.BadInvalidArgument, "One or more arguments were not valid.");
}
// create the result item.
CallMethodResult result = results[callable.Index] = new CallMethodResult();
// process argument errors.
bool errorExists = false;
foreach (ServiceResult argumentError in callable.ArgumentErrors)
{
if (ServiceResult.IsBad(argumentError))
{
result.InputArgumentResults.Add(argumentError.Code);
DiagnosticInfo diagnosticInfo = null;
if ((context.DiagnosticsMask & DiagnosticsMasks.OperationAll) != 0)
{
diagnosticInfo = ServerUtils.CreateDiagnosticInfo(m_server, context, argumentError);
errorExists = true;
}
result.InputArgumentDiagnosticInfos.Add(diagnosticInfo);
}
else
{
result.InputArgumentResults.Add(StatusCodes.Good);
}
}
if (!errorExists)
{
result.InputArgumentDiagnosticInfos.Clear();
}
// copy output arguments into result.
result.OutputArguments.Clear();
foreach (object outputArgument in outputArguments)
{
result.OutputArguments.Add(new Variant(outputArgument));
}
}
#endif
}
/// <summary>
/// Initializes the message with the body.
/// </summary>
public CallMessage(CallRequest CallRequest)
{
this.CallRequest = CallRequest;
}
/// <summary>
/// Calls (invokes) a list of Methods.
/// </summary>
/// <param name="channel">A instance of <see cref="IRequestChannel"/>.</param>
/// <param name="request">A <see cref="CallRequest"/>.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation that returns a <see cref="CallResponse"/>.</returns>
/// <seealso href="https://reference.opcfoundation.org/v104/Core/docs/Part4/5.11.2/">OPC UA specification Part 4: Services, 5.11.2</seealso>
public static async Task <CallResponse> CallAsync(this IRequestChannel channel, CallRequest request, CancellationToken token = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return((CallResponse)await channel.RequestAsync(request, token).ConfigureAwait(false));
}
/// <summary>
/// Invokes the Call service.
/// </summary>
public virtual ResponseHeader Call(
RequestHeader requestHeader,
CallMethodRequestCollection methodsToCall,
out CallMethodResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
CallRequest request = new CallRequest();
CallResponse response = null;
request.RequestHeader = requestHeader;
request.MethodsToCall = methodsToCall;
UpdateRequestHeader(request, requestHeader == null, "Call");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (CallResponse)genericResponse;
}
else
{
CallResponseMessage responseMessage = InnerChannel.Call(new CallMessage(request));
if (responseMessage == null || responseMessage.CallResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.CallResponse;
ValidateResponse(response.ResponseHeader);
}
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "Call");
}
return response.ResponseHeader;
}
public async Task VectorAdd()
{
// describe this client application.
var clientDescription = new ApplicationDescription
{
ApplicationName = "Workstation.UaClient.FeatureTests",
ApplicationUri = $"urn:{System.Net.Dns.GetHostName()}:Workstation.UaClient.FeatureTests",
ApplicationType = ApplicationType.Client
};
// place to store certificates
var certificateStore = new DirectoryStore("./pki");
// create a 'UaTcpSessionChannel', a client-side channel that opens a 'session' with the server.
var channel = new UaTcpSessionChannel(
clientDescription,
certificateStore,
new AnonymousIdentity(), // the anonymous identity
"opc.tcp://*****:*****@" ------------------");
Console.WriteLine($" {result}");
Console.WriteLine($"\nClosing session '{channel.SessionId}'.");
await channel.CloseAsync();
}
catch (Exception ex)
{
await channel.AbortAsync();
Console.WriteLine(ex.Message);
}
}
