Attention, la source et la destination du fichier de restauration doivent avoir exactement la même version. Si la source à une version plus ancienne que la destination, il faut mettre à jour vers la bonne version.

Création d’une sauvegarde de Gitlab:

docker exec -it gitlab.example.com gitlab-rake gitlab:backup:create

Ré-import de l’archive Gitlab:

#copie de l'archive dans le dossier backup du Gitlab de destination
cp 1475786020_gitlab_backup.tar /srv/gitlab/data/backups/

#connexion au conteneur et import de l'archive
docker exec -it gitlab.example.com /bin/bash
gitlab-ctl stop unicorn
gitlab-ctl stop sidekiq
# Verification
gitlab-ctl status

gitlab-rake gitlab:backup:restore BACKUP=1475786020

gitlab-ctl start
gitlab-rake gitlab:check SANITIZE=true

exit

Création d’une archive des fichiers de configuration:

umask 0077;tar cfz $(date "+etc-gitlab-%s.tgz") -C / /srv/gitlab/config -P

sources:
https://gitlab.com/gitlab-org/gitlab-ce/blob/master/doc/raketasks/backup_restore.md
https://docs.gitlab.com/omnibus/settings/backups.html

The post Sauvegarde et restauration de Gitlab dans Docker appeared first on www.php-geek.fr.

Dans ce tuto, le port 3000 du conteneur est mappé sur le ports 4432.
Cela veux dire que le reverse proxy de Nginx installé sur l’host devra « écouter » sur le port 4432.

1 – Configuration du conteneur Docker

1.1 – Création du conteneur

Premièrement, il faut récupérer la dernière image Docker de Redmine.

#https://hub.docker.com/_/redmine/
docker pull redmine

1.2 – docker-compose

On créé un fichier docker-compose.yml avec le contenu suivant:

version: '2'
services:

  redmine:
    image: redmine
    container_name: 'redmine.example.com'
    volumes:
      - "/srv/redmine/files:/usr/src/redmine/files"
      - "/srv/redmine/config/configuration.yml:/usr/src/redmine/config/configuration.yml"
    ports:
      - 4432:3000
    environment:
      REDMINE_DB_MYSQL: mariadb
      REDMINE_DB_PASSWORD: password
    depends_on:
      - mariadb
    restart: always

  mariadb:
    image: mariadb
    container_name: mariadb
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: redmine
    restart: always
    volumes:
      - "/srv/mariadb:/var/lib/mysql"

Pour ajouter un conteneur phpmyadmin lié à mariadb ajoutez ceci au fichier docker-compose.yml

  phpmyadmin:
    image: nazarpc/phpmyadmin
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: redmine
    restart: always
    ports:
      - 1234:80
    links:
      - mariadb:mysql

On peut ensuite accéder à phpmyadmin sur cette URL: http://127.0.0.1:1234

Lancement du conteneur

docker-compose up -d

2 – Configuration SMTP

Dans le fichier docker-compose.yml le fichier de configuration est monté sur /srv/redmine/config/configuration.yml .
Ce fichier contient la configuration SMTP.
Exemple de configuration avec Gmail:

  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      enable_starttls_auto: "true"
      address: "smtp.gmail.com"
      port: 587
      domain: "smtp.gmail.com"
      authentication: :plain
      user_name: "USER@gmail.com"
      password: "PASSWORD"

Une fois la configuration effectuée, il faut redémarrer le conteneur:

docker-compose stop
docker-compose up -d

3 – Configuration du reverse proxy sur la machine host

Dans ce tutoriel nous allons utiliser Nginx pour mettre en place un reverse proxy mais vous pouvez également utiliser Apache.

Installation de Nginx

apt-get install nginx

Configuration du proxy

cd /etc/nginx/
vim sites-available/redmine.example.com

Contenu de /etc/nginx/sites-available/redmine.example.com

