Table contents

• eyeOS 2.5 installation on Ubuntu
  • Requeriments
  • eyeOS installation
  • serverU1DB installation
• Persistence
  • Storage/recovering documents
  • Queries
  • Synchronization
  • Implementation of Oauth into eyeOS calendar
  • Implementation of U1DB into eyeOS calendar
  • Collaborative tool between eyeOS and StackSync
• Implementation of StackSync API into eyeOS
• Implementation of Share API into eyeOS

• Apache HTTP Server

  # apt-get install apache2
  # apache2 -version

  

  Type in the navegation bar of the browser http://localhost, and you'll see apache2 page (It works!)

  

• Mysql

  # apt-get install mysql-server mysql-client
  # mysql --version

  

  Remember the password of database's administrator ('root'), because it'll be requested during the eyeOS 2.5 installation.

• Php

  # apt-get install php5 php5-mysql libapache2-mod-php5 php5-gd php5-mcrypt php5-sqlite php-db php5-curl php-pear php5-dev
  # php5 --version

  

  Configure the php.ini.

  # cd /etc/php5/apache2/
  # nano php.ini

  Change the next parameters:

  • error_reporting = E_ALL & ~E_NOTICE

    

  • display_errors = Off

    

  • max_execution_time = 30

    

  • max_input_time = 60

    

  • memory_limit = 128M

    

  • post_max_size = 200M

    

  • upload_max_filesize = 100M

    

  • allow_url_fopen = On

    

  • disable_functions =

    

  • safe_mode = Off

    

  • short_open_tag = On

    

  • magic_quotes_runtime = Off

    

  • file_uploads = On

    

• Java

  # apt-get install python-software-properties
  # add-apt-repository ppa:webupd8team/java
  # apt-get update
  # apt-get install oracle-java7-installer
  # update-alternatives --config java
  # java -version

  

• OpenOffice

  # apt-get install openoffice.org

• Python

  # apt-get install python-support python-simplejson python-uno recoll zip unzip libimage-exiftool-perl
  # pip install requests requests_oauthlib

• Curl SSL

  If you don't have SSL certificate get it by typing:
  # wget http://curl.haxx.se/ca/cacert.pem

  Open the php.ini and introduce the path where the certificate to make requests to secure url is located.
  # cd /etc/php5/apache2/
  # nano php.ini
  ....
  curl.cainfo='/root/cacert.pem'

• Uploadprogress

  # apt-get install make
  # pecl install uploadprogress

  

  # nano /etc/php5/apache2/php.ini (Add the last two lines) .

  

• Sendmail

  # apt-get install sendmail
  # nano /etc/hosts (Add localhost.localdomain to IP 127.0.0.1)

  

  # sendmailconfig (Confirmar todas las preguntas)

  

• Apache

  Configure mod-rewrite in apache:

  # a2enmod rewrite

  

  # nano /etc/apache2/sites-available/default

  Change into <Directory /var/www/> the parameter AllowOverride to All

  

  Restart the apache service

  # /etc/init.d/apache2 restart

  

Download the code into /var/www

# cd /var/www/
# git clone https://github.com/cloudspaces/eyeos-u1db eyeos

Change the eyeos directory's permissions

# chown -R www-data.www-data eyeos
# chmod -R 755 eyeos

Add to DocumentRoot the eyeos directory:

# nano /etc/apache2/sites-available/default

# service apache2 restart

Install python-u1db package:

# cd eyeos/eyeos/packages/
# dpkg -i python-u1db_0.1.4-0ubuntu1_all.deb

If you have dependency problems during package installation follow the next steps:

# apt-get install python-u1db
# apt-get -f install
# dpkg -i python-u1db_0.1.4-0ubuntu1_all.deb

Get into mysql and create the schema 'eyeos'. As showed bellow:

# mysql -uroot -p<password>
> create database eyeos;

