48K Views

API de Twitter: Hacer el mejor fuera de Streaming API

Recientemente me había llegado a través de la tarea de implementación de la cuenta de Twitter Api de secuencias para el proceso de Twitter (Tweets) en tiempo real. Más específicamente, la aplicación para ser construido tenía que ser capaz de escuchar los tweets que van desde varios temas y de los usuarios (nos referiremos a ellos como a las pistas), y debería haber sido capaz de hot-swap estos temas de manera casi instantánea, así.

No mucho antes de trabajar en esta aplicación, he tenido que realizar la misma tarea en el contexto de Facebook. Como contraposición a la de Twitter, que hace uso de su Api de secuencias para proporcionar a las aplicaciones con actualizaciones en tiempo real, Facebook utiliza, en su lugar de Webhooks. Webhooks, siendo un HTTP devolución de llamada, proporcionar a los desarrolladores con un nivel de sofisticación que es mucho más fácil de tratar. El Streaming Api proporcionadas por Twitter, sin embargo, requiere la aplicación para mantener una conexión HTTP persistente con uno de Twitter muchos streaming de los extremos. Escribir una aplicación que se basa en una conexión persistente para su funcionamiento nos obliga a pensar en una forma ligeramente diferente de lo que estamos supuestamente utilizados para la construcción de una aplicación web tradicional.

Todo el enfoque de este artículo estará en el desarrollo de una aplicación de este tipo.

La Cuenta De Twitter Api De Secuencias

Si usted echa un vistazo a Twitter en la Documentación para Desarrolladores, vas a ver que nos ofrecen Streaming Api. Por supuesto, también nos proporciona el DESCANSO y la Api de Anuncios, pero para nuestros propósitos, vamos a ser sólo centrándose en su Api de secuencias.

Entonces, ¿qué son exactamente los de Streaming Api? Para ponerlo en términos simples, el uso de la Api de secuencias, su aplicación puede establecer una baja latencia de la conexión con Twitter para la transmisión de los extremos. Una vez que una conexión se ha establecido correctamente, Twitter enviar adelante cualquier tiempo real alimentar a su aplicación ha solicitado para esta conexión de la tubería de forma casi instantánea. De acuerdo a la documentación:

El Streaming Api de dar a los desarrolladores de baja latencia de acceso a Twitter en la transmisión mundial de Tweet de datos. Una adecuada implementación de un cliente de streaming será empujado mensajes indicando Tweets y otros eventos que se han producido, sin que ninguno de los gastos generales relacionados con el sondeo de un extremo REST.

El Streaming Api requiere que el dijo conexión persistente (esencialmente de nunca acabar) en la naturaleza. En esencia, es similar a la de la descarga de los infinitamente grande de archivos de su sistema va a seguir en la recepción de datos a menos que manualmente terminar la conexión.

El tipo de alimentos recibe la aplicación dependerá del tipo de los arroyos que va a utilizar. El Streaming Api proporciona a los desarrolladores con tres diferentes tipos de corrientes:

  • Pública de Corrientes Corrientes del público los datos que fluyen a través de Twitter. Adecuado para los siguientes usuarios específicos o temas, y la minería de datos.
  • Usuario Corrientes – el Único usuario de los arroyos, que contiene alrededor de todos los datos correspondiente con una sola visión del usuario de Twitter.
  • Sitio Corrientes – La multi-usuario de la versión de usuario arroyos. Sitio arroyos están destinados para los servidores que se conectan a Twitter en nombre de muchos usuarios.

Como he dicho antes, las fuentes de recibir dependerá de la clase de los arroyos vamos a utilizar. Así que antes de continuar, vamos a echar un vistazo a los requisitos de nuestra aplicación, dependiendo de lo que vamos a utilizar, ya sea Pública Corrientes o del Usuario de los Arroyos (Sitio de las Secuencias de una beta cerrada).

Nuestra aplicación debe cumplir los siguientes requisitos:

  • Escucha en vivo los tweets de las pistas que nos han solicitado
  • Ser capaz de procesar los tweets recibidos sin interrumpir la conexión con la transmisión de extremo
  • Ser capaz de cambiar estas pistas ya que se han cambiado con la menor cantidad de interrupciones de la conexión dijo