server {
        listen *:443 ssl http2;


	## Strong SSL Security
	## https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html & https://cipherli.st/
	ssl on;
	ssl_certificate /srv/redmine/ssl/redmine.example.com.crt;
	ssl_certificate_key /srv/redmine/ssl/redmine.example.com.key;

	ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4';
	ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
	ssl_prefer_server_ciphers on;
	ssl_session_cache  builtin:1000  shared:SSL:10m;
	ssl_session_timeout  5m;


	server_tokens off; ## Don't show the nginx version number, a security best practice

        proxy_redirect  off;
        proxy_set_header        Host    $host;
        proxy_set_header        X-Real-IP $remote_addr;
        proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header        X-Forwarded-Proto https;

        server_name  redmine.example.com;
        access_log  /var/log/redmine.example.com.access.log;
        error_log  /var/log/redmine.example.com.nginx_error.log debug;
        location / {
                proxy_pass         http://127.0.0.1:4432/;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
                root   /var/www/nginx-default;
        }
}

Pour terminer:

ln -s /etc/nginx/sites-available/redmine.example.com sites-enabled/redmine.example.com
/etc/init.d/nginx restart

4 – Première connexion

Rendez vous sur https://redmine.example.com/ pour la première authentification.
Les accès par défaut sont admin/admin.

Rendez-vous sur https://redmine.example.com/settings pour configurer le hostname et le protocol https et sur https://redmine.example.com/settings?tab=authentication pour empêcher la création de compte.

BONUS: Backup/Restore

Pour faire une backup de Redmine, il suffit d’exporter la base « redmine » de mariadb et de faire une archive du dossier /srv/redmine/files qui contient les fichiers uploadés.

Pour exporter la base redmine de l’instance mariadb:

docker exec mariadb sh -c 'exec mysqldump -uroot -p"password" redmine' > /chemin/sur/host/redmine.sql

Script bash pour la création automatique d’une archive du dossier /srv/redmine/file:

#!/bin/bash

# Number of backups to keep
NBACKUPS_TO_KEEP=6

# Also keep backups of the first day of each month
KEEP_FIRST_DAY_MONTH=true

REDMINE_VOLUMES_PATH="/srv/redmine"

BACKUP_PATH="/path/to/backups"

EMAIL_DEST="admin@redmine.example.com"

EMAIL_SUBJECT="redmine.example.com - backup"

TODAY=$(date)

HOST=$(hostname)

NEWLINE_CHAR="\n"

if [ ! -d $BACKUP_PATH/files ]; then
	mkdir -p $BACKUP_PATH/files;
fi

echo "----------------"
MESSAGE_TO_SEND="----------------"

echo "$TODAY - $HOST"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND"${NEWLINE_CHAR}$TODAY - $HOST"

echo "Backing up redmine into $BACKUP_PATH"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"backing up redmine into $BACKUP_PATH"

echo "----------------"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"----------------"
echo ""


LINE="creating /usr/src/redmine/files archive.."
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
echo $LINE
umask 0077;tar cfz $BACKUP_PATH/files/$(date "+files-redmine-%s.tgz") -C / $REDMINE_VOLUMES_PATH/files -P
echo "done"
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"done"${NEWLINE_CHAR}

echo ""
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"Removing old backups"
echo "Removing old backups"

backups=( $( ls $BACKUP_PATH/files/ | sort -n -r -t _ -k 2 ) );
i=1;
for filename in "${backups[@]}";do

	if [ $i -gt $NBACKUPS_TO_KEEP ]
	then
		if [ $KEEP_FIRST_DAY_MONTH == true ]
		then
			day=$( date -d @$( echo $filename | sed -e "s/files-redmine-//g" | sed -e "s/.tgz//g") '+%d' )
			if [ ! $day == 01 ]
			then
				rm "$BACKUP_PATH/files/$filename"
				LINE="removed $filename"
				MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
				echo $LINE
			else
				LINE="keeping $filename"
				MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
				echo $LINE
			fi
			
		else
			rm "$BACKUP_PATH/files/$filename"
			LINE="removed $filename"
			MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}$LINE
			echo $LINE
		fi
	fi
	i=$[i+1]
done
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"done"
echo "done"

