Pas facile de trouver un hébergeur gratuit de WAR

       

Pas facile de trouver un hébergeur gratuit de WAR Full JAVA. Heureusement avec le Cloud, de nombreux services apparaissent et permettent gratuitement de disposer de JVM gratuites, d'espaces gratuits de stockage, et d’innombrables services complémentaires.

Hébergeur WAR CLOUDBEES :

    Ce site vous permettra de déposer 5 WEBAPP de manière gratuite. Certe la mémoire max sera limitée à 128M, mais c'est déjà pas mal. Au chapitre des services tous aussi gratuits : 

       - Possibilité de configurer une base de données MYSQL (Pour notre application, cela ne nous concerne pas trop, puisqu'une configuration DB4O a été retenue, on verra par contre l'inconvénient de CloudBees)

           -  Mise à Disposition d'outils d'analyse de votre code.

           -  Intégration continue avec Jenkins.

           -  Repository Maven, Subversion ..

           -  Intégration dans Eclipse.

           -  Total management de vos applications.

           -  Mise en sommeil de l'application

Accès à la console d'administration

2 possibilités pour déployer les wars :

               1) Dépose par upload du war (classique, mais lent tout dépend de votre taux de transfert en upload)

                   2) Compilation et déploiement depuis le dépot Cloudbees, utilisation du SDK à intégrer dans Eclipse (plus rapide, la compile et le déploiement se faisant à distance). Intéressant en cas de "fat" war.

      Inconvénient pour HomeAutomate. L'utilisation de DB4O comme base de données Objets nécessite la présence d'un filesystem permanent. Or, avec CloudBees, le filesystem et purement volatile. La JVM disposera au démarrage d'un filesystem mais qui sera complètement purgé au redémarrage de l'application. On se voit donc mal y stocker le fichier DB4O.

      L'idée étant de disposer un espace de stockage gratuit sur le Cloud, nous permettant de stocker / récupérer un fichier de manière autonome. Le best-of serait qu'en plus cet outil dispose d'API JAVA permettant d'y accéder programmatiquement. Ainsi à chaque démarrage d'HomeAutomate à l'aide d'un properties embarqué, l'application irait chercher la dernière sauvegarde de la base. Une sauvegarde automatique serait également intégrée dans le SystemManager, permettant de sauvegarder à intervalles réguliers, ou en fonction de l'activité.

     Je suis donc tombé sur DROPBOX (Il y a également depuis peu GoogleDrive), DROPBOX semble plus robuste et plus expérimenté pour ce besoin. Biensur le compte est gratuit, on dispose de 2go nativement et totalement expandable via $$. Il existe des clients OS Windows, Linux et Mac. Sous windows, l'installation ajoute automatiquement un lecteur réseau où vous pouvez glisser/coller vos fichiers à sauvegarder (J'imagine même principe pour les autres).

          Cette fonctionnalité n'est pas transcendante, ce qui m'intéresse, ce sont les API proposées par DropBox pour les développeurs, on y retrouve donc tous les environnements du moments proposés :

Et donc celui qui nous intéresse c'est JAVA. Après différentes recherches dans le forum expliquant le mode d'authentification par systéme de clés publiques puis clés privées, voici l'explication. 

       Lorsque vous utilisez une API pour une application, vous déclarez l'application sur le site. Le site vous fournit alors une clé (TOKEN key) et un mot secret (TOKEN SECRET). Cela ne permet pas encore de sauvegarder ou récupérer le moindre fichier par l'application. Il faut appairer l'application afin de valider son accès définitif. Pour cela il faut se connecter et via l'API demander explicitement un couple de clés appairées (TOKEN_PAIR key + secret). Il faudra alors pendant la demande, passer ensuite sur le site DropBox et valider l'appairage. Cela parait peut être un peu lourdingue, mais une fois terminé, le site vous retourne votre couple d'appairage, que vous stockerez au chaud dans un properties et plus besoin de se réauthentifier (On utilisera alors les clés appairées).

Voici la classe utilisée pour générer un lien vers un compte DROPBOX, vous noterez les méthodes getFile et putFile assez simplistes. L'api propose également d'autres méthodes (Le main permet l'étape d'authentification)

package com.homeautomate.cloud.dropbox;