Mantener estos requisitos en mente, ahora nos tenemos que conformar con los flujos que vamos a utilizar. Usuario arroyos, como se indicó anteriormente, proporciona los datos de un individuo punto de vista del usuario. De acuerdo a Twitter de la documentación para el Usuario de los Arroyos:

Usuario de Flujos de proporcionar un flujo de datos y eventos específicos para el usuario autenticado. Tenga en cuenta que el Usuario Corrientes no están destinados para el servidor-a-servidor de conexiones. Si usted necesita para hacer las conexiones en nombre de varios usuarios en la misma máquina, considere la posibilidad de usar el sitio arroyos.

Minimizar el número de conexiones que su aplicación hace que el Usuario Arroyos. Cada cuenta de Twitter está limitado a sólo un par de usuarios simultáneas Flujos de conexiones por OAuth aplicación, independientemente de la IP. Una vez que la aplicación se sobrepasa el límite, la más antigua de conexión se dará por terminado. Una cuenta de registro en muchos casos de la misma OAuth aplicación del ciclo de conexiones como las instancias de aplicación de conectar y desconectar cada uno de los otros.

Ya estamos más enfocados en ser capaz de recibir los tweets de numerosos usuarios, no es claro en cuanto a cómo muchos de los usuarios que van a ser. Pasando por la documentación, el Usuario Arroyos no se corte para nuestra aplicación de caso de uso. Así que ahora estamos a la izquierda para hacer Pública Arroyos.

Como oposición al Usuario Corrientes, que nos permite recibir fuentes en el contexto en el individuo limitado los usuarios, de las Corrientes de proporcionar a las aplicaciones con un flujo de datos públicos que fluye a través de Twitter. Hablando en el contexto de tweets en concreto, si utilizamos pública flujos de elegancia, en nuestra aplicación no estará obligado a alcance limitado de usuarios individuales en contraste con el Usuario de los Arroyos. Ya no estamos necesariamente preocupado por privado flujo de datos, se puede pasar a lo largo de Twitter Maneja (@nombre de usuario) que corresponden a cada Usuarios de Twitter a lo largo de pistas antes de establecer una conexión con el público de transmisión de extremo. Esto permitirá que nuestra aplicación para escuchar en vivo público tweets de varios usuarios. Un rápido punto de aviso antes de ir más lejos, como por la cuenta de Twitter de la Documentación para el Público de los Arroyos, nuestra aplicación sólo puede establecer una conexión única con el público corrientes en cualquier momento dado.

la Comunicación con el Streaming API: la Construcción de nuestra aplicación

Ahora que hemos terminado con todos los introductorio de bits, podemos empezar a trabajar en la construcción de nuestra aplicación. Voy a ser el desarrollo de la aplicación en PHP que se ejecuta en Linux, utilizando el popular Framework Symfony y Compositor como el administrador de paquetes. Dicho esto, usted debería ser capaz de aplicar los conceptos fundamentales y la implementación del proyecto en cualquier idioma de su elección.

yo, sin embargo, ser el uso de Phirehose por Fennb, una tercera parte de la biblioteca para facilitar el proceso de comunicación con el Twitter Api de secuencias. Si usted está desarrollando en la plataforma de PHP, he aquí una lista extensa de las bibliotecas de terceros usted puede hacer uso de. Usted puede agregar Phirehose para su proyecto a través de Compositor con el siguiente comando:

php composer require “fennb/phirehose”

La configuración de nuestra aplicación:

Crear un nuevo proyecto Symfony (vamos a llamar atwitterFeeds) ejecutando el siguiente comando:

symfony nueva twitterFeeds

Antes de que nos movemos junto con el artículo, asegúrese de que ha instalado la librería de terceros como se mencionó anteriormente. A continuación, cree un nuevo paquete (vamos a llamar a esteTwitterBundle) ejecutando el siguiente comando:

php bin/console generate:bundle

Siga junto con cualquiera de los detalles de configuración se te pide. A continuación, vaya a suTwitterBundle directorio de su proyecto y crear un nuevo Servicios directorio. En este directorio, cree un nuevo archivo denominado TwitterService.php que vamos a utilizar. Asegúrese de registrar este servicio para su aplicación.