echo "----------------";
MESSAGE_TO_SEND=$MESSAGE_TO_SEND${NEWLINE_CHAR}"----------------"
echo -e $MESSAGE_TO_SEND | mail -s "$EMAIL_SUBJECT" $EMAIL_DEST

Pour restaurer, extraire l’archive des fichiers dans /srv/redmine/files et importer /chemin/sur/host/redmine.sql dans l’instance mariadb.

sources:
http://www.redmine.org/boards/2/topics/14177
https://github.com/docker-library/docs/tree/master/mariadb
https://hub.docker.com/r/nazarpc/phpmyadmin/
redmine.org/projects/redmine/wiki/redmineinstall

Pour l’installation de docker-compose ou pour générer les certificats SSL jetez un oeil à mon précédent article: Installer Gitlab en https avec Docker et Nginx

Tutoriel réalisé sous Ubuntu Xenial (16.04 LTS)

The post Installer Redmine en https avec Docker et Nginx appeared first on www.php-geek.fr.

Nous allons aujourd’hui utiliser la puissance de Docker pour créer une instance en https de Gitlab derrière un proxy Nginx.

Dans ce tuto, les ports 443 (SSL) et 22 (SSH) du conteneur sont mappés respectivement sur les ports 4431 et 2201 de l’host mais libre à vous de changer ces valeurs.
Cela veux dire que le reverse proxy de Nginx installé sur l’host devra « écouter » sur le port 4431 et que l’url SSH de vos dépôts sera du type « ssh://git@gitlab.example.com:2201/user/repo.git »

1 – Configuration du conteneur Docker

1.1 – Création du conteneur

Premièrement, il faut récupérer la dernière image Docker de Gitlab.

#https://hub.docker.com/r/gitlab/gitlab-ce/
docker pull gitlab/gitlab-ce

On lance ensuite le conteneur, n’oubliez par de remplacer gitlab.example.com par votre nom de domaine.
Les différents fichiers de Gitlab seronts stockés dans /srv/gitlab/

docker run --detach \
    --hostname gitlab.example.com \
    --publish 4431:443 --publish 2201:22 \
    --name gitlab.example.com \
    --restart always \
    --volume /srv/gitlab/config:/etc/gitlab \
    --volume /srv/gitlab/logs:/var/log/gitlab \
    --volume /srv/gitlab/data:/var/opt/gitlab \
    --volume /srv/gitlab/logs/reconfigure:/var/log/gitlab/reconfigure \
    gitlab/gitlab-ce:latest

1.2 – Configuration

Configuration de Gitlab /etc/gitlab/gitlab.rb

#ouverture de gitlab.rb dans le conteneur
docker exec -it gitlab.example.com vi /etc/gitlab/gitlab.rb

Dans le fichier gitlab.rb, remplacez les valeurs par défaut par les vôtres

#configuration de l'url de Gitlab. Notez le https.
#https://docs.gitlab.com/omnibus/docker/
external_url 'https://gitlab.example.com'

#modification du port ssh pour coller avec le mapping du conteneur
gitlab_rails['gitlab_shell_ssh_port'] = 2201

#configuration du smtp avec un compte gmail
#https://docs.gitlab.com/omnibus/settings/smtp.html
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.gmail.com"
gitlab_rails['smtp_port'] = 587
gitlab_rails['smtp_user_name'] = "USERNAME@gmail.com"
gitlab_rails['smtp_password'] = "PSW_GMAIL"
gitlab_rails['smtp_domain'] = "smtp.gmail.com"
gitlab_rails['smtp_authentication'] = :plain
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['smtp_tls'] = false
gitlab_rails['smtp_openssl_verify_mode'] = 'peer'

# on garde les backups pendant 7 jours
#https://docs.gitlab.com/ee/raketasks/backup_restore.html
gitlab_rails['backup_keep_time'] = 604800

Reconfiguration de Gitlab pour prendre en compte les changements

docker exec -it gitlab.example.com gitlab-ctl reconfigure

1.3 – Alternative: docker-compose

Cette configuration peut être faite bien plus simplement avec docker-compose.

Après avoir fait un docker pull gitlab/gitlab-ce comme vu précédemment, on créé un fichier docker-compose.yml avec le contenu suivant:

web:
  image: 'gitlab/gitlab-ce:latest'
  restart: always
  hostname: 'gitlab.example.com'
  container_name: 'gitlab.example.com'
  environment:
    GITLAB_OMNIBUS_CONFIG: |
      external_url 'https://gitlab.example.com'
      gitlab_rails['gitlab_shell_ssh_port'] = 2201
      gitlab_rails['smtp_enable'] = true
      gitlab_rails['smtp_address'] = "smtp.gmail.com"
      gitlab_rails['smtp_port'] = 587
      gitlab_rails['smtp_user_name'] = "USERNAME@gmail.com"
      gitlab_rails['smtp_password'] = "PSW_GMAIL"
      gitlab_rails['smtp_domain'] = "smtp.gmail.com"
      gitlab_rails['smtp_authentication'] = :plain
      gitlab_rails['smtp_enable_starttls_auto'] = true
      gitlab_rails['smtp_tls'] = false
      gitlab_rails['smtp_openssl_verify_mode'] = 'peer'
      gitlab_rails['backup_keep_time'] = 604800
  ports:
    - '4431:443'
    - '2201:22'
  volumes:
    - '/srv/gitlab/config:/etc/gitlab'
    - '/srv/gitlab/logs:/var/log/gitlab'
    - '/srv/gitlab/data:/var/opt/gitlab'

CF: https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/docker/docker-compose.yml

Si docker-compose n’est pas installé:

#https://docs.docker.com/compose/install/
curl -L https://github.com/docker/compose/releases/download/1.8.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

Lancement du conteneur

docker-compose up -d

2 – Création du certificat SSL

Après avoir ouvert et redirigé le port 443 sur votre box ADSL, on peut utiliser letsencrypt pour générer des certificats gratuits. Attention, ces certificats ne sont valides que 90 jours, il faut penser à les renouveler.

#https://certbot.eff.org/#ubuntuxenial-other
apt-get install letsencrypt 
letsencrypt certonly --standalone -d gitlab.example.com

Copie des certificats dans le dossier config de Gitlab

cd /etc/letsencrypt/live/gitlab.example.com/
mkdir -p /srv/gitlab/config/ssl
chmod 700 /srv/gitlab/config/ssl
cp privkey.pem /srv/gitlab/config/ssl/gitlab.example.com.key
cp cert.pem /srv/gitlab/config/ssl/gitlab.example.com.crt

Reconfiguration de Gitlab pour prendre en compte les changements

docker exec -it gitlab.example.com gitlab-ctl reconfigure

3 – Configuration du reverse proxy sur la machine host

Dans ce tutoriel nous allons utiliser Nginx pour mettre en place un reverse proxy mais vous pouvez également utiliser Apache.

Installation de Nginx

apt-get install nginx

Configuration du proxy

cd /etc/nginx/
vim sites-available/gitlab.example.com

Contenu de /etc/nginx/sites-available/gitlab.example.com

## Redirects all HTTP traffic to the HTTPS host
server {
	listen 0.0.0.0:80;
	listen [::]:80 ipv6only=on;
	server_name gitlab.example.com; 
	server_tokens off;
	return 301 https://$http_host$request_uri;

	access_log  /var/log/gitlab.example.com80.access.log;
	error_log  /var/log/gitlab.example.com80.nginx_error.log debug;
}

server {
        listen *:443 ssl http2;

	ssl on;
	ssl_certificate /srv/gitlab/config/ssl/gitlab.example.com.crt;
	ssl_certificate_key /srv/gitlab/config/ssl/gitlab.example.com.key;

	ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4';
	ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
	ssl_prefer_server_ciphers on;
	ssl_session_cache  builtin:1000  shared:SSL:10m;
	ssl_session_timeout  5m;

	server_tokens off;

        server_name  gitlab.example.com;
        access_log  /var/log/gitlab.example.com.access.log;
        error_log  /var/log/gitlab.example.com.nginx_error.log debug;
        location / {
                proxy_pass         https://127.0.0.1:4431/;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
                root   /var/www/nginx-default;
        }
}

