flosy.info | Développement Web, Open source …

Sous symfony2 permet de déployer un bundle à l’aide de Composer.
Voyons ensemble comment déployer nos propres bundles à l’aide de Composer.

Nous partons du principe que Composer est installé sur le serveur.

Fichier composer.json

Ce fichier doit être placé à la racine de notre bundle et il va contenir les différentes informations nécessaires à l’installation.
Les différentes propriétés qui le composent sont définies dans la documentation : http://getcomposer.org/doc/04-schema.md.

Voici un exemple :

{
    "name": "flosy/Demo-bundle",
    "description": "Demo Bundle",
    "type": "symfony-bundle",
    "license": "MIT",
    "authors": [
        {
            "name": "Flosy",
            "email": "contact@flosy.info",
            "homepage": "http://www.flosy.info",
            "role": "Developer"
        }
    ],
    "require": {
        "php": ">=5.3.8",
        "symfony/framework-bundle":         "~2.3",
        "twig/twig":                        "*",
        "doctrine/doctrine-bundle":         "*",
    },
    "autoload": {
        "psr-0": { "Flosy\\Bundle\\DemoBundle": "" }
    },
    "target-dir": "Flosy/Bundle/DemoBundle"
}

La propriété license n’est pas indiquée comme obligatoire mais pour soumettre notre bundle à Packagist elle sera requise.

Composer dispose de plusieurs commandes dont une qui permet de valider le fichier composer.json. En plus de valider les erreurs classiques JSON elle vous indiquera les propriétés recommandées pour publier sous forme de package.

  $ composer.phar validate src/Flosy/Bundle/DemoBundle/composer.json
  src/Flosy/Bundle/DemoBundle/composer.json is valid

Déclaration du package

Nous allons utiliser GitHub comme un dépôt pour notre Bundle puis nous le référencerons dans Packagist.

La déclaration d’un package pour Composer s’effectue par le biais du site packagist.org.
Pour référencer un bundle il vous faudra créer un compte ou passer par une authentification via GitHub.

Une fois connecté à Packagist il suffit de donner l’url du dépôt pour soumettre le package.

Une dernière étape optionnelle permet de mettre à jour automatiquement le package lors des mises à jour du dépôt GitHub.
Ceci s’effectue grâce au Service Hooks proposés par GitHub (menu Settings du dépôt GitHub).
Dans le cas du service Packagist il suffit de renseigner les champs suivants :

  • User avec le username présent dans le profile Packagist.
  • Token avec l’API token présent dans le profile Packagist.
  • Domain qui correspond au nom de notre bundle « flosy/demo-bundle » (défini dans le fichier composer.json).

Webographie

Article très complet http://www.idci-consulting.fr/creer-un-bundle-symfony2-reutilisable-et-le-diffuser-via-composer/.

La documentation http://getcomposer.org/doc/

Related Posts:

· ·

Symfony fournit un système d’ACL qui par défaut utilise un OU logique sur les droits. Voici un extrait du fichier security.yml :

security:
    access_control:
        - { path: ^/css/compile.*$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/js/compile.*$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/user/is_authenticated, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/user, roles: [ROLE_ADMIN, ROLE_MANAGE_USER] }

Dans cette configuration par défaut l’utilisateur accède à /user s’il dispose du rôle ROLE_ADMIN ou ROLE_MANAGE_USER.

Ce fonctionnement ne correspond pas à celui attendu. Dans le projet nous souhaitons que l’utilisateur ait les 2 droits pour accéder à /usr.

Pour cela nous changeons la stratégie de décision d’accès :

security:
    access_decision_manager:
        # strategy can be: affirmative, unanimous or consensus
        strategy: unanimous

    access_control:
        - { path: ^/css/compile.*$, role: IS_AUTHENTICATED_ANONYMOUSLY }

