Avant toute chose, commençons par rappeler que FeedReader n’a rien à voir avec… FeedReader, application similaire (mais propriétaire) disponible sous Microsoft Windows.

FeedReader est donc un agrégateur de flux RSS, qui peut utiliser des services en ligne (non libres) comme feedly ou Inoreader, mais également, je vous rassure, des services libres qui peuvent être auto-hébergés, comme ownCloud ou Tiny Tiny RSS. Ça peut également utiliser des services de gestion de listes d’articles comme Pocket, Instapaper ou Readability. Mais là, pour le coup, je n’ai pas trouvé trace de wallabag :-/

L’utilisation d’un service en ligne étant surtout utile si vous aimez bien retrouver facilement tous vos flux sur tous vos écrans, sans avoir à les gérer manuellement sur chacun d’eux.

Au niveau des fonctionnalités, ça propose tout plein de filtres de recherche, la prise en charge des notifications de l’environnement de bureau, le choix parmi différents thèmes de lecture et d’interface, l’ajout d’étiquettes, la catégorisation, le partage d’articles…

Mais pour en revenir à cette nouvelle version, cette dernière apporte les nouveautés suivantes :

• prise en charge d’Inoreader
• ajout d’un mode hors ligne
• ajout d’un mode plein écran
• ajout d’une fenêtre des raccourcis clavier
• ajout d’une option pour changer la taille de police
• possibilité d’ajouter, de supprimer ou de manipuler des flux et des catégories
• possibilité de choisir parmi différents thèmes d’interface (GTK+, foncé, elementary)
• possibilité d’ouvrir un article dans le navigateur en double cliquant dans la liste
• prise en charge de l’authentification http-basic-auth
• l’URL des liens est désormais affichée au bas de l’écran quand on passe le curseur au-dessus de l’un d’eux
• un clic droit sur un lien permet désormais de l’ouvrir ou de le copier
• prise en charge de GTK+ 3.20
• prise en charge des écrans HiDPI
• possibilité de zoomer avec Ctrl + la molette de la souris (ou +/-)

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

Après plus d’un an de développement entre Freya et cette dernière version, Loki est maintenant officiellement disponible au téléchargement.

L’aventure elementary a débuté il y a maintenant plusieurs années et c’est avec la quatrième mouture qui vient d’être libérée en version finale par l’équipe de développement. Voici un récapitulatif des précédentes versions :

• 0.1 Jupiter : sortie en version x86 sur une base d’Ubuntu 10.10 le 11 avril 2011 (fin de support avril 2012).
• 0.2 Luna : disponible sur les architectures x86 et amd64 sur une base d’Ubuntu 12.04 a été libérée le 10 août 2013 (fin de support annoncé avril 2017).
• 0.3 Freya : disponible, comme Luna sur les deux architectures CPU x86 et amd64, le 11 avril 2015, le support de cette version prendra fin en avril 2019.
• 0.4 Loki : disponible depuis le 09 septembre 2016, uniquement pour les architectures CPU amd64

Loki, dans sa phase de développement, n’a été disponible que sous deux versions Beta 1 (en date du 13 juin 2016) & 2 (en date du 16 juillet 2016) à destination du publique, ce qui est extrêmement court en comparaison du cycle de développement de Freya. Cette version, à l’époque, disposait de deux version disponible au publique : la Beta 1 disponible le 10 août 2014, la deuxième Beta fut disponible quant à elle le 08 février 2015 soit 7 mois de développement.

Pourquoi ce compte à rebour ?

La présentation de Loki se fait en grand, en large, façon présentation produit et nous on aime ça, pour suivre le flux en temps réel, c’est par ici.

 

Pour vous permettre disposer de Loki, vous pouvez télécharger l’ISO ou depuis un fichier torrent depuis le site officiel de l’équipe https://elementary.io/fr/

 

Le billet elementary 0.4 Loki est disponible a été publié sur le site de la elementary OS -

Original post of elementary OS.Votez pour ce billet sur Planet Libre.