Pour terminer:

ln -s /etc/nginx/sites-available/gitlab.example.com sites-enabled/giltab.example.com
/etc/init.d/nginx restart

4 – Première connexion

Rendez vous sur https://gitlab.example.com/ pour la première authentification.
Saisissez deux fois un mot de passe que vous choisissez et connecter vous avec l’utilisateur root et ce mot de passe.

Pour empêcher la création de compte allez sur: https://gitlab.example.com/admin/application_settings

5 – Mise à jour de l’image

Avec docker-compose, il suffit de lancer les commande suivantes:

docker-compose pull 
docker-compose up

Dans un prochain article, j’aborderai comment créer des backups et les restaurer.

Tutoriel réalisé sous Ubuntu Xenial (16.04 LTS)

sources:
https://docs.gitlab.com/omnibus/docker/
https://forum.gitlab.com/t/nginx-as-reverse-proxy-for-gitlab-with-ssl/1641
https://docs.gitlab.com/omnibus/settings/nginx.html
https://gitlab.com/gitlab-org/gitlab-recipes/raw/master/web-server/nginx/gitlab-omnibus-ssl-nginx.conf
ttps://gitlab.com/gitlab-org/gitlab-ce/issues/1331

The post Installer Gitlab en https avec Docker et Nginx appeared first on www.php-geek.fr.

mysql -h localhost -u root -p -e "SHOW DATABASES LIKE 'mon_prefix_%';" > ~/databases-list

The post MySQL: afficher la liste des bases de données qui ressemblent à un certain modèle appeared first on www.php-geek.fr.

iptables -A INPUT -s AA.BB.CC.DD -j DROP

Dé-bannir une IP

iptables -D INPUT -s AA.BB.CC.DD -j DROP

Liste des adresses bannies:

iptables -L INPUT -v -n

The post Linux/Debian: bannir/dé-bannir une adresse IP appeared first on www.php-geek.fr.

Premièrement il faut récupérer l’IP du serveur ou est hébergé T411. On peut pour cela utiliser un service web de « ping » comme https://cloudmonitor.ca.com/en/ping.php

Avec ce service, on voit que T411 est hébergé sur deux IP différentes:

108.162.204.254
108.162.203.254

Il suffit alors d’en prendre une au hasard et d’ajouter ce qui suit dans votre fichier hosts.
Sous Ubuntu, le fichier est localisé dans /etc/hosts

108.162.203.254 www.t411.io 
108.162.203.254 t411.io
108.162.203.254 www.t411.me
108.162.203.254 t411.me
108.162.203.254 forum.t411.io
108.162.203.254 forum.t411.me
108.162.203.254 tracker.t411.me
108.162.203.254 tracker.t411.io

Et voilà !

The post T411 – comment contourner le blocage DNS avec le fichier hosts appeared first on www.php-geek.fr.

Ce réglage se fait en passant l’option PDO::ATTR_TIMEOUT (constante de la classe PDO qui vaut 2) au driver pdo_mysql. Cette option marchera aussi pour certains autres pilotes mais sa signification peut différer (avec sqlite par exemple).

Avec Zend, il faut définir cette option lors de la création de l’adapter soit en utilisant Zend_Db::factory soit en créant une nouvelle instance de Zend_Db_Adapter_Pdo_Mysql.

Exemple avec un timeout de 10 secondes en utilisant Zend_Db::factory:

      $driverOptions = array(
          PDO::ATTR_TIMEOUT => 10
      );

      $params = array(
        'host' => '127.0.0.1',
        'port' => '3306',
        'username' => 'user',
        'password' => 'password',
        'dbname' => 'my_db',
        'driver_options' => $driverOptions
      );
      $adapter = Zend_Db::factory('pdo_mysql', $params);

sources/docs:
PDO::setAttribute
documentation Zend_Db_Adapter

The post Zend: regler le timeout des connexions MySQL avec pdo_mysql appeared first on www.php-geek.fr.

1script.fr

