Voici comment déployer (presque rapidement) un environnement Ruby pour bénéficier du compilateur css SASS via Compass et rechargement automatique de la page en fonction des modifications enregistrées, grâce à Livereload, le tout chapeauté par Guard.

Il faut installer gem et bundle au besoin :

sudo apt-get install gem
sudo gem install bundle

Ensuite dans le dossier parent du projet on crée un Gemfile

Puis on lance coup sur coup Compass et Guard via Bundle pour initier le projet (ici avec l’option bootstrap-sass)

bundle install
bundle exec compass create mon_projet -r bootstrap-sass --using bootstrap

Je copie ici mes fichiers Guardfile et config.rb pour info :

Il reste à installer le module Firefox LiveReload

Avec ça l’environnement doit être prêt et fonctionnel.

On lance Guard via Bundle depuis le dossier parent du projet

bundle exec guard start

Pour toute demande, vous pouvez nous adresser un mail à l’adresse : contact@roxing.net.

La même chose, mais en mieux, dans le cadre de la création d’un plugin est d’utiliser le pipeline insert_head($flux).

Installation des dépendances 32bits

Créer un répertoire de travail et récupérer les outils d’installation

Creer un repertoire de travail.

Aller dans le répertoire de travail.

Récupérer l’installateur de DVD X-Plane 9 sur la page du wiki officiel X-Plane

Récupérer l’outil de mise à jour sur le site officiel d’X-Plane

Décompresser les 2 outils

Installation d’X-plane 9

[Inserer DVD-ROM du jeu]

rendre executable le script d’installation

lancer l’installation

Si cette erreur apparaît lors du lancement de l’installation :

Faire un lien symbolique :

Problèmes rencontrés :

Bizarrement certain de mes DVD (Trés peu utilisés) "plantaient" au cours de l’installation. J’ai résolu le problème en générant des ISO pour ensuite les les monter et lancer l’installeur de DVD.

Monter une ISO de DVD de scène d’ x-plane 9 puis lance l’installeur de DVD.

s’assurer qu’aucun autre média d’x-plane et présent, puis lancer l’installeur du DVD

1) Configuration du serveur openvpn

Pour info, voici le fichier de configuration du serveur en mode bridge afin de fournir les infos DHCP et DNS du réseau :

server.conf

2) Configuration du client openvpn

Ci-dessous la configuration client nommer client.conf. J’insiste sur L’extension, car le script de démarrage d’openvpn va lire les fichiers aux extension *.conf et demarrer autant de tunnel que de fichier .conf

client.conf

On peux tester la config et suivre les logs :

3) Obtenir l’adresse IP et le DNS via le DHCP du vpn

Lorsque le service openvpn se connect il démarre pas l’interface tap0 je devais taper les commandes suivantes :

4) Automatiser l’obtention de l’IP et du DNS

Pour utiliser le script ci-dessous il est important d’installer le paquet resolvconf

Pour automatiser toute la procédure de connexion j’ai modifié le script update-resolv-conf dans /etc/openvpn

/etc/openvpn/update-resolv-conf : L 31 -> 36

Et voilà, désormais un simple service openvpn start connecte directement la machine au réseau privé et récupère une ip en dhcp.

A noter que le service démarre automatiquement au boot de la machine.

Récupérer les sources du noyau, le patch grsec et la config ovh qui va bien

Se rendre dans un dossier de travail

Téléchargement du kernel

Téléchargement du patch grsecurity [1] correspondant à la version du noyau (3.9.6 dans l’article)

récuperer la config du noyaux ovh sur leur serveur ftp [2]

Préparer les sources

décompresser [3] le noyau

copier la configuration ovh dans racine du noyau linux décompressé précédemment

aller dans le répertoire du noyau fraichement décompressé

appliquer le patch grsec

Configuration des cgroups

dans le repertoire du kernel, lancer l’utilitaire de configuration du noyau make menuconfig et configurer lxc cgroup [4] en activant les options suivantes :

-> General setup
	[renommer votre kernel] Local version - append to kernel release
	-> Control Group support
		[x] Namespace cgroup subsystem
		[x] Freezer cgroup subsystem
		[x] Cpuset support
		[x] Simple CPU accounting cgroup subsystem
		[x] Resource counters
		[x] Memory resource controllers for Control Groups
		-> Group CPU scheduler
			[x] Basis for grouping tasks (Control Groups) (!)
			[x] Group scheduling for SCHED_OTHER (NEW)
			[x] CPU bandwidth provisioning for FAIR_GROUP_SCHED
			[x] Group scheduling for SCHED_RR/FIFO
		-> Namespaces support
			[x] UTS namespace
			[x] IPC namespace
			[x] User namespace (!)
			[x] Pid namespace
			[x] Network namespace
 -> Device Drivers
	-> Character devices
		[x] Support multiple instances of devpts
		[*] Unix98 PTY support
	-> Network device support
		[x] MAC-VLAN support
		[x] Virtual ethernet pair device
 -> Networking support
	-> Networking options
		[x] 802.1d Ethernet Bridging
		[x] Network priority cgroup
	-> Security options
		[x] File POSIX Capabilities (!)

Une fois votre configuration terminée, retourner sur la page d’accueil de menuconfig sélectionner < Exit >, une boite de dialogue vous demande d’enregistrer votre configuration selectionner < yes > avant de quitter.

Avant de compiler, On va tester la configuration :

CONFIG=/usr/src/linux-3.9.6/.config lxc-checkconfig

 --- Namespaces ---
