In the PHP development work very much uses the time-out processing to the time-out situation, I say several scenes:
1. Get data asynchronously if a backend data source gets unsuccessful then skips without affecting the entire page presentation
2. To ensure that the Web server does not have access to other pages due to poor performance of the page processing, some page operations are set
3. For some upload or uncertain processing time, you need to set the entire process to unlimited time, or any one of the links set incorrectly, will lead to inexplicable execution interruption
4. Multiple back-end modules (MySQL, Memcached, HTTP interface), in order to prevent poor performance of a single interface, resulting in the entire front to get data too slow, affecting the page opening speed, causing avalanche
5 ..... Lots of occasions that need to be timed out
These places need to consider the setting of timeouts, but the time-out in PHP is categorized, each processing method and strategy are different, in order to describe the system, I summed up the common PHP time-out processing summary.
"Web server timeout Processing"
[Apache]
Generally in high performance situations, the default all timeout configuration is 30 seconds, but in the case of uploading files, or network speed is very slow, it is possible to trigger a timeout operation.
There are currently three timeout settings in APACHEFASTCGIPHP-FPM mode:
FastCGI Timeout setting:
Modify the httpd.conf fastcgi connection configuration, similar to the following:
Copy CodeThe code is as follows:
Fastcgiexternalserver/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/php-fpm.sock
scriptalias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
addhandlerphp-fastcgi.php
actionphp-fastcgi/fcgi-bin/php-cgi
addtypeapplication/x-httpd-php.php
The default configuration is 30s, if you need to customize your configuration, you need to modify the configuration, such as modified to 100 seconds: (restart Apache after modification):
Copy CodeThe code is as follows:
fastcgiexternalserver/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/ php-fpm.sock-idle-timeout100
scriptalias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
addhandlerphp-fastcgi.php
actionphp-fastcgi/fcgi-bin/php-cgi
addtypeapplication/x-httpd-php.php
If the timeout returns a 500 error, disconnect the back-end PHP service and log an Apache error logs:
[thujan2718:30:152011] [ERROR] [client10.81.41.110] Fastcgi:commwithserver "/home/forum/apache/apache_php/cgi-bin/php-cgi" Aborted:idletimeout (30sec)
[thujan2718:30:152011] [ERROR] [client10.81.41.110] Fastcgi:incompleteheaders (0bytes) receivedfromserver "/home/forum/apache/apache_php/cgi-bin/php-cgi"
Additional fastcgi configuration parameter description:
Copy CodeThe code is as follows:
IdleTimeout Daze time limit
Processlifetime the longest life cycle of a process, and unconditionally kill after expiration
Maxprocesscount Maximum number of processes
Defaultminclassprocesscount the minimum number of processes started per program
Defaultmaxclassprocesscount the maximum number of processes started per program
Ipcconnecttimeout Program Response Time-out
Ipccommtimeout the maximum time to communicate with the program, the above error may be caused by this value set too small
Maxrequestsperprocess the maximum number of processes per process to complete and commit suicide
[LIGHTTPD]
Configuration: lighttpd.conf
In the LIGHTTPD configuration, there are several parameters about timeouts (space considerations, write-only timeouts, and write timeout parameters):
The main concerns are options:
Server.max-keep-alive-idle=5
Server.max-read-idle=60
Server.read-timeout=0
server.max-connection-idle=360
Copy CodeThe code is as follows:
The maximum number of requests #每次keep-alive, the default value is 16
server.max-keep-alive-requests=100
The maximum wait time #keep-alive, in seconds, the default value is 5
server.max-keep-alive-idle=1200
#lighttpd的work子进程数, the default value is 0, single-process run
server.max-worker=2
#限制用户在发送请求的过程中, the maximum intermediate pause time (in seconds),
#如果用户在发送请求的过程中 (no request), the middle of the pause is too long, LIGHTTPD will actively disconnect
#默认值是60 (seconds)
server.max-read-idle=1200
#限制用户在接收应答的过程中, the maximum intermediate pause time (in seconds),
#如果用户在接收应答的过程中 (not finished), the middle of the pause is too long, LIGHTTPD will actively disconnect
#默认值是360 (seconds)
server.max-write-idle=12000
#读客户端请求的超时限制, unit is seconds, with 0 means no limit
Read-timeout in effect when #设置小于max-read-idle
Server.read-timeout=0
#写应答页面给客户端的超时限制, unit is seconds, with 0 means no limit
Write-timeout in effect when #设置小于max-write-idle
Server.write-timeout=0
#请求的处理时间上限, if Mod_proxy_core is used, it is the interaction time limit with the backend, in seconds
server.max-connection-idle=1200
Description
For successive requests on a keep-alive connection, the maximum interval for sending the content of the first request is determined by the parameter max-read-idle, and the maximum interval for sending the requested content from the second request is determined by the parameter max-keep-alive-idle. The interval timeout between requests is also determined by Max-keep-alive-idle. The total time timeout for sending the requested content is determined by the parameter read-timeout. The timeout for lighttpd interaction data with the backend is determined by Max-connection-idle.
Extended reading:
http://www.snooda.com/read/244
[Nginx]
Configuration: nginx.conf
Copy CodeThe code is as follows:
http{
#Fastcgi:(for back-end Fastcgi, Fastcgi not in proxy mode)
FASTCGI_CONNECT_TIMEOUT5; #连接超时
fastcgi_send_timeout10; #写超时
fastcgi_read_timeout10; #读取超时
#Proxy:(in effect for proxy/upstreams)
proxy_connect_timeout15s; #连接超时
proxy_read_timeout24s; #读超时
proxy_send_timeout10s; #写超时
}
Description
Nginx timeout settings are very clear and easy to understand, the above time-out for different modes of operation, but because the time-out caused by a lot of problems.
Extended reading:
Http://hi.baidu.com/pibuchou/blog/item/a1e330dd71fb8a5995ee3753.html
Http://hi.baidu.com/pibuchou/blog/item/7cbccff0a3b77dc60b46e024.html
Http://hi.baidu.com/pibuchou/blog/item/10a549818f7e4c9df703a626.html
http://www.apoyl.com/?p=466
"PHP itself timed out processing"
[PHP-FPM]
Configuration: php-fpm.conf
Copy CodeThe code is as follows:
//...
Setsthelimitonthenumberofsimultaneousrequeststhatwillbeserved.
Equivalenttoapachemaxclientsdirective.
equivalenttophp_fcgi_childrenenvironmentinoriginalphp.fcgi
Usedwithanypm_style.
Number of processes #php-cgi
128
Thetimeout (inseconds) forservingasinglerequestafterwhichtheworkerprocesswillbeterminated
Shouldbeusedwhen ' Max_execution_time ' Inioptiondoesnotstopscriptexecutionforsomereason
' 0s ' means ' off '
#php-FPM Request Execution time-out, 0s is never timed out, otherwise an Ns is set to the number of seconds to time out
0s
Thetimeout (inseconds) forservingofsinglerequestafterwhichaphpbacktracewillbedumpedtoslow.logfile
' 0s ' means ' off '
0s
Description
In PHP.ini, there is a parameter max_execution_time can set the maximum execution time for PHP scripts, but in php-cgi (PHP-FPM), this parameter will not work. Really able to control the maximum execution of PHP scripts:
0s
This means that if you are running Max_execution_time using mod_php5.so mode, it will take effect, but not when running in PHP-FPM mode.
Extended reading:
http://blog.s135.com/file_get_contents/
[PHP]
Configuration: PHP.ini
Options:
Max_execution_time=30
or set it in code:
Ini_set ("Max_execution_time", 30);
Set_time_limit (30);
Description
Valid for the current session, such as setting 01 to not timeout, but if PHP Safe_mode is turned on, these settings will not take effect.
The same effect, but the specific content needs to refer to php-fpm part of the content, if the php-fpm set Request_terminate_timeout, then Max_execution_time will not take effect.
"Backend & Interface Access Timeout"
"HTTP Access"
In general, we visit HTTP many ways, mainly: Curl,socket,file_get_contents () and other methods.
If you encounter the other side of the server has not been responding, we are tragic, it is easy to kill the entire server, so when accessing HTTP also need to consider the problem of timeouts.
[CURL Access HTTP]
CURL is one of the more reliable LIB libraries that we use to access HTTP protocol interfaces, with high performance, and some features that are supported concurrently.
CURL:
curl_setopt ($ch, opt) can set some timeout settings, mainly including:
* (important) Curlopt_timeout sets the maximum number of seconds that curl is allowed to execute.
* (important) Curlopt_timeout_ms sets the maximum number of milliseconds that curl is allowed to perform. (added in cURL7.16.2.) Can be used from PHP5.2.3 onwards. )
Curlopt_connecttimeout the time to wait before initiating the connection, or infinite wait if set to 0.
Curlopt_connecttimeout_ms the time, in milliseconds, that the connection is trying to wait. If set to 0, the wait is infinite. Was added in the cURL7.16.2. Available starting from PHP5.2.3.
Curlopt_dns_cache_timeout sets the time to save DNS information in memory by default of 120 seconds.
Curl normal second time-out:
$ch =curl_init ();
curl_setopt ($ch, Curlopt_url, $url);
curl_setopt ($ch, curlopt_returntransfer,1);
curl_setopt ($ch, curlopt_timeout,60);//Just set the number of seconds to
curl_setopt ($ch, Curlopt_httpheader, $headers);
curl_setopt ($ch, curlopt_useragent, $defined _vars[' http_user_agent ');
Curl normal second time-out use:
curl_setopt ($ch, curlopt_timeout,60);
Curl needs to be increased if it needs a millisecond timeout:
Curl_easy_setopt (curl,curlopt_nosignal,1l);
Or is:
curl_setopt ($ch, curlopt_nosignal,true), which can support millisecond-level timeout settings
Curl An example of a millisecond-level timeout:
Copy CodeThe code is as follows:
if (!isset ($_get[' foo ')) {
Client
$ch =curl_init (' http://example.com/');
curl_setopt ($ch, curlopt_returntransfer,true);
curl_setopt ($ch, curlopt_nosignal,1);//Note that the millisecond timeout must be set for this
curl_setopt ($ch, curlopt_timeout_ms,200);//timeout in milliseconds, cURL7.16.2 is added. Can be used from PHP5.2.3
$data =curl_exec ($ch);
$curl _errno=curl_errno ($ch);
$curl _error=curl_error ($ch);
Curl_close ($ch);
if ($curl _errno>0) {
echo "Curlerror ($curl _errno): $curl _errorn";
}else{
echo "datareceived: $datan";
}
}else{
Server
Sleep (10);
echo "done.";
}
?>
Some other tricks:
1. According to experience is: Curl version >=libcurl/7.21.0 version, the millisecond time-out is bound to take effect, remember.
2. The millisecond timeout for Curl_multi is also problematic. A single access is to support MS-level timeouts, curl_multi parallel tuning will not be allowed
[Streaming mode access HTTP]
In addition to curl, we often use the fsockopen, or the file operation function to do the HTTP protocol processing, so we have the time-out processing of this block is also necessary.
The general connection timeout can be set directly, but the stream read timeout needs to be handled separately.
Write your own code handling:
Copy CodeThe code is as follows:
$tmCurrent =gettimeofday ();
$intUSGone = ($tmCurrent [' sec ']-$tmStart [' sec ']) *1000000
+ ($tmCurrent [' usec ']-$tmStart [' usec ']);
if ($intUSGone > $this->_intreadtimeoutus) {
Returnfalse;
}
Or use the built-in stream handler functions Stream_set_timeout () and Stream_get_meta_data () Processing:
Copy CodeThe code is as follows:
Timeoutinseconds
$timeout = 5;
$FP =fsockopen ("example.com", $errno, $errstr, $timeout);
if ($fp) {
Fwrite ($fp, "get/http/1.0rn");
Fwrite ($fp, "HOST:EXAMPLE.COMRN");
Fwrite ($fp, "connection:closernrn");
Stream_set_blocking ($fp, true);//important, set to non-blocking mode
Stream_set_timeout ($fp, $timeout);//Set timeout
$info =stream_get_meta_data ($FP);
while ((!feof ($FP)) && (! $info [' timed_out '])) {
$data. =fgets ($fp, 4096);
$info =stream_get_meta_data ($FP);
Ob_flush;
Flush ();
}
if ($info [' timed_out ']) {
echo "connectiontimedout!";
}else{
Echo$data;
}
}
File_get_contents timeout:
Copy CodeThe code is as follows:
$timeout =array (
' HTTP ' =>array (
' Timeout ' =>5//set a time-out in seconds
)
);
$ctx =stream_context_create ($timeout);
$text =file_get_contents ("http://example.com/", 0, $ctx);
?>
fopen Timeout:
Copy CodeThe code is as follows:
$timeout =array (
' HTTP ' =>array (
' Timeout ' =>5//set a time-out in seconds
)
);
$ctx =stream_context_create ($timeout);
if ($fp =fopen ("http://example.com/", "R", False, $ctx)) {
while ($c =fread ($fp, 8192)) {
echo$c;
}
Fclose ($FP);
}
?>
"MySQL"
The MySQL client in PHP does not have the option to set the timeout, neither mysqli nor MySQL, but Libmysql is a timeout option, but we just hide it in PHP.
So how to use this operation in PHP, we need to define some of our own MySQL operation constants, mainly related to the constants are:
mysql_opt_read_timeout=11;
mysql_opt_write_timeout=12;
With these two, you can use the options to set the corresponding values after the definition.
But there is a point of note, MySQL internal implementation:
1. Time-out setting is seconds, minimum configuration is 1 seconds
2. But MySQL's underlying read will retry two times, so it will actually be 3 seconds.
Retry two times + self once = 3 times times the timeout, so that the minimum timeout is 3 seconds, no less than this value, for most applications is acceptable, but for a small number of applications need to be optimized.
To view a PHP instance that sets access to the MySQL timeout:
Copy CodeThe code is as follows:
Self-defined read/write super-constant amount
if (!defined (' mysql_opt_read_timeout ')) {
Define (' Mysql_opt_read_timeout ', 11);
}
if (!defined (' mysql_opt_write_timeout ')) {
Define (' Mysql_opt_write_timeout ', 12);
}
Set timeout
$mysqli =mysqli_init ();
$mysqli->options (mysql_opt_read_timeout,3);
$mysqli->options (mysql_opt_write_timeout,1);
Connecting to a database
$mysqli->real_connect ("localhost", "root", "root", "test");
if (Mysqli_connect_errno ()) {
printf ("connectfailed:%s/n", Mysqli_connect_error ());
Exit ();
}
Execute query sleep1 seconds does not time out
printf ("hostinformation:%s/n", $mysqli->host_info);
if (! ( $res = $mysqli->query (' selectsleep (1) ')) {
echo "Query1error:". $mysqli->error. " /n ";
}else{
echo "query1:querysuccess/n";
}
Execute query SLEEP9 seconds will time out
if (! ( $res = $mysqli->query (' Selectsleep (9) ')) {
echo "Query2error:". $mysqli->error. " /n ";
}else{
echo "query2:querysuccess/n";
}
$mysqli->close ();
echo "closemysqlconnection/n";
?>
Extended reading:
http://blog.csdn.net/heiyeshuwu/article/details/5869813
"Memcached"
[PHP extensions]
Php_memcache Client:
Connection timeout: Boolmemcache::connect (String$host[,int$port[,int$timeout]])
There are no explicit timeout parameters at get and set.
Libmemcached client: There is no obvious timeout parameter in the PHP interface.
Description: So, access to memcached in PHP is a lot of problems, you need to hack part of the operation, or refer to the online patch.
[C&c++ visit memcached]
Client: libmemcached Client
Description: Memcache Timeout configuration can be configured with small points, such as 5, 10 milliseconds is enough, more than this time than the database query.
The following is a C + + example of a timeout to connect and read the set data:
Copy CodeThe code is as follows:
Create connection timeout (connect to memcached)
Memcached_st*memcacheproxy::_create_handle ()
{
Memcached_st*mmc=null;
MEMCACHED_RETURN_TPRC;
if (_mpool!=null) {//getfrompool
Mmc=memcached_pool_pop (_MPOOL,FALSE,&PRC);
if (mmc==null) {
__log_warning__ ("Memcacheproxy", "gethandlefrompoolerror[%d]", (int) PRC);
}
RETURNMMC;
}
Memcached_st*handle=memcached_create (NULL);
if (handle==null) {
__log_warning__ ("Memcacheproxy", "Create_handleerror");
Returnnull;
}
Set connection/Read timeout
Memcached_behavior_set (Handle,memcached_behavior_hash,memcached_hash_default);
Memcached_behavior_set (Handle,memcached_behavior_no_block,_noblock),///parameter Memcached_behavior_no_block is 1 for the timeout configuration to take effect, Do not set timeout will not take effect, critical time will be tragic, easy to cause avalanche
Memcached_behavior_set (handle,memcached_behavior_connect_timeout,_connect_timeout);//Connection timed out
Memcached_behavior_set (handle,memcached_behavior_rcv_timeout,_read_timeout);//Read timeout
Memcached_behavior_set (handle,memcached_behavior_snd_timeout,_send_timeout);//write timeout
Memcached_behavior_set (handle,memcached_behavior_poll_timeout,_poll_timeout);
Set consistent hash
Memcached_behavior_set_distribution (handle,memcached_distribution_consistent);
Memcached_behavior_set (handle,memcached_behavior_distribution,memcached_distribution_consistent);
MEMCACHED_RETURNRC;
for (uinti=0;i<_server_count;i++) {
Rc=memcached_server_add (Handle,_ips[i],_ports[i]);
if (MEMCACHED_SUCCESS!=RC) {
__log_warning__ ("Memcacheproxy", "addserver[%s:%d]failed.", _ips[i],_ports[i]);
}
}
_mpool=memcached_pool_create (Handle,_min_connect,_max_connect);
if (_mpool==null) {
__log_warning__ ("Memcacheproxy", "Create_poolerror");
Returnnull;
}
Mmc=memcached_pool_pop (_MPOOL,FALSE,&PRC);
if (mmc==null) {
__log_warning__ ("Mymemcacheproxy", "gethandlefrompoolerror[%d]", (int) PRC);
}
__log_debug__ ("Memcacheproxy", "gethandle[%p]", handle);
RETURNMMC;
}
Set a key timeout (set a data to memcached)
Boolmemcacheproxy::_add (Memcached_st*handle,unsignedint*key,constchar*value,intlen,unsignedinttimeout)
{
MEMCACHED_RETURNRC;
CHARTMP[1024];
snprintf (tmp,sizeof (TMP), "%u#%u", key[0],key[1]);
There is a timeout value
Rc=memcached_set (Handle,tmp,strlen (TMP), (char*) value,len,timeout,0);
if (MEMCACHED_SUCCESS!=RC) {
Returnfalse;
}
Returntrue;
}
Memcache Read Data timeout (not set)
Libmemcahed the interface definition in the source code:
Libmemcached_apichar*memcached_get (memcached_st*ptr,constchar*key,size_tkey_length,size_t*value_length,uint32_ T*FLAGS,MEMCACHED_RETURN_T*ERROR);
Libmemcached_apimemcached_return_tmemcached_mget (Memcached_st*ptr,constchar*const*keys,constsize_t*key_length, Size_tnumber_of_keys);
It can be seen from the interface that there is no time-out setting when reading data.
Extended reading:
http://hi.baidu.com/chinauser/item/b30af90b23335dde73e67608
Http://libmemcached.org/libMemcached.html
"How to implement timeouts"
The program needs to have time-out this function, such as you access a back-end socket module, the socket module does not belong to any of the above described by the time, its protocol is also private, then this time may need to implement some time-out processing strategy, this time need some processing code.
[Timeout implementation in PHP]
First, beginner: The simplest time-out implementation (seconds timeout)
The idea is simple: Link a backend, then set to non-blocking mode, and if there is no connection on the loop, determine the difference between the current time and the time-out.
The original timeout is implemented in Phpsocket: (the current time of each loop is reduced, performance is poor, CPU usage is higher)
Copy CodeThe code is as follows:
$host = "127.0.0.1";
$port = "80";
$timeout =15;//timeoutinseconds
$socket =socket_create (AF_INET,SOCK_STREAM,SOL_TCP)
Ordie ("Unabletocreatesocketn");
Socket_set_nonblock ($socket)//must be set to blocking mode
Ordie ("Unabletosetnonblockonsocketn");
$time =time ();
We subtract the corresponding value every time I loop.
while (! @socket_connect ($socket, $host, $port))//If there is no connection on the dead loop
{
$err =socket_last_error ($socket);
if ($err ==115| | $err ==114)
{
if (Time ()-$time) >= $timeout)//You need to decide whether or not to time out.
{
Socket_close ($socket);
Die ("CONNECTIONTIMEDOUT.N");
}
Sleep (1);
Continue
}
Die (Socket_strerror ($err). " n ");
}
Socket_set_block ($this->socket)//Reset blocking mode
Ordie ("Unabletosetblockonsocketn");
?>
Second, upgrade: Using PHP with asynchronous IO to implement (millisecond time-out)
Description
Asynchronous IO: The concept of asynchronous IO is relative to synchronous IO. When an asynchronous procedure call is made, the caller cannot get the result immediately. The part that actually handles the call notifies the caller via status, notification, and callback after completion. Asynchronous IO transfers bits into groups, and the group can be 8-bit 1 characters or longer. The sender can send these bit groups at any time, and the receiver never knows when they will arrive.
Multiplexing: A multiplexed model detects multiple IO operations and returns an actionable set that can be manipulated. This avoids the blocking IO not being able to handle the determination of the various IO and non-blocking system resources at any time.
Using Socket_select () to implement timeouts
Socket_select ($timeout), ceil ($timeout *1000000));
Select Features: Ability to set timeout to microsecond level!
Use the timeout code for Socket_select () (need to understand some of the knowledge of asynchronous IO programming)
Copy CodeThe code is as follows:
Programming calls Class Programming #
$server =newserver;
$client =newclient;
for (;;) {
foreach ($select->can_read (0) as$socket) {
if ($socket = = $client->socket) {
Newclientsocket
$select->add (socket_accept ($client->socket));
}
else{
There ' Ssomethingtoreadon$socket
}
}
}
?>
Programming Asynchronous Multiplexing IO & Timeout connection processing classes
classselect{
Var$sockets;
Functionselect ($sockets) {
$this->sockets=array ();
foreach ($socketsas $socket) {
$this->add ($socket);
}
}
Functionadd ($add _socket) {
Array_push ($this->sockets, $add _socket);
}
Functionremove ($remove _socket) {
$sockets =array ();
foreach ($this->socketsas$socket) {
if ($remove _socket!= $socket)
$sockets []= $socket;
}
$this->sockets= $sockets;
}
Functioncan_read ($timeout) {
$read = $this->sockets;
Socket_select ($read, $write =null, $except =null, $timeout);
Return$read;
}
Functioncan_write ($timeout) {
$write = $this->sockets;
Socket_select ($read =null, $write, $except =null, $timeout);
Return$write;
}
}
?>
[Time-out implementation in c&c++]
Typically in linuxc/c++, you can use: Alarm () to set a timer for a second time-out, or: asynchronous multiplexing Io, such as SELECT (), poll (), Epoll (), to achieve a millisecond time-out. You can also use the two-time encapsulated asynchronous IO Library (Libevent,libev).
One, using the signal to achieve time-out (second-level timeout) alarm
Description: The Linux kernel connect timeout is typically 75 seconds, and we can set a smaller time, such as 10 seconds, to return from connect in advance. Here, using the signal processing mechanism, call alarm, generate SIGALRM signal after timeout (also can use Select implementation)
Example of setting the timeout code with the Alarym-second implementation of Connect:
Copy CodeThe code is as follows:
Signal processing functions
Staticvoidconnect_alarm (Intsigno)
{
debug_printf ("Signalhandler");
Return
}
Alarm Timeout Connection Implementation
Staticvoidconn_alarm ()
{
sigfunc*sigfunc;//existing signal processing functions
Sigfunc=signal (sigalrm,connect_alarm);//Establish signal processing function connect_alarm, (if any) to save existing signal processing functions
inttimeout=5;
Set Alarm
if (Alarm (timeout)!=0) {
//... Alarm has been set for processing
}
Make a connection operation
if (Connect (M_socket, (structsockaddr*) &addr,sizeof (addr)) <0) {
if (ERRNO==EINTR) {//If the error number is set to EINTR, the timeout is interrupted
debug_printf ("Timeout");
http://www.bkjia.com/PHPjc/326022.html www.bkjia.com true http://www.bkjia.com/PHPjc/326022.html techarticle in the PHP development work very much uses the time-out processing to the time-out situation, I say several scenes: 1. Asynchronously gets the data if a backend data source gets unsuccessful then skips, without affecting the whole ...