Après avoir essayé le connecteur de confluent kafka-connect-jdbc, je me suis aperçu qu’il y avait encore quelques bugs qui le rendaient inutilisable dans mon environnement ( notamment avec les champs numériques).

J’ai donc décidé de créer mon propre connecteur. Certes celui-ci sera moins générique mais il correspondra à mon besoin ( ou pas …).

API utilisées

• JAVA8
• API KAFKA CONNECT

Configuration maven

Cette configuration me permet de créer un fat jar avec les dépendances nécessaires à la bonne exécution du connecteur.

Voici mon fichier pom.xml

 

<project xmlns="http://maven.apache.org/POM/4.0.0"?utm_source=rss&utm_medium=rss xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"?utm_source=rss&utm_medium=rss
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0?utm_source=rss&utm_medium=rss http://maven.apache.org/xsd/maven-4.0.0.xsd">?utm_source=rss&utm_medium=rss
    <modelVersion>4.0.0</modelVersion>

    <groupId>info.touret.myconnect</groupId>
    <artifactId>myconnect</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>myconnect</name>
    <url>http://maven.apache.org</url>?utm_source=rss&utm_medium=rss

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <kafka.version>0.10.0.0</kafka.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>LATEST</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-all</artifactId>
            <version>LATEST</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.oracle.weblogic</groupId>
            <artifactId>ojdbc7</artifactId>
            <version>12.1.3-0-0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>connect-runtime</artifactId>
            <version>${kafka.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>connect-api</artifactId>
            <version>${kafka.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>1.7.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <shadedArtifactAttached>true</shadedArtifactAttached>
                            <shadedClassifierName>allinone</shadedClassifierName>
                            <artifactSet>
                                <includes>
                                    <include>*:*</include>
                                </includes>
                            </artifactSet>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>reference.conf</resource>
                                </transformer>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Main-Class></Main-Class>
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>


        </plugins>
    </build>
</project>

Développement

Comme le dit le guide de développement, il faut créer a minima une classe héritant de la classe SourceConnector et une classe héritant de SourceTask.

MySourceConnector

Cette classe permet la récupération de la configuration du connecteur.

public class MySourceConnector extends SourceConnector {

    public static final String TOPIC_CONFIG = "topic";

    private static Logger logger = LoggerFactory.getLogger(MySourceConnector.class);

    public String version() {
        return AppInfoParser.getVersion();
    }

    public void start(Map<String, String> map) {
    }

    public Class<? extends Task> taskClass() {
        return MySourceTask.class;
    }

    public List<Map<String, String>> taskConfigs(int maxTasks) {
        ArrayList<Map<String, String>> configs = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put(TOPIC_CONFIG, "montopic");
        configs.add(map);
        return configs;
    }

    public void stop() {

    }

    public ConfigDef config() {
        return new ConfigDef().define(TOPIC_CONFIG, ConfigDef.Type.STRING, ConfigDef.Importance.HIGH, "Kafka Topic");
    }
}

MySourceTask

Cette classe gère l’exécution de l’extraction et chargement dans KAFKA. Elle permet dans la méthode start() de démarrer le connecteur et de lancer les ressources (connexions JDBC).

Comme le connecteur standard, je m’appuie sur un champ de type Timestamp. celui -ci me permet de créer un offset et de faire un parcours incrémental de mes résultats .

public class MySourceTask extends SourceTask {

    private String topic = null;
    private Logger logger = LoggerFactory.getLogger(MySourceTask.class);
    private Connection connection;
    private PreparedStatement preparedStatement;

    public void start(Map<String, String> props) {
        topic = props.get(MySourceConnector.TOPIC_CONFIG);
        logger.warn("Starting Task ");
        try {
            connection = createConnection(); // connexion jdbc classique
            preparedStatement = connection.prepareStatement("select *from mytable");
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    public List<SourceRecord> poll() throws InterruptedException {
        logger.warn("Polling");
        List<SourceRecord> results = new LinkedList<>();
        try {
// recuperation de la partition
            Map sourcePartition = Collections.singletonMap("table", "mytable"));
// recuperation du dernier offset
            final Timestamp lastRecordedOffset = getLastRecordedOffset(sourcePartition);
            preparedStatement.setTimestamp(1,lastRecordedOffset);
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
// recuperation du champ de type timestamp permettant le chargement incremental
                Timestamp timestamp = resultSet.getTimestamp(18);
// extraction de la ligne (oui je sais c'est bourrin)
                String line = new StringBuilder().append(resultSet.getString(1)).append(resultSet.getString(2)).append(timestamp).toString();
je cree un nouveau offset 
                Map sourceOffSet = Collections.singletonMap("position", new Long(timestamp.getTime()));
                results.add(new SourceRecord(sourcePartition, sourceOffSet, topic, Schema.STRING_SCHEMA, line));
            }
        } catch (SQLException e) {
            throw new InterruptedException(e.getMessage());
        }
        return results;
    }
/**
 * extraction du timestamp du dernier champ extrait. Par defaut, je positionne l'EPOCH
 */
    private Timestamp getLastRecordedOffset(Map<String,Object> partition) {
        Map<String,Object> offset = context.offsetStorageReader().offset(partition);
        Timestamp lastRecordedOffset = Timestamp.from(EPOCH);
        if(offset !=null){
            lastRecordedOffset = new Timestamp((Long)offset.getOrDefault("position",Timestamp.from(EPOCH)));
        }
        return lastRecordedOffset;
    }

    public void stop() {
        try {
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (preparedStatement != null) {
                connection.close();
            }
        } catch (SQLException e) {
            logger.error(e.getMessage(), e);
        }
    }

    public String version() {
        return new MySourceConnector().version();
    }
}

Configuration nécessaire à l’exécution du plugin

Il faudra créer également un fichier properties contenant les informations suivantes :

name=my-connector-source
connector.class=info.touret.MySourceConnector

Exécution

De la même manière que pour le connecteur standard…

Conclusion

Voila le squelette de mon connecteur crée. Pour l’instant les données sont sérialisées de manière un peu brutale. La prochaine étape sera de les mettre au format JSON. La suite dans un prochain numéro…

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

Lorsque l’on est en réunion, que l’on travaille en groupe, il faut prendre des notes. Pour cela, un Framapad, c’est plutôt pratique. Mais dès que vous voulez organiser ces notes, on en revient au tableau blanc avec les sempiternels papiers jaunes à bouts collants (dont on ne doit pas prononcer le nom)…

Du coup, nous on s’est dit « Ce serait-y pas formidable qu’un logiciel libre permette de simuler le tableau blanc et les papiers, de manière collaborative, comme les pads ? »

Et c’est là que nous avons découvert Scrumblr, de Ali Asaria ; qui a eu la belle idée de créer un logiciel compréhensible instinctivement, en deux clics. La suite, vous la devinez…

Framemo expliqué aux kanbanistes agiles

Oui, le tableau blanc, les colonnes et les papiers repositionnables, cela s’appelle du Kanban. Le passage qui suit est donc à réserver aux personnes qui connaissent déjà la méthode (ou veulent un bref aperçu de ce service). Si vous voulez une illustration explicative, pas de soucis, rendez-vous au titre suivant ;) !

Framemo vous propose donc :

• De créer des tableaux kanban en ligne (sans ouverture de compte) ;
• De les partager via l’URL (adresse web) ;
• De travailler collaborativement en temps réel ;
• Le tout en mode cliquer-glisser-déposer ;
• L’édition, l’ajout et la suppression de colonnes ;
• L’édition, l’ajout et la suppression de notes (4 couleurs dispos) ;
• L’ajout ou le retrait de gommettes sur les notes ;
• L’ajout et l’édition du pseudonyme des participant-e-s ;

Ce service est basé sur le logiciel Scrumblr (participez-y ici), sous licence GNU GPL, et notre tuto pour l’installer sur vos serveurs est sur le Framacloud.

L’initiative Cot-Cot-Commons ouvre un Framemo

Prenons l’exemple (purement fictionnel) de Cot-Cot-Commons, une organisation qui voudrait créer un prototype de poulailler Libre (en plus d’être open source) et auto-géré, dans le jardin partagé de l’immeuble de Sandrine. Cette dernière s’y investit (elle aime réduire ses déchets végétaux) mais voit très vite que les idées fusent en réunion sans être forcément notées pour les personnes n’ayant pas pu venir. Qu’à cela ne tienne, lors de la réunion suivante, elle ouvre un Framemo !

Elle se rend donc sur Framemo.org et décide de créer un tableau sobrement intitulé “CotCotCommons“. Pas besoin de créer un compte, il suffit juste de taper le nom de son tableau et de cliquer sur “Allons-y” !

Bon, pour l’instant, il faut avouer que ce n’est pas super entraînant : un tableau tout vide, et quelques boutons “plus” et “moins” ici ou là, de petits points colorés…

En passant sa souris sur la droite du tableau, Sandrine fait apparaître un petit “plus” qui lui permet d’ajouter des colonnes. Lorsqu’elle clique sur leur titres, elle s’aperçoit qu’elle peut en modifier le nom. Sandrine prépare un tableau kanban assez classique (de toutes façons elle voit bien qu’on peut toujours modifier les noms de colonnes par la suite).

Notons au passage que Sandrine a vu qu’il suffisait de cliquer sur “Anonyme (vous)” pour entrer son prénom (ou son pseudo). Étant une habituée des pads, elle sait combien c’est pratique et met vite le sien.

Puis elle commence à noter les idées du compte rendu de la séance précédente. Pour créer une note, elle clique sur le “plus” à gauche sous le tableau. Un petit papier apparaît qui ne demande qu’à être édité, puis déplacé d’un geste de la souris…

Sandrine n’y tient plus, elle finit juste quelques notes avant que de partager l’adresse web du tableau avec le reste de Cot-Cot-Commons. Elle est facile à retenir c’est le nom du site puis le nom de son tableau : framemo.org/CotCotCommons

Très vite, Abdel, le secrétaire de séance, décide de projeter le tableau sur le mur de la salle de réunion. Dans le groupe, plusieurs s’emparent de leurs ordinateurs (dont Naya, restée chez elle à cause d’une jambe cassée, qui participe donc en visio conf) pour réorganiser les notes de Sandrine et y ajouter leurs idées !

C’est d’ailleurs Naya qui découvre qu’on peut glisser et déposer sur chacune des notes les gommettes qui se trouvent en bas à droite. Le groupe décide donc d’un code couleur pour attribuer les tâches à chacun-e. Bien vite, il y a tant de notes qu’il leur faut agrandir le tableau (en le tirant vers le bas d’un simple geste de la souris !)

 

À vous de tester (et partager) Framemo !

Et voilà : Ali Asaria (et toute l’équipe de Scrumblr) nous propose là un petit service efficace, pratique, facile d’accès… L’idéal pour collaborer aisément sans avoir à apprendre et à s’habituer à un logiciel plus complexe !

Car si le collectif Cot-Cot-Commons est une pure invention, nous sommes certains que Framemo peut être utile à vos associations, syndicats, familles, entreprises, institutions : bref, dans tous les cercles où vous vous organisez en commun.

Et si vous trouvez Framemo trop léger pour vos besoins, nous vous rappelons qu’il existe un outil plus orienté gestion de projets – et donc plus complexe – nommé Framaboard.org utilisant lui aussi la méthode kanban.

Nous sommes ravis de pouvoir vous proposer ce nouveau service, et attendons de voir avec impatience si vous allez vous en emparer, l’utiliser, le partager… et surtout le quitter parce que vous l’aurez finalement adopté sur vos serveurs ;) !

Pour aller plus loin :

• Tester Framemo
• Découvrir Scrumblr
• Installer Scrumblr sur vos serveurs

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

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