FAQ's - Frequent answer questions

You'll find all the online documentation of the SaltOS project.


From the November 17, 2014, the access to the Google's API v1 and v2 services have stopped working forcing all developers to migrate their code to the new API v3 (https://developers.google.com/api-client-library/php/). In SaltOS, like other applications, we had to make this change and it makes everything work.

Previously, access to the service could be obtained using the user+password for the service account. Currently this no longer works well, but must obtain a token that will allow us to use the service in future access until the user revokes the token. For this it is necessary to create a key from the console of the google developers. There are 2 types: for online application and therefore will be linked to a host, or application installed, which is not associated with a host. This second case is that we have used to create the key to access the service because the first not worth us.

Currently, when it is necessary that the user is authenticated, the API proposes to redirect our page to Google where you should follow three steps:

1) If you are not logged into Google, it asks the email and password to Google.
2) You are asked if you want to give permission for the application to access data on the desired application (Google Calendar in the SaltOS's case).
3) A screen appears with a text box containing the token and explain to the user that must to copy and paste the core into the application.

If the key has an associated host, point 3 is automatic, because it is redirected to the host passing the token as parameter. In our case we have created a key for installed application and no host redirection works.

As you can see, it is a tedious process for the user, and from SaltOS, we have programed a solution to automate this process caused by the lack of a mechanism for direct authentication from Google API v3. The "trick" is to make the steps that Google want to get the token (token1 onwards) by programmatically.

This token must be passed to the google client authenticate method and this will get the second token (token2 onwards) which will be used in future requests to access the service. To summarize:

1) If we have not the token2, we get the token1 user+password and authenticate. The token2 used in future requests will be obtained using the getAccessToken.
2) if we have the token2, we use it to authenticate using setAccessToken

To do this, SaltOS defines the following functions:

function __gcalendar_getattr($html,$attr)

This function returns the value of the first attribute in $html. For example, if you pass $html a node <form> and pass in $attr the string "method", it returns GET or POST.

function __gcalendar_getnode($html,$name)

This function returns the portion of $html code that tag is $name. For example, if you pass an html form node and the node <form> is requested, this function will return the html code from <form> to </form> with everything that contains this form.

function __gcalendar_parse($html)

This function returns an array with 3 data elements from the first form found in $html:

1) method.
2) action.
3) An array with a list of key=>value where key is the name of the inputs and value are the values of the inputs
.
function __gcalendar_request($url,$method="",$values=array(),$cookies=array(),$referer="")

This function uses an used SaltOS's class (http://www.phpclasses.org/package/3-PHP-HTTP-client-to-access-Web-site-pages.html) which allows http requests quickly.

This function makes a request to the $url, using the $method, sending variables array $values, using the cookies contained in the $cookies array and using as referer the $referer variable. Returns an array with 3 elements:

1) The body.
2) An array with the headers.
3) An array with cookies.

function __gcalendar_token1($client,$login,$password) {
    $url=$client->createAuthUrl();
    list($body,$header,$cookies)=__gcalendar_request($url);
    // PROCESS LOGIN PAGE
    $parsed=__gcalendar_parse($body);
    $parsed["inputs"]["Email"]=$login;
    $parsed["inputs"]["Passwd"]=$password;
    $parsed["inputs"]["continue"]=str_replace("&","&",$parsed["inputs"]["continue"]);
    list($body,$header,$cookies)=__gcalendar_request($parsed["action"],$parsed["method"],$parsed["inputs"],$cookies,$url);
    // PROCESS ACCEPT PAGE
    $url=$parsed["action"];
    $parsed=__gcalendar_parse($body);
    $parsed["action"]=str_replace("&","&",$parsed["action"]);
    $parsed["inputs"]["submit_access"]="true";
    list($body,$header,$cookies)=__gcalendar_request($parsed["action"],$parsed["method"],$parsed["inputs"],$cookies,$url);
    // PROCESS TOKEN PAGE
    $html=__gcalendar_getnode($body,"input");
    $token1=__gcalendar_getattr($html,"value");
    return $token1;
}

