I'm trying to understand how this call scenario is implemented in WebRTC / libJingle:
Caller A want to call callee B but B is not online so server redirects A to a voice mail.
After A send connection requests to server, and XMPP server don't have B in the presence list, what happens? How the server redirects the caller to a voicemail instead of continue with the regular call flow? What messages are returned to A? ...
Related
When the Apache server receives a POST request, I want to immediately send back a response, stating that the client should wait and not send anything.
While at the same time client's request will be passed on to a script (either PHP or Perl). And then the script will send back a response to the client.
Is this possible? I know that it is possible for Apache to send a 4xx response header, so that the client would stop sending. But I want to run a script while the client has stopped sending and then have the client redirect to somewhere..
There are a few HTTP status codes that may be of use IF you want to be fully REST-ful and use the HTTP verbs (GET, POST, PUT, DELETE, etc) and status codes
https://www.restapitutorial.com/httpstatuscodes.html
In particular for what I am interpreting as your use case, status code 202 Accepted may be correct for your use:
The request has been accepted for processing, but the processing has
not been completed. The request might or might not eventually be acted
upon, as it might be disallowed when processing actually takes place.
There is no facility for re-sending a status code from an asynchronous
operation such as this.
The 202 response is intentionally non-committal. Its purpose is to
allow a server to accept a request for some other process (perhaps a
batch-oriented process that is only run once per day) without
requiring that the user agent's connection to the server persist until
the process is completed. The entity returned with this response
SHOULD include an indication of the request's current status and
either a pointer to a status monitor or some estimate of when the user
can expect the request to be fulfilled.
I have a web server that is currently running my asp.net mvc website. I am making a connection to an external website that sends a request back to the server via a specific URL and attaches the information sent as a query string.
I have no idea if this query string being sent is in the correct format but I do know that the action result function is being called. I need to see what requests are being sent to the server so that I can see the format in which the request was sent.
I know how to view the currently executing requests using the request monitor, but this is not enough since you can miss the request if it happens to fast.
Is it possible to view a history of requests that have occurred on the server? So that I may find the one that I need after the request has occurred.
Consider below scenario:
Client --> Call1 ---> Server
Client <--- Response1 <--- Server
Client processes the response and makes another call
Client --> Call2 ---> Server
Client <--- Response2 <--- Server
Client processes the response and makes another call
Client --> Call3 ---> Server
Client <--- Response3 <--- Server
For above scenario, which tools should I use to make the calls, process the response and measure the response time for the server calls.
Does SOASTA has this capability or any other tool?
What are the things I should keep in mind when doing this?
Without any code changes, you can use Runscope to log and measure API calls. From the Traffic Inspector, click on URL Builder. Enter the URL of the API that you're calling, and you'll see a Runscopified URL below it. Any call that you make to the Runscopified URL will proxy through Runscope to the original destination URL.
In Traffic Inspector, you'll see the HTTP traffic appear, showing you the details of each request (request headers/body/params, response headers/body, status codes, response times, etc.) Again, no need to change any code -- just your request URL, and you'll have full visibility into your API traffic between your client and server.
Scenario:
- An application want to send a push to a list of device.
- so she sends information to my mule application which must be listening to the arrived information.
- My application will send this information via web service to the application which will send the push and then my application will wait for a response which is a json file with content: success: 0/1 failed: 0/1,
- according to this answer my mule application will send email which i take from the database, if the device concerned didn't receive the push.
I have done the last part of this scenario. from the receipt of the answer of the push. Now I have some questions about the first part:
I guess that the application sends a json file that contains a list of information of each device.
How processed the list of information devices. I must loop on the contents of the json file. any example of this?
How to put my application in listening for the arrivals request for sending push?
is the http connector sufficient? if so how to configure the path variable.
I'm using mule 3.5.0 CE, Thank you in advance.
Lets break this down, to the various components:
Sender Application - this is the service that needs to communicate with the devices.
Device Controller - this is the application that talks to the hardware devices.
Proxy - this is what you are developing on the Mule ESB. It will connect to both the Sender Application, and the Device Controller and transfer the request from Sender to Controller; and then send the results from the Controller back to the Sender.
The flow would look something like this:
Sender Application needs to communicate with devices.
Sender Application transmits information using JSON.
Proxy receives this JSON request.
The Proxy then contacts the Device Controller over HTTP.
The Device Controller only talks to the Proxy, and returns a result of 0 or 1 depending on the result from the physical device.
The Proxy then needs to communicate this result to the Sender Application.
At first, you might think to develop your Proxy over HTTP (using the HTTP Connector). This connector creates a web service endpoint (a website, basically) that can listen and respond to requests.
The Sender Application connect to this endpoint over HTTP and submits the JSON document containing the commands to be executed.
Your proxy then immediately contact the Device Controller (again, over HTTP using the same connector).
The device controller talks to the devices, and then returns the response to your Proxy (over HTTP).
You take this response and then send it back as the response to the original HTTP request (from the Sender Application).
The problem here is if there is any delay between your connection and the Device Controller (or the Device Controller and the physical devices), the connection will remain blocked on both sides (since you need to send a response).
If there is a large delay the HTTP connection between your Proxy and Sender Application may terminate.
This is the same when some site is overloaded and doesn't respond - eventually the browser will timeout.
To avoid this scenario, split your integration into three separate flows.
The first flow will create a normal HTTP connection to which the Sender Application will upload the JSON document. It will take the JSON document and convert each entry into a message using the batch module (note: this is only available in the Enterprise edition - for the CE version you'll have to code this logic yourself). Next, take this message and put them in a separate queue. Return the unique ID of this message as a JSON response back to the Sender Application.
Your second flow is listening on this queue and whenever a message arrives, it connects to the Device Controller and gets the response. The response is then written to another queue.
Your third and final flow listens on this results queue, takes each message on this queue and converts it to JSON/XML. It then has a HTTP connector where it can be queried for results for each command.
In the above setup, your Sender Application can drop a large JSON file of commands to be executed; for each command, a unique ID will be returned to the Sender Application.
It will then query the result endpoint (what your last flow exposes) and send it the message ID. The result endpoint will then check the status of this request and respond with the appropriate code.
Here is an example of how this would work (from the point of view of the Sender Application):
I is the input to your flow, O is the result sent.
Step 1 - send a request for commands to be executed:
I: Sender Application > http://localhost:8080/input-commands?device=1&command=Y
O: <command><req-status>OK</req-status><id>1234-123</id></command>
Step 2 - Query results:
I: Sender Application > http://localhost:8080/result?id=1234-123
O: <command><id>1234-123</id><result>0</result></command>
I am working on a chat app using XMPP Protocol.
I tried following
this tutorial from github . Everything is working fine using
XMPP.
But I'm unable to receive offline messages when user comes
online.
As user A is logged out and user B sends messages to user A, and when user A logs into app, it must receive all the messages that
were sent by user B during offline session.
How can I receive these offline messages?
My app is totally stuck on this issue. Please help if anyone
knows the solution. Any help will be appreciated. Thanks
You need to enable mod_offline on server, if you are using ejabberd XMPP Server.
Here is the code needs to enable module:
ignore_pep_from_offline: true
max_user_offline_messages:
admin: 5000
all: 100
mod_offline:
access_max_user_messages: max_user_offline_messages
Write this code in ejabberd.yml config file.
It will store unto 100 messages per user received when client was offline.
At client side, you may have to register for service:
'http://jabber.org/protocol/disco#info'
If you done this, whenever offline client gets online, server will send those stored messages to respective client.
You've to send Request for offline message if server supports. XMPP works on TCP protocol so as soon as client is up, it should send request to server.
<iq type='get'>
<query xmlns='http://jabber.org/protocol/disco#info'
node='http://jabber.org/protocol/offline'/>
</iq>