Namespaces: enabled
Utsname namespace: enabled
Ipc namespace: enabled
Pid namespace: enabled
User namespace: enabled
Network namespace: enabled
Multiple /dev/pts instances: enabled

 --- Control groups ---
Cgroup: enabled
Cgroup clone_children flag: enabled
Cgroup device: enabled
Cgroup sched: enabled
Cgroup cpu account: enabled
Cgroup memory controller: missing (!)
Cgroup cpuset: enabled

 --- Misc --- 
Veth pair device: enabled
Macvlan: enabled
Vlan: enabled
File capabilities: enabled

 

Cgroup memory controller : missing (!) - Debian Wheezy

Youpi ! la configuration est maintenant terminée, il est temps de lancer la compilation avant de boire un café !

Compilation du noyau

Penser à installer les outils pour la compilation des noyaux. Sur Debian, le paquet s’appelle build-essential c’est un meta-paquet dédié a l’installation de tous les outils de compilation make, gcc, etc..

Lancer la compilation, ou -j X (correspond au nombre de core ) :

Le kernel se retrouve dans le dossier arch/x86/boot. On va Copier/renommer le nouveau kernel dans le dossier /boot du système :

Installer le kernel et redémarrer

Je vous invite à consulter mon article précédent intitulé Installer un nouveau kernel Linux en 5 étapes

1 - Mettre le nouveau kernel linux super optimisé dans le dossier /boot

2 - Editer Le fichier de "pré-configuration" personnalisé pour Grub2

Et ajouter une entrée en s’inspirant de /boot/grub/grub.cfg (notamment pour les uuid) pour votre tout nouveau kernel

3 - Forcer Grub à utiliser le Super Kernel par défaut

repérer la ligne GRUB_DEFAULT="1", sinon l’ajouter.

Modifier par le nom du "menuentry" créé précédemment.

4 - Régénérer le fichier de config de Grub2

5 - Zen et Confiant on Reboot !

Méthode 1 - Rapide & gourmande en mémoire sur de gros fichiers

    $tab = file('/path/fichier.txt');
    $pattern = "/recherche/i";
    $line = preg_grep($pattern, $tab);
    print_r($line);    //affiche les lignes qui contiennent le mot recherche

Méthode 2 - Plus lent mais moins gourmand

$fh = fopen('/path/fichier.txt', 'r') or die($php_errormsg);
while (!feof($fh)) {
    $line = fgets($fh, 4096);
    if (preg_match($pattern, $line)) { $result[ ] = $line; }
}
fclose($fh);
print_r($result)

Headjs [1] est une librairie jquery permettant d’optimiser le chargement des fichiers js.

Pour spip, une petite fonction pour utiliser headjs sur les scripts ajouter par les plugins dans le

[(#INSERT_HEAD|headjs)]

function headjs($insert_head){

    $pattern = "#src=\"(.*)\"#Ui" ; //khkzh

    preg_match_all($pattern, $insert_head, $split_content);
    foreach($split_content[1] as $libjs)
        $tabjs[]= '"'. $libjs . '"';
   
    $insert_head = implode(', ',$tabjs);
    
    return $insert_head;
}

Avec la nouvelle version de spip3 il est possible de boucler sur des tableaux [1].

Un bon exemple pour récuperer des tableaux multidimensionnels est la table spip_meta. Les plugins insèrent souvent des données sous forme de tableaux multidimensionnels sérialisés [2] pour sauvegarder leur configuration.

La boucle ci-dessous va récupérer le tableau php stocké en bdd.
Ce tableau va être affecté à la variable tabMetaAuteur, puis passé en "critère" de boucle.
On effectue une boucle sur les valeurs puis une boucle récursive [3] a l’intérieur de celle-ci qui va descendre dans toute la profondeur du tableau.

[(#REM)<!-- Récupération d'un tableau en bdd-->]
<BOUCLE_recup_tableau(spip_meta){nom = champs_extras_spip_auteurs}>
    #SET{tabMetaAuteur,#VALEUR}
</BOUCLE_recup_tableau>

[(#REM)<!-- Boucle sur le tableau  -->]
<ul>
    <BOUCLE_data_tab(DATA){source table, #GET{tabMetaAuteur}}>       
        <li>#CLEF
            <B_data>
                <ul>
                    [(#REM)<!-- Boucle sur le tableau et toute sa profondeur -->]
                    <BOUCLE_data(DATA){source table, #VALEUR}{' '}>
                        <li>\[#CLE\] => #VALEUR
                            <BOUCLE_recursive_data(BOUCLE_data)>
                             </BOUCLE_recursive_data>
                        </li>      
                    </BOUCLE_data>
                </ul> 
            </B_data>
        </li>
    </BOUCLE_data_tab>
</ul>

Noter l’écriture raccourcie de la boucle de calcul :

<BOUCLE_recursive_data(BOUCLE_data)/>

Il est possible d’éviter une boucle et d’arriver au même résultat avec le code ci-dessous.

<BOUCLE_recup_tableau(spip_meta){nom = champs_extras_spip_auteurs}>
    <BOUCLE_data(DATA){source table, #VALEUR}{' '}>
        \[#CLE\] => #VALEUR
    <BOUCLE_recursive_data(BOUCLE_data)/>
    </BOUCLE_data>
</BOUCLE_recup_tableau>

Une solution encore plus rapide et d’utiliser print_r($array) de php en guise de filtre :’).

À noter que le tableau doit être désérialisé contrairement au critère de boucle DATA qui accepte les 2 formats.