This function is the most interesting of the whole explanation, because using the above functions, manages to get the first token to access Google Calendar service.

To do what it does is:

1) Get the url authentication $client object
2) Make the first request. This first request will get the HTML code of the page you requested that ask email and password to access Google.
3) Obtain the action, method and list of variables of the form from the resulted body.
4) Set the Email and Passwd inputs of the form
5) The second request with action, method and list of modified variables. This second request will get the HTML code of the page that prompts the user for permission to access Google Calendar.
6) Obtain the action, method and list of variables of the form from the resulted body.
7) Set "true" to the "submit_access" input
8) The third reqiest with the action, method and list of modified variables. This will return an html page with an input containing the token we need.
9) In the body of the results, we get the node <input> and from it node, gets the value of the "value" attribute. With this we have the token.

Notes:

- Point 1 is simple using Google API v3
. - In sections 2, 5 and 8 are 3 requests to pages that need (access to google, permission to the application and obtaining token)
. - In sections 3 and 6, we get the action, method and variable list from the form
. - In sections 4 and 7, we modify the form (emulating user interaction)
. - Point 9 is to process the results page
.
function __gcalendar_connect($login,$password) {
    $client=new Google_Client();
    $client->setAuthConfigFile("lib/google/saltos.json");
    $client->setRedirectUri("urn:ietf:wg:oauth:2.0:oob");
    $client->addScope("https://www.googleapis.com/auth/calendar");
    $client->setAccessType("offline");
    $token2=execute_query(make_select_query("tbl_gcalendar","token2",make_where_query(array(
        "id_usuario"=>current_user()
    ))));
    if($token2!="") {
        $client->setAccessToken(base64_decode($token2));
        if($client->getAccessToken()) return $client;
    }
    $token1=__gcalendar_token1($client,$login,$password);
    if($token1=="") return null;
    $client->authenticate($token1);
    $token2=$client->getAccessToken();
    if(!$token2) return null;
    $query=make_update_query("tbl_gcalendar",array(
        "token2"=>base64_encode($token2)
    ),"id_usuario='".current_user()."'");
    db_query($query);
    return $client;
}

This function returns an object that will allow to access to the Google Calendar service.

Create a Google_Client object, sets the file that contains the key created for our project, set where we want access, access type and:

1) If we already have a token2 in the database, we use it to authenticate yourself by setAccessToken. If this is valid through getAccessToken, return the $client.
2) If token2 is invalid or does not exist, we call the above function (__gcalendar_token1) that by the above trick we return the token1 access for get the token2.
3) With the above token1, call the authenticate function and obtain the token2 by getAccessToken.
4) If all went well and we have already token2, we will keep in the database to reuse the token2 in future SaltOS requests.

More info:

For more details about what I explained here, you can see the SaltOS's source code and in particular the file php/action/gcalendar.php.

Credits:

This R&D work has been carried out by Josep Sanz and Jordi Company.

The following explains how to install SaltOS quickly with a free web host:
  1. Access any of the following vendors (there are a lot of other sites with the same benefits, conditions and are still free)
    1. http://www.000webhost.com/
    2. http://www.nixiweb.com/
  2. Create a hosting (the first let you have a custom url, but the second does not, they propose other services that are also free)
  3. Access hosting control panel you've created before
  4. Download the nightly SaltOS (file .tgz)
  5. Rename it to .tar.gz in the computer where you download it
  6. Depending on the hosting and language, search through the control panel for the option:
    1. "1-Click Website Restore"
    2. "Importar Sitio"
    3. "Import website"
  7.  Wait while the file is uploaded to the server (this can be quite time consuming, depending on the bandwidth that you have available)
  8. Go to hosting website you have created in step 2 and voila :) the SaltOS installer is waiting to you.
  9. Press the Next button on all screens until SaltOS is fully installed.
