Goffi non-hebdo

Aller au contenu | Aller au menu | Aller à la recherche

Mot-clé - jabber-xmpp-en

Fil des billets - Fil des commentaires

vendredi 19 septembre 2014

Salut à Toi v0.5.1

We are happy to announce the release of Salut à Toi v0.5.1! This version focuses on security and code refactorisation to ease the add of new features and maintenance.

We remind you that SàT is a multi-purposes and multi-frontends XMPP client, mainly developed in Python. The more advanced frontends are Primitivus (console) and Libervia (web). Jp (command line) can be used for administrative tasks. Wix (desktop/WxWidgets) will be deprecated and replaced with Bellaciao (desktop/Qt). An Android frontend is also planned.

overview_libervia

Security

A new parameter has been added to define a password for the SàT profile, it is stored hashed in the database. Its raw version is used to cipher the other passwords - including the one for the XMPP account - which are encrypted. A scheme on the wiki explains how this all works: encryption.

Libervia now handles HTTPS. The administrator can choose the service(s) to enable: HTTP, HTTPS or both.

You can uses OTR for instant messaging end-to-end encryption. Primitivus console interface uses the Python library potr while Libervia is based on the Javascript implementation otr.js. Thus, your encrypted discussions on Libervia are really private because the encryption is done directly by your browser; you may encounter some slowdowns, especially when starting OTR.

http<em />unsecure</em>warning

stdui<em />profile</em>manager<em>primitivus</em>1

stdui<em />profile</em>manager<em>primitivus</em>2

Other additions

You will notice:

  • the add of chat rooms bookmarks;
  • the display of the composing states in chat rooms;
  • a better integration of the ad-hoc commands, e.g. to allow the administration of the server from Primitivus or Libervia;
  • the possibility to erase all your blog posts, change your password or delete your account from Libervia;
  • contextual menus on the roster contacts and the discussion panels;
  • a couple of new stuff concerning the static blog pages.

bookmarks<em />manager</em>primivitus

manage<em />account</em>delete_blogposts

static_blog

Refactorisation

We care to redesign the code when some conception issues are found, or if we imagine a new mechanism which would work better. It is especially important for a project like SàT which is multi-interfaces and still in development. For this version we made several refactorisations concerning:

  • XMPP service discovery;
  • messages sending and reception;
  • textual commands management;
  • contact list management;
  • hierarchical organization of the constants;
  • Libervia's source files hierachy;
  • Primitivus keyboard shortcuts.

These modifications are not of a big interest for the users, but they ease our life, and maybe those of the people who would like to give us a hand! We see them as required first steps to initiate the development of the mobile phone frontend and the add of new features.

We extended the usage of XMLUI, our internal micro-format for describing user interfaces. We use it to manage frontend's dialogs from the backend. The user actions are now better integrated and we will keep on improving it for the next versions.

stdui<em />contact</em>list_primitivus

announcement_admin

adhoc_administration

To be mentioned

The backend is now launched as a Twisted plugin and starts by default in daemon mode, just as Libervia. The initialisation sequence backend / frontends has been improved; this fixes the issues that could occur when SàT and Libervia were launched from a script within a short time. Moreover, we added a .service file for D-Bus to automatically launch the backend when a frontend needs it.

The default paths for the user files are now compliant to the XDG recommendations: configuration file in ~/.config/sat, database and the rest in ~/.local/share/sat. Any previously existing default configuration file will be retrieved and eventually updated.

If the XMPP server address and port are left empty in the connection parameters, the actual values can be retrieved from a DNS SRV record - if one is set for the "domain" part of your JID.

There's a new log system, fully customisable and managing the colors, formatting, filtering and outputs (files, memory...).

logging

logging_primitivus

Administrative aspects

We submitted the file for the creation of the association "Salut à Toi"... which has been accepted without any trouble, positively surprising us. Our working mode is indeed a bit special for a French "1901-law" association: a collegial board with no president, secretary nor treasurer but two co-administrators. We remind you that there is behind this project a desire to fully involve ourselves, and this is not compatible with the pursue of another professional activity. This means, for the developers, the necessity to find a funding source. We will start with testing / adapting our idea of a good funding model for SàT, of course meeting the ethical and moral commitments that are defined by our social contract.

The association memberships are our favorite source of income! We defined in the internal rules several amounts for the annual subscription, between 0 and 100 euros and every one is free to choose. There's no typo! For the persons who would like to support us without being able or willing to contribute financially, that's possible - because moral support is important too. So there's no reason not to join ;-)

We are unfortunately not ready yet to offer you the possibility to make it online. We actually plan to open a bank account for the association at the end of this month, then we will prepare the online form to manage the subscriptions.

Meetings

We attended this year the "Free Software Days" (aka JDLL in French) in Lyon, "Pas Sage en Seine" in Paris and the "Libre Software Meeting" (aka RMLL) in Montpellier - see the links to watch the recorded conferences (in French). We met or saw again some nice people at the stands and during the speeches Goffi made. Many thanks to the organizers of these events, and to Reflets.info which wrote an article about SàT following the last version's release, allowing a larger public to get to know about the project.

We also participated last week to the "XMPP Summit" and its hackaton in Berlin. We met there some XMPP developers, including two with whom we have regular contact, such as Edhelas from Movim. We presented together our issues with the protocol and will suggest new XEPs to standardize some practices (especially regarding Publish-Subscribe and blogging), and push their implementations.

Saturday, September the 27th between 2pm and 5:30pm, Goffi will participate to a radio program from "Ici et maintenant", recorded in Paris and about self-hosting. There will be many guests including two from the Jappix project.

