The developers mind

mardi 20 mars 2012

Faire du HTTP server PUSH avec QT en C++

Je continue avec ma série sur le server PUSH. En effet, j'ai du tester plusieurs solutions afin de trouver celle qui me convenait le mieux. En voici, donc une autre basé sur QT.

Voici d'abord l'implémentation du serveur:

Server.h

Server.cpp

#include "Server.h"

ServerHttp::ServerHttp(QObject *parent)
 : QTcpServer(parent)
{
 m_step = 0;

m_timer.setInterval(1000);
 connect(&m_timer, SIGNAL(timeout()), this, SLOT(generateNextStep()));
}

ServerHttp::~ServerHttp()
{

}

bool ServerHttp::start(int port)
{
 if(!listen(QHostAddress::Any,port))
 {
  qDebug() << "ServerHttp::start(): Unable to open Server Push on port"<<port<<": Is it already in use?";
  return false; 
 }
 
 qDebug() << "ServerHttp::start(): Started Server Push on port "<<port;
 
 return true;
}

void ServerHttp::incomingConnection(int socketDescriptor)
{
 ServerThread *thread = new ServerThread(socketDescriptor);
 connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
 connect(this, SIGNAL(stepReady(int)), thread, SLOT(stepReady(int)), Qt::QueuedConnection);
 thread->start();
 qDebug() << "ServerHttp: Client Connected, Socket Descriptor:"<<socketDescriptor;
 
 thread->moveToThread(thread);

if(!m_timer.isActive())
  m_timer.start();
}

void ServerHttp::generateNextStep()
{
 emit stepReady(m_step);
 m_step++;
}

/** Thread **/
#define BOUNDARY "ServerThread-uuid-0eda9b03a8314df4840c97113e3fe160"

ServerThread::ServerThread(int socketDescriptor, QObject *parent)
    : QThread(parent)
    , m_socketDescriptor(socketDescriptor)
{
 
}

ServerThread::~ServerThread()
{
 m_socket->abort();
 delete m_socket;
}

void ServerThread::run()
{
 m_socket = new QTcpSocket();
 
 if (!m_socket->setSocketDescriptor(m_socketDescriptor)) 
 {
  emit error(m_socket->error());
  return;
 }
 
 writeHeaders();
 
 // enter event loop
 exec();
 
 // when stepReady() signal arrives, write data with header to socket
}

