Table contents

• eyeOS Open Source installation on Ubuntu
  • Requeriments
  • eyeOS installation
• eyeOS Platform
  • Introduction
  • eyeOS integration with Personal Clouds
    • Integration
    • Authorization and authentication
    • Storage API
  • Personal Clouds and eyeOS interoperability
    • Implementation interoperability
    • Examples
  • Collaborative editing tool
  • Replacement U1DB to API
    • Implementation
    • Comments
    • Calendar
  • ANNEXES
    • ANNEX 1 Configuration file
    • ANNEX 2 Oauth Manager
    • ANNEX 3 Oauth API
    • ANNEX 4 Storage Manager
    • ANNEX 5 Storage API

• 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.

eyeOS is a web platform that provides a remote virtual desktop for the end user.

The overall user experience is strongly influenced by the classic desktop design, widely known thanks to the most popular operating system on the market. eyeOS Personal Web Desktop includes several features such as: file manager, contacts, groups and other collaborative capabilities. eyeOS Personal Web Desktop is a disruptive technology that fits in perfectly with the CloudSpaces Open Personal Cloud paradigm.

One of the key values that eyeOS provides is the possibility to work directly with files in the cloud. eyeOS does not require users to manually download any files onto their computer nor is it necessary to install anything locally, so the experience is totally transparent: users just log into a website and start working with their files normally.

Furthermore, eyeOS lets you add additional services and applications within the web desktop, so that all the company or organization‟s web resources are available within a single controlled environment that can be accessed using single sign-on.

By combining eyeOS‟ web file management capabilities with Personal Cloud, users can access their Personal Cloud contents via web, with a user experience very similar to local desktop environments.

eyeOS allows users to quickly and safely access private data stored in their Personal Cloud and use them remotely. They are able to access the information from multiple devices. Desktop PC, laptop, tablet, smartphone, anywhere and any time.

In a constantly changing environment such as today‟s, being able to access data regardless of the device used, and share said data with other users who only need an Internet connection and a browser, constitutes an important advantage.

Within the eyeOS platform, one of its key features is file management. It provides an interface that allows the user to access the files stored in their Personal Cloud directly from the browser, with an experience similar to the file manager of any desktop operating system, such as Microsoft WindowsTM or GNU/Linux. For example users can see any saves documents they have saved online on Stacksync and NEC, create directories, move files, share documents, etc.

In order for eyeOS to provide these services to the user, it needs to communicate with the Personal Cloud to obtain all the user information it needs. This communication is made using the Storage API and it provides all the resources necessary that allows the user to manage their files efficiently.

User can share their information with other users, regardless of the Personal Cloud that they use (interoperability). For example, a Stacksync user can share files with another Stacksync user of with another NEC user. eyeOS provides an interface that helps the user at all times to decide whether the carpet should continue to be shared and which users may access it.

A main feature of the eyeOS platform is to establish collaborative environments so that users can exchange information in real time. It provides the eyeDocs application, a word processor that allows users to edit files previously shared between them in a collaborative environment.

eyeOS users also have tools to add comments to files and manage their calendars within their Personal Cloud. An API Sync has been developed which allows all of these functions to be developed, replacing the U1DB synchornisation API previously used for this purpose.

The eyeOS platform integrates the services of the Personal Cloud in the file manager, which allows users to go online and see files they have saved in the Personal Cloud, create directories, move files, share documents, etc.

This dile manager is developed in JavaScript, HTML, and CSS, allowing users to directly view their files in the browser. The interface is similar to any file manager in any operative system. Users can carry out different operations on files in a very intuitive manner.

Once the user is in Cloudspaces they can access their protected data by selecting a specific and existing cloud in the clouds configuration of eyeOS (see annex 1) which is listed in the “Clouds” tab to configure access.

The eyeOS platform integrates the OAuth authorization to interact with the user‟s protected data stored in the Personal Cloud. OAuth is an authorization protocol which allows the user (owner of certain resources) to authorize eyeOS to access said resources in their name but without having to at any time give their authentication credentials; that is, without giving their name and password.

The first time that access is requested to the resources of a specific user of a Personal Cloud, authentication is used to obtain a securitytoken for that same cloud, which allows for interaction with the user's data. The keys are stored in the “token” table of the DBMS database based in MySQL. These keys are linked to the cloud and user who started the session in the platform, so the system can determine the access token for a specific user trying to use the services at any stage.

Below the communication dialog box is shown:

Step 1:

Request the key and secret token from Stacksync that identifies eyeOS as a resource user of CloudSpaces. This communication was carried out via email.

Step 2:

Request the token and provide Stacksync with the forwarding url to eyeOS once the user has given authorization.

Stacksync responds to the aforementioned request with a valid token and authorization url.

Step 3:

Redirect the user to the authorization url where the user gives eyeOS access to their private area.

Once Stacksync verifies the user, the user is redirected to the eyeOS url provided in the previous step.

Step 4:

Request the access token and secret token from Stacksync, which will be used to identify eyeOS when it accesses the private area of the user in CloudSpaces.

The implementation of the authentication in eyeOS is detailed in the following diagram:

The Oauth Manager and Oauth API functions are detailed in annexes 2 and 3 respectively.

Below is a visual representation of the authorization process for allowing eyeOS access to the user's private area in a private or public cloud. This process is only carried out once, when the platform does not have the security token of the active user:

• Access the “Cloudspaces” directory from Home and select the cloud for which access is going to be authorized to eyeOS, for example, Stacksync, from the “Clouds” tab located on the bar on the right (social bar).
• The user is asked whether they provide their credentials to allow eyeOS to access their protected data.

