Makkonen Sami

Enginio: Qt Backend as a Service Launches Tech Preview

Published Thursday April 25th, 2013
16 Comments on Enginio: Qt Backend as a Service Launches Tech Preview
Posted in Cloud, Enginio, Network | Tags: ,

You may have already heard of Enginio at Qt Developer Days 2012  or you may have stumbled across our site, http://engin.io. We are now ready to officially open up the doors to our Enginio Tech Preview and welcome you to test it out. We have already had some early adopters who have given us valuable feedback which we have used to develop the product.

Why Enginio?

When we had a look at the existing cloud solutions, we saw that there was room for improvement. They were sometimes difficult to get started using and required specific knowledge of certain infrastructures or platforms and in most cases did not have Qt/C++ APIs. Using the experience we have from building backend solutions for various kinds of applications, we decided to create a solution that linked applications with a backend cloud storage based on Qt’s intuitive APIs. With Enginio developers can concentrate on creating their application making it visually pleasing and performing and let Enginio manage the backend functionality, scalability, security and performance.

Our goal was to build upon Qt’s motto of making “developer’s lives easier” and so what we wanted to do was provide developers with an uncomplicated and stress-free development experience in the backend. So, we started to create a solution that was easy to use and value-adding for Qt application development and at the same time transmit that Qt effortless development trait to other platforms. We want to make sure that the value-adding benefits of having a Qt backends are available to all. Enginio will be commercially available for both open-source and enterprise Qt users. For enterprise Qt users developing with a commercial license, a few additional value-adding features and functions will be made available to them later on.

The Enginio Technology Previews supports:

  • Web dashboard (UI for configuring & managing your backend)
  • Schema-less data storage (Place to store your application data)
  • Security model (Mechanism to control which end-users can access what data)
  • File support (Save small or large files in the cloud)
  • Full text search (Search stored data by its content)
  • Qt/QML client library (Convenient way to create applications)

How to get started?

1. Sign up for an Enginio account

2. Setup your new backend

3. Develop your App

The latest release version of the Qt library is available from the Enginio dashboard.

Shared library and QML extension plugin are built and installed as usual with `qmake && make && make install`

Qt example:

I. In Qt Creator choose File > New File or Project… and create new “Qt Gui Application”.
II. In the new project’s pro file add:

QT += network
win32:CONFIG(debug, debug|release): LIBS += -lenginioclientd
else: LIBS += -lenginioclient

III. In MainWindow.cpp:

// Include Enginio headers
#include <Enginio/Enginio>

// Instantiate Enginio Client
// Copy your backend ID and secret from Enginio dashboard
const QString backendId("YOUR_OWN_BACKEND_ID");
const QString backendSecret("YOUR_OWN_BACKEND_SECRET");
EnginioClient *client = new EnginioClient(backendId, backendSecret);

// Create new object to backend
EnginioJsonObject banana("objects.fruits");
banana.insert("name", QStringLiteral("Banana"));
banana.insert("price", 1.59);
EnginioObjectOperation *createOp = new EnginioObjectOperation(client);
createOp->create(banana);
createOp->execute(); // Initiates asynchronous operation

// Fetch objects from backend to list model
EnginioObjectModel *objectModel = new EnginioObjectModel();
EnginioQueryOperation *queryOp = new EnginioQueryOperation(client);
queryOp->setObjectType("objects.fruits");
queryOp->setModel(objectModel);
queryOp->execute();

 

QML example:

I. In Qt Creator choose File > New File or Project… and create new “Qt Quick 2 Application (Built-in Elements)”
II. In main.qml:

import io.engin 1.0 as Enginio

// Instantiate Enginio Client
// Copy your backend ID and secret from Enginio dashboard
Enginio.Client {
	id: client
	backendId: "YOUR_OWN_BACKEND_ID"
	backendSecret: "YOUR_OWN_BACKEND_SECRET"
}

Enginio.ObjectModel {
	id: objectModel
}