Notes about the hostings:
  • The hostings list above are merely examples, I do not have any favorite among them.
  • SaltOS has been tested with these hosts (hence appearing here)
SaltOS installation notes:
  • If you want to use a different user name/password to admin/admin, you can modify it at step 3
  • If you want to load some example data, check the appropriate option in step 3
  • Street data can cause problems and may only contain the streets of Spain.
Since PHP 5.3.9, has been added max_input_vars configuration directive which limits the number of variables that can get for $_GET, $_POST and $_COOKIE. This has led to applications using forms with many input type checkbox / hidden / text, may have problems in receiving data loss from the server.

This directive basically mitigates the possibility of denial of service attacks using hash collisions. Therefore, it may happen that in some hostings this variable exists and is restricted to its default value (1000) and have no option to increase the value. If this happens, you must either:
  • Rethinking application not to exceed the maximum number of variables (some really expensive in some cases)
  • Use the technique that I will describe below will solve this problem in a transparent manner without touching anything on the server side.
The technique is to anticipate the server, ie, if we know in advance the limitation may be the server that will receive the form with more than N variables, we can do the following:

1) From a php, inform the client about the value of the variable max_input_vars:

<?php
function ini_get_max_input_vars() {
	return '".intval(ini_get("max_input_vars"))."';
}
?>

2) From the client, before sending the form, add this code:

<script>
var max_input_vars=ini_get_max_input_vars();
if(max_input_vars>0) {
	var total_input_vars=$("input,select,textarea",jqForm).length;
	if(total_input_vars>max_input_vars) {
		var fix_input_vars=new Array();
		$("input[type=checkbox]:not(:checked):not(:visible)",jqForm).each(function() {
			if(total_input_vars>=max_input_vars) {
				$(this).remove();
				total_input_vars--;
			}
		});
		$("input[type=checkbox]:checked:not(:visible)",jqForm).each(function() {
			if(total_input_vars>=max_input_vars) {
				var temp=$(this).attr("name")+"="+rawurlencode($(this).val());
				fix_input_vars.push(temp);
				$(this).remove();
				total_input_vars--;
			}
		});
		$("input[type=hidden]",jqForm).each(function() {
			if(total_input_vars>=max_input_vars) {
				var temp=$(this).attr("name")+"="+rawurlencode($(this).val());
				fix_input_vars.push(temp);
				$(this).remove();
				total_input_vars--;
			}
		});
		fix_input_vars=base64_encode(utf8_encode(implode("&",fix_input_vars)));
		$(jqForm).append("<input type='hidden' name='fix_input_vars' value='"+fix_input_vars+"'/>");
	}
}
</script>

3) Since php has to receive the data, add this code before you start processing the request:

<?php
if(intval(ini_get("max_input_vars"))>0) {
	$temp=getParam("fix_input_vars");
	if($temp!="") {
		$temp=querystring2array(base64_decode($temp));
		if(isset($_GET["fix_input_vars"])) {
			unset($_GET["fix_input_vars"]);
			$_GET=array_merge($_GET,$temp);
		}
		if(isset($_POST["fix_input_vars"])) {
			unset($_POST["fix_input_vars"]);
			$_POST=array_merge($_POST,$temp);
		}
	}
}
?>

Notes:
  • The concept is:
    • Report to the client the max_input_vars server value
    • From the client, proceed to reduce the variables if necessary until the condition that the number of variables is less than the maximum.
    • Thus, it can add an auxiliary variable which will contain the other variables embedded
    • From reception, detect this case and do the reverse step to leave everything as it has to be
  • In the code snippet 2:
  • In the code snippet 3:
    • The functions getParam y querystring2array are functions provided by the SaltOS project (see the file php/strutils.php)
  • For more info, you can look at the source code of SaltOS that incorporates this trick.