Open into the browser the eyeOS configuration screen (http://localhost/install)

Select 'Install eyeOS 2 on my server'

The error "SQLite extension not installed" can be ignored.

Once all requirements are listed, go on with the installation selecting 'Continue with the installation'.

Introduce user and password of mysql database's administrator (root), and in addition, the eyeOS platform root user's password.

Once configured the database and eyeOS user, go on with the installation selecting 'Continue with the installation'.

After the installation is finished select 'Go to my new eyeOS' to see the eyeOS 2.5 platform's login screen.

The url of StackSync resources requests can be configured in the file settings.php

# cd /var/www/eyeos/
# nano settings.php

Follow the steps explained in the Readme.md file, located in /var/www/eyeos/serverU1DB. The serverU1DB can be installed in the same machine than eyeOS or in another independent machine.

If installed in another independent machine the directories /var/www/eyeos/serverU1DB and /var/www/eyeos/eyeos/package must be copied in that machine.

eyeOS Calendar and the comments tool of the file manager store data in a U1DB database.

U1DB is a database API to sync JSON documents that was created by Canonical. It lets applications store documents and synchronize them between machines and devices. U1DB is designed to work anywhere, acting as a storage backup for native platform data. This means it can be implemented on any platform, from different languages, providing backup and sync services between platforms.

The U1DB API contains three sections: document storage/retrieval, querying and synchronization. A short description of their operation is given below.

U1DB stores documents, basically any information that can be expressed in JSON.

created_doc_from_json(json,doc_id=None)

Creates a document from JSON data.

Optionally the doc id can be specified. This id must not exist in the database. If the database specifies a maximum document size and the document exceeds this size, a DocumentTooBig exception is triggered.

put_doc(doc)

Updates documents. If the database specifies a maximum document size and the document exceeds this size, a DocumentTooBig exception is triggered.

set_json(json)

Updates document's JSON data.

delete_doc(doc)

Flags a document as deleted.

Querying in U1DB is done using indexes. To retrieve certain documents from the database according to specific criteria, first you must create an index and then query this index.

create_index(index_name,*index_expressions)

Creates an index that will be used to perform queries in the database. No exceptions are triggered if you try to create an existing index. However, an exception is triggered if you try to create an index that changes the index_expressions of a previously created index.

get_from_index(index_name,*key_values)

Returns the documents containing the keys specified. The same number of values as keys defined in the index must be specified.

U1DB is a syncable database. Any U1DB database can be synced with a U1DB server. Most U1DB installations can be run as server.

Syncing the server and the client updates both sides so that they contain the same data. Data is saved in local U1DBs, whether online-offline, and then synchronized when online.

sync(url,creds=None,autocreate=True)

Syncs documents with a remote replica via a URL.

To sync eyeOS Calendar and the comments tool applications, authentication must be done with the server using the OAuth protocol.

The OAuth server provides access to a unique protected resource, the U1DB server.

The eyeOS platform implements the Credentials.py script, which contains the APIs required for communicating with the OAuth server.

The communication dialog is as follows:

Step 1:

API getRequestToken() gets the consumer key and consumer secret from the settings (see Annex 1.2). It then makes a call to the OAuth server using the “request_token” URL.

The OAuth server retrieves the consumer key from the database and compares it with the consumer key received. If the keys do not match, it returns an error; otherwise, it performs a new search in the database using the consumer key to get the request token.

The OAuth server responds to the eyeOS call, returning the request token and access verifier to request the access token.

The eyeOS platform stores the request token and the verifier in the session variables so that it does not have to repeat the process in subsequent steps.

Step 2:

API getAccesToken(token,verifier) makes a call to the OAuth server through the “access_token” URL.

The OAuth server retrieves the consumer key and request token from the database and compares them with those received from getAccessToken(). If they do not match, it returns an error; otherwise, it performs a new search in the database with the consumer key and request token to get the access token. If no data is obtained or the data obtained has expired, a new access token must be generated and stored in the database, which means that previous tokens will no longer have access.

The OAuth server responds to the eyeOS call, returning the access token.

Step 3:

API protocol(params) calls the OAuth server via the U1DB synchronization API.

The OAuth server retrieves the access token from the database using the consumer and token received. If they do not match, it returns an error; otherwise, it syncs with the U1DB server.

Step 1 only applies where a request token has not been requested during the eyeOS user session.

Authentication implemented in both applications is requested for each resource request. The request process flow is illustrated in the following diagram:

Persistence OAuth Manager and Persistence OAuth API persistence functions are described in more detail, respectively:

Persistence OAuth Manager

callProcessCredentials()

Gets credentials of the eyeOS consumer.

Persistence OAuth API

The configuration file of OAuth API is found at “/var/www/eyeos/eyeos/extern/u1db/” and is called “settings.py”. This file must be modified in the following values:

getRequestToken()

Gets the request token of the eyeOS consumer.

getAccessToken(token,verifier)

Gets the access token of the eyeOS consumer from the request token and verifier received.

EyeOS storages the user's calendars and events into U1DB synchronized database.

Calendar and event sync processes are performed when eyeOS Calendar is opened.

Calendars are synced every 20 seconds. If any changes are detected, the calendar list is refreshed and the waiting time is reset.

Events are synced every 10 seconds. If any changes are detected, the events of the period shown on screen are refreshed and the waiting time is reset.

Persistence in implemented in eyeOS according to the diagram below:

The user performs an action on the calendar, such as adds an event to a specific calendar. The Manager uses the insertEvent function to retrieve the user’s credentials. These values are sent to the API together with the data of the new event. The API is responsible for requesting the resource from the U1DB server using the insertEvent function.

If everything is correct, the U1DB server updates the server database and subsequently notifies other clients of the change. The API receives confirmation of the change and applies it to the client U1DB database. Once the updates have been made, it notifies the Manager, which modifies the local calendar tables and updates the eyeOS interface.

The insertEvent functions of the Calendar Manager and the Calendar API, as well as the other actions performed by the calendar. Now are described in more detail, respectively.

Calendar Manager

The Calendar Manager API consists of a uniform structure in the script call:

The functions are listed and described below.

synchronizeCalendars(user)

Requests credentials of the eyeOS consumer.

insertCalendars(user,calendar)

Creates a new calendar.

deleteCalendars(user,calendar)

Deletes an existing calendar.

synchronizeCalendar(calendarId,user)

Synchronizes all the events of the specified calendar of the user connected to the eyeOS platform.

createEvent(event)

Creates a new event

deleteEvent(event)

Deletes an existing event.

updateEvent(event)

Updates an existing event.

Calendar API

To display the calendars correctly in the eyeOS platform, the structure of the calendars and the events, as well as their indexes, must be respected:

• calendar: type and user_eyeos.
• events: type, user_eyeos and calendar.

The functions are listed and described below.

selectCalendar(data)

Get all calendars of the user.

insertCalendar(lista)

Inserts the new calendar generated by the user in eyeOS.

deleteCalendar(lista)

Identifies the status of the calendar to be deleted (STATUS=”DELETED”) of a specific eyeOS user.

selectEvent(type,user,calendarId)

Gets all the events of the calendar belonging to the specified user.

insertEvent(lista)

Inserts a new event in the calendar of the specified user.

deleteEvent(lista)

Identifies the status of the event of a calendar to be deleted for a specific eyeOS user.

updateEvent(lista)

Changes the data of an event in the existing calendar of a specific eyeOS user.

The comments tool is only valid in the user’s Personal Cloud because it is a collaboration resource between StackSync and eyeOS.

The user accesses the comments tool when they select a Personal Cloud file or directory in the file manager and then clicks the “Comments” tab in the right toolbar (social bar).

The comments tool lists all comments inserted for a specific element, both those from the element’s owner and from other users who have been given privileges to access the element.

The data given in a list comment is:

• name of the user who made the comment
• creation date/time
• text entered

Example:

Other actions that can be performed include insert new comments with the “New” option or delete existing comments with the “Delete” option. The delete option is restricted; only comments made by the user in question can be deleted. Users cannot delete comments made by others.

The comments list is not refreshed, as there is no background process that enables new comments to be displayed automatically.

Persistence is implemented in the eyeOS comments tool according to the diagram below:

The user performs an action, such as inserts a new comment in the list. The Manager using the createComment function retrieves the user’s credentials. These values are sent to the API together with the data of the new comment. The API is responsible for requesting the resource from the U1DB server using the createComment function.

If everything is correct, the U1DB server updates the server database and subsequently notifies other clients of the change. The API receives confirmation of the change and applies it to the client U1DB database. Once the updates have been made, it notifies the Manager, which will update the eyeOS interface.

The createComment functions of the Comment Manager and the Comment API, as well as the other actions performed by the comments tool. Now are described in more detail, respectively:

Comment Manager

The Comment Manager API consists of a uniform structure in the script call:

The functions are listed and described below.

getComments(id)

Gets all the comments of a StackSync element.

createComment(id,user,text)

Links a new comment to a specific StackSync element.

deleteComments(id,user,time_created)

Deletes a comment of a specific StackSync element.

Comment API

getComments(id)

Gets all comments of a specific StackSync element.

createComment(id,user,text,time_created)

Links a new comment to a specific StackSync element.

deleteComment(id,user,time_created)

Deletes a comment from a specific StackSync element.

        </td>
    </tr>
</table>