Original post of crowd42.Votez pour ce billet sur Planet Libre.

Une des choses redondantes dans un projet, c’est le contrôle d’accès. Savoir jusqu’où un utilisateur non connecté peut aller, ou même limiter les droits de certains utilisateurs.
Le truc basique c’est de checker soit dans le constructeur du contrôleur, soit dans chaque fonction du contrôleur si l’utilisateur a les droits suffisants pour continuer. Or lorsque le projet atteint une certaine ampleur, il devient vite contraignant et lourd de rajouter ce contrôle à chaque fonction.

Étendre la classe controller

Au début, je pensais créer un hook pre-controller mais toutes les fonctionnalités dont j’avais besoin n’étaient pas chargées. Du coup j’étends la classe controller afin que chaque contrôleur commence par checker l’accès avant d’aller plus loin.

Pour étendre la classe controller il faut créer un fichier /application/core/MY_Controller.php

Préparer les liens accessibles sans connexion
Ici je définis tous les liens ( controleur/fonction ) qui peuvent être accessibles sans connexion. Pour moi c’est plus simple dans ce sens, il est possible de faire l’inverse s’il y a plus d’endroits accessibles sans connexion qu’avec connexion.

Je créé donc un tableau avec les fonctions qui n’ont pas besoin de contrôle d’accès. C’est utile de mettre les fonctions car on peut très bien imaginer une fonction profil dans le contrôleur user, qui aurait besoin d’un contrôle d’accès.
Mise en place du contrôle d’accès

    protected $_no_access_control = array (
        'utilisateur/nouveau',
        'utilisateur/connexion'
    );

    public function __construct() {
        parent::__construct();
 
        $this->_check_auth();
    }
 
    // Vérifie les authorisations
    private function _check_auth() {
        // Construction de l'uri
        $uri = $uri = $this->router->fetch_class() . '/' . $this->router->fetch_method();
 
        // Si la personne n'est pas connecté et qu'elle veut aller sur un lien non autorisé
        if ( ! $this->session->userdata('login') && ! in_array($uri, $this->_no_access_control) ){
            $this->_kick();
        }
    }
 
    // Redirige les requetes non authorisées
    private function _kick() {
        if ( $this->input->is_ajax_request() ) {
            $response = array('status' => 'disconnected');
            echo (json_encode($response));
            die();
        }
        else {
            redirect('accueil');
        }
    }
}
Voila tout est fait.
Explications:
A chaque chargement du contrôleur, on construit l’URI pour n’avoir que le contrôleur et sa fonction. On vérifie à partir de la session si la personne est connectée et si l’url qu’elle demande lui est autorisée. Avec cet exemple simple, un utilisateur non connecté peut accéder qu’aux liens présents dans le tableau. Pour tous les autres il doit être connecté. Lorsque l’utilisateur n’est pas accepté, il est redirigé directement vers l’accueil.
Maintenant c’est bien beau, mais il va falloir modifier chaque contrôleur afin de les étendre à partir de notre nouveau contrôleur de base.
class Utilisateur extends MY_Controller {

}
Conseil d’utilisation de ce système:
Si vous n’avez pas du tout besoin du contrôle d’accès dans votre contrôleur, vous créez votre contrôleur normalement ( extends CI_Controller ).
Si au moins une fonction de votre contrôleur a besoin du contrôle d’accès alors vous créez à partir de votre contrôleur étendu ( extends MY_Controller ).


Original post of Maxime CHAILLOU.Votez pour ce billet sur Planet Libre.

Trop souvent (Debian/Ubuntu!) je tombe sur cette erreur dans un Nagios :


Error: Could not stat() command file ‘/var/lib/nagios3/rw/nagios.cmd’!

The external command file may be missing, Nagios may not be running, and/or Nagios may not be checking external commands. An error occurred while attempting to commit your command for processing.

La solution est pourtant simple, il suffit pourtant dans le fichier /etc/nagios/nagios.cfg de passer à 1 la valeur de la directive check_external_commands puis d’exécuter :


dpkg-statoverride --update --add nagios www-data 2710 /var/lib/nagios3/rw
dpkg-statoverride --update --add nagios nagios 751 /var/lib/nagios3
service nagios3 restart


Original post of Morot.Votez pour ce billet sur Planet Libre.