El establecimiento de una conexión persistente:

Como he dicho antes, la escritura de una aplicación que se basa en una conexión persistente para su funcionamiento nos obliga a pensar en una manera ligeramente diferente. A diferencia de en el caso de la utilización de las Api de REST, donde podemos hacer llamadas a la API, o Webhooks, donde una devolución de llamada se hizo a nuestros servidores de Streaming Api, estamos estableciendo una conexión persistente con una transmisión de extremo de que, a continuación, vive para siempre (idealmente hablando), y proceso de los datos que recibimos en nuestro extremo a través de este medio. Damos por terminada esta conexión sólo en los casos cuando debemos reiniciar la misma, en orden a la actualización de las pistas. Entonces, ¿cómo ir sobre el establecimiento de tales dicha conexión? Una forma es hacer uso deProcesos En Segundo Plano.

Digamos que tenemos que escuchar para vivir tweets, a continuación, necesitamos establecer una conexión persistente con Twitter públicas de transmisión de las estaciones. Para ello, se puede ejecutar un proceso en segundo plano a través de la terminal. Este proceso en segundo plano se ejecuta como un proceso individual, y establecer dicha conexión persistente nuestra aplicación requiere. Podemos rastrear laproceso de ID (PID) de este proceso en segundo plano si necesitamos modificar de ninguna manera.

Para hacer de nuestro proceso en segundo plano, vamos a crear una consola de comandos que podemos ejecutar desde la terminal en el directorio raíz de nuestro proyecto. Para hacer que nuestro comando, podemos utilizar la Consola de Componentes proporcionados por el Framework Symfony. Primero crear un Comando directorio en su TwitterBundle, y, a continuación, crear TwitterCommand.php del archivo en ese directorio.

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class TwitterCommand extends ContainerAwareCommand
{
	protected function configure()
	{
		$this->setName('twitter:stream')->setDescription('Listen for Live Twitter Feeds.');
	}

	protected function execute(InputInterface $input, OutputInterface $output)
	{
		$twitterTracks = ['#ReasonsToLoveMe']; // Define your tracks you wish to receive updates for
		$this->getContainer()->get('twitter.service')->listenForTweets($twitterTracks); // This will start the streaming process
	}
}

Desde el directorio raíz de nuestro proyecto, ahora podemos ejecutar el código escrito en el interior de la execute() la función mediante el siguiente comando en el terminal:

php bin/console twitter:stream

Como podemos ver, el TwitterCommand::execute() la función será a su vez de llamar a laTwitterCommand::listenForTweets() función definida en la TwitterService, , que va a establecer una nueva conexión persistente con el Twitter de la transmisión de extremo. Así que vamos a este código hasta la próxima. En su TwitterService.php que hemos creado anteriormente,

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Services;

const CONSUMER_KEY = YOUR_APP_CONSUMER_KEY;
const CONSUMER_SECRET = YOUR_APP_CONSUMER_SECRET;
const APPLICATION_TOKEN = YOUR_APP_ACCESS_TOKEN;
const APPLICATION_TOKEN_SECRET = YOUR_APP_ACCESS_TOKEN_SECRET;

// Include the third-party library
require_once __DIR__ . '/../../../vendor/fennb/phirehose/lib/OauthPhirehose.php';

class TwitterListener extends \OauthPhirehose
{
    public function __construct() {
        parent::__construct(APPLICATION_TOKEN, APPLICATION_TOKEN_SECRET, \Phirehose::METHOD_FILTER);
        $this->consumerKey = CONSUMER_KEY;
        $this->consumerSecret = CONSUMER_SECRET;
    }

    public function enqueueStatus($status)
    {   
        $twitterFeed = json_decode($status, true);
        if (is_array($twitterFeed) && isset($twitterFeed['user']['screen_name'])) {
            $twitterData = array('feed' => $twitterFeed);
            dump('New Feed Recieved');
            dump($twitterData);
        }
    }
}