After several business transactions that have led to MySQL from one side to another, finally now owned by Oracle (company dedicated to commercialize other proprietary DBMS). From my point of view (I don't know if this expression is correct in english!!!), these facts have led to the MySQL open source project to live an overall deterioration since this database management system (DBMS) currently offers a very low yield, which is latent in SaltOS when the system has a large number of data.

The tests I use to optimize queries of SaltOS uses a predefined data packet and running on SQLite and MySQL (the currently supported DBMS). To measure the response time, I use the time and the wget commands from the command line, so I can get a quick idea of ​​the efficiency of queries while I'm developing. The differences between these two systems for the queries related to the email application and the same data set are:
  • page=correo&action=list: 289ms (SQLite) vs 1548ms (MySQL)
  • page=correo&action=quickform: 286ms (SQLite) vs 1380ms (MySQL)
As can be seen, the difference is substantial: SQLite only requires 20% approx. that the time needed by MySQL. After reviewing and trying to make optimizations, all useless by the way, I discovered MariaDB, a fork of the MySQL project, by one of the authors of MySQL who left his job after understanding, without anyone to explain anything, of the intentions that had the new company with MySQL. I installed quickly this replacement on my laptop, from the project's own repositories for Fedora 17 and voila, already had a running MariaDB instead of MySQL. My surprise was substantial when you run the tests for the same application, I observed that queries MariaDB ran with speeds similar to those of SQLite:
  • page=correo&action=list: 288ms (SQLite) vs 413ms (MariaDB)
  • page=correo&action=quickform: 285ms (SQLite) vs 335ms (MariaDB)
Incredibly, it had reduced the runtimes of MariaDB without make anything. Everything still works ok, phpMyAdmin works ok, Saltos works ok and RhinOS too works ok on MariaDB, the really free replacement of MySQL. See the link for more info about the MariaDB project:
How to install MariaDB in Fedora 17?

The installation process of the MariaDB in fedora 17 is very simple, just follow these steps and voila:

1) Add the MariaDB repository

[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/5.5/fedora17-amd64
gpgcheck = 1
enabled = 1

2) Run the following commands

service mysqld stop
rpm -e --nodeps mysql-libs mysql-client mysql-server
rpm --import http://yum.mariadb.org/RPM-GPG-KEY-MariaDB
yum install MariaDB-server MariaDB-client MariaDB-common MariaDB-compat MariaDB-shared
service mysql start
service httpd restart

3) If when you access to phpMyAdmin, do you get the error about that the mysqli extension is not found, it's because you're using the php-mysql package instead of php-mysqlnd, and can be solved formally doing:

rpm -e --nodeps php-mysql
yum install php-mysqlnd
service httpd restart

Notes:
  • You can ignore the error messages that appear saying that there are some mysql needed files, because when you install MariaDB, dependencies are checked and detect that there are packages that have dependencies of the uninstalled packages.
  • Regarding the repositories: there are all these repositories (the example install the Fedora 17 to 64 bits repository):
    • centos5-amd64
    • centos5-x86
    • centos6-amd64
    • centos6-x86
    • fedora16-amd64
    • fedora16-x86
    • fedora17-amd64
    • fedora17-x86
    • rhel5-amd64
    • rhel5-x86
    • rhel6-amd64
    • rhel6-x86
Updated (2013-09-07):