import java.awt.Desktop;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Properties;


import javax.swing.JOptionPane;


import com.dropbox.client2.DropboxAPI;
import com.dropbox.client2.DropboxAPI.Entry;
import com.dropbox.client2.exception.DropboxException;
import com.dropbox.client2.session.AccessTokenPair;
import com.dropbox.client2.session.AppKeyPair;
import com.dropbox.client2.session.RequestTokenPair;
import com.dropbox.client2.session.Session.AccessType;
import com.dropbox.client2.session.WebAuthSession;
import com.dropbox.client2.session.WebAuthSession.WebAuthInfo;




public class DropBox {


private static String APP_KEY = "";
public static String DEFAULT_PATH = "myApplication";
private static String APP_SECRET = "";
private static final AccessType ACCESS_TYPE = AccessType.APP_FOLDER;
private static DropboxAPI<WebAuthSession> mDBApi;
private static Boolean authentified = Boolean.TRUE;
private static String TOKEN_KEY = "";
private static String TOKEN_SECRET = "";


public static void main(String[] args) throws Exception {


AppKeyPair appKeys = new AppKeyPair(APP_KEY, APP_SECRET);
WebAuthSession session = new WebAuthSession(appKeys, ACCESS_TYPE);


if (authentified) {


WebAuthInfo authInfo = session.getAuthInfo();


RequestTokenPair pair = authInfo.requestTokenPair;
String url = authInfo.url;


Desktop.getDesktop().browse(new URL(url).toURI());
JOptionPane.showMessageDialog(null,
"Press ok to continue once you have authenticated.");
session.retrieveWebAccessToken(pair);


AccessTokenPair tokens = session.getAccessTokenPair();
System.out
.println("Use this token pair in future so you don't have to re-authenticate each time:");
System.out.println("Key token: " + tokens.key);
System.out.println("Secret token: " + tokens.secret);
} else {
session.setAccessTokenPair(new AccessTokenPair(TOKEN_KEY,
TOKEN_SECRET));
}


mDBApi = new DropboxAPI<WebAuthSession>(session);


System.out.println();
System.out.print("Uploading file...");
String fileContents = "Hello World!";
ByteArrayInputStream inputStream = new ByteArrayInputStream(
fileContents.getBytes());
// Testing
Entry newEntry = mDBApi.putFile("/testing.txt", inputStream,
fileContents.length(), null, null);
System.out.println("Done. \nRevision of file: " + newEntry.rev);


DropBox db = new DropBox();
File uploadFile = new File("C:/chat.jsp");
db.putFile("database", uploadFile);


File downloadFile = new File("C:/downloadFile.txt");
db.getFile("database/chat.jsp", downloadFile);


}


public Entry putFile(String path, File file) throws IOException,
DropboxException {
InputStream fis = new FileInputStream(file);
Entry newEntry = mDBApi.putFileOverwrite(DEFAULT_PATH + "/" + path,
fis, file.length(), null);
fis.close();
return newEntry;


}


public void getFile(String fileNameWithPath, File destinationFile)
throws IOException, DropboxException {
FileOutputStream fos = new FileOutputStream(destinationFile);
mDBApi.getFile(DEFAULT_PATH + "/" + fileNameWithPath, null, fos, null);
fos.close();
}


public DropBox() {
Properties properties = new Properties();
InputStream in = this.getClass().getResourceAsStream(
"/dropbox/dropbox.properties");


try {
properties.load(in);
APP_KEY = properties.getProperty("APP_KEY");
APP_SECRET = properties.getProperty("APP_SECRET");
TOKEN_KEY = properties.getProperty("TOKEN_KEY");
TOKEN_SECRET = properties.getProperty("TOKEN_SECRET");
} catch (IOException e) {
e.printStackTrace();
}
AppKeyPair appKeys = new AppKeyPair(APP_KEY, APP_SECRET);
WebAuthSession session = new WebAuthSession(appKeys, ACCESS_TYPE);
session.setAccessTokenPair(new AccessTokenPair(TOKEN_KEY, TOKEN_SECRET));
mDBApi = new DropboxAPI<WebAuthSession>(session);
}
}

Et voilà notre petit tour sur les nuages est terminé.