We coded for days and nights to realize the vision. To create every single building block that made the iKnode cloud. Learning from our beta users, and our testing. We were 3 at the time. With Joel doing the Graphics and the fron-end, Jorge and me working on the engine.

We saw Backend as a Service providers pop up from everywhere. It seemed like the market started to get full of competitors, and that made us feel excited, empowered even. It validate our idea, but most importantly it validated our dream. We welcomed the competition enriching the market and make it more fun.

Around May 2012, we noticed more BaaS providers started to popup. A lot of them were companies that seemed to be cloning other BaaS providers features, and most of them didn’t bring anything new to the table. The competition started to get boring.

Nothing interesting was coming out, except for one company: Spire.io. We glanced through their site, and saw a spark of new, but something about them seemed very familiar. Their passion, it seems, was the same as ours: making developers life easier by creating a serverless world. The best way to make distributed computing easy, is to remove servers. We felt the competition was getting too close this time. For a moment we were afraid, but also happy. We were not alone.

We kept a close eye on them for the following months and then dozed back in to our own product and our own vision. We began to ramp up development to release at the DEMO conference in October. With Sophie’s help, and an amazing design by Joel, we invested in T-Shirts, Stickers and swag. We were proud to wear and iKnode T-Shirt, we still are.

October (2012) came and we launched iKnode at DEMO. We were a great success, attracting a big number of users into our dream cloud. Sophie joined to run the business, which was just starting. The following months after that we kept the feedback loop active learning and learning from our users.

By December 2012, I was able to get back to market analysis. Moving away a bit from our own user base to the information on the web. The first thing my list was to check on Spire.io. I was afraid to find them ahead of us. After all we were the only providers going after the web in the same way.

So I typed on my chrome instance: spire.io….. Nothing. The site was down. I thought. It seemed crazy that a Cloud provider would allow their site to go down. So I tried again. And again I got Nothing. I checked www.downforeveryoneorjustme.com, and validated. Their site was down. Completly down. What happenned ?

I began to tirelessly look for news around the web regarding Spire.io, to see if there were any press releases, blog post, etc. Checked Hacker News first, then Reddit, then Tech Crunch, and every other imaginable tech news site. Got Nothing. Nada.

I was perplexed. I was scared even. How can a company disappear over night? I began to be very scared. What happens if our dream is wrong ? What happens if what we are looking for is unattainable ? The team at Spire.io had the answer and I had to find out.

I first sent a tweet to the @spireio account:

@spireio Hey guys we are in Orange County, and building a BaaS (@iknode) as well. We should get together to talk BaaS :D

— Alex Espinoza (@alespinoza) December 4, 2012

The CEO responded:

@alespinoza @spireio @iknode hi Alex, unfortunately, we had to wind down spire. But thank you very much for reaching out.

— Diego Prats (@mexitlan) December 4, 2012

He was very nice, but still I needed to know more, so I insisted.

@mexitlan @spireio @iknode I would still love to talk to you, if you are interested. I would love to hear what went wrong.

— Alex Espinoza (@alespinoza) December 4, 2012

To make the story short, he contacted me over email, and we were able to talk over the phone for an hour or so. Several interesting things happened during that phone call. Not only did we had the same dream to make a serverless world, but also he is from Mexico, just like us. And he lives in LA, which is pretty close to us; we are in Orange County. I thought that was amazing. And it seemed to me to be a cosmical connection.

After I hanged up, I felt relieved to know that our dream was still attainable. Additionally I made a friend, which shares our dream. I was a happy camper.

In the following months Diego, began helping more and more to pave the way for iKnode. For the iKnode team, Diego seemed part of it already, so we decided to officially invite him to be part of the iKnode family.

Today, we are proud to announce, Diego Prats joins the iKnode team as Chief Strategy Officer. His experience and expertise is first rate in the Backend as a Service industry. He will be mainly helping to build the dream on solid ground with a real solid business framework that will hold iKnode’s feet in the ground, but keep the heart flying in the serverless clouds.

And now with a complete team, in the words of Buzz Light Year:

Packages are prebuilt themselves are applications, and as such can be executed from the dashboard, directly from the API or from inside your application just like any other iKnode application. The same properties that apply to custom applications apply to packages with the only difference is that packages are not editable. “Packages” is inspired by the spirit of NuGet and apt-get. The idea is to allow the installation applications that are already built and that you can start using by just the click of a button.

Installation

To install a package, just go to the packages section and clik the “Install” button for the package you want to install. The package will be installed and it will appear in the Dashboard with the “.App” postfix. If for example, you were to install the Twitter package you would see “Twitter.App” in your dashboard. You would not see it in the Apps section though, due to the fact that packages are not editable.

If you decide you don’t want to use the package anymore, just go to the Packages section, click the “Installed Packages” button. The list of Installed packages will be displayed. Just click the Remove button for the package you want to remove and the package will be removed.

Configuration

Some package require configuration, like the Emailer. The emailer is used to send emails using an external email server like Gmail. You can configure the package by using the CreateConfig Package.

This method in the Emailer App creates a record in the AppConfig collection in the Data section. You can change the configuration at anytime by just going to the AppConfig collection and edit the selected item.