Great news: Fedora 19 has replaced MySQL by MariaDB. Like many other distributions, when installing Fedora 19, is installed MariaDB by default instead of MySQL.
SaltOS is distributed in 4 different packages:
  • PHP: This package contains the program SaltOS and includes everything necessary to uncompress and unpack the program online. To use this package, please download the package and leave it in a directory on your hosting visible from the Internet. Access the installation file with a browser and the screen "Welcome to SaltOS setup" appear. Follow these steps to install quickly SaltOS in your server.
  • RPM: This package is aimed at users who use RPM-based servers such as RedHat, CentOS, Fedora and many others who have chosen this package format. To install this package, simply run from a terminal with root permissions the following command: "rpm -i PACKAGE.RPM". SaltOS will be installed on your system. After installing the package, access from a browser to the url of the hosting using http://www.example.com/saltos/. This url will give access to the "Welcome to SaltOS setup". Also create a shortcut in the applications menu so you can access easily.
  • EXE: This package is aimed at users who want to try SaltOS on a computer running Microsoft Windows (XP, Vista or 7). To install this program, you must download the EXE format package on your computer and run it. The installation wizard that appears install on your computer the SaltOS program. Additionally, also installs Apache 2 and PHP 5.3 required for running the SaltOS program. If your computer already has installed these programs, use another package format. After installing the package, access from a browser to the url of the hosting using http://www.example.com/saltos/. This url will give access to the "Welcome to SaltOS setup". Also create a shortcut in the applications menu so you can access easily.
  • TGZ: This package contains the source code of SaltOS. Is aimed at expert users or for updates that do not require initial setup process provided by the "SaltOS setup".
SaltOS, creates 2 directories called:
  • code: This directory contains the source code of the application. When you want to upgrade SaltOS, simply replace this directory by the new directory code of the new package.
  • user: This directory contains the same directory structure as the code using symbolic links to the code directory. This allows the application to run in this directory, saving data and user settings, and it is separated logically from the directory containing the source code. This type of directory that contains symbolic links only, is what is called an instance of the application. If we have n instances for n companies, simply replicate the user directory, but only having 1 copy of the application source code.
SaltOS using external programs:
  • xsltproc: This program will be necessary only if the PHP installation does not support DomDocument or XSLTProcessor. In the remaining cases will never be used.
  • unoconv: This program allows to SaltOS to convert any document to PDF format for viewing with the online PDF viewer.
  • elinks: This command allows you to convert text emails and feeds downloaded. Required for email and feeds applications.
  • text2wave: This program allows you to convert text into sound. It will be necessary for the voice feature.
  • ffmpeg: This program allows you to convert .wav files to .mp3 files. It will be necessary for the voice feature.
  • apertium: This program allows you to translate text into different languages. It will be necessary for the online translation feature.
  • calc: This program allows you to perform mathematical operations. It will be necessary for the online calculator feature.
  • aspell: This program allows you to correct texts in different languages. It will be necessary for the online translator and check speller.
  • zcat: This program is only used in the installation process. If not available, the installer requires more installation time, but it will work.
  • sqlite3: This program is only used in the installation process. If not available, the installer requires more installation time, but it will work.
  • mysql: This program is only used in the installation process. If not available, the installer requires more installation time, but it will work.