La plateforme permet de partager ou vendre un script de manière simplifiée et propose une large choix de langages et de catégories. Une section CV est également disponible pour se mettre en avant.

Pour les intéressés je vous invite à visiter la bêta-test sur 1script.fr  en utilisant une clé si dessous:

b3a19b6f1498b90e05781778874dd8d6f2211a61
6aa9badac2ca4b68c095568763fb2d065fc2b0b7
8712e0f3fb29fc9d2416a0564471e9f9365fcada
fcac0af3fe6d8a953562997b85a8ba6fb7d6aaf6
c1e3d2cbe45a77de96ed55f96fabda62f52f69e6
0eee120ab864cfce232bbfee50f3a45a1f24c5b8
42a66039d8b7d99bcc3e0714911a150b832009be
c9f3841cc868d201cdcb41d5c4c0c0c34e19af4b
a41ba8b9756495db7d4712f6ac8233503bfb5fe8
759e59104e3068065a1e3417a28307d93bb19185

Attention chaque clé est à usage unique.

Vidéo explicative

Liens utiles

• Le site: http://www.1script.fr/
• Facebook: https://www.facebook.com/1script.fr
• Twitter: https://twitter.com/1scriptfr

The post 1script.fr : une plateforme française pour les développeurs appeared first on www.php-geek.fr.

Exemple avec le namespace « bootstrap-styles »:

.bootstrap-styles textarea {
overflow: auto;
}
.bootstrap-styles optgroup {
font-weight: bold;
}

Pour encapsuler bootstrap, il faut compiler le fichier bootstrap.less à l’aide de Grunt.

Installation de Grunt

Installation de Node.js

sudo apt-add-repository ppa:chris-lea/node.js
sudo apt-get update
sudo apt-get install nodejs

Installation de Git

sudo  apt-get install git git-core

Clonage de bootstrap depuis github

git clone https://github.com/twbs/bootstrap.git

Installation de Grunt

sudo npm install -g grunt-cli
cd bootstrap
sudo npm install

Compilation

Editer le fichier bootstrap.less pour ajouter la classe bootstrap-styles autour de tous les imports:

cd less/
vim bootstrap.less

contenu de bootstrap.less

.bootstrap-styles {
// Core variables and mixins
@import "variables.less";
@import "mixins.less";

[...]
// Utility classes
@import "utilities.less";
@import "responsive-utilities.less";
}

Pour compiler le CSS et le Javascript:

grunt dist

Les fichiers compilés se trouveront ensuite dans le dossier dist.

Attention, même les sélecteurs html et body seront préfixés de .bootstrap-styles. Étant donné que les balises html et body sont rarement entourées de balises div dans le code source d’une page web, il faut donc supprimer ou modifier ces deux entrées dans le fichier bootstrap.css

Testé sous Ubuntu 14.04 serveur

sources:

• http://doc.ubuntu-fr.org/nodejs
• https://github.com/twbs/bootstrap/blob/master/README.md
• http://getbootstrap.com/getting-started/
• http://stackoverflow.com/questions/13966259/how-to-namespace-twitter-bootstrap-so-styles-dont-conflict

The post Compiler et encapsuler Twitter Bootstrap dans un namespace appeared first on www.php-geek.fr.

Dans la doc officielle de WP il est précisé que pour autoriser les utilisateurs à poster des marqueurs HTML ou du JavaScript il faut que le rôle auquel ils sont associés ait la capacité « unfiltered_html ».

Cependant si l’ont fait un test en ajoutant ce bout de code dans le fichier functions.php du thème:

$role = get_role( 'administrator' );//récupération du rôle "administrator"
$role->add_cap( 'unfiltered_html' ); //ajout de la capacité "unfiltered_html"

on se rend compte que cela ne fonctionne pas..

En fouillant un peu pour résoudre mon problème j’ai trouvé ce plugin: WP-Admin-Unfiltered-HTML qui fonctionne très bien.

Attention cependant à ne donner cette capacité qu’à une personne de confiance

source: Documentation WP

The post WordPress: permettre aux administrateurs d’ajouter du JavaScript dans un widget ou article appeared first on www.php-geek.fr.