Dans un précédent billet, je parlais de l'ajout de l'application Documents à solution d'informatique dans les nuages ownCloud. Je n'avais pas réussi à la tester mais c'est maintenant chose faite.

Je vous propose de regarder ce qu'il se cache derrière Documents.

Ma configuration de test se résume à mon PC portable sous Debian Wheezy/Testing, apache2, Firefox et du Pink Floyd. Le tout en local. J'ai commencé avec la première version beta et j'ai terminé avec la deuxième. Il peut donc y avoir des petites différences entre certaines captures d'écran, rien de bien méchant dans l’ensemble.

Une nouvelle application

Qui dit nouvelle application dans votre instance ownCloud dit nouvelle icône. Documents va logiquement se glisser dans la barre d'outils latérale. Un simple clique et vous êtes à la maison.

Documents va naturellement chercher les fichiers compatibles dans les répertoires que contient votre instance. Il vous est quand même possible d'en créer des nouveaux ou d'en téléverser d'autres depuis l'application elle-même.

Partage des documents

Le système de partage est exactement le même que celui que nous avons nous utilisons déjà. Il n'y a pas de quoi se tromper, rien de nouveau de ce côté. Il se rapproche de celui qui sert à partager les images.

Accédez au document que vous voulez partager, chercher le groupe ou l'utilisateur avec lequel vous voulez bosser et partagez.

On retrouve les options ordinaires : partager avec les utilisateurs, partager via un lien, ajouter un mot de passe et donner un date d'expiration au partage.

Les utilisateurs connectés au document partagé s'affichent dans une simple colonne de droite, avec leur image de profil s'ils en ont une ou la première lettre leur login par défaut.

Les possibilités offertes par Documents

Si on regarde la concurrence, il faut être honnête, il n'y a pas encore de quoi sauter au plafond. Ceci-dit, tout est configurable.

De base, on retrouve 7 styles, dont les différences ne sautent pas tout de suite aux yeux :

• Default Style
• Standard
• Heading
• Text Body
• List
• Caption
• Index

Comme je le dis plus haut, tout est configurable. Pour ajouter un nouveau style : cliquez sur Format et laissez vous aller.

Voici deux captures d'écran pour vous présenter les deux onglets pleins d'options :

On est à la limite du DIY (Do It Yourself) mais avec un peu de préparation, on peut configurer toutes les façons que l'on veut d'écrire du texte. Un exemple :

Oui, c'est moche mais c'est un exemple.

Les autres trucs

• J'ai cherché et je n'ai pas trouvé comment supprimer un style créé. En en créant un, j'ai fait une faute de frappe : je ne peux pas le supprimer, arf.

• Manipulation des images, des liens, des tableurs, etc : y'a pas. Gageons que ça va venir.

• J'ai testé l'application avec un document assez conséquent. Le résultat n'est pas vraiment mauvais : seules les images disjonctent de temps en temps.

Pour finir, je remarque que la propagation des modifications n'est pas franchement rapide. C'est sans doute un petit défaut de jeunesse mais ça m'inquiète, étant auto-hébergé. J'ai un débit en upload très lent et je crains des délais de latence horriblement long.

Voilà pour le rapide tour d'horizon !

Original post of dada.Votez pour ce billet sur Planet Libre.

Me voila avec un index flambant neuf ( ou presque) importé en presque 30 minutes. Je n'ai plus qu'à rechercher. Voici ce qu'on peut faire assez simplement "out of the box":

Via l'interface d'administration

L'interface d'administration possède déjà un outil de recherche assez simple d'utilisation. On renseigne le critère de recherche et on obtient la réponse au format souhaité ( JSON, XML, PYTHON, CSV,...)

Cette option peut être intéressante pour une interface d'administration

Via une requête REST

J'ai fait un simple appel REST avec JERSEY pour effectuer la même requête. J'ai utilisé le mapping des POJO pour mapper la réponse à mon bean.

On retrouve les mêmes paramètres

public class RESTQueryTest {

 
    private final static String QUERY_URL = "http://127.0.0.1:8080/customers/customers/select";

    public static final int HTTP_STATUS_OK = 200;

    private Client client;

    private WebResource queryWebResource;

    private ClientConfig clientConfig;