SaltOS, can use 6 different drives for accessing databases:
  • SQLite (PDO): This driver uses SQLite and is recommended for simplicity of installation and the efficiency in most cases. Use the php-pdo package and normally include support for SQLite and MySQL.
  • MySQL (PDO): This driver is the same as above but using MySQL instead of SQLite.
  • SQLite (extension): This driver allows you to use sqlite native functions but usually are outdated and therefore fail the test of GROUP_CONCAT.
  • MySQL (extension): This driver allows you to use sqlite native functions and usually tend to use the latest versions happening in most cases the test of GROUP_CONCAT.
  • SQLite (binary wrapper): This driver allows those servers where no other driver work correctly the use of the sqlite binary (downloadable from http://www.sqlite.org/download.html) using communication pipes and shared files, execute queries to SQLite database enabling the smooth SaltOS function.
  • MySQL (improved extension): This driver is an evolution of MySQL native driver. It is not usually installed on the servers.
The 500 error is an error generated by the server when it encounters an error condition that can not resolve automatically. That is, if a file is not found, the error is 404 (Not found), if you can not lists a directory, the error 403 will be launched (Forbidden). For errors that do not have an explicit definition, will raise the error 500 (Internal error).
 
This error usually occurs in Apache:
  • when used in the .htaccess file some unsupported directives.
  • in some hostings where by security constraints limit the execution of PHP scripts, for example, only if the write permissions are restricted to the propietary user (chmod 0644).
That is, when a 500 error, we must try to disable directives located in the .htaccess files and check the permissions of your PHP scripts.
After a few months to be with us the new Microsoft browser, Mr. Internet Explorer 9, some visitors saltos.net informed me that the web did not look properly using this browser.

After watching what was happening, detected from the apache logs that requests for style sheets that make Internet Explorer 9, were answered by the apache server itself with an error HTTP 406 Not acceptable (not acceptable).

This portal is developed using the RhinOS technology, which generates PHP style sheets from templates. This means that in reality the CSS request is made, even if they are made to a static .css file, is served by a PHP script that will intercept the request to consider and respond with the contents of the CSS and headers corresponding with the content-type "text/css".

As the new browser sends the header "Accept: text/css" only instead of what everyone does it "Accept: text/css; */*", the apache server does not process with php the request and not finding a way to resolve it, send the error 406.

To fix this problem, simply add in the .htaccess file the follow line: "AddType text/css .php". With this entry in the .htaccess file, the server may relate the requests to a .php with Accept "text/css", so that everything will work as usual.

If the server has disabled the .htaccess overload feature, RhinOS provides another method that is to use an alternative url that solves the problem. To do this, simply add the tag <!-- INCLUDE PRINT_BASE_IE9CSS --> in the CSS file path. Automatically, detects the IE9 client and the new url is published to serve the content without generating the 406 error.

Thanks Microsoft for making things easier!!!
SaltOS has experienced several transformations since I began the development. Here I show some screenshots where you can see how it all started...

The second version of SaltOS, began to use the blue color, but still did not know about jQuery-UI...

And finally, I began to use the jQuery and jQuery-UI framework, rewriting the interfacing with the current graphical style, too I began to use the AJAX technology in all of the transactions.

I hope that you like the SaltOS graphical style...
Some time ago I use JQuery-UI to do the user interfaces of my applications. From the beginning, SaltOS has incorporated the 24 themes predefined in the ThemeRoller application.

These themes are practical and the colors are well combined, but I detect a problem in SaltOS: JQuery-UI defines styles for the Header, Content, Default, Hover, Active, Highlight and Error classes (among others) and when I make a list or a menu as in SaltOS, using multiple classes to mark the odd and even rows, to program the hover effect (I use the highlight class instead of the hover class because it is more visual) or even the background of the page itself. This causes that some themes are not "pretty" to be used and only end up using some of the 24 themes.

This problem is not a problem of the JQuery-UI. The problem is how SaltOS uses the color combinations (and you have to be realistic, make an application with graphical environment is no easy task).

The solution has been to use a theme as base (Redmond) and program something that allows colorize this theme (which is blue-leaning) using other base colors and so have a unique theme that is "nice" to see and you may swap among several palettes.

To do this, I researched the ThemeRoller application to see how it generates the themes (CSS + images) and program an equivalent ThemeRoller code to colorize the SaltOS themes. Now has 18 themes based on permutations of Redmond theme colors (there are 9 white themes and 9 black themes).

Whoever wants to see the ThemeRoller integrated in SaltOS, visit the demos and whoever wants to see how is programmed, see the contents of the files themeroller.php and themeroller.xml in the source code.
Desktop Notifications is a feature defined and used by Google (with Google Chrome and GMail products) for displaying notifications integrated in the user's own desktop when an event occurs.

SaltOS, also adds support to redirect notifications that appear within the application to the user's desktop. For example: when receiving a new mail, a new post or just trigger a calendar alarm, SaltOS shown in the user's desktop a message indicating the event.

Additionally, SaltOS includes other mechanisms to alert users as favicon animation and voice notifications, allowing users to hear the messages and to hear the subjects of the mails, posts and events.

For Firefox, there are extensions that add support to the browser to use the integrated desktop notifications: https://addons.mozilla.org/es-ES/firefox/addon/html-notifications/
SaltOS appears in the publication of March, number 124, of the journal Todo Linux. The article is called "SaltOS: CRM and ERP opensource", written by Arturo Fernandez and leaves us pretty well.





Introduction:
 
The Cloud Computing, also called nuve computing is the term used to discuss the concept of having the applications from the Internet.
 
To understand the difference between Cloud Computing and the traditional model, explain some parts of the brief history of computing:
  • At the beginning of the computer, applications running on servers and users operating terminals (also called dumb terminals) and had no specific functionality. Were connected to the server via Telnet and operated by terminals.
  • The emergence and evolution of operating systems, led to decentralized computer systems allowing to have a computer with your operating system and applications installed on it (this is the model that is currently used in most cases). This model has the disadvantage that for large business infrastructure, the maintenance cost is very expensive and complex.
Explanation:
 
The Cloud Computing, is a mixture of the two models. Currently users have computers with operating systems and certain features built into them. The Cloud Computing wants to use the model based on client-server where applications (code + data) are centralized and located on a server or server farm and client can work with a simple client application type (which is usual a web browser).
 
The technology also allows for solving certain problems present the first model (centralized server) as the management of resources. Until now, companies engaged in a finite and limited number of resources for an application or service, but if the computational load exceeded this forecast, obtained a denial of service due to overload. Cloud Computing The concept also includes the dynamic provisioning of resources (CPU, RAM, hard drive, peripherals, etc ...). In this way ensures that an application will spend only what you need, when overloaded, new machines will be activated computer to output to the needs of that moment in time.
 
This ends up being a benefit to anyone because it provides the following enhancements:
  • Advantages of centralization: it is easy to back up (usually does the service provider itself).
  • Universal Access: anywhere, can be employed if desired applications have access to the Internet.
  • Low maintenance costs: an update applies to all users quickly and safely without having to go team by team by applying patches.
But it also has disadvantages:
  • Supplier dependence: if the service provider cut us, we ran out of application.
  • In some cases, the data is held by third parties and we will have the technological dependency of your application and data (it is important to export the data in a standardized format for application to change or dispose of the sources of the application that created).
Conclusion:
 
In conclusion, to say the market's natural tendency is towards the nuve applications and technologies using RIA (Rich Internet Applications). SaltOS was therefore designed as a RIA for nuve or more commonly known as Rich Internet Application & Cloud Computing.
Introduction:
 
POP (Post Office Protocol) and IMAP (Internet Message Access Protocol) are two protocols that allow access to mail folders incoming mail server (not allow sending mail). We can refer to POP with POP3 (latest version) and IMAP with IMAP4. These protocols are supported by most existing mail servers.
 
Advantages and disadvantages of POP3 vs. IMAP4:
  • The number of transactions is low, which is efficient.
  • No correlation between the mailing list with the identifiers are used, so each time you connect, you must download the mailing list with your ID (UIDL's).
  • Lets work offline, as customer data is downloaded and managed from within the client application.
  • You can only manage a single folder.
  • The management is simple, it can not mark a message as read on the server, the client is up to that effort.
Advantages and disadvantages of IMAP4 vs. POP3:
  • The number of transactions is high, thus requiring greater connectivity between client and server.
  • Lets work offline but you must connect to the server for updates in the states of the e-store (if you read an email on the client, indicate on the mail server that is already read with another client that uses the same protocol , will already have read this email and not marked as new)
  • You can handle multiple folders (there is only one inbox, but you can move mail to another folder on the server itself).
  • Management is more complex, since each action that makes the client must be notified to the server to maintain consistency (if you read mail from a client, other clients should update their status to read, although it depends on the complexity implement the client).
Conclusion
 
The two protocols provide the basic service for managing email. Keep in mind if you want a distributed system of clients or customers a unified system. For example, if you use multiple email clients like Evolution and Thunderbird, it is interesting to use IMAP4. If instead, you choose to read only the mail using an application such as SaltOS, then POP3 is a good choice, because management is not required on the server unread emails, folders and other benefits it brings as they IMAP4 because SaltOS integrates these benefits in the mail client itself.
MariaDB (the new MySQL really free) is one of the management systems relational databases known in the world of free software (in fact, is used to indicate LAMP for Linux + Apache + MariaDB (MySQL) + PHP).
 
SQLite3 is another management system databases, but oriented embedded applications, used in applications like Firefox, Thunderbird, Android, i and to complete a long list of programs that use it.
 
The differences are basically that MariaDB (MySQL) is a server that services requests to be made to a port using a TCP/IP village while SQLite3 is more than a server, a library supported by most programming languages and providing access to a local file as a database is involved.
 
So as a summary we can say that SQLite3 is a database-oriented file while MariaDB (MySQL) is oriented as a service.
 
The problem I often have the database file is aimed at the crowd (check when you write another does not do to maintain the integrity of the file itself).
 
In SaltOS, is solved using POSIX semaphores that allow this type of control and thus avoid concurrent access 2 threads on the server, for example, at the same time to write.
 
SaltOS APIs define 2 functions calls semaphore_release and semaphore_acquire, which internally uses the PHP flock function that allows precisely the control of locking a file that is defined as a semaphore.
 
With this mechanism, it prevents competition on the SQLite3 database ensures the integrity of the file, and therefore the data.
SaltOS is a trick of words between the sugar and salt.
 
When the company was created in 2007, sought a solution for managing existing business. One of the premises was the use of emerging technologies and it was supported by most hosting companies such as PHP.
 
At that time, we only found a software called SugarOS (now called SugarCRM) and after trying, we decided to undertake the adventure of creating a new application that would apply evolutionary quickly.
 
As the last option we reviewed was Sugar and "sugar" is "sugar" in English, decided to turn around and build the name with "Salt" and "OS" resulting in the word SaltOS, which also has correspondence in Spanish with an existing word.
 
OS termination is typically used in the operating systems projects, but in our case, the OS termination is Open Source.
Yes. The terms of the GPL-3.0 state that any modification being distributed to the public, must provide its source code.
No. If you use the program as amended in a private setting or in your own company, you are not obligated to share it with anyone.
At the moment there is no partner program and you can get technical support asking to the forum.
The SaltOS qualities that make it a good candidate to develop CRM/ERPs are:
  • Using emerging technologies such as PHP, XML, XSLT and Javascript.
  • Simple and fast interface.
  • Easy configuration and parameterization
  • Simple data model
  • Friendly pseudo-language based on XML tags
  • Quick and easy creation of new applications
Besides the above, SaltOS has a community that   evolves it constantly.
This project began as an internal development to solve a requirement itself: WS3 management.

After searching through numerous existing projects, we find that there are several solutions but all had drawbacks:
  • Some were based  on Java technology, which made complex and expensive to find hosting companies that give that service.
  • The coding was not layered, with HTML, CSS and PHP mixed in a single piece of code.
The facts led us to develop a simple application that uses PHP technology, XML, XSLT and JavaScript resulting in SaltOS.
No, the released versions can not suffer any change in their conditions.
No, as our programs are Free Software, you are not subject to any fee or royalty for use.
 
 
These are the main advantages of free software:
  • You don't have to pay any license fee or royalty. This leads to significant savings in the acquisition and holding.
  • You are free to use and distribute.
  • The source code is accessible, so you may modify the application to fit your needs. This also guarantees the independence of supplier.
The company Wide Spectrum Software Solutions SL firmly believed in the philosophy of Free Software and wanted to contribute their grain of sand to the community.

Currently, the company has ceased operation, and Josep Sanz Campderrós, co-founder of the company, continues its own with the development of these free software projects released under GPL-3.0

Any person or company wishing to use our products, can do so without paying any license, initial or annual. This amount represents a cost saving that can be invested in the customization and adaptation of the product.