We would like to organize some gatherings via the association, at least once per year as a general assembly and maybe more often. The date and the location haven't been discussed yet.

Please also notice the recent creation of a "users" mailing list for SàT, it completes the chat room and the "dev" mailing list.

And then?

We would like to migrate our own blogs to SàT. The version 0.6 will focus on blogging (in SàT, it is based on a fine access permission system, so you only write to the people you want), pictures storage and tags implementation. These are essentials features and maybe the last important works before the publication of the first public release, which has been a bit delayed and should be stamped 0.7 or 0.8.

mercredi 26 février 2014

Salut à Toi 0.4.0: a new version of the powerful XMPP/Social software

G'day!

We are pleased to announce « Salut à Toi » version 0.4, which comes with many important changes, also regarding the project's life.

Salut à Toi is a powerful communication tool, free and multi-frontends. It offers some features like micro-blogging, instant messaging, an easy way to manage groups permissions (elsewhere called « aspects » or « circles »), games and much more.

Constantly designed with ethical and social thoughts (politically speaking), Salut à Toi (abbr.: SàT) is also bound to its social contract.
Being based on XMPP, SàT is decentralised and compatible with the other projects that use this protocol.

Before starting with the traditional listing of the new features, a few words about the evolution of the project. We are now two persons working full-time on SàT: so did Souliane, a friend for a long time, join me. We would like to live from the project, but we also want to respect our ideals (cf. the social contract) : we are firmly opposed to commercial advertisements, selling data or any similar behaviors.

We decided to organize ourselves as a self-managed entity, probably under the terms of a cooperative and we would like to start it this summer.
There are 3 economical models that we are thinking about:
  • the first would be based on donations. This is a precarious model but it would offer us the largest independance in our decisions taking process.
  • the second, more trendy, is the use of the so-called crowdfunding platforms. It is finally very close to the donations system, but it requires more work to file the applications etc. Moreover, we would need to select with care the platforms to be used.
  • the third one runs more classically, based on services : technical support, specific customizations etc. This is the one model which would leave us the least interdependancy, and the least time to focus on the project itself.
We often discuss about the project organisation, the features to be implemented, etc. We not only agree that privacy is primordial, we also believe that it is not the sole aspect to be studied, and that the impact these kinds of tools have on our lives deserve some special attention. Technology is not neutral, so we are thinking about how to implement and design things, and we are open to discuss (in real life better then behind a screen) ; feel free to launch a discussion with us.

That being said, let's have a look at the change log!
The list is quite long (the last version was more than a year ago), here is a selection:

Micro-blogging

The micro-blogging has been much improved. Comments are now handled, still using the fine access tuning for Pubsub: comments inherit the permissions from the micro-blogs they are replying to. The unibox of Libervia was disturbing many people and it is now optional, the default behavior for typing messages being more classic.

vue_globale.png


Rich texts have been implemented. The system is quite versatile and it's easy to add new syntaxes that would be available for all frontends.

sat_capture_rich.png

When you update some content, you can edit it using the syntax of your choice, even if it has been published with another one. Thus it is possible to edit in Markdown a post that has been originally created in XHTML.