Social Packages

The Social Packages like Facebook or Twitter require OAuth as an authentication mechanism to do anything useful. For that we created the Social Connector. The main purpose of the social connector is guide you through the OAuth process so that you can integrate with Twitter and Facebook without you having to do any coding whatsoever.

To use the social connector simply go to the apps section, and click on the Social Connector button.

You will then get a tab that shows the Connectors that we have. Currently we only support Twitter and Facebook, but more are on the way. Just select the Service you want to connect to (Facebook or Twitter) and the Social Connector will guide you through the process.

Once the process is done, the OAuth credentials will be stored in the SocialMedia collection.

Available Packages

• Emailer: Send emails using your own Emailer Server.
• Facebook: Post messages to your facebook timeline.
• FTP: Upload and Download Text Files using your own FTP Server.
• Logger: Log Errors and Events with this application.
• Site Monitor: Application that helps you Keep track of your site by checking the status of your http/https site or your net.tcp services.
• Twitter: Post messages to your twitter timeline.

In future releases we will be upgrading the current packages and adding new ones. If you have a package that you wish to see implemented, drop us a line, we will gladly consider it.

For more information go to: Packages Documentation.

The Login Page

The first thing we tackled was the login. We felt the login seems old and resembled a Desktop application. The login is important, because this is the first thing you see when you log into iKnode. It had to be cleaner and attractive. So we remove most of the text, focused on making the login screen more iconic and easier to understand.

Instead of having the word “Email :” next to the email field we added an email icon, and next to the password field a lock. By removing the field labels the login screen automatically looked more pleasing and inviting, so we knew we were going in the right direction. We also simplified the welcome message. Nobody really reads it or pays attention to it, so we made it more functional; instead of a welcome message we replaced it with “Login or Create a new Account”.

Before you could only create an account from the main site, but we noticed that some tried to create an account directly from the login, so we added the link to the login.

The Sidebar

The second thing we focused our attention to was the ever growing sidebar. It had too many options and only a handful of options were really being used. But the biggest problem was that the sidebar didn’t make it clear what features were offered. Too many choices, and not a clear part on where to start.

With the new sidebar we make clear that we have 3 main features: Backend Apps, Data Storage and Scheduling. The order is also set to let the user know where to start. The first thing to do in iKnode is create an App. Then create Data Stores and if needed Schedule some apps to run at a specified period in time.

The new sidebar also improves the usage for mobile devices where screens are smaller. For this iteration we focused completly on tablets like the iPad, Nexus 7 and the Surface RT. The sidebar buttons are now big enough for a very precise finger button click, when before you usually needed to zoom in.

Additionally we removed the “Feedback & Support” floating tab and added it to the sidebar. This decision was made to unify the design, the tab always looked out of place. With the Support button as part of the sidebar it feels more accessible and consistent.

The Topbar

The third place we focused our attention to was the top bar. This top bar has changed considerably since iKnode started. In this time, we made the top bar a kindda scoreboard. We had the metrics on the dashboard before, but nobody really saw them, because most users spent their time coding in the editor. So we moved the stats to the top where they are visible no matter where you are in the site.

The Application List

The fourth item we decided to improve was the Application List. The application list used to look like a small desktop grid, which made usage in tablets very complicated because of the size of each row. What we decided to do was make the grid line higher and wider, with big buttons at the end. It still needs improvement, but the this is a start. We also added the Application icon to make applications easier to identify.

The Editor

The fifth place and one of the most important ones is the editor. We have been working tirelessly to make the editor more usable. We are using ACE and for sometime we used a really old version of it. In the past month Jorge decided to put some love into the editor integrating the latest version of ACE and adding some well deserved keyboard bindings. It was frustrating to save an app by cliking the button. I usually save my code everytime I finish a line, which means that my development time was impacted considerably.

So in the editor, we first focused on making the code editor itself larger, so that we can focus on the code. The references and Properties that were part an editor sidebar were only used around 5% of the time, where the editor was used approximately 95% of the time. Additionally I am an avid Emacs user, and I love the simplicity of the editor with no toolbar, sidebar or anything else.

In order to achieve what a lot of developers call the “Zen Mode” we had to allow the editor to take the rest of the screen. So we moved the References and Properties tabs out of the way. We created a tab for the editor, one for the references and one for the properties. This made a hell of a difference. It feels like Emacs, and I love it.

We also changed the icons. We felt the Disk icon, which reprented the save process, was outdated. I think the Disk is no longer the best way to represent the save operation, so we changed to a Server Save icon.

This UI improvement experience was amazing. We had been so focused on pumping up our infrastructure that we overlooked the user interface. We put a lot of heart and love into iKnode, most of the time it can’t be seen with the naked eye, but in this case, it is out there for everybody to enjoy.

Please let use know your thoughts about the new changes.

One of the major changes is the upgrade of the application editor, this will allow us to extend the editor functionality and features plus the improvements and fixes that come with the upgrade, e.g. you’ll notice you are now able to collapse or expand code blocks.

So as a start we’ve added some key shortcuts for what we consider the most common operations when using the editor, we are talking about saving, compiling and publishing your apps, so here are the key shortcuts you may use when using the editor, for PC and MAC:

• Save (Ctrl+S, Command+S).
• Compile (Ctrl+Alt+B, Command+Alt+B).
• Publish (Ctrl+Alt+P, Command+Alt+P).

As I mentioned, this is just the beginning, we are planning to add more features that make the editor better and easier to use, as an example:

• Toggle comments blocks.
• Indent code regions.
• Search and replace.

Your comments and suggestions are of course more than welcome. More things are on the way, so stay tuned.

Happy Coding!

The SDKs are built with the purpose of making it easier to access your API through the REST interface. It is not required for you to learn how to use the SDKs at all. Our REST API is very friendly as well, but we do recommend using it; it makes it so much easier.

The SDK follows exactly the same philosophy for all platforms. This means that if you know how to use the Javascript SDK or the C# SDK, the iOS SDK will be a piece of cake.

For this example we are going to use the following API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using iKnode.Applications;
using iKnodeSdk.UnitTest.Domain;

namespace iKnodeSdkTest
{
  /// <summary>
  /// Defines the User Service.
  /// </summary>
  [Application]
  public class UserService
  {
        /// <summary>
        /// Gets the User First Name by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User First Name/.</returns>
        public string GetFirstNameById(int id)
        {
            return "Robert";
        }

        /// <summary>
        /// Gets the Most Common User First Name.
        /// </summary>
        /// <returns>Most Common User First Name/.</returns>
        public string GetMostCommonFirstName()
        {
            return "John";
        }

        /// <summary>
        /// Gets the User by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User Information.</returns>
        public User GetById(int id)
        {
            if(id != 1) {
                return null;
            }

            return new User(1, new FullName("John", "Doe"));
        }

        /// <summary>
        /// Saves the User Information.
        /// </summary>
        /// <param name="user">User Information.</param>
        /// <returns>User Identifier.</returns>
        public int Save(User user)
        {
            if(user == null) {
                return -1;
            }

            //TODO: Here your store the User Information.

            return user.Id;
        }

        /// <summary>
        /// Creates a new User with the Default Information.
        /// </summary>
        /// <returns>User Information.</returns>        
        public User CreateDefault()
        {
            return new User(2, new FullName("Jane", "Doe"));
        }

        /// <summary>
        /// Creates a new User.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        /// <returns>User Information.</returns>        
        public User Create(int id, FullName name)
        {
            return new User(id, name);
        }
  }
}

The model used by the iKnode Application is the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        /// <summary>
        /// First Name.
        /// </summary>
        public string FirstName;

        /// <summary>
        /// Last Name.
        /// </summary>
        public string LastName;

        /// <summary>
        /// Initializes a new instance of the <see cref="FullName"/> class.
        /// </summary>
        /// <param name="firstName">First Name/</param>
        /// <param name="lastName">Last Name.</param>
        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the User class.
    /// </summary>
    [Serializable]
    public class User
    {
        /// <summary>
        /// Identifier.
        /// </summary>
        public int Id;

        /// <summary>
        /// Full Name.
        /// </summary>
        public FullName Name;

        /// <summary>
        /// Initializes a new instance of the <see cref="User"/> class.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        public User(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

This API is the same used to demostrate the usage with the Javascript and C# SDKs.

Using just the REST endpoint we would call this API in the following way:

1
2
3
4
5
6

curl -X POST \
-H "iKnode-UserId: [YOUR-USERID]" \
-H "iKnode-ApiKey: [YOUR-APIKEY]" \
-H "Content-Type: application/json" \
-d '{ "parameters" : "{ id: \"1\" }" }' \
https://api.iknode.com/Applications/execute/UserSvc/GetById

In the iOS SDK the return type is usually NSDictionary for complex objects as seen in the following example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ApplicationClient *client = [[ApplicationClient alloc] initWithServiceUrl:BaseUrl
                                                              AndUserId:UserId
                                                                AndApiKey:ApiKey
                                                               AndAppName:@"UserService"];

NSDictionary *params = [NSDictionary dictionaryWithObject:@"1" forKey:@"id"];
NSData *data = [client ExecuteWithMethodName:@"GetById" AndParameters:params];

NSDictionary *user = (NSDictionary *) data;

// User Id
user["Id"];

// User Full Name
user["FullName"];

Hope you find it useful. This SDK, as well as all the others are open source and can be found in here. You can use them as you wish.

We decided to submit our own app to the Chrome Web Store so it’ll be easier for the iKnode developers to access iKnode, now just a click away ;) for Google Chrome lovers, so just search for “iknode” on Web Store or click here to go directly to it.

We are working really hard to improve the iKnode experience, enjoy.

You can install the SDK for your projects using:

1

PM> Install-Package iKnodeSdk

Don’t forget that you can always get the latest source code and binary releases directly from our Github Page. If you want to download the latest version of the SDK without using NuGet, you can do so by going to the Downloads Section in Github.

Happy Coding!!!

In this spooky day, we wish everybody a Happy Halloween!!! We are getting our costumes set, and our bags are ready to be filled with a lot of candy.

By the way, the halloween icons used in this site are courtesy of RocketTheme Halloween Icon Pack 1 by RocketTheme - http://www.rockettheme.com.