• If the user selects “No”, the eyeOS file structure is shown without displaying the

directory of the “Stacksync” cloud.

<center><img src=img/image6.jpg/></center>

• If the user selects “Yes” in the first screen of the process, communication with

StackSync begins to obtain the accesstoken.

• A new window is opened in the browser, which redirects the user to the

authorization url received from StackSync, where the user gives eyeOS access to their private area.

• Once access to StackSync has been given, the user is redirected to the url

provided by eyeOS to obtain the requesttoken. The page informs the user that the process has been successfully completed and they can return to the eyeOS desktop.

• The *accesstoken* is saved for the current user of eyeOS. From that moment the

user can access their protected data from the Stacksync directory without having to log in again.

If the cloud appears active in the list and its folder is present in “Cloudspaces”, access can be removed by selecting the name again from the list in the “Clouds” tab. The de-authorization process is started on the following screens:

• Access the “Cloudspaces” directory from Home and select the cloud for which eyeOS access is to be removed, for example NEC, from the “Clouds” tab located on the right bar (social bar).

• The user is asked whether they want to close access with NEC.

• If the user selects “No”, the file structure of eyeOS is shown with the “NEC” cloud

directory.

• If the user selects “Yes” in the initial screen of the process, the process of

deleting the data related to the specific user and cloud begins.

• The *accesstoken* of the current eyeOS user is deleted. From that moment the

user cannot access their protected data from the NEC directory without starting the authentication process.

Once access to the cloud has been established, the private data can be accessed from eyeOS by sending queries to the Storage API. This returns metadata with all the structural information regarding directories and files, which uses eyeOS to generate a local replica.

The directories and files are created without content. Once an element is selected an any operation is carried out, such as opening, moving, or copying, the content is then downloaded from it. This process manages not to overload the system, recovering information that the user is not going to use at that moment. If a file or directory has been open before and no change has been made, it will not be updated.

The content of the current directory is synchronized with the Personal Cloud directory through a process carried out in the background, which sends queries every 10 seconds to check whether any changes have been made. If there are changes the current structure is updated.

The API Storage of the Personal Cloud is essential in the file manager, because is provides different services which allow the user to carry out operations with their files.

The importance of the API Storage will be better understood with the following example, where the user accesses the Comments folder in Stacksync and creates the folder New Folder.

• A call is made with the GET method using a token that is valid in Stacksync to check the content of the Comments folder (id: 2053).

URL parameters: { “id”: “2053” }

URL: http://api.stacksync.com:8080/v1/folder/:id/contents

• It returns metadata with the files in the Comments folder.

{"status": "RENAMED", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-06-12 09:53:55.312", "filename": "Comments", "is_root": false, "parent_id": "null", "version": 2, "is_folder": true, "id": 2053, "contents": [{"status": "CHANGED", "mimetype": "text/plain", "checksum": 296026785, "modified_at": "2015-06-15 12:59:57.414", "filename": "New File.txt", "parent_id": 2053, "version": 2, "is_folder": false, "chunks": [], "id": 2059, "size": 10}], "size": 0}

• A call is made with the POST method to the Storage API to create the folder New Folder within the Comments folder (id: 2053).

URL: http://api.stacksync.com:8080/v1/folder

POST: { “name”: New Folder,”parent”:2053 }

• The following metadata confirms that the folder has been created correctly:

{"status": "RENAMED", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-06-12 09:53:55.312", "filename": "Comments", "is_root": false, "parent_id": "null", "version": 2, "is_folder": true, "id": 2053, "contents": [{"status": "CHANGED", "mimetype": "text/plain", "checksum": 296026785, "modified_at": "2015-06-15 12:59:57.414", "filename": "New File.txt", "parent_id":2053, "version": 2, "is_folder": false, "chunks": [], "id": 2059, "size": 10}, {"status": "NEW", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-09-05 12:13:55.107", "filename": "New Folder", "is_root": false, "parent_id": 2053, "version": 1, "is_folder": true, "id": 2062, "size": 0}], "size": 0}

<center><img src=img/image19.jpg/></center>

Annexes 4 and 5 detail the queries made by the file manager to the Storage API to allow the user to carry out different actions in their files.

The eyeOS platform provides access to multiple clouds as well as interoperability between them, both in a private and public environment.

A possible definition of interoperability would be: “It is the capacity of information systems and the procedures which they support to share data and enable the exchange of information and knowledge between them”.

Interoperability is the condition which allows different systems or products to relate to each other to exchange data. The aim is to be able to share information with any user regardless of the system that they use.

The implementation of interoperability is detailed in the following diagram, with the exchange of information between two Clouds (Personal Cloud A and Personal Cloud B) and the eyeOS platform:

Step 1:

The user makes a request to Personal Cloud A with the URL and a valid ACCESS TOKEN from Personal Cloud A, to list all of the directories and files that a directory identified with a specific ID contains

Step 2:

Personal Cloud A returns a structure of directories and files. In this structure it is possible to find directories shared with Personal Cloud B. The feature which identifies these directories is a URL and a valid ACCESS TOKEN from Personal Cloud B.

Step 3:

To list the content of this directory, the user makes a request to the API of Personal Cloud B with the URL, directory ID, and ACCESS TOKEN received in Step 2.

Step 4:

Personal Cloud B returns a structure of directories and files corresponding to the directory specified in the URL. From this point, all requests implemented in the Storage API which are carried out in this directory will use the URL and the ACCESS TOKEN of Personal Cloud B.

The following example details how a Stacksync user creates a folder called New Folder in the folder interop1 shared by another NEC user:

• A call is made with the GET method using a valid Stacksync token to check the content of the Stacksync root folder:

URL parameters: { “id”: “0” }

URL: http://api.stacksync.com:8080/v1/folder/id/contents

• It returns metadata with the files in the Stacksync root folder. Within this metadata there are new tags: resource_url, access_token_key and access_token_secret. These tags show us that the folder is shared with another NEC user and it provides the connection URL and a token to be able to make calls to the Storage API of NEC:

{"status": "null", "mimetype": "null", "checksum": "null", "filename": "root", "is_root": true, "parent_id": "null", "version": "null", "is_folder": true, "id": "null", "contents": [{"status": "NEW", "mimetype": "application/pdf", "checksum": 2230714779, "modified_at": "2015-03-27 16:46:33.243", "filename": "chicken.pdf", "parent_id": "null", "version": 1, "is_folder": false, "chunks": [], "id": 1587, "size": 51500},{"status": "RENAMED", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-04-23 12:11:09.351", "filename": "interop1", "is_root": false, "parent_id": "null", "version": 2, "is_folder": true, "id": 1972, "size": 0, ,”resource_url”: ”http://csdev.neccloudhub.com:1080/api/cloudspaces/”, “access_token_key”: “e7e2b8e-14bc-4a75-942b-d757fe7035da”, “access_token_secret”: “30c60a55-0b50-4262-9720-c50e0e3489f0”}], "size": "null"}

• A call is made with the GET method using the URL and token of NEC recovered in the previous query to find out the content of the folder interop1 (id: 1972):

URL parameters: { “id”: “1972” }

URL: http://csdev.neccloudhub.com:1080/api/cloudspaces/folder/:id/contents

• It returns metadata with the files contained in the folder interop1 of NEC:

{"status": "RENAMED", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-06-12 09:53:55.312", "filename": "interop1", "is_root": false, "parent_id": "null", "version": 2, "is_folder": true, "id": 2053, "contents": [], "size": 0}

• A call is made using the POST method with the token obtained from the first

query to create the folder New Folder within the folder interop1 (id: 1972).

URL: http://csdev.neccloudhub.com:1080/api/cloudspaces/folder

POST: {“name”: New Folder,”parent”:1972}

The following metadata confirms that the folder has been created correctly:

{"status": "RENAMED", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-04-23 12:11:09.351", "filename": "interop1", "is_root": false, "parent_id": "null", "version": 2, "is_folder": true, "id": 1972, "contents": [{"status": "NEW", "mimetype": "inode/directory", "checksum": 0, "modified_at": "2015-09-06 13:04:03.15", "filename": "New Folder", "is_root": false, "parent_id": 1972, "version": 1, "is_folder": true, "id": 2063, "size": 0}], "size": 0}

The user can also share or stop sharing any directory with users from the same or different Personal Clouds. Using the options of the context menu and the activity tab of the Social Bar, the user can manage the directories that they share, deciding at each moment which users can or cannot have access to them.

The following example details the process of how the eyeos user shares the folder share with the user tester1 from the same Personal Cloud as them (Stacksync):

• A call is made with the GET method using a valid Stacksync token to obtain information of the users who share the folder share (id: 1973):

URL parameters: { “id”: “1973” }

URL: http://api.stacksync.com:8080/v1/folder/:id/members

• It returns metadata with the users who share that folder, in this case since it is not shared, it only returns the owner user:

[{"joined_at": "2015-03-27", "is_owner": true, "name": "eyeos", "email":"eyeos@test.com"}]

• The share option is selected from the context menu to share the folder *share* with

the user tester1:

• The email of the user *tester1* is added so that Stacksync can share this folder

with this user:

• In a POST call the list of emails is sent of the users with whom the folder is going

to be shared:

URL parameters: { “id”: “1973” }

URL: http://api.stacksync.com:8080/v1/folder/:id/share

POST: { [ “tester1@test.com” ] }

• When doing another GET call to check which users share the folder, it can be seen that it has been shared with the user tester1 in the tab Activity of the Social Bar:

URL parameters: { “id”: “1973” }

URL: http://api.stacksync.com:8080/v1/folder/:id/members

[{"joined_at": "2015-03-27", "is_owner": true, "name": "eyeos", "email": "eyeos@test.com"},[{"joined_at": "2015-03-27", "is_owner": false, "name": "tester1", "email": “tester1@test.com”}]

The shared directories are identified in the Files Manager with the icon

• The unShare option is selected from the contect menu to stop sharing the folder share with the user tester1:

• Once “unShare” has been selected, a form is displayed to select the users with

whom the directory is no longer going to be shared. The directory cannot be unshared with the owner of said directory, so they are not shown on the list.

• In a POST call the list of emails is sent of the users with whom the folder is going

to be unshared:

URL parameters: { “id”: “1973” }

URL: http://api.stacksync.com:8080/v1/folder/:id/unshare

POST: { [ “tester1@test.com” ] }

If all of the users are removed from the list, the directory will no longer be available for those users and the “unshare” option in the context menu will disappear.

The eyeOS platform offers the native eyeDocs app, a word processor which allows users to create and edit documents in the eyeOS format. Since it is a Cloud application, text editing with eyeDocs can be done from any computer without pre-installed local programs. Like other Cloud-based text editors, it does not guarantee that the formatting of documents with sophisticated borders and tables will be preserved. Therefore, far from competing with applications such as Microsoft Word, eyeDocs is optimized to load quickly and be a comfortable tool to create documents and take notes.

It is a tool made for collaborating with functions that allows different users to edit or see the content of a document at the same time. These functions are only available for users of eyeOS who share a single document in the cloud.

The collaboration between users is achieved by linking the data of the editing user to the file, in a server synchronized with other eyeOS platforms. When a user opens a file, a query is sent to a Sync API which collects information from the server to indicate its current state.

The implementation of the collaboration between users to edit a document is detailed in the following diagram:

Step 1:

The user stacksync (User A) opens the document eyeos2.edoc (id: 1980) located in the folder Comments of Stacksync. Two checks are made:

• The document is not being used by any user.
• The document is being used by another user, but the date and time of the last update is greater in minutes than the time specified in settings.php in the root of the project.

In both cases it is blocked by the current user.

To configure the maximum blocking time of the file, the constant TIME_LIMIT_BLOCK in settings.php should be modified. In the following example it is set at 10 minutes:

If (!defined('TIME_LIMIT_BLOCK') define('TIME_LIMIT_BLOCK',10);

To block the file the user stacksync (User A) makes a call with the POST method using a valid Stacksync token to the Sync API:

URL:http://api.stacksync.com:8080/v1/lockFile

POST: {"id":"1980", "cloud": "Stacksync", "user": "stacksync", "ipserver": "192.68.56.101, "datetime": "2015-05-12 10:50:00", "timelimit":10}

Step 2:

The user stacksync (User A) gets permission to edit the requested document.

{"lockFile":true}

Step 3:

The user stacksync2 (User B) opens the same document that the user stacksync (User A) is editing. It is confirmed that the user does not have permission to edit the document.

The same call is made as in Step 1:

URL:http://api.stacksync.com:8080/v1/lockFile

POST: {"id":"1980", "cloud": "Stacksync", "user": "stacksync2", ,"ipserver": "192.68.56.101, "datetime": "2015-05-12 10:55:00", "timelimit":10}

Step 4:

The user stacksync2 (User B) is informed that they do not have permission to edit the document:

{"lockFile":false}

In the eyeDocs application this document will be identified with the label "(Read Only)" in the title bar and the Menu, Toolbar, and document container will be blocked.

Step 5:

The user stacksync (User A) updates the content of the document. Each content update causes the time and date of the last document update to change to current values.

The user stacksync (User A) makes a call using the PUT method to the Sync API to update the time and date of the document:

URL: http://api.stacksync.com:8080/v1/updateTime

PUT: {"id":"1980", "cloud": "Stacksync" ,"user": "stacksync", "ipserver": "192.68.56.101", "datetime":"2015-05-12 10:57:00"}

It returns metadata showing that the update has been made:

{"updateFile":true}

Step 6:

The user stacksync (User A) still has permission to edit the document.

Step 7:

Every 10 seconds the user stacksync2 (User B) checks if the document is still being blocked by the user stacksync (User A). As it continues to be blocked the user makes a request for the content of the document.

Step 8:

The content is updated in the eyeDocs document of the user stacksync2 (User B).

Step 9:

The user stacksync (User A) closes the document and frees the editing permissions.

A PUT call is made to the Sync API to remove the document block.

URL: http://api.stacksync.com:8080/v1/unLockFile

PUT: {"id":"1980", "cloud": "Stacksync", "user": "stacksync", "ipserver": "192.68.56.101", "datetime":"2015-05-12 10:59:00"}

It returns metadata that states that the file has been freed:

{"unLockFile":true}

Step 10:

User B checks if the document is still being blocked by User A. Since it has been freed, User B unblocks it and makes a request to recover the content of the document.

Step 11:

The same procedure is carried out as in Step 8 and the following message appears:

User B closes the document and frees the editing permissions.

The functions used to block and unblock files are detailed in annexes 4 and 5.

Previously, the comments and calendars used U1DB, which is an API to synchronize JSON document databases created by Canonical. It allows applications to store documents and synchronize them between machines and devices. U1DB is a database designed to work everywhere, offering storage backup for the data that is native to the platform. This means that it can be used on different platforms, with different languages, with support and synchronization between all of them.

Currently, the use of the U1DB database has been removed, implementing a new Sync API which stores the comments and calendars of the user on their Personal Cloud.

The following image details how the new Sync API is implemented:

The eyeOS platform implements a tool that allows users to manage comments on files shared in the Personal Cloud. Comments can be created or deleted, and comments made by other users can also be seen.

In the settings file (See annex 1), there is the key “comments”, which indicates whether comments can be visualized or inserted in the files in the cloud. If it is deactivated(value set at false), the “Comments” tab will be shown but no comments will be listed, and new ones will not be able to be made.

The following diagram establishes a framework for detailing the process involved in checking, creating, and deleting comments based on the collaboration between two users:

Step 1:

When selecting a file shared with other users from the same or different cloud, when clicking on the “Comments” tab of the file 2005 12 10-w50s.flv (id:1950) located in the folder Information, the user stacksync will make a GET request using the valid Stacksync token to obtain the comments related to the file:

URL parameters: { “id”: “1950, “cloud”: “Stacksync”}

URL: http://api.stacksync.com:8080/v1/comment/:id/:cloud

Step 2:

It returns metadata with the list of comments associated to the file:

[ { “id”: “1950”, “user”: “stacksync”,”cloud”: “Stacksync”, ”text”: “Test 1”, ”time_created”: “201509071822”, “status”: “NEW” }, { “id”: “1950”, ”user”: “stacksync”, ”cloud”: ”Stacksync”, ”text”: ”Test user”, ”time_created”: “201509071823”, “status”: “NEW”}]

The comments are shown in a list which shows the most current comments first.

Step 3:

Clicking on the New button will bring up a form which will allow the user stacksync2 to insert a comment associated to the shared file.

A POST call is made to the Sync API to add the comment of the user *stacksync2* to the file on Stacksync:

URL: http://api.stacksync.com:8080/v1/comment

POST: { “id”: “1950”, “user”: “stacksync2”, “cloud”: “Stacksync”, “text”: “Test comment” }

Step 4:

It returns metadata with the data of the new comment.

{ “id”: “1950”, “user”:“stacksync2”, “cloud”:“Stacksync”, “text”: “Test comment”, “time_created”: “201509071827”, “status”: “NEW” }

Step 5:

The user stacksync makes a query as in Step 1.

Step 6:

It returns metadata with the comment introduced by the user stacksync2:

[{ “id”: “1950”, “user”: “stacksync2”,”cloud”: “Stacksync”, ”text”: “Test comment”, ”time_created”: “201509171710”, “status”: “NEW” }, { “id”: “1950”, “user”: “stacksync”,”cloud”: “Stacksync”, ”text”: “Test 1”, ”time_created”: “201509071822”, “status”: “NEW” }, { “id”: “1950”, ”user”: “stacksync”, ”cloud”: ”Stacksync”, ”text”: ”Test user”, ”time_created”: “201509071823”,”status”: “NEW”}]

It is possible to witness one of the more important restrictions of this tool, which is to not allow for comments made previously by another user to be deleted. In the previous image the current user (*stacksync2*), who lists the comments, is not able to delete comments made by other users, such as the comment made by *stacksync.*

If at any time the file changes its state (it stops being shared with other users), the list of comments will still be shown to the owner, but the actions of inserting and deleting them will be disabled.

The change of state is reversible, so if the file is shared again, options for inserting and deleting comments will automatically be enabled again.

Step 7:

A call is made using the DELETE method to the Sync API to delete the comment made previously by the user stacksync2:

URL parameters: { “id”: “1950”, “user”: “stacksync2”, “cloud”: “Stacksync”, ”time_created”: “201509071827” }

URL: http://api.stacksync.com:8080/v1/comment/:id/:user/:cloud/:time_created

Step 8:

It returns metadata with the data of the deleted comment.

{ “id”: “1950”, “user”:“stacksync2”, “cloud”:“Stacksync”, “text”: “Test comment”, “time_created”: “201509071827”, “status”: “DELETED” }

For more detailed information of the functions regarding comments implemented by the Sync API, refer to annexes 4 and 5.

Another function which has been affected by the new Sync API is the management of calendars and events. Previously the U1DB database was used in the same way as for comments. This is no longer available, to allow the user a comprehensive management of all of their calendars and events by associating them to a cloud.

With this API the user can carry out the different actions (create/update/delete), both with their calendars and with their events, regardless of the platform used.

When opening the calendar, a list of options is displayed:

1. Names of the different clouds able to manage calendars and registered with an access_token from the current user

2. Local calendar of the eyeOS platform.

   

To identify a cloud with calendar and event management privileges in the eyeOS platform, the settings file needs to be accessed (see annex 1), where the “calendar” key can be set at true (active) and false (not active).

When selecting a specific cloud, the user can manage their calendars and events, and see the changes applied in real time through other platforms.

The synchronization of calendars is detailed in the following diagram:

Step 1:

The user stacksync (User A), logged into eyeOS, makes a request to the cloud to obtain a list with all their calendars.

A GET call is made to the Sync API using a valid Stacksync token:

URL parameters: { “user”: “stacksync”, “cloud”: “Stacksync”}

URL: http://api.stacksync.com:8080/v1/calendar/:user/:cloud

Step 2:

It returns metadata with the list of calendars:

[{"status": "NEW", "description": "Test Calendar", "user": "stacksync", "timezone": 0, "type": "calendar", "cloud": "Stacksync", "name": "Calendar 1"}]

The calendar application adds these calendars to the list on the left side of the screen.

Every 20 seconds it checks whether the user has created a new calendar on another platform. If the answer is affirmative, the new calendar is added to the list.

Step 3:

The user stacksync (User A) creates a new calendar using the New calendar button and specifying the name that they want it to have on the cloud:

A POST call is made to the Sync API to create the calendar entered by the user *stacksync*:

URL: http://api.stacksync.com:8080/v1/calendar

POST: {"user": "stacksync", "name" : ”Calendar 2, "cloud": "Stacksync", "description": "Test Calendar2","timezone":0}

Step 4:

It returns metadata with the data of the new calendar.

{"status": "NEW", "description": "Test calendar2", "user": "stacksync", "timezone": 0, "type": "calendar", "cloud": "Stacksync", "name": "Calendar 2"}

The list of calendars is updated with the data of the new calendar.

Step 5:

The user stacksync (User A), logged in on another platform, makes a request to obtain the list of calendars. The calendar introduced previously on eyeOS is included on this list.

Step 6:

The platform will update the calendars of the user, with the data obtained in the response to the request.

Step 7:

The user stacksync (User A) creates a new calendar on this platform, identifying with a name on the cloud.

Step 8:

The platform refreshes the list of calendars including the new calendar.

Step 9:

The calendar application checks every 20 seconds to see if a change has been made in the user's calendar. When a request is made to obtain the list of calendars, it checks if a new calendar has been created from another platform.

Step 10:

The list of calendars is updated, adding the calendar created from another platform.

Step 11:

The user stacksync (User A) deletes a calendar form the context menu:

When using this option a DELETE call is made to the Sync API to delete the calendar:

URL parameters: {“user”: “stacksync”, “name”: “Calendar 2”, “cloud”: “Stacksync”}

URL: http://api.stacksync.com:8080/v1/calendar/:user/:name/:cloud

It returns metadata with the data of the deleted calendar.

{"type":"calendar" ,"user": "stacksync" , "name": "Calendar 2", "cloud": "Stacksync", "description": "Test calendar 2, "timezone": 0,"status": "DELETED"}

Step 12:

The list of calendars is updated, deleting the selected calendar.

Step 13:

The user stacksync (User A) makes a request on the other platform to obtain a list of their calendars. They check whether any change has been made to the calendars from another platform.

Step 14:

The platform deletes the calendar deleted with eyeOS from the list.

The user can synchronize their events with other platforms, selected the calendars from the list. When a calendar is selected, events can be created/updated/delted in the cloud.

The synchronization of events is detailed in the following diagram:

Step 1:

The user stacksync (User A), logged into eyeOS, selects the calendars they wish to view and makes a request to obtain all of the events associated to the calendar which are stored in the Personal Cloud.

A GET call is made to the Sync API using a valid Stacksync token:

URL parameter: {“user”: “stacksync”, “calendar”: “Calendar 1”, “cloud”: “Stacksync”}

URL: http://api.stacksync.com:8080/v1/event/:user/:calendar/:cloud

Step 2:

It returns metadata with the events associated to Calendar 1:

[{"status": "NEW", "description": "Test", "location": "Barcelona", "finalvalue": "0", "timeend": "20150828110000", "finaltype": "1", "timestart": "20150828100000", "isallday": 0, "user": "eyeos", "repeattype": "n", "calendar": "personal", "repetition": "None", "type": "event", "cloud": "Stacksync", "subject": "Test"}]

The calendar application shows the events according to the type of calendar selected by the user. Events can be viewed by day, week, or month.

In this case, the user has selected the option to view events by week.

Step 3:

When clicking on a cell in the calendar, a dialog box is shown which allows users to insert an event and associate it with a particular calendar:

A POST call is made to the Sync API to introduce an event in *Calendar 1*:

URL: http://api.stacksync.com:8080/v1/event

POST: {"user": "stacksync", "calendar": "Calendar 1", "cloud": "Stacksync", "isallday": 0, "timestart": "20150828120000", "timeend": "20150828130000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject" :"Test", "location": "Barcelona", "description": "Test", "repeattype":"n"}

Step 4:

It returns metadata with the data of the event introduced in the calendar.

{"type": "event", "user": "stacksync", "calendar": "Calendar 1", "cloud": "Stacksync", "isallday": 0, "timestart": "20150828120000", "timeend": "20150828130000", "repetition": "None", "finaltype":"1", "finalvalue":"0", "subject":"Test", "location": "Barcelona", "description":"Test", "repeattype":"n","status":"NEW"}

Calendar introduces the details of the new events in the calendar cells.

It checks every 10 seconds if any change has been made in the events from another platform. If they have, the calendar cells are refreshed with the updated events.

Step 5:

From a different platform, the user stacksync (User A) makes a query to obtain a list of events associated to the selected calendar. This list includes the event created previously from the eyeOS platform.

Step 6:

The platform updates its list of events and displays them on the screen.

Step 7:

The user stacksync (User A) can edit all the information related to the event. If the platform used is eyeOS, they need to click on a previously entered event. The following dialog box is displayed:

A PUT call is made to the Sync API to update the description of the event.

URL: http://api.stacksync.com:8080/v1/event

POST: {"user": "stacksync", "calendar": "Calendar 1", "cloud": "Stacksync", "isallday": 0, "timestart": "20150828120000", "timeend": "20150828130000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject" :"Test", "location": "Barcelona", "description": "Detail Test", "repeattype":"n"}

Step 8:

It returns metadata with the data of the updated calendar.

{"type": "event", "user": "stacksync", "calendar": "Calendar 1", "cloud": "Stacksync", "isallday": 0, "timestart": "20150828120000", "timeend": "20150828130000", "repetition": "None", "finaltype":"1", "finalvalue":"0", "subject":"Test", "location": "Barcelona", "description":"Detail Test", "repeattype":"n","status":"NEW"}

The platform updates the event with the data received from the cloud.

Step 9:

The calendar application checks every 10 seconds whether changes have been made to the events associated to the calendar. In this case, it finds that there are updates to an event made from a different platform.

Step 10:

The event is updated locally with the data received from the cloud.

Step 11:

The user stacksync (User A) can delete an event by clicking on the event and selecting delete from the dialog box to edit the event.

A DELETE call is made to the Sync API to delete the selected event:

URL parameter: { “user”: “stacksync”, “calendar”: “Calendar 1”, “timestart”: “20150828120000”, “timeend”:” 20150828130000”, “isallday”: 0}

URL:http://api.stacksync.com:8080/v1/event/:user/:calendar/:cloud/:timestart/ :timeend/:isallday

Step 12:

The event is deleted from the calendar cell.

Step 13:

The platform makes a query to check if any of the events have been changed. In this case it is seen that an event has been deleted.

Step 14:

The platform deletes the event previously deleted from eyeOS from its calendar.

For more detailed information on the reference functions of the calendars and events that the Sync API implements, refer to annexes 4 and 5.

The synchronization of comments and calendars are associated to a specific cloud, with which the configuration of the Sync API is linked to the configuration of that cloud (annex 1). In the event that synchronization in the cloud is not implemented, an external Rest API can be used, following the same defined contract in our Sync API, which can be configured in settings.php, identifying the url where our API should connect. The constant is API_SYNC.

Installation Sync API

The cloud configuration file is found at the address “/var/www/eyeos/eyeos/extern/u1db/” and is called “settings.py”.

Below is a list of components that make up the configuration of a specific cloud, in our case “Stacksync” or “NEC”:

getRequestToken(cloud)

Request the request token from a specific cloud for the eyeOS consumer.

getAccessToken(cloud, token, verifier)

Request the Access token from a specific cloud for the eyeOS consumer from a request token.

The configuration file of the Oauth API is detailed in Annex 1.

getRequestToken(oauth)

Request the request token of the eyeOS consumer.

getAccessToken(oauth)

Request the Access token of the eyeOS consumer from the saved request token.

getMetadata(cloud, token, id, path, user, resourceUrl, consumerKey, consumerSecret)

Obtain the metadata of the current element. Generate its structure from files and/or directories in eyeOS.

getSkel(cloud, token, file, id, metadatas, path, pathAbsolute, pathEyeos, resourceUrl, consumerKey, consumerSecret)

Recursively obtain the metadata that depends on the current element. Used in the action of copying and moving in eyeOS.

createMetadata(cloud, token, user, file, name, parent_id, path, pathAbsolute, resourceUrl, consumerKey, consumerSecret)

Create a new file or directory.

downloadMetadata(token, id, path, user, isTmp, cloud, resourceUrl, consumerKey, consumerSecret)

Download the content of a file.

deleteMetadata(cloud, token, file, id, user, path, resourceUrl, consumerKey, consumerSecret)

Delete an existing file or directory.

renameMetadata(cloud, token, file, id, name, path, user, parent, resourceUrl, consumerKey, consumerSecret)

Rename a file or directory.

moveMetadata(cloud, token, file, id, pathOrig, pathDest, user, parent, filenameOld, filenameNew, resourceUrl, consumerKey, consumerSecret)

Move a file or directory.

listVersions(cloud, token, id, user, resourceUrl, consumerKey, consumerSecret)

Obtain the list of versions of a specific file.

getFileVersionData(cloud, token, id, version, path, user, resourceUrl, consumerKey, consumerSecret)

Download the content of a specific version of an existing file.

getListUsersShare(cloud, token, id, resourceUrl, consumerKey, consumerSecret)

Obtain the list of users who share the directory.

shareFolder(cloud, token, id, list,shared, resourceUrl, consumerKey, consumerSecret)

Share or stop sharing a directory with a list of users.

  <span>Example:</span><br>
  <span>{ “status”: “OK”}</span><br>
  <span>{“error”: 401}</span>
</td>

insertComment(cloud, token, id, user, text, resourceUrl, consumerKey, consumerSecret)

Create a new comment associated to a file shared on the cloud.

  <span>Examples:</span><br>
  <span>{“id”: “2401”,“user”: “tester1”,”text”:”Test comments”, ”cloud”: ”Stacksync, ”status”:”NEW”, ”time_created”:”201506101548”}</span><br><br>
  <span>{ “status”: “KO”, “error”:400}</span>
</td>

deleteComment(cloud, token, id, user, timeCreated, resourceUrl, consumerKey, consumerSecret)

Delete a comment associated to a file shared on the cloud.

  <span>Examples:</span><br>
  <span>{“id”: “2401”, “user”: “tester1”, ”text”: ”Test comments”, ”cloud”: ”NEC”,

getComments(cloud, token, id, resourceUrl, consumerKey, consumerSecret, interop)

Obtain a list of comments associated to a file shared on the cloud

  <span>Examples:</span><br>
  <span>[{“id”: “2401”, “user”:“tester1”, ”text”:”Test comments”, ”cloud”:”Stacksync”,

insertEvent(cloud, token, user, calendar, isallday, timestart, timeend, repetition, finaltype, finalvalue, subject, location, description, repeattype, resourceUrl, consumerKey, consumerSecret)

Create a new event in the calendar.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”calendar”:”personal”, ”isallday”:0,

deleteEvent(cloud, token, user, calendar, timestart, timeend, isallday, resourceUrl, consumerKey, consumerSecret)

Delete an event from the calendar.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”calendar”:”personal”, ”isallday”:0,

updateEvent(cloud, token, user, calendar, isallday, timestart, timeend, repetition, finaltype, finalvalue, subject, location, description, repeattype, resourceUrl, consumerKey, consumerSecret)

Update the event data in the calendar.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”calendar”:”personal”, ”isallday”:0,

getEvents(cloud, token, user, calendar, resourceUrl, consumerKey, consumerSecret)

Obtain all the events from a calendar.

  <span>Examples:</span><br>
  <span>[{“user”:”eyeos”, ”calendar”:”personal”, ”isallday”:0,

insertCalendar(cloud, token, user, name, description, timezone, resourceUrl, consumerKey, consumerSecret)

Create a new calendar.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”name”:”personal”, ”description”:”detail”, ”timezone”:”0”,

deleteCalendar(cloud, token, user, name, resourceUrl, consumerKey, consumerSecret)

Delete a calendar.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”name”:”personal”, ”description”:”detail”, ”timezone”:”0”,

updateCalendar(cloud, token, user, name, description, timezone, resourceUrl, consumerKey, consumerSecret)

Update calendar data.

  <span>Examples:</span><br>
  <span>{“user”:”eyeos”, ”name”:”personal”, ”description”:”detail”, ”timezone”:”0”,

getCalendars(cloud, token, user, resourceUrl, consumerKey, consumerSecret)

Obtain a list with all of the user's calendars.

  <span>Examples:</span><br>
  <span>[{“user”:”eyeos”, ”name”:”personal”, ”description”:”detail”, ”timezone”:”0”,

getCalendarsAndEvents(cloud, token, user, resourceUrl, consumerKey, consumerSecret)

Obtain a list with all of the user‟s calendars and events.

  <span>Examples:</span><br>
  <span>[{“user”:”eyeos”, ”name”:”personal”, ”description”:”detail”, ”timezone”:”0”,

deleteCalendarsUser(cloud, token, user, resourceUrl, consumerKey, consumerSecret)

Delete all the calendars and events of the user.

  <span>Examples:</span><br>
  <span>{“delete”:”true”}</span><br>
  <span>{ “status”: “KO”, “error”:400}</span>
</td>

unLockedFile(cloud, token, id, user, ipserver, timeLimit, dt_now, resourceUrl, consumerKey, consumerSecret, interop)

Check if the file is blocked by another user.

  <span>Examples:</span><br>
  <span>{“id”:”2150”, ”cloud”:”Stacksync”, ”user”:”eyeos”,

lockFile(cloud, token, id, user, ipserver, timeLimit, dt_now, resourceUrl, consumerKey, consumerSecret, interop)

Unblock an eyeDocs file.

  <span>Examples:</span><br>
  <span>{“lockFile”: true}</span><br>
  <span>{ “status”: “KO”, “error”:400}</span>
</td>

updateDateTime(cloud, token, id, user, ipserver, dt_now, resourceUrl, consumerKey, consumerSecret)

Update the metadata with the date and time of the latest change.

  <span>Examples:</span><br>
  <span>{“updateFile”: true}</span><br>
  <span>{ “status”: “KO”, “error”:400}</span>
</td>

unLockFile(cloud, token, id, user, ipserver, dt_now, resourceUrl, consumerKey, consumerSecret)

Unblock an eyeDocs file.

  <span>Examples:</span><br>
  <span>{“unLockFile”: true}</span><br>
  <span>{ “status”: “KO”, “error”:400}</span>
</td>

getMetadataFolder(cloud, token, id, resourceUrl, consumerKey, consumerSecret)

Obtain the file structure of a file in the cloud.

  <span>Examples:</span><br>
  <span>{

The configuration file of the Storage API is detailed in Annex 1.

getMetadata(oauth, file, id, contents)

Obtain the metadata of a directory and/or files.

updateMetadata(oauth, file, id, name, parent)

Update the metadata of the element when renaming and moving.

createMetadata(oauth, file, name, parent, path)

Create a new element (file or directory).

uploadFile(oauth, id, path)

Upload the content of an existing file.

downloadFile(oauth, id, path)

Download the content of an existing file.

deleteMetadata(oauth, file, id)

Delete an element (file or directory).

getFileVersions(oauth, id)

Obtain the list of versions of a specific file.

getFileVersionData(oauth, id, version, path)

Download the content of a specific version of an existing file.

getListUsersShare(oauth, id)

Obtain the list of users who share the directory.

shareFolder(oauth, id, list, isShared)

Share or stop sharing a directory with a list of users.

insertComment(oauth, id, user, text, cloud)

Create a new comment associated to a file shared on the cloud

Create new comment in the cloud through the use of the Sync API

deleteComment(oauth, id, user, cloud, time_created)

Delete a comment associated to a file shared on the cloud.

Delete a comment in the cloud through the use of the Sync API

getComments(oauth, id, cloud, interop)

Obtain the list of comments of a file shared on the cloud

Obtain the list of comments of the file in the cloud through the use of the Sync API

insertEvent(oauth, user, calendar, cloud, isallday, timestart, timeend, repetition, finaltype, finalvalue, subject, location, description, repeattype)

Create a new event in the calendar.

Create new event in the cloud calendar through the use of the Sync API

deleteEvent(oauth, user, calendar, cloud, timestart, timeend, isallday)

Delete an event in the calendar.

Delete an event in the calendar in the cloud through the use of the Sync API

updateEvent(oauth, user, calendar, cloud, isallday, timestart, timeend, repetition, finaltype, finalvalue, subject, location, description, repeattype)

Update the event data in the calendar.

Update an event in the calendar in the cloud through the use of the Sync API

getEvents(oauth, user, calendar, cloud)

Obtain a list with all the events in the calendar.

Obtain the list with the events in the calendar in the cloud through the use of the Sync API

insertCalendar(oauth, user, name, cloud, description, timezone)

Create a new calendar.

Create a new calendar in the cloud through the use of the Sync API

deleteCalendar(oauth, user, name, cloud)

Delete a calendar.

Delete a calendar in the cloud through the use of the Sync API

updateCalendar(oauth, user, name, cloud, description, timezone)

Update calendar data.

Update a calendar in the cloud through the Sync API

getCalendars(oauth, user, cloud)

Obtain the list with all the user's calendars

Obtain the list of all the calendars in the cloud through the use of the Sync API

getCalendarsAndEvents(oauth, user, cloud)

Obtain a list with all the user‟s calendars and events.

Obtain a list of all the calendars and events in the cloud through the use of the Sync API

deleteCalendarsUser(oauth, user, cloud)

Delete all the calendars and events of the user.

Delete all the calendars and events in the cloud with the Sync API

lockFile(oauth, id, cloud, user, ipserver, datetime, timelimit, interop)

Unblock an eyeDocs file.

Block the eyeDocs file in the cloud through the use of the Sync API

updateDateTime(oauth, id, cloud, user, ipserver, datetime)

Update the metadata with the date and time of the latest change.

Update date and time of last change in the eyeDocs file in the cloud with the Sync API

unLockFile(oauth, id, cloud, user, ipserver, datetime)

Unblock an eyeDocs file.

Unblock the eyeDocs file in the cloud through the use of the Sync API

getMetadataFile(oauth, id, cloud, interop)

Obtain the metadata of the file.

Obtain the metadata of the eyeDocs file in the cloud with the Sync API