6blog

Cut a file on specified lines

Domenjoud Yannick — 2011-08-12T13:14:53Z

I tried to look on a script/cmd which allow me to cut a file into several files by line number.

I can't find any, that's why I create a script by myself.

Here is the results :

#!/bin/bash
# Cut a file into pieces
# specifie delimiter line number with -l
LINESLIST=()
FILENAME=""
while getopts f:l: option
do
case $option in
f)
FILENAME=$OPTARG
;;
l)
LINESLIST=($(echo $OPTARG|tr "," " "))
;;
esac
done
if [ ${#LINESLIST} = 0 ]; then
echo "lines list is empty"
echo "use -l \"1000,2000,..."
exit
fi
if [ -z $FILENAME ]; then
echo "filename is empty"
echo "use -f \"filename\""
exit
fi
if [ ! -f $FILENAME ]; then
echo "$FILENAME doesnt exists"
exit
fi
# start cut
CURRENT=0
CURRENTFILE=""
for line in ${LINESLIST[@]}
do
START=$CURRENT
END=$line
LENGTH=$(($END-$START))
echo "cut $START to $END (length $LENGTH)"
CURRENTFILE="$FILENAME.$START-$END"
[ "$START" = "0" ] && START=$END
head -n $END $FILENAME | tail -n $LENGTH > $CURRENTFILE
CURRENT=$END
done

Télécharger

Pool de connexion

2008-04-08T22:14:57Z

Sommaire

La gestion des base de données sous Struts est un vrai problème. Les tags du framework ( tel ) commence à perturber l'idée originelle de Struts. Struts n'est qu'un framework de présentation, et le fait de lui permettre de gérer les bases de données revient à mélanger les différentes couches d'une application MVC2 . Il est donc conseillé de ne pas utiliser cette librairie de tag ( qui devrait disparaître dans les versions futures )

Une meilleur approche serait de configurer la gestion de ses bases de données par tomcat lui même grâce encore une fois au fameux fichier de context : /META-INF/context.xml . Quelques lignes permettront de peaufiner toute une gestion tel que le nombre de connexion maximale, le nombre minimal à prévoir, le timeout, etc. Ce que l'on appel un pool de connexion !

Configuration du pool

La configuration commence donc par ces quelques lignes dans un fichier context.xml :


  type="javax.sql.DataSource"
 username="database_user" password="database_passwd"
 driverClassName="com.mysql.jdbc.Driver"
 url="jdbc:mysql://localhost:3306/database_base" maxActive="8" maxIdle="8"
 removeAbandoned="true" removeAbandonedTimeout="30" logAbandoned="true" />

Pour la signification des attributs je vous suggère d'aller voir : common apache

Lier le pool à l'application

Une fois ce pool créé, il peut être intéressant de le lier à l'application dans son fichier web.xml par la balise resource-ref :

 
 
 Pool de connexion à la base de données
 
 jdbc/myProject
 javax.sql.DataSource
 Container

L'utilisation dans vos servlets

Ensuite pour l'utiliser, il vous suffira de récupérer une connexion du context par ces quelques lignes :

 try {
 Context initCtx = new InitialContext(); // récupération du context
 DataSource ds = (DataSource) initCtx.lookup("java:comp/env/jdbc/myProject"); // récupération de la source
 Connection con = ds.getConnection(); // récupération de la connexion
 .....
 } catch (Exception e) {
 Logger.getLogger(this.CLASS).error("DATABASE : "+e.getMessage());
 }

Il pourra être subtil de créer une classe s'occupant de récupérer cette connexion et d'effectuer une requête dessus.

Erreurs fréquentes

Attention toute fois à bien comprendre ce que vous faites. La création d'un pool de connexion et sa limitation implique de fermer correctement toute demande de connexion une fois la requête achevée. Un appel à con.close() terminera la connexion courrante, mais prenez garde à bien fermer vos ResultSet et PreparedStatement dans le bon ordre et avant la fermeture de la connexion principale.

Si votre script se bloque ou se met en pause ; cela est généralement du à l'oubli de fermeture de connexion. Le pool de connexion voyant son capital de connexions s'amenuiser, ne distribuera plus de nouvelles connexions tant que les précédentes n'auront pas été libérées ..

Dernières précisions

Si vraiment, vraiment, vraiment vous préférez quand même, contre toute opposition sensée et argumentée, utiliser la taglib 'sql' de struts, vous pouvez en haut de vos pages renseigner la source précédemment configurée dans le web.xml et dans le context.xml par

Vous pouvez également vouloir configurer un pool de connexion au niveau du serveur tomcat directement, et partager ce pool avec plusieurs applications en créant une section ressource dans le server.xml (plus facilement faisable par l'administration de tomcat ) ; ensuite il conviendra de spécifier dans chaque contexte le pool à utiliser par :
name="jdbc/myProject" global="jdbc/myProject" type="javax.sql.DataSource"/>

Cette solution écarte l'étape de configuration du web.xml

Paradigme des fonctions

2008-04-08T21:28:16Z

Sommaire

Ceci est un post à vues pédagogiques sur la création de fonctions php.

Tout le monde utilise les fonctions de php telles que explode(), strpos(), mysql_db_query(), etc . Mais qui n'a jamais voulu en créer lui même ? la création/utilisation de fonctions suit 2 étapes :

Tout d'abord, commençons par le commencement :

la déclaration

Elle ( la déclaration [1]) commence par le mot-clé : function et ce, selon la syntaxe suivante :

 function NomDeLaFonction(arg1,arg2,arg3 .... ){
 corps de la fonction;
 }

La fonction peut très bien ne prendre aucun argument. Dans le corps de la fonction vous mettez les instructions destinées à être exécutées.

Exemple de fonction

function affiche_text_gras($texte){
 echo "".$texte.""; 
 }

// affiche un texte en gras

Une fonction peut également renvoyer une valeur à son exécution grâce au mot-clé : return

Exemple de fonction

function carre($nb){
 return $nb*$nb; //retourne le carré d'un nombre
 }

L'appel de la fonction

l'appel se fait de façon explicite :

Si la fonction retourne une variable, il faut affecter à une variable le résultat de la fonction : $variable = NomDeLaFonction($arg1,$arg2, ....) ; // autant de $arg que d'argument
Si la fonction n'en retourne pas : NomDeLaFonction($arg1,$arg2...) ; // autant de $arg que d'argument

[1] doit se faire obligatoirement avant l'appel de la fonction

Mail HTML en image

2008-04-08T21:22:35Z

Sommaire

Il arrive parfois de vouloir envoyer un mail en HTML et d'y incorporer des images. Généralement, il suffit de placer l'adresse absolue de l'image dans le tag correspondant. Cependant, il peut être nécessaire de lier l'image dans le mail, pour par exemple pouvoir relire le mail hors connexion.

Les différentes composantes d'un mail

Dans un mail il y a 3 grosses parties :

Les entêtes qui indiquent ce que contient le mail, qui est le destinataire, qui est l'envoyeur, à qui faut il répondre, ....
Le corps du message ( qu'il soit en HTML ou en texte simple )
Les fichiers joins ( images, documents, ...)

Ces trois parties sont séparées par un délimiteur qu'il convient de renseigner dans les entêtes du mail.

Le délimiteur

Il convient d'utiliser une séquence difficile à retrouver dans le reste du mail ( de façon à ne pas confondre une occurrence d'un texte avec le délimiteur ). On va le définir de la façon suivante et récupérer un délimiteur de 32 caractères.

$delimiteur = '--'.'---='.md5( uniqid( rand() ) ); ?>

J'ai du couper les 4 tirets du délimiteur pour contrer les raccourci typographiques de spip :)

Les entêtes

Les entêtes sont importantes, une erreur bien placée pourrait vous donner l'envie de vous arracher les cheveux pendant 2 semaines sans jamais trouver la source de l'erreur.

On va définir le type MIME du message, , le sous type ou la nature du contenu du mail ( présentement « related » [1] ), l'adresse à laquelle répondre et l'envoyeur. On définit également quel sera la séquence du délimiteur servant à départager les différentes informations du mail.

$headers = "MIME-Version: 1.0\r\n"; $headers .= "Content-Type: multipart/related; boundary=\"$delimiteur\"\r\n"; $headers .= "Reply-to: $from\r\n"; $headers .= "From: $from\r\n"; $headers .= "\r\n"; ?>

( ceci est une liste non exhaustive d'entêtes )

Référencer les images dans le mail

Afin d'insérer les images dans le mail, il convient d'assigner à chaque image une référence et indiquer dans le texte la référence. On appellera cette référence le « CID » [2].

On pars du principe que vous avez possédez déjà une liste des images de votre message HTML dans une variable nommée $imgListe( sinon il faudra trouver d'autre moyen comme preg_match_all, ou alors un listing de répertoire si jamais toutes les images de votre mail se retrouve « par chance » dans un même dossier. )

On va donc assigner à chaque image un identifiant nommé "image-*" où * sera remplacé par l'indice du tableau correspondant à cette image, et on remplacera l'occurence de cette image dans le contenu du mail ( symbolisé ici par $content ) par cet identifiant.

foreach($imgListe as $k => $v){ $content = str_replace($v, 'cid:image'.$k, $content); } ?>

++++

Renseigner le corps du message

Avant dernière étape : spécifier le corps du message transformé dans la partie précédente. Il est important de spécifier le type mime [3] du contenu ( text/html ) et son encodage.

$msg = "Content-Type: text/html; charset=\"iso-8859-1\"\r\n"; $msg .= "Content-Transfer-Encoding:8bit\r\n"; $msg .= "\r\n"; $msg .= $content."\r\n"; $msg .= "\r\n"; ?>

Attacher les images

Voici la dernière étape avant l'envoi du mail : attacher les images. On considère toujours que vous avez un tableau contenant les noms des images de votre mail. On va donc créer pour chaque item de ce tableau une entrée dans le mail grâce à cete fonction préalablement créée :

# fonction qui va générer le texte des images du mail function buildImageContent($file, $key){ $fp = fopen($file, 'r'); $attached = fread($fp, filesize($file)); fclose($fp); $attached = chunk_split(base64_encode($attached)); $msg = "Content-Type: application/octet-stream; name=\"$file\"\r\n"; $msg .= "Content-Transfer-Encoding: base64\r\n"; $msg .= "Content-ID: \r\n"; $msg .= "\r\n"; $msg .= $attached . "\r\n"; $msg .= "\r\n\r\n"; return $msg; } ?>

Cette fonction récupère le contenu de l'image dans une variable, segmente ce contenu en ligne de 76 octets après l'avoir encoder en MIME base64 ( pour les systèmes qui ne gèrent pas correctement les 8bits ), spécifie quelle est la référence de cette image et indique le contenu de l'image. Il est important de toujours mettre une ligne vide entre des entêtes et le contenu de la partie.

/!\ Ne pas oublier de séparer chaque partie du mail par le délimiteur

++++

Exemple

Une fois cette fonction déclarée, vous pouvez facilement créer le message. Voici le code dans son intégralité :

# fonction qui va générer le texte des images du mail function buildImageContent($file, $key){ $fp = fopen($file, 'r'); $attached = fread($fp, filesize($file)); fclose($fp); $attached = chunk_split(base64_encode($attached)); $msg = "Content-Type: application/octet-stream; name=\"$file\"\r\n"; $msg .= "Content-Transfer-Encoding: base64\r\n"; $msg .= "Content-ID: \r\n"; $msg .= "\r\n"; $msg .= $attached . "\r\n"; $msg .= "\r\n\r\n"; return $msg; } # On définit le délimiteur $delimiteur = '--'.'---='.md5( uniqid( rand() ) ); # Le contenu HTML du message, le destinataire, l'envoyeur, et le sujet $content = 'mon message en html'; $to = 'you@spam.com'; $from = 'me@spam.com'; $subject = 'Happy to be spamed'; # la liste des images du message $imgListe = array('monImage.gif'); # Les entêtes du mail $headers = "MIME-Version: 1.0\r\n"; $headers .= "Content-Type: multipart/related; boundary=\"$delimiteur\"\r\n"; $headers .= "Reply-to: $from\r\n"; $headers .= "From: $from\r\n"; $headers .= "\r\n"; # On va transformer le HTML du mail foreach($imgListe as $k => $v){ $content = str_replace($v, 'cid:image'.$k, $content); } # Le contenu du mail avec le HTML transformé $msg = "Content-Type: text/html; charset=\"iso-8859-1\"\r\n"; $msg .= "Content-Transfer-Encoding:8bit\r\n"; $msg .= "\r\n"; $msg .= $content."\r\n"; $msg .= "\r\n"; # on attache toutes les images du mail foreach($imgListe as $k => $v){ $msg .= '--'.$delimiteur."\r\n"; $msg . = buildImageContent($v,$k); } # Une dernière petite ligne $msg .= '--'.$delimiteur."\r\n"; # Et on envois le mail mail($to, $subject, $msg, $headers); ?>

[1] permet de spécifier que les différentes parties du message devrait être traitées comme un tout

[2] Content-ID

[3] A ne pas confondre avec le protocole MIME

Fonction multi-résultat

2008-04-08T21:07:41Z

Sommaire

Il arrive souvent lors de construction de fonctions personnalisées en PHP de vouloir retourner plusieurs variables calculées par la fonction en une fois plutôt que de créer une fonction différente par traitement.

Retour par tableau

Cette solution consiste en fait à renvoyer un tableau contenant les différents résultats. L'absence de typage en PHP nous permet facilement de renvoyer plusieurs résultat de types différents dans une même structure.

Exemple de retour par tableau On veux pouvoir récupérer les carrés et les cubes d'un nombre à partir d'une seule fonction

unction calcul_puissance($n){ $puiss1 = $n; $puiss2 = $puiss1*$n; $puiss3 = $puiss2*$n; $table = array($puiss1,$puiss2,$puiss3); // créer un tableau avec les valeurs $puiss1, $puiss2 et $puiss3 return $table; // retourne le tableau précédemment créé } ?>

Le passage par référence

Vous pouvez modifier directement des variables du script en les passant par référence à la fonction avec le préfix & sur le nom de variable. Toutes modifications effectuées intra-muraux dans la fonction affectera la variable passée en paramètre par référence à la fonction.

Exemple de passage par référence

function assign_valeur($var, $value){ $value = $var; } $chaine = 'Voici une chaine de test'; assign_valeur(&$chaine,'2e chaine de test'); echo $chaine; ?>

La variable $chaine contenant une valeur d'origine sera modifiée directement au niveau du script par la fonction assign_valeur qui lui assignera la valeur contenu dans le deuxième paramètre de la fonction ( en l'occurence, echo $chaine affichera "2e chaine de test" )

La modification par global

Une autre solution un peu du même genre que la précédente permet de modifier une variable du script à partir de la fonction. Il faut pour cela spécifier avant traitement de la variable par la fonction que la variable est à modifier au niveau du script général par le mot clef global

Exemple de modification par global

$nb_pizza=0; function ajouter_pizza(){ // déclaration de la fonction global $nb_pizza; $nb_pizza = $nb_pizza+1; // itération du nombre de pizza } ajouter_pizza(); // ajoute une pizza ajouter_pizza(); // ajoute une pizza echo "Nombre de pizza(s) : ".$nb_pizza; ?>

Résultat : Nombre de pizza(s) : 2

On spécifie au niveau de la fonction que la variable $nb_pizza à utiliser n'est pas une nouvelle variable mais bien celle définie précédemment au début du script. Si jamais vous enlevez le mot clef global, la fonction essayera de créer une nouvelle variable et l'incrémentera de un. Cependant à la sortie de la fonction la variable du même nom au niveau du script restera inchangée et gardera sa valeur initiale : 0

La surcharge de fonctions

2008-04-08T21:03:07Z

Sommaire

Qui n'a jamais voulu créer deux fonctions différentes mais avec un profil relativement proche ( même nom, mais le dernier paramètre serait un entier supplémentaire par exemple) ou alors a défini maladroitement la même fonction dans plusieurs fichiers mais décide de modifier son profil ?

Il existe pour cela plusieurs méthodes qui dépendent majoritairement de la structure que vous employez.

Appel de fonction classique

Cette solution consiste à créer une fonction sans paramètres ( ou avec uniquement les arguments communs à la fonction de base et ses éventuelles surcharges ) et d'appliquer un traitement différent en fonction du nombre d'arguments passés en paramètres grâce aux fonctions : func_get_args() et func_num_args()

Exemple de fonction à nombre d'argument variable On veut récupérer le plus grand nombre parmi les paramètres fournis à la fonction si leur nombre est pair, ou le plus petit si leur nombre est impair.

function minMaxFromValue(){ $argsCount = func_num_args(); $argsList = func_get_args(); $selected = $argsList[0]; for($i=1;$argsCount;$i++) if( $argsCount%2==0 ? $args[$i] > $selected : $args[$i] < $selected ) $selected = $args[$i]; return $selected; } ?>

On peut donc influencer le comportement d'une fonction à travers son nombre d'argument.

Une autre méthode plus simple consiste à positionner des arguments à des valeurs par défaut dans le cas où ils ne sont pas spécifiés.

Exemple de fonction à argument par défaut Un exemple sur les pizzas.

$nb_pizza = 0; function ajouter_pizza($action = '',$nb = 1){ global $nb_pizza; switch($action){ case 'affichage': echo 'Nombre de pizza actuel : '.$nb_pizza.' '; break; case 'envoyer': $nb_pizza = $nb_pizza - $nb; echo 'Il reste encore '.$nb_pizza.' pizza(s) '; break; case '': $nb_pizza = $nb_pizza + $nb; break; } } ajouter_pizza('',3); // ajoute 3 pizza ajouter_pizza('affichage'); // affiche les pizzas ajouter_pizza(); // ajoute 1 pizza ( valeur par défaut) ajouter_pizza('affichage'); // affiche les pizzas ajouter_pizza('envoyer', 2); // Enlève 2 pizzas et affiche le nombre restant ?>

++++

Appel de méthode d'objet

En Php5, on peut récupérer les appels de méthodes et traiter les informations d'une façon différente grâce à la méthode __call() qui s'occupera de gérer les appels aux fonctions inexistantes.

Exemple avec __call()

class Pizzeria { private $pizzaCounter = 0; private $pizzaStorage = array(); public function __call($name, $args) { // Si la méthode appelée s'appelle 'modifyPizza' if( $name == 'modifyPizza' ){ $argsCount = count( $args ); // Si il y a un argument passé à la fonction if( $argsCount == 1 ){ // On va ajouter une pizza return call_user_func_array(array(&$this, 'addPizza'), $args); // Si il y'en a deux } else if( $argsCount == 2 ){ // On va modifier le nom d'une pizza return call_user_func_array(array(&$this, 'modifyPizzaName'), $args); } } } public function addPizza($name){ $this -> pizzaStorage[$name] = (int)$this -> pizzaStorage[$name] + 1; } public function modifyPizzaName($oldName, $newName){ // On récupère le nombre de pizza anciennement nommée oldName $pizzaStock = (int)$this -> pizzaStorage[$oldName]; // On supprime l'entrée correspondante unset($this -> pizzaStorage[$oldName]); // On créé la nouvelle entrée $this -> pizzaStorage[$newName] = $pizzaStock; } } $pizzeria = new Pizzeria(); $pizzeria -> modifyPizza('Pizza aux 4 fromages'); // on créé un stock de 1 pour les "Pizza aux 4 fromages" $pizzeria -> modifyPizza('Pissaadiè'); // on créé un stock de 1 pour les "Pissaadiè" // Mais on a fait une faute on décide de changer le nom $pizzeria -> modifyPizza('Pissaadiè', 'Pissaladière'); // on change le nom des "Pissaadiè" en "Pissaladière" ?>

Surchage de getter et setter

De la même manière il est possible de surcharger les getters et setters d'une classe par la définition des méthodes __get() et __set() qui vont automatiquement attraper les fonctions get**** et set**** si elles n'existent pas. Ensuite en jouant sur le nom de la fonction appelée ou le nombre d'argument, on peut facilement créer des profile de fonction différent.

La surcharge de méthode prend un aspect différent des autres langages et s'affiche plus comme étant une liste de méthode de substitution et non de réel surcharge.

Le gestionnaire d'erreur de PHP

Il est possible également de redéfinir un gestionnaire en php et de récupérer les erreurs liés à un appel de fonction pour effectuer un autre traitement puis de continuer le reste de l'exécution du script.

Ceci sera plus détaillé dans un article sur les gestions d'erreurs en PHP