Si vous souhaitez aller plus loin vous trouverez l’explication sur le fonctionnement de l’Access Decision Manager dans la documentation du composant (http://symfony.com/doc/master/components/security/authorization.html).

Related Posts:

· ·

Le but recherché est ici d’écrire une trace lors de la déconnexion de l’utilisateur.

L’une des solutions est de passer par un service qui sera appelé par le LogoutListener.

Souscription à l’évènement LogoutSuccess

Pour savoir comment gérer cela référons-nous à la documentation sur la configuration de la sécurité (http://symfony.com/doc/current/reference/configuration/security.html ).

Le firewall permet de préciser un service qui sera appelé en cas de succès de la déconnexion.


logout:
  path:   /logout
  target: /
  success_handler: flosy.user.logout.handler

Création du service

Il nous reste maintenant à créer ce service.
Pour cela créons le fichier LogoutHandler.php

< ?php
namespace Flosy\Bundle\UserBundle\Handler;
 
use Flosy\Bundle\CommonBundle\Model\EventLogManager;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\Security\Http\Logout\LogoutSuccessHandlerInterface;
 
/**
 * Ce Handler permet de gérer des actions lors de la déconnexion de l'utilisateur.
 */
class LogoutHandler implements LogoutSuccessHandlerInterface {
 
    protected $elm;
 
    public function __construct(EventLogManager $elm)
    {
        $this->elm = $elm;
    }
 
    /**
     * Opération réalisées suite à la deconnexion.
     * 
     * @param \Symfony\Component\HttpFoundation\Request $request
     * @return \Symfony\Component\HttpFoundation\RedirectResponse
     */
    public function onLogoutSuccess(Request $request)
    {
        $this->elm->add('Log de deconnexion');
 
        $response = new RedirectResponse($request->headers->get('referer'));
        return $response;
    }
}

La classe doit implémenter l’interface LogoutSuccessHandlerInterface et plus particulièrement la méthode onLogoutSuccess qui sera appelée par le LogoutListener.
Pour l’écriture nous faisons appel à un autre service que nous ne détaillerons pas ici.

Déclaration du service

Il nous reste à déclarer le service.
Nous éditons pour cela le fichier services.xml de notre bundle.

< ?xml version="1.0" ?>
 
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
 
    <services>
        <service id="flosy.user.logout.handler" class="Flosy\Bundle\UserBundle\Handler\LogoutHandler">
            <argument type="service" id="flosy.common.eventlog.manager"></argument>
        </service>
    </services>
</container>

Maintenant à chaque déconnexion un log sera écrit.

Webographie

L’article suivant traite de la gestion des redirections à la connexion et à la déconnexion à l’aide de ses services.

http://www.reecefowell.com/2011/10/26/redirecting-on-loginlogout-in-symfony2-using-loginhandlers/

Related Posts:

· ·

L’hébergement de 1and1 permet de disposer de d’un dépot GIT. Pour cela nous allons commencer par créer le dépôt.

  $ ssh moncompte@flosy.info
  $ mkdir git
  $ cd git
  $ git init --bare monDepot.git

Ensuite je crée un dépôt local.

  $ mkdir monDepot
  $ cd monDepot
  $ git init
  $ git add .
  $ git commit

Maintenant j’ajoute un remote et j’envoie le dépôt local vers le dépôt distant.

  $ git remote add origin ssh://moncompte@flosy.info/~/git/monDepot.git
  $ git push origin master

Related Posts:

Le déploiement d’un projet est toujours une étape fastidieuse et parfois complexe.
Pour automatiser cela nous pouvons utiliser un outil comme Fabric qui va nous permettre de scripter notre déploiement.
J’ai découvert cet outil dans la présentation Adopt Devops philosophy on your Symfony projects de Fabrice Bernhard lors de la conférence symfony live 2011.

Fabric est un outil écrit en Python et disponible sur le site suivant : http://docs.fabfile.org/en/latest/index.html.

Installation

Il est recommandé de passer par pip pour installer Fabric. Pip n’est pas installé de base sur la Fedora. Il est cependant disponible sous forme de package.

  # yum install python-pip

Pip va nous permettre d’installer Fabric grâce à la commande suivante :

  # pip-python install fabric

Note : Dans mon cas cela n’a pas fonctionné directement. En effet Fabric a comme dépendance la bibliothèque PyCrypto qui va être compilée par pip. Il m’a fallu installer le package python-devel.

Utilisation

À titre d’exemple nous allons créer un fichier fabric qui va nous permettre de créer un projet symfony et de lui associer un dépôt GIT.

Nous créons le fichier fabfile.py dans le dossier parent du futur projet (dans mon cas /var/www/symfony2).

from fabric.api import *
 
version_symfony = 'Symfony_Standard_2.0.12.tgz'
url_symfony = 'http://symfony.com/download?v=' + version_symfony
 
def install_symfony(project_name):
  local("wget " + url_symfony)
  local("tar xzvf " + version_symfony)
  local("rm " + version_symfony)
  local("mv Symfony " + project_name)
  local("cp %s/app/config/parameters.ini %s/app/config/parameters.ini.dist " % (project_name, project_name))
 
def create_repository(project_name):
  local('touch ./%s/.gitignore' % project_name)
  ignore_file = open('./%s/.gitignore' % project_name, 'w')
  ignore_file.write("""/web/bundles/
/app/bootstrap*
/app/cache/*
/app/logs/*
/vendor/
/app/config/parameters.ini""")
  with lcd(project_name):	# Context managers lcd pour local, cd pour remote (run).
    local('git init ')
    local('git add .')
    local('git commit -m  "Initial commit"')
 
def install_vendors(project_name):
  with lcd(project_name):
    local('php bin/vendors install')
 
def install(project_name):
  install_symfony(project_name)
  create_repository(project_name)
  install_vendors(project_name)

Le fichier décompose l’installation en 3 fonctions :

install_symfony
Installe une version donnée de symfony sans les vendors.
create_repository
Gère toutes les opérations nécessaires à la création du dépôt GIT.
install_vendors
Installe les vendors.

La fonction install nous sert de facade.

Nous pouvons donc les appeler successivement ou utiliser la facade.

  $ fab install_symfony:symfabric
  $ fab create_repository:symfabric
  $ fab install_vendors:symfabric

ou

  $ fab install:symfabric

Vous noterez l’utilisation du context manager lcd qui permet de spécifier un dossier de travail pour un groupe d’instructions.
Dans le cas d’un accès distant il convient d’utiliser le context manager cd.

Connexion sur un hôte distant

Nous allons utiliser une connexion ssh par clé. Pour cela nous allons ajouter sur l’hôte distant, la clé publique dans le fichier .ssh/authorized_keys.
Attention à donner les bons droits au fichier :

  $ chmod 600 .ssh/authorized_keys

Pour l’exemple je vous renvoie vers le très bon exemple de la présentation de Fabrice Bernhard disponible sur GitHub.

Related Posts:

  • No Related Posts

No tags

Sep/11

7

Projet Spring avec SQL Server

Ce post décrit les différentes étapes suivies pour connecter un projet Spring au travers d’Hibernate à une BDD SQL Server. Il s’agit d’une première aussi je suis très intéressé par tout retour.

Installation du driver

Après avoir téléchargé et décompressé le fichier (disponible ici), se placer dans le dossier qui contient le JAR.
La commande suivante permet d’ajouter le JAR au dépôt Maven local.

mvn install:install-file -Dfile=sqljdbc4.jar -DgroupId=com.microsoft.sqlserver -DartifactId=sqljdbc4 -Dversion=3.0 -Dpackaging=JAR

Nous pouvons maintenant ajouter la dépendance suivante dans le pom.xml.

 <dependency>
  <groupid>com.microsoft.sqlserver</groupid>
  <artifactid>sqljdbc4</artifactid>
  <version>3.0</version>
 </dependency>

Configuration de SQL Server Express

Pour cet exemple nous utilisons SQLServer Express 2008. Suite à l’installation le connexion TCP/IP n’était pas disponible. Pour l’activer il convient de passer par le gestionnaire de configuration SQL Server (Sql Server Configuration Manager) .

Un clic droit sur TCP/IP donne accès à propriétés. Dans l’onglet Protocole, vérifiez que la ligne Activé est à Oui.

Dans l’onglet Adresses IP vérifiez que celle utilisée est activée. Vérifiez également que l’entrée IPALL précise le port TCP 1433.

Configuration de Hibernate

Dans la configuration suivante nous avons utilisé le compte administrateur défini dans SQL Server Express et le schéma par défaut dbo.

  <hibernate -configuration>
    <session -factory>
        <property name="hibernate.connection.driver_class">com.microsoft.sqlserver.jdbc.SQLServerDriver</property>
        <property name="hibernate.connection.url">jdbc:sqlserver://127.0.0.1;databaseName=myDatabase</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password">myPassword</property>
        <property name="hibernate.default_schema">dbo</property>
        <property name="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</property>
 
        <!-- Log -->
        <mapping class="info.flosy.global.model.Log"/>
 
    </session>
  </hibernate>

Définition du modèle

Table associée

CREATE TABLE [dbo].[log](
	[ID] [INT] IDENTITY(1,1) NOT NULL,
	[ADD_AT] [datetime] NULL,
	[message] [nvarchar](4000) NULL,
 CONSTRAINT [PK_log] PRIMARY KEY CLUSTERED 
(
	[ID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
 
GO

Nous avons choisi d’utiliser une clé primaire auto-incrémentée. Ceci implique l’utilisation de l’annotation @GeneratedValue(strategy=GenerationType.IDENTITY).

Sans cette annotation nous obtenons l’erreur suivante :

WARN : org.hibernate.util.JDBCExceptionReporter - SQL Error: 544, SQLState: S0001
ERROR: org.hibernate.util.JDBCExceptionReporter - Impossible d'insérer une valeur explicite dans la colonne identité de la table 'log' quand IDENTITY_INSERT est défini à OFF.
ERROR: org.hibernate.event.def.AbstractFlushingEventListener - Could not synchronize database state with session
package info.flosy.global.model;
 
import java.util.Date;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
 
/**
* Log generated by hbm2java
*/
@Entity
@Table(name = "log", catalog = "myDatabase")
public class Log implements java.io.Serializable {
 
	private int id;
	private Date addAt;
	private String message;
 
	public Log() {
	}
 
	public Log(int id) {
		this.id = id;
	}
 
	public Log(int id, Date addAt, String message) {
		this.id = id;
		this.addAt = addAt;
		this.message = message;
	}
 
	@Id
	@Column(name = "ID", unique = true, nullable = false)
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public int getId() {
		return this.id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	@Temporal(TemporalType.TIMESTAMP)
	@Column(name = "ADD_AT", length = 23)
	public Date getAddAt() {
		return this.addAt;
	}
 
	public void setAddAt(Date addAt) {
		this.addAt = addAt;
	}
 
	@Column(name = "MESSAGE")
	public String getMessage() {
		return this.message;
	}
 
	public void setMessage(String message) {
		this.message = message;
	}
}

Related Posts:

  • No Related Posts

· ·

Google propose maintenant l’API Google Static Maps API qui permet d’intégrer Google Maps sans avoir à créer une clé API.

Ce service intègre la carte sous forme d’une image sans recourir au JavaScript.

Le service comporte un grand nombre de fonctionnalités dont :

  • Le positionnement de markers fonction d’une adresse ou de coordonnées géolocalisées.
  • La gestion de parcours.
  • ou encore la personnalisation du style de la carte.

Related Posts:

  • No Related Posts

·

Installation et configuration du serveur

Le serveur utilisé pour l’installation est une Fedora 15.
La première étape passe par l’installation de l’extension PHP.

# yum install php-pecl-xdebug

Le package crée automatiquement le fichier de configuration /etc/php.d/xdebug.ini.
Il reste à le compléter avec les valeurs fournies dans la documentation de NetBeans disponible ici.

zend_extension=/usr/lib/php/modules/xdebug.so
xdebug.remote_enable=1
xdebug.remote_handler=dbgp
xdebug.remote_mode=req
xdebug.remote_host=127.0.0.1
xdebug.remote_port=9000

Après avoir redémarré Apache, Xdebug apparait dans le phpinfo.

Configuration de NetBeans

Il reste à configurer le projet dans NetBeans de la façon suivante :

À partir de là Netbeans va vous permettre d’utiliser Xdebug.

Related Posts:

· · ·

Juin/11

24

Traduc Party KDE (1ère partie)

Voici une transcription de la traduc party KDE organisée par le LUG Alternatives87.

Nous commençons par récupérer les documentations du projet pour gérer leur traduction et alimenter la mémoire de traduction de lokalize.
Pour cela nous allons utiliser le svn anonyme du projet (toutes les explications sont là).

Une version Web du dépôt SVN va nous permettre d’identifier les éléments qui nous intéressent.

Récupération des sources

Tout d’abord nous créons un dossier pour accueillir notre copie de travail.

$ mkdir depot_traductions
$ cd depot_traductions

Nous procédons ensuite à la récupération des documentations en français.
Vous noterez l’utilisation de l’option -N qui permet de passer en mode non récursif. Ceci permet de récupérer uniquement les éléments nécessaires.

$ svn co svn://anonsvn.kde.org/home/kde/trunk -N
A    trunk/.git-checkout
Révision 1238075 extraite.
 
$ cd trunk/
$ svn update l10n-kde4 -N
A    l10n-kde4
A    l10n-kde4/teamnames
A    l10n-kde4/subdirs
A    l10n-kde4/README
Actualisé à la révision 1238075.
 
$ cd l10n-kde4/
$ svn up fr
A    fr
A    fr/messages
....
A    fr/docmessages/playground-games/kbackgammon.po
Actualisé à la révision 1238075.

Compilation d’une documentation

La compilation de la documentation nécessite les éléments présents dans le dossier scripts de l10n-kde4.

$ svn up scripts
A    scripts
A    scripts/posieve_check-tp-kde_results_to_webpage.sh
...

Nous récupérons également les éléments suivants bien qu’ils ne soient pas nécessaires à la compilation de la documentation.

$ svn up templates
A    templates
...
 
cd ..
$ svn up l10n-support -N
A    l10n-support
A    l10n-support/subdirs-w-summit
A    l10n-support/README
A    l10n-support/subdirs
Actualisé à la révision 1238075.

Pour générer la documentation plaçons-nous dans le dossier trunk/l10n-kde4. La commande suivante va nous permettre de générer la documentation en docbook.

$ ./scripts/update_xml fr extragear-graphics kiconedit

Ce script gère la création d’un dossier documentation dans l10n-kde4. Il y place les documentations anglaises à traduire.

Attention sous la Fedora 14 il me manquait md5deep. Voici le package a installer :

# yum install md5deep

Related Posts:

· ·

À ma grande surprise après avoir lancé la commande pour désactiver mon projet le site reste actif.

$ symfony project:disable prod
>> file+     /var/www/symfony/flosy/data/frontend_prod.lck
>> enable    frontend [prod] has been DISABLED

Pour que le verrouillage d’une application soit pris en compte, il faut le paramétrer au niveau de chaque application. Éditez le fichier settings.yml de l’application et ajoutez le paramètre check_lock.

all:
  .settings:
    # Enable project locking
    check_lock:             on

Comme vous l’aurez deviné ce paramètre est par défaut à off (cf. documentation).

Related Posts:

·

Older posts >>

Theme Design by devolux.nh2.me