class TwitterService
{
	/**
	 * This function will establish a persistent connection with one of the twitter's streaming endpoint.
	 * @param  array  $twitterTrackCollection Collection of tracks which we'll receive updates for
	 */
	public function listenForTweets(array $twitterTrackCollection = [])
    {
    	// Terminate the process if there are no active tracks
    	if (empty($twitterTrackCollection)) {
    		echo 'No active tracks. Terminating Process...' . PHP_EOL . PHP_EOL;
    		exit(0);
    	}

    	$twitterListener = new TwitterListener();
        $twitterListener->setTrack($twitterTrackCollection);
        $twitterListener->consume();
    }
}

Ahora si ejecutamos el comando que hemos creado desde su terminal, una nueva conexión con Twitter Streaming API será establecido y vas a empezar a recibir público tweets por las pistas que hemos definido. En el momento de escribir este artículo, «#ReasonsToLoveMe» fue trending por lo que he usado como ejemplo de la pista. Ahora cada vez que un tweet que consiste en cualquiera de nuestras pistas específicas (en este caso, «#ReasonsToLoveMe»), que el tweet será pasado a lo largo de la conexión de tuberías. Este tweet va a ser transmitida a lo largo de la TwitterListener::enqueueStatus() de la función, donde puede procesar la recibió de alimentación. Sin embargo, la usted debe evitar hacer cualquier tiempo intensivo de operación en este punto. La razón de que, si su aplicación no es capaz de procesar este flujo de datos lo suficientemente rápido en contraste con la tasa que usted está recibiendo la alimenta, se corre el riesgo de que su conexión terminado, que para la mayoría de nosotros sería indeseable.

Real-Time Twitter Feeds

En Tiempo Real En Twitter

Hasta ahora, hemos sido el inicio manual de la conexión a través de nuestra terminal y ejecutar el comando. Pero desde las aplicaciones del mundo real son mucho diferentes, vamos a automatizar el proceso de inicio y cierre de la conexión. En nuestro DefaultController, vamos a escribir una acción de controlador (llamaremos a este startStreamAction), que cuando se ejecuta dará inicio a nuestro proceso de transmisión. Asegúrese de que ha configurado la ruta para este controlador en el correspondiente routing.yml del archivo. En DefaultController.php

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class DefaultController extends Controller
{
    // .....

    /**
     * This handler will switch to the root directory and start a new background process
     */
    public function startStreamAction(Request $request)
    {
        chdir('../');
        $command = 'php bin/console twitter:listen';
        exec($command);
        exit(0);
    }

    // .....
}

Ahora cada vez que visita la ruta para este controlador, este comando será ejecutado por separado en un nuevo hilo.

Con el Público Corrientes, solo recibimos feeds públicos para las pistas que hemos definido antes de establecer una conexión permanente con la transmisión de extremo. Así que si surge una necesidad de actualizar nuestro camino, tendremos que terminar la conexión anterior, re-definir nuestras pistas y, a continuación, volver a establecer una nueva conexión con la transmisión de extremo. Este proceso es muy importante ya que sólo puede tener una conexión con la transmisión de extremo a un tiempo (corremos el riesgo de tener nuestra IP prohibidas con múltiples conexiones). Así que necesitamos asegurarnos de que antes de intentar crear una nueva conexión, todo lo anteriormente a cabo las conexiones están cerradas.