void ServerThread::writeHeaders()
{
 m_socket->write("HTTP/1.0 200 OK\r\n");
 m_socket->write("Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY "\r\n");
 m_socket->write("\r\n");
 m_socket->write("--" BOUNDARY "\r\n");
}

void ServerThread::stepReady(int step)
{
 static int frameCounter = 0;
  frameCounter++;
 
 qDebug() << "ServerThread::stepReady(): Sending text " << frameCounter << ", threadId:"<<QThread::currentThreadId();
 
 if(m_socket->state() == QAbstractSocket::ConnectedState)
 {
  //m_socket->write("Content-type: image/jpeg\r\n\r\n");
  m_socket->write("Content-type: text/plain\r\n\r\n");
  QString szTmp;
  szTmp.sprintf("Step %d", step);
  m_socket->write(qPrintable(szTmp));
 }
 
 m_socket->write("--" BOUNDARY "\r\n");

}

Puis voici le code permettant de démarrer le service.

main.cpp

Enfin comme tout projet QT, voici le fichier du projet, nécessaire pour compiler le server.

TestServerQt.pro

Il ne vous reste alors plus qu'a lancer les commandes:

qmake TestServerQt.pro
make
./TestServerQt

On peut alors attaquer le serveur depuis le navigateur en pointant l'adresse : http://localhost:8081/

samedi 24 décembre 2011

Logging en Java suivant la convention

Le SDK Java dispose d'une quantité astronomique de classe et package qui peuvent être réutilisé pour gagner un temps considérable en développement.

C'est le cas du package java.util.logging. Ce paquet est une bibliothèque qui contient toute les classes de base nécessaire à l'écriture de log (journaux) en Java.

Pour cela on dispose de :

la classe java.util.logging.Logger : c'est sur une instance de cette classe permet que l'on va envoyer nos logs. Un Logger peut exporter les logs qu'il reçoit vers une ou plusieurs sorties simultanées, appelé Handler.
les java.util.logging.Handler : Java fourni déjà de base différents Handler (Console, Fichier, XML, Socket....). Par défaut, la classe Logger possède un seul Handler vers la sortie Console. Mais il est possible de rajouter des Handler au Logger.
les java.util.logging.Formatter : les formatter sont des classes qui définissent la présentation des logs. Clairement, on définit via ces classes l'affichage qu'aura un java.util.logging.LogRecord (un enregistrement de log) à la sortie d'un Handler. Java fourni la classe SimpleFormatter par défaut pour la présentation des logs.
java.util.logging.LogManager : une application possède une seul instance d'un LogManager (gestionnaire). Cette classe est utilisé notamment pour modifier la configuration des Logger de l'application, par exemple en chargeant la configuration depuis un fichier logging.properties.
Fichier de configuration : l'un des point fort de l'API de logging de Java est qu'elle offre la possibilité de paramétrer simplement via un fichier de "properties", les Formatter et les Handler à utiliser, mais aussi le niveau de log à qui doit être exporté au niveau de chaque classe.

Classe métier rapportant des logs :

Voici un exemple de classe rapportant des logs. Dans la convention Java, on déclare un Logger statique pour chaque classe de l'application. Mais rien, n'oblige à suivre cette convention.

Exemple de Formatter :

Admettons maintenant que l'on désire afficher nos logs avec uniquement le niveau de log et le texte de celui-ci.

On créé donc un formatter qu'on ajoutera à notre logger.

Fichier de configuration :

On créé alors un fichier de configuration "logging.properties" :

Il existe plusieurs façon de spécifier au programme l'utilisation d'un fichier de configuration.

Passer une option à Java : "java -Djava.util.logging.config.file=/path/to/logging.properties ..."
Utiliser le LogManager pour lire la configuration.

Lancement de l'application :

Et voici donc enfin la classe qui permet l'exécution du programme. Toutes les classes ainsi que le fichier de configuration sont placés dans un package "org.rikutips.logger".
On utilise donc le LogManager pour charger le fichier de configuration installer dans le package.

package org.rikutips.logger;

import java.io.InputStream;
import java.util.logging.LogManager;
import java.util.logging.Logger;

public class TestLogger {

private static final Logger logger = Logger.getLogger(TestLogger.class.getName());
  
  public static void main(String[] args) {
    
    logger.info("Starting application");

logger.fine("Loading configuration");

LogManager manager = LogManager.getLogManager();
    InputStream is = TestLogger.class.getResourceAsStream("logging.properties");
    try {
      manager.readConfiguration(is);
    } catch (Exception e) {
      logger.severe("Error to read the configuration");
    }
    
    double res;
    
    try {
      res = Math.divide(1, 0);
      logger.info("Result=" + res);
    } catch (IllegalArgumentException e){
      logger.severe("Error for the division");
    }

try {
      res = Math.divide(1, 2);
      logger.info("Result=" + res);
    } catch (IllegalArgumentException e){
      logger.severe("Error for the division");
    }
  }

}

Voici alors ce qu'on obtient en sortie :

Notez que la première ligne est affichée selon le format de la classe SimpleFormatter. Ceci est normal, du fait que au début du programme, la configuration n'est pas encore chargée.

Voilà, j'espère que ce tuto vous aura aidé à mieux comprendre la gestion des logs en Java.

vendredi 23 décembre 2011

Faire du HTTP server PUSH en PHP

Voici un bout de code utile en PHP qui permet d'envoyer une réponse HTTP suivant la méthode Push. En résumé, cette méthode permet d'envoyé des réponse HTTP à intervalle régulier au sein de la même requête. Ceci est notamment utilisé par les caméra IP qui possède un serveur HTTP desservant un flux Motion JPEG.

Voici donc un bout de code permettant d'envoyer la valeur d'une variable à un intervalle régulier. La valeur sera donc mis à jour automatiquement dans le navigateur sans émettre une nouvelle requête HTTP.

<?
# Used to separate multipart
$boundary = "my_boundary";

# We start with the standard headers. PHP allows us this much
header("Cache-Control: no-cache");
header("Cache-Control: private");
header("Pragma: no-cache");
header("Content-type: multipart/x-mixed-replace; boundary=$boundary");

# From here out, we no longer expect to be able to use the header() function
print "--$boundary\n";

# Set this so PHP doesn't timeout during a long stream
set_time_limit(0);

# Disable Apache and PHP's compression of output to the client
@apache_setenv('no-gzip', 1);
@ini_set('zlib.output_compression', 0);

# Set implicit flush, and flush all current buffers
@ini_set('implicit_flush', 1);
for ($i = 0; $i < ob_get_level(); $i++)
    ob_end_flush();
ob_implicit_flush(1);

$val = 0;

# The loop, producing one jpeg frame per iteration
while ($val < 100) {
    # Per-image header, note the two new-lines
    print "Content-type: text/plain\n\n";

# Your function to get one jpeg image
    print "value:".$val;

# The separator
    print "--$boundary\n";

$val++;

usleep(300000);
}
?>

Le code d'origine provient du blog cité ci-dessous.

Source : http://ben-collins.blogspot.com/2010/06/php-sending-motion-jpeg.html

Faire du HTTP Server Push en Java

Voici un bout de code utile qui permet de créer un serveur HTTP en Java et envoyant une réponse suivant la méthode Push. En résumé, cette méthode permet d'envoyé des réponse HTTP à intervalle régulier au sein de la même requête. Ceci est notamment utilisé par les caméra IP qui possède un serveur HTTP desservant un flux Motion JPEG.

Voici donc un bout de code permettant d'envoyer la valeur d'une variable à un intervalle régulier. La valeur sera donc mis à jour automatiquement dans le navigateur sans émettre une nouvelle requête HTTP.

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

class MyHttpHandler implements HttpHandler {

public void handle(HttpExchange exchange) throws IOException {

System.out.println("Request from : " + exchange.getRemoteAddress());

String requestMethod = exchange.getRequestMethod();

if (requestMethod.equalsIgnoreCase("GET")) {
      
      OutputStream responseBody = null;
      
      try {
        // Used to separate multipart
        String strBoundary = "my_boundary";

// We start with the standard headers
        Headers responseHeaders = exchange.getResponseHeaders();
        responseHeaders.set("Cache-Control", "no-cache");
        responseHeaders.set("Cache-Control", "private");
        responseHeaders.set("Pragma", "no-cache");
        responseHeaders.set("Content-Type", "multipart/x-mixed-replace; boundary=" + strBoundary);
        exchange.sendResponseHeaders(200, 0);

// Define the multipart tag separator
        String strTagBoundary = String.format("--%s\n", strBoundary);

// Start output from here
        responseBody = exchange.getResponseBody();
        responseBody.write(strTagBoundary.getBytes());
        responseBody.flush();

int val = 0;
        // The loop, producing one response per iteration
        while (val < 100) {
          // Per-image header, note the two new-lines
          //print "Content-type: image/jpeg\n\n";
          // Set the header, we will send text/plain data
          responseBody.write("Content-type: text/plain\n\n".getBytes());

// Send the response
          String strTmp = String.format("value: %s", val);
          responseBody.write(strTmp.getBytes());
          System.out.println("Sending response: " + strTmp);
          val++;

// The separator
          responseBody.write(strTagBoundary.getBytes());
          responseBody.flush();

try {
            Thread.sleep(300);
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
        }

responseBody.close();
        System.out.println("Request ended");

} catch (IOException e){
        System.out.println("Request aborted");
        throw e;
      }
    }
  }
  
  public static void main(String[] args) throws IOException {
    InetSocketAddress addr = new InetSocketAddress(8080);
    HttpServer server = HttpServer.create(addr, 0);

server.createContext("/", new MyHttpHandler());
    server.setExecutor(Executors.newCachedThreadPool());
    server.start();
    System.out.println("Server is listening on port 8080" );
  }
}

Ouverture

Bonjour à tous et bienvenu sur mon blog.

Entre mon travail et mes hobbies liés à l'informatique je suis souvent (comme tous le monde) confronté à des nouveaux problèmes plus ou moins difficile à résoudre.

Cela peut aller de comment configurer ou installer un logiciel pour répondre à son besoin, comment réaliser un bout de code remplissant une fonctionnalité bien spécifique, ou encore que signifie tel ou tel notion issue du jargon informatique.

Pouvant généralement passer un temps conséquent à résoudre ces problèmes souvent un épluchant les messages des forums, j'ai décidé de créer ce blog afin de partager les solutions que j'ai trouvé en tâchant de les expliquer de façon clair.

Le but étant que mon travail de recherche puisse être réutilisé plus rapidement pas vous autres.

Voilà, j'espère que mes conseils vous seront utiles.