There are frameworks that make it easier, but even after you reduce the complexity by adding a library to handle Web Requests, parsing adds to the problem. Thinking about these two problem we designed an SDK for iKnode Applications that makes it extremely simple to execute from your client.

First, by handling ALL Web Requests without your client having to know about the security or how to do POST requests. Second it parses the results as as native C# classes or Javascript objects.

One very important aspect of the new SDK, is that you learn it once in any language, and you learn it for the rest. Right now we are only supporting C# and Javascript, but the Android and iOS SDKs are on the way and will be handled in the same way, focused completly on consitency.

It’s time to look at some code. Let’s say that we are building a User Service which is used to manage User information in the cloud:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using iKnode.Applications;
using iKnodeSdk.UnitTest.Domain;

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the User Service.
    /// </summary>
 [Application]
  public class UserService
  {
        /// <summary>
        /// Gets the User First Name by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User First Name/.</returns>
        public string GetFirstNameById(int id)
        {
            return "Robert";
        }

        /// <summary>
        /// Gets the Most Common User First Name.
        /// </summary>
        /// <returns>Most Common User First Name/.</returns>
        public string GetMostCommonFirstName()
        {
            return "John";
        }

        /// <summary>
        /// Gets the User by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User Information.</returns>
        public User GetById(int id)
        {
            if(id != 1) {
                return null;
            }

            return new User(1, new FullName("John", "Doe"));
        }

        /// <summary>
        /// Saves the User Information.
        /// </summary>
        /// <param name="user">User Information.</param>
        /// <returns>User Identifier.</returns>
        public int Save(User user)
        {
            if(user == null) {
                return -1;
            }

            //TODO: Here your store the User Information.

            return user.Id;
        }

        /// <summary>
        /// Creates a new User with the Default Information.
        /// </summary>
        /// <returns>User Information.</returns>        
        public User CreateDefault()
        {
            return new User(2, new FullName("Jane", "Doe"));
        }

        /// <summary>
        /// Creates a new User.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        /// <returns>User Information.</returns>        
        public User Create(int id, FullName name)
        {
            return new User(id, name);
        }
  }
}