Para cerrar una conexión con la transmisión de extremo, podemos terminar el proceso en segundo plano correspondiente a la conexión. Para matar el proceso, podemos hacer uso de ella de la ID de proceso (PID), o buscarlo usando el nombre y los argumentos de los procesos en segundo plano. Mediante el proceso de ID, cada vez que establecer una nueva conexión, se necesitará de registro (base de datos, archivo de texto, etc…) el proceso de ID correspondiente a ese proceso en segundo plano. Mediante este registro, usted puede terminar con anterioridad a cabo los procesos de fondo antes de iniciar una nueva. Vamos a actualizar nuestra startStreamAction controlador para iniciar el proceso de ID cada vez que se realiza una conexión, y en nuestro DefaultController, crear una nueva acción de controlador (vamos a llamar a este stopStreamAction), para terminar con anterioridad a cabo los procesos de fondo. Podemos llamar a este controlador antes de iniciar un nuevo proceso en segundo plano para asegurar que sólo una instancia de una conexión persistente con el streaming extremo está activo en un momento.

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class DefaultController extends Controller
{
    // ......

    /**
     * This handler will first terminate any previously held background process  
     * by firing the stopStreamAction() handler. Then it'll create a new background  
     * process which establish a new connection with a streaming endpoint.
     */
    public function startStreamAction(Request $request)
    {
    	// Execute the stopStreamAction() handler
        $curlHandler = curl_init();
        $stopStreamPath = $this->generateUrl('twitter_stream_stop', array(), UrlGeneratorInterface::ABSOLUTE_URL);
        curl_setopt($curlHandler, CURLOPT_URL, $stopStreamPath);
        curl_setopt($curlHandler, CURLOPT_RETURNTRANSFER, 1);
        curl_exec($curlHandler);

        // Create a new background process
        chdir('../');
        $output = array();
        $command = 'nohup php bin/console twitter:listen > /dev/null 2>&1 & echo $!';
        exec($command, $output);
        $processId = (int) $output[0]; // Process ID of the newly created background process. Log this.
        exit(0);
    }

    /**
     * This handler will fetch a log of Process IDs corresponding to any background
     * process and terminate them.
     */
    public function stopStreamAction(Request $request)
    {
        $activeProcesses = ARRAY_COLLECTION_OF_PROCESS_IDS_TO_TERMINATE;

        if (!empty($activeProcesses)) {
            foreach ($activeProcesses as $processId) {
                $command = 'kill ' . $processId . ' 2>&1';
                exec($command, $output);
                $this->get('logger')->info('Twitter Stream Process Terminated: ' . $processId);
            }
        }
        exit(0);
    }

    // ......
}

Si usted mira cuidadosamente, hemos modificado el comando que vamos a ejecutar desde el terminal con el exec() de la función.

nohup php bin/console twitter:listen > /dev/null 2>&1 & echo $!

Todos los bits y piezas devolverá el ID de proceso del proceso de fondo creado a través de la exec() función. Ahora, cada vez que un nuevo proceso en segundo plano se crea siguiendo este enfoque, todas nuestras anteriormente en manos de fondo se pondrá fin al proceso (si los hubiere). Esto debería ser más que suficiente para asegurar que sólo una conexión activa a la vez, siempre y cuando usted correctamente registro de sus Identificadores de proceso. Usted puede mejorar su funcionalidad de acuerdo a sus necesidades.

Todo lo que queda ahora es procesar el flujo de datos que vamos a estar recibiendo a través de la conexión de tuberías. Para ello, vamos a hacer mejoras a nuestro Servicio de Twitter (TwitterService.php) en primer lugar, y, a continuación, redirigir cualquier tweets que nuestra aplicación recibe a un controlador (vamos a llamar a este processStreamAction), que a su vez el proceso de estos tweets. En su TwitterService.php

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Services;

const CONSUMER_KEY = YOUR_APP_CONSUMER_KEY;
const CONSUMER_SECRET = YOUR_APP_CONSUMER_SECRET;
const APPLICATION_TOKEN = YOUR_APP_ACCESS_TOKEN;
const APPLICATION_TOKEN_SECRET = YOUR_APP_ACCESS_TOKEN_SECRET;

require_once __DIR__ . '/../../../vendor/fennb/phirehose/lib/OauthPhirehose.php';

class TwitterListener extends \OauthPhirehose
{
    private $curlHandler = null;
    private $processStreamPath = null;

    public function __construct() {
        parent::__construct(APPLICATION_TOKEN, APPLICATION_TOKEN_SECRET, \Phirehose::METHOD_FILTER);
        $this->processStreamPath = URL_TO_PROCESS_STREAM_ACTION_HANDLER;
        $this->consumerKey = CONSUMER_KEY;
        $this->consumerSecret = CONSUMER_SECRET;
        $this->configureCURL();
    }

    private function configureCURL()
    {
        $this->curlHandler = curl_init();
        $headers = array('Content-type: multipart/form-data');
        curl_setopt($this->curlHandler, CURLOPT_POST, true);
        curl_setopt($this->curlHandler, CURLOPT_URL, $this->processStreamPath);
        curl_setopt($this->curlHandler, CURLOPT_RETURNTRANSFER, 1);
    }