    private String MAX_ROWS;

 
    @Before
    public void setUp() throws Exception {

        clientConfig = new DefaultClientConfig();

        clientConfig.getFeatures().put(JSONConfiguration.FEATURE_POJO_MAPPING, Boolean.TRUE);

        client = Client.create(clientConfig);

        queryWebResource = client.resource(QUERY_URL);

    }

 
    @Test
    public void testQueryByLastName() throws Exception {

        MultivaluedMap<String, String> parameters = new MultivaluedMapImpl();

        parameters.add("q", "lastname:JAN");

        parameters.add("wt", "json");

 
        ClientResponse response = queryWebResource.queryParams(parameters).type(MediaType.TEXT_PLAIN_TYPE).
                accept(MediaType.APPLICATION_JSON_TYPE, MediaType.TEXT_PLAIN_TYPE).get(ClientResponse.class);

        assertEquals(response.getStatus(), HTTP_STATUS_OK);

    }

 
    @Test
    public void testQueryFuzzy() throws Exception {

        MultivaluedMap<String, String> parameters = new MultivaluedMapImpl();

        final String FUZZY_QUERY_BY_LASTNAME = "lastname:JAN~";

        parameters.add("q", FUZZY_QUERY_BY_LASTNAME);

        parameters.add("wt", "json");

        parameters.add("indent", "true");

        final int MAX_ROWS = 20;

        parameters.add("rows", String.valueOf(MAX_ROWS));

 
        ClientResponse response = queryWebResource.queryParams(parameters).type(MediaType.APPLICATION_JSON_TYPE).
                accept(MediaType.APPLICATION_JSON_TYPE, MediaType.TEXT_PLAIN_TYPE).get(ClientResponse.class);

        assertEquals(response.getStatus(), HTTP_STATUS_OK);

        SOLRResponse<CustomerResource> solrResponse=response.getEntity(new GenericType<SOLRResponse<CustomerResource>>(){});

        assertNotNull(solrResponse);

        assertEquals(solrResponse.getResponse().getDocs().size(), MAX_ROWS);

        assertEquals(solrResponse.getResponseHeader().getParams().getQuery(),FUZZY_QUERY_BY_LASTNAME);

    }

}

La classe SOLRResponse décrit la réponse JSON, Elle est annotée avec JAXB.

@XmlRootElement

public class SOLRResponse<T> {

 
    private SOLRResponseHeader responseHeader ;

    private SOLRResponseBody<T> response;

 
    public SOLRResponseBody<T> getResponse() {

        return response;

    }

 
    public void setResponse(SOLRResponseBody<T> response) {

        this.response = response;

    }

 
    public SOLRResponseHeader getResponseHeader() {

        return responseHeader;

    }

 
    public void setResponseHeader(SOLRResponseHeader responseHeader) {

        this.responseHeader = responseHeader;

    }

 
 
}

J'ai rendu cette réponse générique pour ensuite appliquer ce que l'on veut dans les documents (ex. Classe CustomerResource)

Via l'API SOLRJ

Pré-requis

Ajouter la dépendance solr au projet

>
            >org.apache.solr>

            >solr-solrj>

            >${solr.version}>

        >

Je trouve cette solution beaucoup plus simple à mettre en oeuvre. Elle prend dynamiquement les champs de la réponse ( qui peuvent changer selon les paramètres d'appels ). De plus il n'y a pas besoin de décrire l'enveloppe de la réponse comme en REST.

public class JavaQueryTest {

 
    private final static String QUERY_URL = "http://127.0.0.1:8080/customers/customers";

    private HttpSolrServer solrServer;

    private SolrQuery solrQuery;

 
    @Before
    public void setUp() throws Exception {

        solrServer = new HttpSolrServer(QUERY_URL);

        solrServer.setAllowCompression(true);

        solrServer.setMaxRetries(5);

        solrQuery = new SolrQuery();

    }

 
    @Test
    public void testQueryFuzzy() throws Exception {

        solrQuery.setQuery("TOURET~");

        solrQuery.addSort("dtcrea", SolrQuery.ORDER.asc);

        QueryResponse response = solrServer.query(solrQuery);

        assertNotNull(response);

        assertNotNull(response.getResults());

        assertFalse(response.getResults().isEmpty());

        System.out.println("Premier champ:" + response.getResults().get(1).toString());

        List<CustomerResource> customers = response.getBeans(CustomerResource.class);

        assertNotNull(customers);

        assertFalse(customers.isEmpty());

    }

}

Original post of Littlewing.Votez pour ce billet sur Planet Libre.