For now, XHTML, Markdown and raw text are available, more should arrive soon (for instance Dokuwiki and Dotclear's syntax).

sat_params.png


The textual (micro)blogs are now recognizing and displaying inline URLs.
In addition to the rich text edition, a WYSIWYG edition (also to be used as a preview feature) is available in Libervia.
sat_wysiwyg.png


And there's still the static blog to display your public messages. It is now completed with an Atom feed. We are getting closer to a full decentralised blog engine and we plan to
move our own blogs to SàT by the next release, so some import tools to migrate from Dotclear and Dokuwiki are to be expected.

sat_static_blog.png

Messaging


It is possible to send messages in carbon copy or blind carbon copy, according to the XEP-0033
sat_extended_addressing.png


The MUC configuration has been implemented (the menu is currently only available in Primitivus)
Chat states notifications have been implemented, letting you know if someone is writing to you or if she/he left.

sat_chat_states.png

one plugin is adding some IRC-like commands e.g. /nick or /join

Command line

thanks to Dal, jp – the command line frontend – has been upgraded to ArgParse, allowing a proper commands refactorisation and confirming jp as being an XMPP “swiss knife”.

it's easy to forward a command or pipe output to a contact, but also to create a remote control (see below) or to transfer a file. Some more commands to publish micro-bloggs, manage your roster etc. are planned.

there's a bundled script to offer you the auto-completion with Zsh
Complètement de jp dans zsh

Misc

important work on the extra-features for the discussion rooms. The Collective Radio (allowing the members of a discussion room to upload some music and listen to it at the same time) has been improved, it also handles the user leaving and return.
sat_radiocol.png

sat_radiocol_invit.pngsat_radiocol_invit_2.png


Ad-Hoc commands are available, allowing to remotely control an entity with any XMPP client

based on the Ad-Hoc commands, a universal remote control has been implemented to offer the possibility to control most of the softwares. A post on my blog is presenting this feature, there's also a short demonstration video featuring VLC

telecommande_-_libervia_-_4.png

command export
: command export : another original feature - it's possible to redirect the input/output of a process to any of your contact (including to another network via a gateway), again the easy way with the fine accesses tuning. There is a demonstration on my blog with an FTP session export to a contact using Gajim

messages notifications are available in Libervia (a contribution from Link Mauve): if someone is talking to you while the tab is hidden, a message should appear on your desktop.

sat_notifs.png

In Libervia: in addition to the drag and drop which was already available, you can click on a contact or a group to open the associated widget. Widgets can now be moved from one tab to another.

considering the importance of the groups in SàT (used a lot to manage the permissions), a roster management user interface has been added to Libervia

sat_roster_manager.png

a mini XMPP discovery service has been started, it's already running on the libervia.org demonstration server.

Under and around the hood:

Some heavy refactorisations have been done to ease the development of future frontends e.g for small screen devices.
The SQLite database is automatically upgraded.

Some work has been done on the testing system, with the installation of a buildbot ( https://buildbot.goffi.org ) which is running a test batch after each commit.
Some SàTellites projects:
  • SàT Pubsub (based on Idavoll) is a Pubsub component for Prosody to manage fine access tuning, it's used for micro-blogging
  • Urwid SàText (based on Urwid) is a widgets library for console display, used by the frontend Primitivus.
  • "Salut" is a XMPP directory, at a very early development stage

Did you know ?

Some reminders about a couple of (hidden) features:

In Libervia you can position your widgets over several columns / lines

SàT comes with an IMAP server that let you use a MUA like Firefox or KMail to read your messages

Future

Beside our projects regarding the cooperative, the following should happen from the technical perspective:
  • an important work concerning the security. Until now, we left on purpose this aspect behind, to not do things by halves and fully focus on it when the time has come. So we plan to integrate HTTPS to Libervia, end to end encryption and password encryption in the database.
  • finish the micro-blogging support and migrate our own blogs to SàT
  • (hash)tags
  • frontends/ports for telephones and tablets, Windows (and Mac?)
  • update the Bellaciao frontend (Qt-based)
  • RSS/Atom feed integration
  • event and calendar management, etc.
We plan to release a public version this summer, it would be the first named version and, as already announced, it will be named « la Commune ».

Credits:

A big thank to contributors:
  • Link Mauve (Emmanuel Gil Peyrot): notifications Twisted plugin for Libervia, style improvments
  • Dal: jp profiles management, ArgParse in jp
  • Robotux (Thomas Preud'homme): locales correction, distribute update
thanks also to packagers (Naha and Robotux for Debian, Link Mauve for Arch, and surely other that we don't know, don't hesitate to contact us).
thanks to Elefantom for using daily the demo, and to give us several feedbacks
thanks to Parinux and Nanterrux to invite me for a talk, and to the JDLL where we'll be again this year.
thanks to the Loop to host the first Salut à Toi hackathon :). Ambiance and location where great.
thanks to Luc and Manu for the interview in the "Symbiose" emission, and for the following discuss.

Come and join us on XMPP MUC room sat@chat.jabberfr.org

mardi 18 février 2014

A universal remote for your softwares

G'day,
Salut à Toi (SàT) now allows to easily create a remote for most of your softwares, and to share it with permissions management.
Suppose that you are in a flatshare, and you want that your flatmates can change the music of the Amarok running in your living room: the following command is all you need for that:

jp ad-hoc remote -g flatmates -- amarok

where "flatmates" is the name of the group which can control Amarok. You may also want to remote control Okular (e.g. for a talk), or VLC on your phone.
Below is an example with VLC.
telecommande_-_jp_-_1_-_aide.png


The syntax may seem complex in apparence, it's actualy very simple:
telecommande_-_jp_-_2_-_vlc.png
  • " jp ad-hoc remote" tell that we want a remote control
  • "-pgoffi" say thaat we want to use the profile "goffi", but if it's the default profile, it's not needed
  • "-cl" the "-c" means "connect this profile if it's not already done", the "-l" means that we want to loop on commands (after launching a command, we will return to the command menu instead of finishing the ad-hoc session).
  • "-g coloc" is a filter (coloc mean "flatmates" in french): it tells that in addition of your own jid, the jids from the group "coloc" are allowed to use the remote
  • " -- vlc" the "--" is just here to terminate optional arguments, and "vlc" is the name of the software to control.

once the command entered, SàT fill look in D-Bus's Session bus to find buses which have "vlc" in their names, and add commands which don't need arguments. The output show what has been found.

Now, let's see how we can use the remote in Libervia (web interface of SàT):



telecommande_-_libervia_-_1.png

We use the remote with the ad-hoc "commands" menu


telecommande_-_libervia_-_2.png
we enter the jid which exported the remote. So far, we have to enter manualy the full jid, but in the future, a simple right click should be enough.


telecommande_-_libervia_-_3.png
vlc is indeed visible in commands


telecommande_-_libervia_-_4.png
and voilà ! Commands are available. Once again, it's a bit unfriendly at the moment, but it will be easy to replace common names like "play", "stop", "previous", etc with nice icons...


telecommande_-_gajim_-_1.png

telecommande_-_gajim_-_2.png
And it's of course working with every XMPP clients featuring ad-hoc commands, like Gajim or Psi (here Louise can use the remote control created by Goffi because she is in her group "coloc").
There are many advantages: ease of use, it's generic (the software just need to have its commands exported via D-Bus, which is pretty common on freedesktop environments like Kde, Gnome or XFCE), authorisation can be easily managed, and it works everywhere where an XMPP client featuring ad-hoc commands is available. An another proof that XMPP can be used for far more than just instant messaging, and a demonstration of the potential of jp, the command line frontend of SàT...

To conclude, a short demo video (in french).

As usual, to watch the video you can use a recent browser (the last Firefox/Iceweasel for example).
You can also use VLC (version >=1.1 only), by using the "Media/Open Netword Stream" menu and by entering this URL: http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_7_t%c3%a9l%c3%a9commande_universelle.webm
Last but not least, you can use mplayer:: mplayer "http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_7_t%c3%a9l%c3%a9commande_universelle.webm"

this video is licenced under Creative Common BY-SA

vendredi 22 février 2013

Export command to a contact (with video)

G'day everybody,

I have made a small plugin for fun which export the input/outputs of an Unix command to a contact. The principle is really simple: you enter a command (so far it's not implemented in the frontends, so you'll have to directly use the D-Bus API, throught e.g. D-Feet or qdbus), then the contacts allowed to communicate with it, with options if necessary, and voilà !

There are 2 mains advantages by doing this:

the first one is that you can give access to an interpreter to any of your contacts (I'm doing this with FTP in the video, I have also made tests with bc, ipython or zsh), without using heavy tools like ssh which need to create an access account, a client, an opened port, etc. Of course, it's not elaborated, it's not a terminal, but it can help out. The escape sequences (what bring colors and others things in your interpreter) are not managed yet, and it can scramble your output (I had the case with ipython). I'm thinking about catching them, and convert to color with XHTML-IM (well, a first step would be that SàT manage XHTML-IM :p ).

the second one is to help to write bots really quickly: you just have to make a script with read stdin and react to it. You can make a bot in a couple of minutes with any scripting language (sh, Python, Ruby, etc) or others. And you can directly debug it from a terminal, without the need of an XMPP server to test it. To show you how easy it is, I have made a little test in Python, here what it looks like:

#!/usr/bin/python
#-*- coding: utf-8 -*-
import sys

class QuickBot(object):

    def out(self, msg):
        sys.stdout.write((u"%s\n" % msg).encode('utf-8'))
        sys.stdout.flush()

    def start(self):
        while(True):
            _input = raw_input().decode('utf-8','ignore')
            if _input.startswith('!'):
                args = _input[1:].split()
                try:
                    getattr(self, "cmd_%s" % args[0].encode('ascii').lower())(args[1:])
                except (IndexError, AttributeError, UnicodeEncodeError):
                    pass

    def cmd_salut(self, args):
        self.out(u"à Toi !")

if __name__ == "__main__":
    bot = QuickBot()
    bot.start()

The contact just have to enter !command [arguments] to make it do something (here !salut). To add a new command, you just have to create a new method named cmd_my_command, e.g. cmd_toto will add the command !toto. Easy isn't it ?

I have made a short video to show you this, it's in french but easy to understand even without sound, where I export a FTP server.

I have also made a small web widget for Libervia (it's not pushed on the repository yet). Of course it's limited (because of javascript security restrictions), but it allow to show whatever you want beside your conversations, and to enjoy Libervia's layout management (you'll can, for example, put 4 websites on a grid).

See you soon

As usual, to watch the video you can use a recent browser (the last Firefox/Iceweasel for example).
You can also use VLC (version >=1.1 only), by using the "Media/Open Netword Stream" menu and by entering this URL: http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_6_export_commande.webm
Last but not least, you can use mplayer:: mplayer "http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_6_export_commande.webm"

this video is licenced under Creative Common BY-SA

vendredi 11 janvier 2013

Salut à Toi version 0.3.0 (with demo online !)

Salut à vous !

No news is good news ! The lack of news on the blog lastly is due to the work on Salut à Toi, which is comming in a new 0.3.0 release.

Really a lot of new things in this release, the 0.2 being more that one year old. If you follow the blog, you should have seen some of them like the radio collective, the pipe over XMPP, Primitivus becoming modal, the license change to full AGPL v3 or the group microblogging improvments. Other are still in early stage like the "Bellaciao" Qt frontend, or the quiz game. This year also came the new website, and misc other additions, more or less big. I will not talk again about all of this, there were already posts about most of named features. The installation instructions are at the bottom of this page.

Instead, let's talk about the new online demo. You'll find it at http://www.libervia.org, and you'll just have to click on "register" to easily create a new account. This account come with a Jabber address (Jabber Id or jid), and will let you talk to the world. Don't hesitate to join the SàT room (menu "Groups/join room", then let the default address which is the one of the room: sat@chat.jabberfr.org) to ask your questions or just talk about the project.

Web Interface

The main goal of this demo is to let you try the web interface.


Libervia v0.3.0: sending a message to Louise

You can add widget as you want by drag and drop. This way, by moving the name of a group (well, you'll need to add some contacts of course ;) ) to the center, you'll create a new panel with the microblogs of this group. If you do the same thing with a contact, you'll start a chat. Drag over the "contact" header in the same spirit, and you'll obtain a panel with all microblogs, from all groups. In the future, it should be possible to save the layout to bring it back easily.

To send a message in a discussion, you need to click on it (the title bar become red, like for Louise in the screenshot above). When you enter a text, a green banner certify you that you're talking to one person or in a room.

If you unselect the widget, you can either click on an other one, either click on the gray space under the text entry (it's the status area). If you enter a text without nothing selected, it will be your status message.

For group microbloging, enter the target group by writing your message like this "@group: message". e.g.: "@friends: Salut à Vous !". A message written like "@@: Salut à tous" will be public (readable also for people which have no account, see below). NB: the banner will be blue for a group message, and red to say "careful, this message will be public, either for people you don't even know".

You can also try the collective radio, or the french tarot game (which will hopefuly work correctly).

public microbloging

the public messages page is a the following address: http://www.libervia.org/blog/login (e.g.: http://www.libervia.org/blog/goffi). Here you'll find open microblogs (the ones written like "@@: message") from the person, a bit like identi.ca or Twitter. This page is currently really basic, it will for sure become better with time.

using an e-mail client(MUA)

Like seen previously on the blog (well, in french actually :) ), you can use an e-mail reader like Thunderbird, KMail or Mutt to connect to SàT.


Thunderbird, connected to SàT show a message send by Psi through XMPP

So far it's really basic (it's not yet possible to create directories with IMAP, the account must be logged will using the e-mail client, you can't send message on the traditional e-mail network), but this should become better and better to finally bring a full e-mail server.

This feature show the way to many experiments through XMPP gateways or project like Weboob. Thank to it, we can for example send message through KMail to IRC, SIP or SMS (using gateways like Spectrum's ones). Add Weboob to this (using an XMPP gateway that I have started), and you'll can send messages to website like DLFP.

We can imagine "smart" answer: are you never annoyed by receiving notifications for messages from a website, and to have to connect to it using a web browser, just to read and/or answwer the message ? It will be possible to automate this, so you'll can do everything from your favorite email software.

I have other ideas in head, which should slowly come.

To use this, you have to indicate your jid (which is like login@libervia.org) as your e-mail address, the IMAP and SMTP server to use are www.libervia.org (both) and the respective ports are 10143 and 10125. So far, you have to be logged to the web interface to be able to check you e-mail with your e-mail client, a issue which will of course disappear in the future. Other issue: you can't create an IMAP directory yet, so you'll have to save your messages/draft and other templates locally (in Thunderbird, in the account parameters, you'll have to put "Local Folders" for everything in "Copies & Folders").

Once the configuration is done, you can try with a jabber contact: ask her to sent you a "normal" message (the ones with a subject) with - for example - Psi or Gajim, and answer her with you e-mail client :)

Installation

The installation should be really easy (for people on GNU/Linux: multi-platform is not yet managed; please be patient ;) ), as the project is on pypi. So, a simple "pip install sat" (as root) should be enough. If you're using Arch, a package is already here (thanks to Link Mauve). On a fresh install of Debian, the following command should install "Salut à Toi" (to enter as root):

#apt-get install python-pip python-dev
#pip install sat

Once SàT is installed, you can launch it (by entering "sat"), then use the console ui (by entering "primitivus"). To use Wix, you'll have to install media as shown on the wiki. And don't forget the new website, with useful links and some screenshots: http://sat.goffi.org

Okay, I think this post is long enough (and I need to sleep to be honest), see you soon...

Goffi

jeudi 2 août 2012

New website for Salut à Toi + some news

G'day,



a quick post for the opening of the new Salut à Toi's presentation website: http://sat.goffi.org. The goal was to have something more accessible than a wiki page: you should have quickly a global idea of what the project is with it. It's available in French and in English (any help to add a new language is welcome).

In addition, I was to Linux Software Meeting in Geneva (RMLL in French) in July, and I have had a talk about the project: http://video.rmll.info/videos/salut... . It's in French, I'm thinking about subtitling it soon (again, any help welcome). The meeting was good, I had a common booth with Romain from the friend project Weboob, and I have also seen again people from other project like MOVIM (we were neighbours), Jappix or Newebe.

People seemed interested by "Salut à Toi". More and more people know the project, at least by name. I hope next year the running version will be usable for everybody (not only developers)...

Other news: the project is now fully AGPL v3+ (before it was a mix between GPL v3+ and AGPL v3+) except the data which are Creative Common By-SA.
The Social Contract has been translated to English, thanks to a contribution from Matthieu Rakotojaona.

cheers
Goffi

dimanche 24 juin 2012

Fine access tuning for PubSub

Warning this post is technical

As you may know, "Salut à Toi" allow to do microbloging with groups access, that mean that you can send post to only a group of your roster (e.g. "family" or "friends"). This feature has been available for a year, but was using a dirty hack (which only works with OpenFire); that was mainly a proof of concept

We need a simple permissions system which can be used beyond microblogging, something generic, which can extend PubSub.
Rather than thinking about tons of pubsub nodes with different access model each time (e.g. a family node, an other one for friends, etc), we need a way to fine tune permissions, by items.

For this reason, I started a pubsub component to validate the concept, and which will be used by SàT to manage microblogging. If the idea proove to be working, I'll talk about it on one of the XSF mailing list, to propose it as a standard.

The way it works is simple: we use exactly the same syntax as for nodes access model (http://xmpp.org/extensions/xep-0060.html#accessmodels), and we apply it to items.
The node access model is applied first, then the ones of items (that mean that an item with an open access model won't be available to somebody which is not in the right roster group if the node has a roster access).
The PubSub component parse the item stanza, apply access model, then save it (without the configuration part).
When somebody wants to get node's items, the pubsub component first check that he is granted to access node (by checking the "access model"), then send him only the items that he can access.

Imagine that Louise has a node with 3 items: 1 with an open access (A), 1 with a roster access, allowed for "family" group (B), and one with a roster access, allowed for "friends" and "coworkers" (C).
Pierre, who is a friend of Louise, will have access to items A and C. Louise's brother will access items A and B.

There a 2 main advantages: first this protocol stay standard compliant (with XEP-0060) - so there is no change to do for an XMPP client to get items -, and secondly the clients have only one node to check by entity that they want to follow.

Some words on test implementation: I use the "Idavoll" PubSub component as a basis, which was made by Ralph Meijer*, and I have slightly modified it for my tests. The main difficuly is that currently components have a very limited access to server, and we can't access entities' roster.
To work around the issue, I use an experimental protocol which allow to access a remote roster. Unfortunately, this protocol only permit to access a part of the roster, so I have patched Prosody's implementation to get the full roster.
Finally, I used some simplifications by saying that node creator, owner and publisher are the same. This is often true for microblogging, but is very limiting when we think about XEP-0060's possibilities.

Anyway it works, but it still need works (and a standardisation) before being a proper way to do.

Below is a server dialog example. We have here Pierre and Louise which are friends, Louise being in "friends" group of Pierre. The later post a microblog as follow**:
<iq from="pierre@example.net/SàT" type="set" id="H_77" to="sat-pubsub.example.net">
  <pubsub xmlns="http://jabber.org/protocol/pubsub">
    <publish node="urn:xmpp:groupblog:pierre@example.net">
      <item id="8f532cc8-be1d-11e1-b5d3-00c0ca4f1546">
        <entry xmlns="">
          <title>G'day my friends !</title>
          <id>8f532cc8-be1d-11e1-b5d3-00c0ca4f1546</id>
          <updated>2012-06-24T18:56:36+02:00</updated>
          <author><name>pierre@example.net</name></author>
        </entry>
        <x xmlns="jabber:x:data" type="submit">
          <field var="FORM_TYPE" type="hidden">
            <value>http://jabber.org/protocol/pubsub#item-config</value>
          </field>
          <field var="pubsub#access_model">
            <value>roster</value>
          </field>
          <field var="pubsub#roster_groups_allowed">
            <value>friends</value>
          </field>
        </x>
      </item>
    </publish>
  </pubsub>
</iq>

After receiving this, the server parse configuration data (the "http://jabber.org/protocol/pubsub#item-config" form***), delete this part of the stanza, save the item with the right permissions (roster access, only for "friends" group), and only send a notification to group's members, so it send one to Louise.

The notification is sent like this:

<message to="louise@example.net" from="sat-pubsub.example.net">
  <event xmlns="http://jabber.org/protocol/pubsub#event">
    <items node="urn:xmpp:groupblog:pierre@example.net">
      <item id="8f532cc8-be1d-11e1-b5d3-00c0ca4f1546">
        <entry xmlns="">
          <title>G'day my friends !</title>
          <id>8f532cc8-be1d-11e1-b5d3-00c0ca4f1546</id>
          <updated>2012-06-24T18:56:36+02:00</updated>
          <author><name>pierre@example.net</name></author>
        </entry>
      </item>
    </items>
  </event>
</message>

There is no way to know on which group Louise is in Pierre's roster (this is a classical notification). Even is an XMPP client doesn't manage the per-item access model, it will receive the notifications and will be able to manage them as usual.

I have sub-licenced the component to AGPL V3, you will find the code in my repository (http://repos.goffi.org/sat_pubsub/). I invite XMPP community's members (authors of clients and servers, or others) to use the code, or to comment the idea

Fine permissions tuning are in my opinion a mandatory feature that XMPP really needs, and they will be more and more used by the "Salut à Toi" project. It was one of the last architecture point of SàT, a new release should follow quickly.

Stay connected :)
Goffi

* Ralph Meijer is also a contributor of Twisted and the author of "Wokkel" library, which are in the heart of SàT, in addition of being one of the authors of PubSub XEP. A huge thank to him for its valuable contributions.
** Normally, microbloging use PEP, but component limitation that I mentionned above forced me to use a custom protocol, which doesn't use PEP.
*** I have used a "jabber.org" namespace instead of "goffi.org", as I should have do for an experimental feature, because I need it so Wokkel's PubSub service could parse it.

jeudi 2 février 2012

Collective radio (with video)

G'day everybody

after the shell pipe over XMPP, here is a new feature in "Salut à Toi": collective radio.

The idea is: you are in a chat room with a common playlist, and everybody can add a song to the playlist. The song is played simultaneously for everybody, making it a collective radio experiment.

So far, there are maximum 2 songs in queue, as soon as one song is played, anybody can add a new one. In the future, we can imagine a more sophisticated system to choose who can add a song in queue (e.g. each one in turn, with a vote if songs played are appreciated, or with a game: the one who can answer a quiz question can choose next song).

Maybe in the future we'll see thematic rooms: jazz, rock, experimental, discovery, song with nice lyrics, etc. Or maybe we'll spend some evenings with friends, each one adding nice songs after the other, or playing blind test. We can also imagine party were everybody can participate to the playlist.
If in addition you use it on your phone: you are your own radio disc jockey :)

Following is a video showing the current implementation of the proof of concept, it's in french but quite easy to understand.

For the record: I'll be in Brussels next weekend for the FOSDEM, where I'll make a demo of the project at the XSF stand; don't hesitate to come to have a chat :). In addition I'll have a short talk in the devroom on saturday evening (18:00), you can have more information by clicking on this link.

To play the video, you nead a recent browser (e.g. Firefox 4+ or the last Chromium).
You can also use VLC (>=1.1 only), by using this url as a flux: http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_5_radio_collective.webm

Last but not least, you can use mplayer: mplayer "http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_5_radio_collective.webm"

This video is licensed under Creative Common BY-SA

vendredi 7 octobre 2011

Shell: pipe you commands out via XMPP with SàT

G'day all,

just a short notice to show a feature i'm currently implementing, the hability to pipe out a command line stream via XMMP, using jp, the command line frontend of the "Salut à Toi" project.

The syntax is quite easy: imagine you have 2 people Pierre and Louise talking together. Louise is talking about the last Blender Foundation movie, Sintel, and Pierre is interested, and want to see the trailer Louise is talking about. To do that, he just has to enter the following command:

jp --pipe-in louise | mplayer -


Which mean "I'm waiting for an incoming stream from louise". Louise correspond to the name Pierre gave to its contact louise@example.org, jp do the association.
He could also have used the full jid instead: louise@example.org/Noumea .

In the other side, Louise can pipe out the trailer to Pierre with the following command:

cat sintel_trailer-480p.ogv | jp --pipe-out pierre

Quite easy isn't it ? You don't have to worry about the IP address of your contact, just to know its jid, or to have it in your roster with an easy-to remember name.

Note that jp was already allowing you to pipe out command line result as a XMPP message (to do some ascii art for example ;) ).

If you want to copy a file, the syntax is quite similar:

jp -wg louise

for reception and:

jp -g sintel_trailer-480p.ogv pierre

to send the file. The -g flag means you want to see the progress bar.

The following short video show this in action. It's in french, but you don't really need the comments to understand it.


To play the video, you nead a recent browser (e.g. Firefox 4+ or the last Chromium).
You can also use VLC (>=1.1 only), by using this url as a flux: http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_4_copie_et_pipe.webm

Last but not least, you can use mplayer: mplayer "http://www.goffi.org/videos/pr%c3%a9sentation_S%c3%a0T_4_copie_et_pipe.webm"

This video is licensed under Creative Common BY-SA

For the technical side, it's just a modified XEP-0096 . It would be intersting to propose this as a standard to the XSF, but maybe by using jingle transfer instead.

Please not that all of this is really experimental.

I plan to release the next version of "Salut à Toi" soon, stay connected :)

dimanche 5 juin 2011

Salut à Toi: a multi-frontends XMPP client

G'day all,

I have been working for a while on an XMPP client with a daemon/frontends architecture: the idea is that you have the main logic centralised in the daemon side, and you can make very different lightweight frontends for the view. The project is intended to be a modular, multi-platform, multi-frontend communication software. The frontends can be adapted to a particular use case, or platform.
Currently, there are a desktop frontend, a console frontend, a command-line frontend, and a web frontend. A Kde frontend is also planned.

The project is quite difficult to summarise, as it touch a lot of domains (it's not intended to be only an instant messaging software, but to explore deeply the power of XMPP): with it you have instant messaging, e-mail style heavy messaging, multi-user chat, microblogging, file sharing, games, etc.

Techical part

Salut à Toi (SàT) - which means « Hi to you » - is heavily based on the Twisted framework, and the XMPP library Wokkel, which is on top of it and should be integrated in Twisted in the future. The core backend concentrate only on the RFC, a couple of XEP, and the essential stuff to run. Most of the XEP and the advanced functionalities are put in plugins, that allow the code to be modular, and to choose which features you want (you can remove plugins to suppress features for e.g. a public station). SàT manage several profiles: you can use different profiles for different accounts on different servers.


The backend communicate with the frontends throught a "bridge", which is actually an IPC: so far, D-Bus is used, but it is possible to use an other one. All the frontends and the backend together make one client, that means that if you enter something in one frontend, it will appear in the other ones like if it was enterred there. It also means that the history of the conversations is shared, and that if you create one profile somewhere, it will be created globally.


As the backend is independent of the frontends, you can use SàT without graphical interface (i.d. without X running), or unplug a frontend while the backend is still running (e.g. to terminate a long file transfert).
As you can guess by seeing Twisted, SàT is made with Python, it is actually 100% Python, including browser side code (see below); but an other language can be used to make a frontend. Actually any language able to talk with D-Bus can work, and the planned Kde frontend will be made with C++.

Here is a global Diagram of the architecture:
Salut à Toi: Global view

The frontends

Wix: the desktop frontend

Wix is the reference frontend, it is used to test implementation of features. It is based on wxPython. It's intended to be a classical desktop frontend, which should work everywhere. In the future, it could be change its interface for a more experimental one.

Primitivus: the console interface

Primitivus is for console lovers. It is based on Urwid, and the interface is more worked. I had to make several widgets for this frontend, so I eventually put them in a separated library: urwid-satext (Urwid's SàT extensions), I hope they can be usefull for other projects.

primitivus_copie_fichier.png

JP: the command-line tool

JP is a swiss knife, it can be used in many ways. It can be use to easily send file: I spend most of my time in a shell, and it's often annoying to have to go in thousand dialogue boxes just to send a file, furthermore if I am already in the good directory. With jp, I can just type:
jp file mycontact@example.org
and I plan to use a more friendly interface like "jp file nickname".
In addition, jp can send a whole directory by compressing it, accept multiple files without having to accept each time, or send the output of an unix command. It can be used as a powerfull scripting tool, e.g. to notify you when something happen on your server.
In the future, it should gain lot of features like sending microblogs, or managing roster.

jp.png

Libervia: the web frontend

I have waited to make this frontend to start the communication about SàT. Libervia is close to what the fashion wants to name "social network", but with a big emphasis on privacy and user respect; it clearly wants to be an alternative to the massively centralised commercial services. It's entirely made in Python, thanks to pyjamas, with is a Python port of GWT.
There are many thing to say about pyjamas: group centred right management, clear interface, use of widgets, unique input box, visual indicator to show who will be able to read your message, etc.
All of this is shown in a video (in French, but I'm pretty sure it's understandable without the sound, any help to make subtitles welcome):

This video is under Creative Common BY-SA

In addition, a technical demo is online: http://www.libervia.org . Please don't pay any attention to the ugly appearance, we are working on it and it should be really nice looking soon.

Libervia, as the whole SàT project in linked to a social contract, see below.

libervia_prototype1.png

Some things you can do with SàT

Here are some stuff you can do with SàT:

  • Use your e-mail client (MUA) to read and send your messages: XMPP manage "normal" type message, which are heavy messages pretty similar to e-mails (with a subject and a body). This messages are often managed really basically by XMPP clients, but this job could be done by feature-full stable and well-known e-mail softwares like KMail, Thunderbird, Mutt, Roundcube, etc. So, 3 extensions have been made: one to manage a Maildir box, one to manage an IMAP server, and one to manage a SMTP server. Theses extensions allow to connect most of e-mails clients to SàT, and use them to send message to your XMPP contacts, receive messages from them, or even send message to standard e-mail network throught an SMTP gateway. I think XMPP is an excellent candidate to be used as an alternative to e-mail.
  • Microblogging: SàT manage microblogs (only in Libervia so far), not only in the popular classical public way, but also with access restriction through roster-based group access. For example, if you have all you family members in the group "family", you just have to enter "@family: Salut à toi la famille" in the input box, and only the member of your family will be able to read this message. If you want to publish this for everybody, just enter a double @, like this: "@@: my global public message". With this, not only all you contacts will be able to read your message, but even people you don't know as it is public (on the online demo, you can see them through http://www.libervia.org/blog/your_nick).
  • receive multiple files from one contact without having to individually accept them: jp, the command-line tool, allow (among other things) to automatically accepts files, or to send a full directory at once by making a tarball with it.*
  • Nothing to do with XMPP, but an extensions allow to send message to a Couchsurfing account. There is a way to make lightweight XML interfaces for plugins: that allow to make a plugin which will work with all frontends; the couchsurfing plugin was just an excuse to try it.
  • Play French Tarot: I have made a French Tarot game (a card game extremely popular in France), which is playable on the desktop with Wix, in text-mode with Primitivus, or in a browser with Libervia. It was a test in the idea to make a general card game XEP, any people interested in cards games for XMPP can contact me.

Games

Games are an important part of SàT. The following stuff are planned:

  • Generic card games engine: the Tarot Game was an implementation test of a card game. I'd like to take profit of this experience to make a generic XEP, wouldn't it be nice to play your favourite card game through your favourite XMPP client with your friends ? If you are too far to play on a real table of course :)
  • I'd like to do the same think for board games, and a Xiangqi game is planned (Chinese chess)
  • A quiz game is planned in the very short term, probably for next release
  • on the long term, everything can be made, even maybe real-time games

wix_tarot.pngprimitivus_tarot.png

Social contract

Maybe the most important point of all the project: a social contract has been made, and show the principles that SàT and people involved in it follow. It can be read here: http://www.libervia.org/contrat_social.html, but it's only available in French so far.

Licences

  • The SàT backend, Wix, Primitivus and jp are under GPL v3+
  • urwid-satex is under LGPL v3+
  • Libervia in under AGPL v3+

What's next ?

I have reached the point I wanted to build the foundations of the project, and make it credible. Now I need to stabilise everything, clean and re-factor several parts of the code, remove all the ugly Q&D hacks, finish half-made things, etc.
It's the perfect time to give a hand :)

But new features are planned on the short time, mainly picture sharing and quizz game.

You want to help ?

All the tools needed for contributions is here (wiki, bug tracker, mailing list, mercurial repository).
The project use many really interesting stuff like Twisted, Wokkel, Urwid, Pyjamas, etc. It can be a good way to discover them and improve you skill, and I hope give them some contributions.

The help I need:

  • developers ! The project begin to be too big for me alone. In particular, I need people to port SàT on other architectures (*BSD, Android, Mac OS X, Windows, etc.). Only portable technologies have been used, so it should ask a reasonable amount of work.
  • tester: SàT should work with most browsers, most platforms, most XMPP server, etc.
  • Graphic designers: many things to do: icons, design, etc. Somebody just started to help me on this point, that means that the aspect should improve quickly.
  • CSS designers, Libervia should offer different kind of presentations
  • translators
  • donations: if the project succeed, would you make some donation ? Should I take some time to have a donation system ?
  • ...

If you are interested, the first thing is to subscribe the mailing list: http://lists.goffi.org . I hope to have around 10 peoples to start to use it seriously.

Conclusion

This post is only an overview of Salut à Toi, and I think the potential is very big. I strongly believe in the community, and I hope I have interested you enough to have a hand :)

I finish with two videos showing the project (the third one is linked above), but they are in French. Any help to make subtitle for them welcome.

This video is under Creative Common BY-SA

This video is under Creative Common BY-SA

mardi 3 mai 2011

RMLL (LSM): Notice to XMPP projects development teams

G'day everybody,

As you may know, Libre Software Meeting (Rencontres mondiales du logiciel libre or RMLL in french) will take place on next july (from 9 to 14) in Strasbourg. You can have a look at the official website: http://2011.rmll.info/

We are planning to have a common stand for various projects around XMPP/Jabber, and I'm taking inventory of people interested.
To make organization easy, if you want to join us, please send me an email ( goffi@goffi.org ) with the following template:

subject: [RMLL] Stand XMPP

Body:

First name *:

Last Name:

Nickname*:

email address:

Phone number:

Project*:

Project website*:

Availability*:

The * mean that the field will be public (put on the wiki).

The nickname is not mandatory, it's just to make link with you if you are on XMPP MUC or forums.

the [RMLL] in the subject is mandatory as messages are filtered.

I will add people as one goes along on the wiki: http://wiki.goffi.org/wiki/RMLL_2011

Please note that I will always send a confirmation email (within 3 days), so please send me again an email if you have no confirmation and your name is not on the wiki.

Last but not least, if you haven't any project but you are interested in XMPP and want to be present on the stand, you are welcome (if the stand is not already too full)

You can contact me for any question on the email given above.