    public function enqueueStatus($status)
    {   
        $twitterFeed = json_decode($status, true);
        if (is_array($twitterFeed) && isset($twitterFeed['user']['screen_name'])) {
            $twitterData = array('feed' => $twitterFeed);
            curl_setopt($this->curlHandler, CURLOPT_POSTFIELDS, http_build_query($twitterData));
            curl_exec($this->curlHandler);
        }
    }
}

class TwitterService
{
	/**
	 * This function will establish a persistent connection with one of the twitter's streaming endpoint.
	 * @param  array  $twitterTrackCollection Collection of tracks which we'll receive updates for
	 */
	public function listenForTweets(array $twitterTrackCollection = [])
    {
    	// Terminate the process if there are no active tracks
    	if (empty($twitterTrackCollection)) {
    		echo 'No active tracks. Terminating Process...' . PHP_EOL . PHP_EOL;
    		exit(0);
    	}

    	$twitterListener = new TwitterListener();
        $twitterListener->setTrack($twitterTrackCollection);
        $twitterListener->consume();
    }
}

Ahora, cada vez que una cuenta de twitter es recibido, TwitterListener::enqueueStatus() enviará la señal a la ruta que hemos especificado el uso de CURL de hacer una petición POST. En esencia, esto es exactamente como un Webhook si usted piensa acerca de ello. Ahora vamos a escribir la processStreamAction() en nuestro controlador DefaultController. En su DefaultController.php,

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class DefaultController extends Controller
{
    /**
     * This handler will first terminate any previously held background process  
     * by firing the stopStreamAction() handler. Then it'll create a new background  
     * process which establishes a new connection with a streaming endpoint.
*/
public function startStreamAction(Request $request)
{
// Execute the stopStreamAction() handler
$curlHandler = curl_init();
$stopStreamPath = $this->generateUrl('twitter_stream_stop', array(), UrlGeneratorInterface::ABSOLUTE_URL);
curl_setopt($curlHandler, CURLOPT_URL, $stopStreamPath);
curl_setopt($curlHandler, CURLOPT_RETURNTRANSFER, 1);
curl_exec($curlHandler);
// Create a new background process
chdir('../');
$output = array();
$command = 'nohup php bin/console twitter:listen > /dev/null 2>&1 & echo $!';
exec($command, $output);
$processId = (int) $output[0]; // Process ID of the newly created background process. Log this.
exit(0);
}
 /**
 * This handler will fetch a log of Process IDs corresponding to any background
 * process and terminate them.
 */
 public function stopStreamAction(Request $request)
{
 $activeProcesses = ARRAY_COLLECTION_OF_PROCESS_IDS_TO_TERMINATE;
 if (!empty($activeProcesses)) {
 foreach ($activeProcesses as $processId) {
 $command = 'kill ' . $processId . ' 2>&1';
 exec($command, $output);
 $this->get('logger')->info('Twitter Stream Process Terminated: ' . $processId);
}
}
 exit(0);
}
 /**
 * A POST request will be made to this handler whenever our application receives
 * a feed. You can write your implementation here.
 */
 public function processStreamAction(Request $request)
{
 if (isset($_POST)) {
 if (array_key_exists('feed', $_POST)) {
 // Real-time Twitter Feed. Write your own implementation over here.
 $streamContent = $_POST['feed'];
 }
 } else {
 // Request method not supported.
}
 exit(0);
}
}

Hay que ir! Ahora tenemos una aplicación totalmente funcional que no sólo escuchar las transmisiones en vivo de Twitter para las pistas específicas, sino que también nos permite actualizar nuestra pistas de forma casi instantánea, mientras se asegura de que sólo una conexión con la transmisión de extremo está activo en un momento. Puede ampliar esta aplicación a tu gusto y hacerlo más robusto y tolerante a fallas. Aquí en UVDesk, seguimos un enfoque similar para proporcionar a nuestros Usuarios de Twitter con mejor experiencia de usuario y conectividad social.

Category(s) uvdesk
. . .

Comment

Add Your Comment

Be the first to comment.

css.php