Enginio.QueryOperation {
	id: queryOp
	client: client
	model: objectModel // Query results are added to model
	objectTypes: ["objects.fruits"] // Get all fruit objects
}

Component.onCompleted: {
	// Create new object to backend
	var banana = {
		objectType: "objects.fruits",
		name: "Banana",
		price: 1.59
	};
	var createOp = client.createObjectOperation();
	createOp.create(banana);
	createOp.execute();
	createOp.finished.connect(function() {
		// Fetch objects from backend to list model
		queryOp.execute();
	});
}

Build and your connected application is ready.

We would like to invite more people to test and provide feedback. However, please bear in mind that the service is still under development and you may experience some bugs, changes and breaks. Go and check it out at http://engin.io. Let us know what you think!

You can reach the Enginio development team at mailus@engin.io.

Do you like this? Share it
Share on LinkedInGoogle+Share on FacebookTweet about this on Twitter

Posted in Cloud, Enginio, Network | Tags: ,

16 comments

smoggy says:

Seems promising, altough i need more complete examples, staircased in functionality.

Dean says:

1gb traffic, 100k i/o, no option for private hosting, enginio doesn’t sound like that much of a good deal to me.

You guys absolutely nailed the ease of getting an example up process. It took longer for me to write a short blog post about the process than it did to have the example app compiled and interacting with your platform. Well done.

bman says:

Are you considering private hosting? How about using your setup on existing cloud services that customers already work with?
We have a significant investment in one cloud provider – unfortunately they do not provide a C++ SDK. If they did we would be writing Qt based tools in a heartbeat to access and manage those services!

hootener says:

This. I’ve also made a significant investment into a certain cloud service provider. One of the biggest hassles to the project was writing Qt/C++ tools to interface with the provider’s services. Would love to see some library support from Qt that can remove the pain of creating your own Qt-based tools to interface with current cloud service providers.

Evan says:

I’m a bit confused on what one would use this for. It seems like a specialized web server… what are some examples of the advantages/use cases for this?

d3fault says:

Mildly interesting. Is this a paid monolithic (vertically scaling) ACID-compliant SaaS…. or a paid dht-type (horizontally scaling) datastore (like Amazon dynamo for example) SaaS?

If the latter, what are it’s CAP properties?

Harri Eronen says:

Datastore in Engin.io is horizontally scaling one.

And from the CAP theorem point of view, we value P (partition tolerance) and C (consistency) over A (availability) in case of our internal datacenter hickups. However, things are not completely black and white.. So we might get back to these issues more deeply on some future posts.

very nice stuff here! mind blown away , great job to the team..

lets see what they are up to the pricing models

Cyttorak says:

How does this interact with qt widgets?

Arto Nykänen says:

EnginioObjectModel inherits QAbstractListModel so you can use it with QListView and other similar widgets.

Cyttorak says:

So if I write a normal widget desktop app it gets somehow (with limitations I guess, of course) translated to web and I can use it from a browser?

Arto Nykänen says:

You can store data from your desktop app to Enginio backend (i.e. “cloud”) and display it with normal Qt widgets (or QML UI). There is web dashboard for managing the data stored in backend but that is meant for you as developer not for regular users of your app.

Ionut Dediu says:

Very very nice

If Digia started on this road, cloud services, maybe it could also start building an Ad framework like Google’s AdMob or Inneractive and then provide your own App Store for Qt only apps 🙂

Steve says:

Looks interesting but I agree that with an indication of pricing for commercial-level usage and no indication of private hosting I wouldn’t look any closer at it. Having an easy-to-use API is great but how is this better than using the Qt classes to access a sql server over the internet or rolling your own AWS wrapper? It needs more of a sales job and some assurance that I am not going to get locked in before I bother trying the examples.

Steven Starr says:

Enginio doesn’t support Qt4 apparently, I “was” interested until I realized they currently only support Qt5.

Commenting closed.

Get started today with Qt Download now