In this case we are going to have the following classes as part of the model to be shared by the service and the C# client. For the Javascript client the model is not required.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        /// <summary>
        /// First Name.
        /// </summary>
        public string FirstName;

        /// <summary>
        /// Last Name.
        /// </summary>
        public string LastName;

        /// <summary>
        /// Initializes a new instance of the <see cref="FullName"/> class.
        /// </summary>
        /// <param name="firstName">First Name/</param>
        /// <param name="lastName">Last Name.</param>
        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the User class.
    /// </summary>
    [Serializable]
    public class User
    {
        /// <summary>
        /// Identifier.
        /// </summary>
        public int Id;

        /// <summary>
        /// Full Name.
        /// </summary>
        public FullName Name;

        /// <summary>
        /// Initializes a new instance of the <see cref="User"/> class.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        public User(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

Now in the C# client side, you would call the UserService in the following way:

1
2
3
4
5
6
7
8
9
10
11

// Creating User Id 1 with Name jdoe.
ApplicationClient userSvc = new ApplicationClient(
                        "https://api.iknode.com",
                        UserId,
                        ApiKey,
                        "UserService");

User user = userSvc.Execute<User>(
                      "Create",
                      new MethodParameter("id", 1),
                      new MethodParameter("name", "jdoe"));

Now in Javascript the same call would look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

   var userSvc = new iKnodeSdk.ApplicationClient({
      userId: USERID,
      apiKey: APIKEY,
      appName: "UserService"
  });

  var user = userSvc.execute({
      methodName: "Create",
      parameters: [{
              name: "id",
              value: 1
          },{
              name: "name",
              value: "jdoe"
          }
      ]
  });

It is as simple as that. The source code for the SDK can be found here. Each platform SDK has a set of Unit Tests that show how the SDK can be used.

If you have any questions don’t hesitate to ask questions in the forums.

We want to thank our Beta users, we really appreciate your feedback. All your data and applications will still be there, and you will get the rest of the year free.

Finally We also want to thank Microsoft for sponsoring us to launch at DEMO. We have been working with Microsoft’s technologies for the past 10 years, and we are proud to be part of the Bizspark program.

And with no further ado, here are some pictures of the event:

Our Badges:

Beautifully created flyer for DEMO:

iKnode Signage:

iKnode kiosk’s next to Windows 8 Kiosk:

Sophie at the Kiosk:

Alex at the Kiosk:

Introducing Icons in the Dashboard

Applications can now have their own icon for the Dashboard. This will make it easy to find apps in the dashboard, while also making it beautiful. Choose from 152 beautifully crafted icons by IconDock.

In order to set an icon for your app, all you have to do is go to the properties tab of your applicaiton and select an icon. By default all applicaitons have the ‘window’ icon set. You can change it easily by selecting the icon that best identifies your app from the list of available icons.

Improved JSON Viewer for the Query Console.

The Query console is now friendlier by displaying the JSON results with a fresh JSON viewer. The JSON viewer makes it easier to browse through the results of your query by allowing the object collapse and expand, and you can still select, copy and paste to anotehr screen. So it pvodies the ability to browse JSON objects without loosing the flexibility of text results.

We had been using the default theme which defaults to the Monaco font (if you have it) on the editor. The problem is that the Monaco Font is created for a font rendering scheme that focuses on the shape of the font which looks blurry sometimtes like the Mac OS. But when you are developing in windows, Monaco looks too blurry, because Windows rendering algorithm forces the font into pixels. So we decided to put Consolas first (which looks amazing on Windows Systems) and then Monaco (which looks amazing in *nix and Mac).

We also decided to change the colors to match the site colors, and preferred a dark background. We created our own theme which we think it is pretty cool.

Let us know what you think. Here is an screenshot of the new theme:

One way to solve this was to serialize the input and outputs of the application using a JSON Serializer (or an XML Serializer). This worked ok, but it poluted the iKnode application with unnecessary serialize/deserialize code, making the application code more difficult to maintain.

The full purpose of iKnode is to make it extremely simple to create services in the cloud, automating things like security configuration, performance configuration and also serialization of custom objects.

We are proud to announce that iKnode now supports custom objects as input and as output. The way it works is with automatic serialization of custom objects into JSON.

Let’s try an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

using System;
using iKnode.Applications;

namespace Applications
{
    /// <summary>
    /// Defines the Custom Objects Test Application.
    /// </summary>
    [Application]
    public class CustomObjectsTest
    {
        /// <summary>
        /// Creates a Default User.
        /// </summary>
        /// <remarks>
        /// This method tests the return of a custom object of Type <c>Client</c>.
        /// </remakrs>
        /// <returns>Client Information.</returns>
        public Client CreateDefault()
        {
            return new Client(1, new FullName("Alex", "Espinoza"));
        }

        /// <summary>
        /// Creates the select User.
        /// </summary>
        /// <remarks>
        /// This method tests the return of a custom object of Type <c>Client</c>.
        /// And also the input of a custom object of Type <c>FullName</c>
        /// </remakrs>
        /// <returns>Client Information.</returns>
        public Client CreateClient(int id, FullName name)
        {
            return new Client(id, name);
        }
    }

    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        public string FirstName;
        public string LastName;

        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the Client class.
    /// </summary>
    [Serializable]
    public class Client
    {
        public int Id;
        public FullName Name;

        public Client(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

We have 3 classes in our application, one that defines the Application class CustomObjectsTest and two classes used as input and output for the application Client and FullName. As you can see, both the Client class and the FullName class have the serializable attribute. Classes used as input/output for the application need to be serializable to work.

Let’s execute the method CreateDefaultUser():

As you can see, the output is already formatted as a JSON object. If you look at the result in the JSON viewer, you’ll be able to see the full client object in a nicer way.

Now let’s try the other method, to test the FullName object as a parameter. Input the following JSON in the fullName parameter and then click execute:

1

{"FirstName":"John","LastName":"Doe"}

As you can see newly created object includes the correct full name:

Now when the iKnode Application gets call, it can be easily deserialized with the Newtonsoft JSON Library:

1

Client defaultClient = JsonConvert.DeserializeObject<Client>(jsonClient);

And Serialized like this:

1

string output = JsonConvert.SerializeObject(fullName);

For this to work, you would need to share the Client and FullName object. This example includes the Client and FullName object inside of the iKnode App for demostration purposes, but I recommend you have those in an assembly that can be shared between your Mobile or Web App and the iKnode App.

Let us know what you think.

The purpose of this post is to show you the usage of this library, as an example we will develop a password manager app on iKnode, so basically it will allow us to:

• Store a new password entry.
• List current passwords.
• Update and delete passwords.

So our password entry which in this case we’d call Credential, consists of the following fields:

• Id
• Name
• Login
• Password

Ok, so the first step is to create our iKnode application, so we go ahead to iKnode Command Center Application Editor and code. This application was shown as a demo in MobileDevNJ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

using System;
using System.Text;

using iKnode.Applications;
using iKnode.Applications.Data;

namespace MobileDevNJ
{
    /// <summary>
    /// Defines the Password Manager Application.
    /// </summary>
    [Application]
    public class PasswordManager
    {
        /// <summary>
        /// Executing User Identifier.
        /// </summary>
        private static readonly Guid UserId = new Guid(""); // Put your userId here.

        /// <summary>
        /// Repository Instance.
        /// </summary>
        private static DocumentRepository Repository = new DocumentRepository(UserId);

        /// <summary>
        /// Collection Name.
        /// </summary>
        private static readonly string CollectionName = "PasswordManager";

        /// <summary>
        /// Returns the list of items.
        /// </summary>
        /// <returns>List of Items in JSON.</returns>
        public string GetList()
        {
            PagedList<Document> items = Repository.GetPagedList(CollectionName);
            return DocumentFactory.DocListToJson(items.List).Replace(Environment.NewLine, String.Empty);
        }

        /// <summary>
        /// Returns the selected item (if found) by identifier.
        /// </summary>
        /// <param name="id">Item identifier.</param>
        /// <returns>Found Item in JSON, <c>String.Empty</c> otherwise..</returns>
        public string GetById(string id)
        {
            Document item = Repository.QueryScalar(CollectionName, "{ \"Id\": \""+id+"\" }");
            if(item != null) {
                return item.ToJson();
            }

            return String.Empty;
        }

        /// <summary>
        /// Returns the selected item (if found) by name.
        /// </summary>
        /// <param name="name">Item name.</param>
        /// <returns>Found Item in JSON, <c>String.Empty</c> otherwise.</returns>
        public string GetByName(string name)
        {
            Document item = Repository.QueryScalar(CollectionName, "{ \"Name\": \""+name+"\" }");
            if(item != null) {
                return item.ToJson();
            }

            return String.Empty;
        }

        /// <summary>
        /// Adds a new item and returns the item's identifier if successful.
        /// </summary>
        /// <param name="name">Item Name.</param>
        /// <param name="login">Item Login.</param>
        /// <param name="password">Item Password.</param>
        /// <returns>New Item Identifier.</returns>
        public string AddNew(string name, string login, string password)
        {
            Document item = CreateItem(null, name, login, password);
            item["Id"] = Repository.Save(item);

            return item["Id"];
        }

        /// <summary>
        /// Updates an existing item.
        /// </summary>
        /// <param name="id">Item Identifier.</param>
        /// <param name="name">Item Name.</param>
        /// <param name="login">Item Login.</param>
        /// <param name="password">Item Password.</param>
        public void Update(string id, string name, string login, string password)
        {
            Document item = Repository.QueryScalar(CollectionName, "{ \"Id\": \""+id+"\" } ");
            if(item == null) {
                throw new Exception("Item with id '"+id+"' not found.");
            }

            item["Name"] = name;
            item["Login"] = login;
            item["Password"] = password;

            Repository.Save(item);
        }

        /// <summary>
        /// Deletes an existing item.
        /// </summary>
        /// <param name="id">Item Identifier.</param>
        public void Delete(string id)
        {
            Document item = Repository.QueryScalar(CollectionName, "{ \"Id\": \""+id+"\" } ");
            if(item == null) {
                throw new Exception("Item with id '"+id+"' not found.");
            }

            Repository.Delete(item);
        }

        /// <summary>
        /// Creates an Item Document.
        /// </summary>
        /// <param name="id">Item Identifier.</param>
        /// <param name="name">Item Name.</param>
        /// <param name="login">Item Login.</param>
        /// <param name="password">Item Password.</param>
        /// <returns>Item Document.</returns>
        private static Document CreateItem(string id, string name, string login, string password)
        {
            Document item = new Document(CollectionName);
            item["Name"] = name;
            item["Login"] = login;
            item["Password"] = password;

            if(!String.IsNullOrEmpty(id)) {
                item["Id"] = id;
            }

            return item;
        }
    }
}

So the application basically provides methods for the usual CRUD operations, just as a reminder, only the public methods in your iKnode app will be, let’s say, callable as tasks, the private method will not be visible, it is more a support method.

Then we save, compile and publish our app and make sure it appears in our app library:

Remeber to set the name of your app in the Properties tab in the editor, the Class does not act as the application name. So let’s go ahead and test our new app:

1
2
3
4
5
6

curl -X POST
     -d "{\"parameters\":\"{}\"}"
     -H "Content-Type:application/json"
     -H "iKnode-UserId:<YOUR_OWN_USER_ID>"
     -H "iKnode-ApiKey:<YOU_OWN_API_KEY>"
     https://api.iknode.com/Applications/execute/PasswordManager/GetList

We should get a JSON array of credential entries.

The next step is to show how to call this iKnode app from our web app, we’ll develop a simple chrome extension that will show a grid with the current passwords, we’d be using ExtJS 4.1 to render our widgets. You can browse the example extension here.

As you can see there’s a file called iknode-client-0.1.min.js which is our library, this is a minified version but you should be able to view it here in our clients repository.

Edit agent.js and go near line 59, this is where we create an instance of the client and provide our user id and api key:

1

var client = new iknode.Client({userId:'<YOUR_USER_ID>' , apiKey: '<YOUR_APIKEY_ID>'});

Then you just need to call the exec(config) function, where config has the following structure:

1

{ task: 'taskexpr', params: '', [callback]:''}

The field task must contain the task we want to execute, the task name follows the pattern ApplicationName:Method, so in our case we want to list the credentials, thus, our task would be PasswordManager:GetList considering you did not change the method names from the example iKnode app provided above and you set your app name to be PasswordManager, if choosed a different application name you must use that one instead. The callback field is optional, you can avoid it if you are executing and don’t care about the server response.

Our call looks like this:

1
2
3
4
5

response = client.exec({ task: 'PasswordManager:GetList',
           params: iknode.Client.EMPTY_PARAMS,
           callback: function(result) {
                 // callback method body
                 }});

As you can see we provided the task name we mentioned, and as for the parameters we are using a constant already defined in our library for empty params, you should be using it in case that your tasks requires no parameters, but if we need to send the password name, our call would be

1
2
3
4
5

response = client.exec({ task: 'PasswordManager:GetByName',
           params: "{\"parameters\":\"{'name':'credential_name'}\"}",
           callback: function(result) {
                 // callback method body
                 }});

You should be able to see the full callback method in the example code, we process the response text a bit, the result parameter constains the raw responseText obtained from the server, and then we parse to get an array of objects which in this case we iterate to populate the GridPanel.

Hope this post helps to get you started with our javascript library, we’d be pleased to hear comments from you or help you solve any doubts you might have.

Happy coding!

It is also very easy to set this up, once you are in Command Center locate the section called “Social Connector”:

This will display on the right panel two buttons

Each of those buttons will begin the traditional authentication/authorization process, if you are already logged on those services you will just have to authorize our app, otherwise you will have to authenticate against the service first, what it is going to happen is that we are going to store your access tokens in your user storage, the collection will be called social media, so you can just look at it right away after you authorize iKnode to access your social accounts.

If you have multiple accounts, iKnode will handle that by naming your token records so you can choose which one to use in your apps. This is how the records will look like:

among other columns, you should see the ones shown below, of course you will a token string for each document (record) in the collection. What you should consider is the column name, on your apps you would refer to this tokens by the name, so let’s say if you wanted to post some random message to one of your twitter accounts, you would have to use the name of the token record to use, you can of couse edit the document and change the name to whatever you like, something that would make more sense to you than twitter1, twitter2, etc.

Now, how to use this? easy, take a look at the iKnode app shown below, your apps method ‘Shout’ will try to post a message (provided as a parameter) to facebook and twitter, we will make use of our twitter and facebook accounts, twitter1 and facebook1 respectively.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

using System;
using iKnode.Applications;
using iKnode.Applications.Social.Clients;

namespace Applications
{
    [Application]
    public class SocialPoster
    {
        private TwitterClient twClient = new TwitterClient("twitter1", "yourNumericUserId");
        private FacebookClient fbClient = new FacebookClient("facebook1", "yourNumericUserId");

        public string Shout(string message)
        {
            string result;

            try {
                twClient.Post(String.Concat(message, "!!"));
                fbClient.Post(String.Concat(message, "!!"));

                result = "true";
            } catch(Exception) {
                result = "false";
            }

            return result;
        }
    }
}

Of course you have to provide your own user id, you can take your user id from the profile section, just click your name on the top right corner of Command Center and you should see your user information, your user id should be the first field.

Copy as paste this app in the Command Center application editor, save, compile and execute to test! you should be able to see the text provided as a parameter to the Shout method in your Twitter and Facebook timelines with the string “!!” as a suffix.

Happy iKnode coding!.

We were already writing a service to allow iKnode Apps to call others, but to Create, Compile and Publish Applications from an iKnode Application was an amazing idea which would give iKnode Apps a lot more power and flexibility. We went ahead to spec, design and implement the feature. And today, we unveil the Frankestein Feature as we like to call it.

The iKnode engine is already implemented as a set of Services which are only accessible from the inside of our network. When an iKnode application runs, it is running inside our network, so it made sense to just allow iKnode Apps to just call our services. We created a service in the assembly iKnode.Applications (which is used by ALL iKnode Applications) to simplify the call to our internal service, allowing the caller to Save, Publish and Execute iKnode Applications.

Programming Interface

The Service is called “iKnode.Applications.ApplicationService” (docs) and handles “Application” (docs) objects. The Application class represents an application for the service. Let’s look at the structure:

The ApplicationService is the class that allows the application to perform operations in the iKnode engine. The structure is defined below:

The important operations for the Application Service are:

Save

Allows the Application to be Saved. There is not compilation or validation of code. A ‘Saved’ application is considered in Draft mode, which means it cannot be executed. Use this method to store partial or drafts of an application.

1
2
3

Guid userId = new Guid("YOUR_USERID");
ApplicationService svc = new ApplicationService(userId);
svc.Save(app);

Publish

Allows the Application to published. The Application is first saved, then compiled and then published so that it can be executed. If there is any compilation errors, and exception will be generated. A successfully published Application can be Executed.

1
2
3

Guid userId = new Guid("YOUR_USERID");
ApplicationService svc = new ApplicationService(userId);
svc.Publish(app);

Execute

Executes the Application and returns the application result if any.

1
2
3

Guid userId = new Guid("YOUR_USERID");
ApplicationService svc = new ApplicationService(userId);
svc.Execute(appName, appMethod, methodParamsInJson));

Remove

Removes an existing application even if the application has been published. If removal is successful the Application will not longer be available.

1
2
3

Guid userId = new Guid("YOUR_USERID");
ApplicationService svc = new ApplicationService(userId);
svc.Remove(app);

GetById

Returns the Application Information by using the Application Identifier. It will return null if not found.

1
2
3
4

Guid userId = new Guid("YOUR_USERID");
Guid appId = new Guid("APPID");
ApplicationService svc = new ApplicationService(userId);
svc.GetById(appId);

GetByName

Returns the Application Information by using the Application Name. It will return null if not found.

1
2
3

Guid userId = new Guid("YOUR_USERID");
ApplicationService svc = new ApplicationService(userId);
svc.GetByName(appName);

Example

We have built an example that covers all of the operations. Throughout this example we will class this Application “The Host”. The host’s main purpose is to create the Guest Application if it doesn’t exist, and then run it. But if the application already exists then it sohuld only execute it.

The code for the Host is shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using System.Text;
using iKnode.Applications;
using System.Collections.Generic;

namespace Applications
{
    /// <summary>
    /// Defines the Application Service Test.
    /// </summary>
    [Application]
    public class ApplicationServiceTest
    {
        /// <summary>
        /// User Identifier.
        /// </summary>
        private static readonly Guid UserId = new Guid("YOUR_USERID");

        /// <summary>
        /// Tests the Application Service.
        /// </summary>
        /// <returns>Trace Information.</returns>
        public string TestAppService()
        {
            string appName = "GuestApp";
            StringBuilder trace = new StringBuilder();

            ApplicationService svc = new ApplicationService(UserId);
            Application app = svc.GetByName(appName);

            if(app == null) {
                trace.AppendLine("App was not found!");
                Guid id = this.CreateApplication(appName);
                trace.AppendLine("App '"+appName+"' created with Id - "+id);
            } else {
                trace.AppendLine("App '"+appName+"' found!");
            }

            trace.AppendLine("Application Executed: "+ svc.Execute(appName, "Sum", "{ a:'10', b:'20'}"));

            return trace.ToString();
        }

        /// <summary>
        /// Creates an application with the selected name.
        /// </summary>
        /// <param name="appName">Application Name</param>
        /// <returns>Application Identifier of the created application.</returns>
        private Guid CreateApplication(string appName)
        {
            string content = @"using System;
using iKnode.Applications;

[Application]
public class GuestApp
{        
    public Double Sum(Double a, Double b)
    {
        return a + b;
    }
}";

            List<string> dependencies = new List<string>();

            Application app = new Application(appName, "Test Application", content, "1.0", dependencies);

            ApplicationService svc = new ApplicationService(UserId);

            // Saves the App but no publish. Cannot be executed.
            if(!svc.Save(app)) {
                return Guid.Empty;
            }

            // Saves, Compiles and Publishes. If successful, then app can be executed.
            if(!svc.Publish(app)) {
                return Guid.Empty;
            }

            return app.Id;
        }
    }
}

What the Host application does is create another application named “Test” which performs a “Sum” operation. We will refer to the generated application as the Guest. The code this new Application will have is:

1
2
3
4
5
6
7
8
9
10

using iKnode.Applications;

[Application]
public class GuestApp
{
  public Double Sum(Double a, Double b)
  {
      return a + b;
  }
}

Let’s test the Host application. Before executing the Host, this is how the Application Library looks like:

If we execute the application the first time, this is what we will see:

As we can see the application was not found by the Host application and created it before executing it. If we run it a second time, this is what we’ll see:

As we can see the guest application was found, so it was just executed. If we go to the Application Library we’ll see the GuestApp, just like any other application.

We hope you enjoy this new feature, we had a lot of fun writing it and coming up with applications to use it. Try it and let us know what you think.

Image Reference: Link

Setting up Wordpress.

Wordpress uses the XML RPC protocol for integration. In order for iKnode to be able to interact with a Wordpress blog, XMLRPC needs to be enabled in the site. You can do this by going to Settings > Writings, in the Remote Publishing Section check the XML-RPC check box.

Now we ready to create the iKnode App.

Creating the iKnode Application

The wrapper we created is in iKnode.Applications, so we don’t need to add any other assemblies. We just need to use the iKnode.Applications.Web namespace.

The signature of the method to add a new post is displayed below:

1
2
3
4
5
6
7
8
9
10

/// <summary>
/// Posts a news Document into a wordpress blog.
/// </summary>
/// <param name="title">Post Title.</param>
/// <param name="content">Post Content.</param>
/// <param name="categories">Categories Array.</param>
/// <param name="keywords">Keywords.</param>
/// <param name="excerpt">Excerpt.</param>
/// <returns>Post Identifier if successful.</returns>
public string NewPost(string title, string content, string[] categories, string[] keywords, string excerpt)

1
2

WordPressClient wp = new WordPressClient("http://my.domain.com/xmlrpc.php", "myUserName", "MyPassword");
wp.NewPost("Test Title", "Hello World!", new string[] {"Uncategorized"}, new string[]{}, String.Empty);

It is as simple as initializing the WordPressClient and then just passing the parameters to the NewPost method.

Here is the complete sample

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

using System;
using iKnode.Applications;
using iKnode.Applications.Web;

namespace Applications
{
  [Application]
  public class MyWordpressApp
  {
        public string HelloWorld()
        {
            WordPressClient wp = new WordPressClient("http://my.blog.com/xmlrpc.php", "myUserName", "myPassword");
            return wp.NewPost("Test Title", "Hello World!", new string[] {"Uncategorized"}, new string[]{}, String.Empty);
        }
  }
}

Just run this sample. Once it finishes it will return the blog post id and you should be able to see it in your Wordpress site.

We will be updating and improving the documentation regularly. If you find there is an specific topic you want to have documented first, please let us know. Right now we are going to tackle it by topic, starting with Applications, then Data Storage, Application scheduling and finally Application Monitoring. We will also start posting complete samples which include complete applications.

You can read the documentation here: Documentation.