For those of you who are upgrading from the closed beta, the Whats New section of the documentation describes the new features.

BrightstarDB is available to download now. If you do download please consider adding this blog’s feed to your RSS feed reader and/or joining our Google Group where you can post questions and get answers directly from the developers.

Before starting, ensure you have the following installed;

1. BrightstarDB
2. Node.js
3. ASP.NET MVC

Node needs to be able to access data from BrightstarDB, unfortunately we can’t use WCF under Node, so first of all we will create a simple ASP.NET MVC Rest service which will handle querying and interactions with BrightstarDB.

If you just want to get straight to the code, a download for the source of both projects is available at the end of the post.

Creating MVC Rest interface for BrightstarDB

For the blogging system, our Rest interface will allow the following commands;

• Query a store by name using sparql and returning the results as JTriples
• Post a new article using N-Triples

To get started, first create a new ASP.NET MVC 3 Project. For the Template, choose Empty.

In the project References add a reference to the NetworkedPlanet.Brightstar.dll.

Add a new Controller to the project and name it StoreController.cs. This will serve as the main interface to the BrightstarDB store. We will be using the BrightstarService class to create an embedded client, so we need to include the following using statement in the top of our controller;

Before using the embedded client we need a location for our BrightstarDB data. Open the BrightstarDB management application Polaris and create a new Embedded connection to a location on your computer.

Creating a BrightstarDB Embedded Connection in Polaris

From the Server menu, choose New Store… and call it ‘Blog’.

Create a new store called 'Blog'

This will create a new store in our BrightstarDB data folder named ‘Blog’. Back to our MVC project and StoreController.cs, we can now create an embedded client and point it to the path we used in Polaris to create the ‘Blog’ store.

In StoreController.cs add the following property, be sure to use the location of the BrightstarDB data folder and not the location of the ‘Blog’ store folder;

This will create a BrightstarService property called Context which will be using to perform queries and transactions on our ‘Blog’ store.

Next, we first need to be able to query our store, the path to this Rest method will look like this;

/store/{storename}?query=<sparql query>

Add the following method that accepts a storeName and a query variable;

The above method uses the BrightstarService Context to execute a Sparql query against our named store. The results are iterated by row and the names of the columns and its value added to a Dictionary for each row. A List<Dictionary<string,string>> allows us to return the results using the JsonResult class from ASP.NET in the JTriples format.

Note, the above method uses a Sparql extension method, GetVariableNames, if the method is not available in the release you are using, then add the following code to StoreController.cs and change the above code to use the private mehtod GetVariableNames below.

To support adding new blog posts, we need to add an Insert method. Our insert method will use the Rest path;

/store/{storename}/insert?triples=<triples>

In StoreController.cs add the following method;

The above method accepts NTriple data and uses the BrightstarService Context to insert the data into the named store. Because we want to return when the job is finished, we wait until the job status is OK before returning. Of course we are assuming that the NTriples are valid and the job will never fail, this may not always be the case so you would need to check for this.

Lastly, to finish the MVC project we need to add additional routes in Global.asax.cs.

Update the RegisterRoutes method with the following;

This will map our methods in StoreController.cs to the routes specified earlier. Make sure to run the server by pressing F5 and make a note of the port number that the server is using.

Creating the Node blog application

Before starting to write the Node application, first of all we should look at the triples that we will be storing in BrightstarDB for our blog articles.

In the above triple we are defining a ‘type’ named ‘post’ that has a ‘title’, ‘body’ and ‘date’. For the sake of simplicity we will exclude storing comments in this post. To get started with the Node application, as well as Node installed, we need to install Express. To do this, execute the following in a command prompt;

npm install express -g

Note: Installing Nodejs under Windows should add node and npm to the system path, if it doesn’t add the following to your Path system environment variables;

C:\Users\*username*\AppData\Roaming\npm;C:\Program Files (x86)\nodejs\;

With Express installed, we can now create an Express starter project. In a command prompt run the following;

mkdir blog
cd blog
express -c stylus
npm install -d

This will generate an Express application using the stylus css engine, and download any dependancies using npm. To test that the application generated successfully, run node against the main app.js;

node app.js

You should now be able to access localhost:3000 and see the default express content. We will be creating the following operations in our blog application, these are:

1. Displaying all blog articles
2. Creating a blog article
3. Displaying an individual blog article

To create the interface between our application and the BrightstarDB ASP.NET MVC  service created earlier, we will add an communication layer named brightstar-server.js to our app.

Create a new file under the /blog folder named ‘brightstar-server.js’ and add the following;

The BrightstarServer class provides a single method collection, that will contact the BrightstarDB ASP.NET MVC server using an HTTP request, execute a Sparql query to return all blog posts and process the resulting JSON. The Sparql query is requesting the ‘_id’, ‘title’, ‘body’, and ‘created_at’ properties for each blog post. The JSON returned will look similar to the data below;

Next we will create an articleprovider that uses the brightstarserver class. Add a new file named ‘articleprovider-brightstar.js’ and include the following;

The ArticleProvider provides a single method findAll that uses the BrightstarServer class to fetch all of the blog posts. To make our blog app uses our ArticleProvider, we need to update app.js to render a view when the ‘/’ route is called and display all of the blog posts.

Update app.js with the following ensuring that the port number for the ASP.NET server earlier is used when initialising ArticleProvider;

Our application is now using the BrightstarDB ArticleProvider, calling its findAll method to fetch all of the blog posts and passing them to a view ‘index.jade’, which we will add now. Create a new file named index.jade and add the following code;

Update the file style.styl the following css rules;

Before we can test that the app is working correctly and fetching blog posts, we need to populate our store with some test data. Using Polaris, run a new transaction on the ‘Blog’ store using the following test data;

Add Triples using Polaris

With the test data added, restart the Node server and run node app.jsagain. Refresh the site and there should now be three blog posts displayed on the page.

Blog first page showing our test data

Now that we can display our posts we need to add functionality to create new articles. Create a new view named blog_new.jade and the following code;

In app.js add another two routes to handle creating new blog posts;

In brightstar-server.js and articleprovider-brightstar.js we need to add the the save methods to handle saving blog posts. Open brightstar-server.js and add the following method after the collection method;

The save method creates a set of NTriples from our post object and sends them to our ASP.NET MVC Rest server. Next we need to add the save method to our ArticleProvider.

In articleprovider-brightstar.js add another method for saving posts;

In the above method we first get all of the posts using the findAll method and use the number of existing posts to create an Id, then pass the article to BrightstarServer to save the post to the server. Reload the Node server and navigate to localhost:3000/blog/new and check that posts can be saved. Note, since characters are not escaped when saving the posts as triples, using carriage returns will cause an error!

Finally, we will add the ability to view a single post by Id. Open brightstar-server.js and add another method beneath the save method added previously;

In the method above we are using another Sparql query to return the ‘title’, ‘body, and ‘created_at’ properties from the given Id. Since we are storing the ISO date, we need to create a Date() object using the date string for each row.

Next update articleprovider-brightstar.js with the following code to fetch a single post;

In the  code above we are simply calling the BrightstarServer method findById. Lastly, we need to add a new view to display a single article and add a route in app.js.

Create a new view and name it blog_show.jade, and add the following code;

In app.js add another route for viewing individual posts;

Restart the Node server and we should now be able to view all posts, open individual posts, and create new posts. It should also be possible to add comments to the blogging system so adding comments has been left as an exercise for the reader.

Hopefully this shows the possibilities that are available in using Node.js and BrightstarDB together.

Download the source for both projects.
BrightstarNodeJS-source

CodeProject

This release adds a number of new features which I’ll briefly list here. We will add more detailed content about some of these new features to the blog over the coming days.

Windows Phone 7.1 Support. We now provide SDK libraries for building Windows Phone 7.1 applications that use BrightstarDB for storage. The data files are managed in the application’s Isolated Storage space and you can have multiple stores available to a single application if required.  Crucially, the store data files format is exactly the same as with the standard .NET 4.0 SDK. This means that you can create a store on your workstation and simply copy the files to your device and open them with the mobile version of the SDK! We have provided a few samples to get you going, including a sample of how to distribute a store as part of your application.

Data Object API. By request, we have now publicly exposed and documented a mid-level API to BrightstarDB that sits between the low-level RDF API and the high-level Entity Framework. The Data Object API allows you to manage all the properties of a single RDF resource as a collection, making it easier to work with any shape of RDF data without having to map all the types to .NET interfaces.

Optimistic Locking. The Data Object API and the Entity Framework now both support a simple form of optimistic locking that helps applications to ensure that they avoid concurrently modifying the same data.

Data Export API. By request, we now provide an API for exporting the complete content of a BrightstarDB store as an NQuads file.

Entity Framework API Improvements. The Entity Framework now supports creating inheritance hierarchies in your data model. Entity models now support properties that are collections of native types (e.g. ICollection<string>). We have added support to the LINQ implementation for the string comparison functions String.StartsWith and String.EndsWith and support for Regex.IsMatch for doing more complex regular expression pattern matching. We have also added some really cool support for polymorphism – any Entity Framework object can .Become() and instance of another Entity type by a single method call.

In this tutorial we are going to create a Custom Membership Provider that will enable an MVC3 Web Application to use BrightstarDB as our datasource.

Part 1: Creating a new project and adding a Custom Membership Provider

1. Open Visual Studio 2010 and create a new MVC3 Web Application
2. Important: choose ‘Internet Application’ when asked, which will pre-populate your application with the models, views and controller needed to have basic login functionality
3. Add a new class to your project and name it BrightstarMembershipProvider.cs
4. Make this new class inherit from the MembershipProvider class (System.Web.Security namespace)
5. Right click on the MembershipProvider class name and choose “Implement abstract class” from the context menu, this automatically creates all the override methods that your custom class can implement.
6. Make sure that your project has references to the BrightstarDB DLLs that are available in the SDK
7. Add a Brightstar Entity Context to your project, naming it NerdDinnerContext.tt (see the documentation for Developing with BrightstarDB for more details)
8. Add a new interface to the Models directory and name it INerdDinnerLogin.cs
9. Add the [Entity] attribute to the interface, and add the properties shown below:
10. The Id property is decorated with the Identifier attribute to allow us to work with simpler string values rather than the full URI that is generated by BrightstarDB (for more information, please read the Entity Framework Documentation).

To update the Brightstar Entity Context, right click on the NerdDinnerContext.tt file and select “Run Custom Tool” from the context menu.

Part 2: Configuring the application to use the Brightstar Membership Provider

First we must add a connection string to the Web.Config so that the Brightstar Service can connect to the store

To configure your web application to use this custom Membership Provider, we simply need to change the configuration values in the Web.config file in the root directory of the application. Change the membership node contained within the <system.web> to the snippet below:

Part 3: Adding functionality to the Custom Membership Provider

Note – for the purpose of keeping this example simple, we will leave some of these methods to throw NotImplementedException, but you can add in whatever logic suits your business requirements once you have the basic functionality up and running. The full code is given below, but can be broken down as follows:

Initialization

We add an Initialize() method along with a GetConfigValue() helper method to handle retrieving the configuration values from Web.config, and setting default values if it is unable to retrieve a value.

Private helper methods

We add three more helper methods: CreateSalt() and CreatePasswordHash() to help us with user passwords, and ConvertLoginToMembershipUser() to return a built in .NET MembershipUser object when given the BrightstarDB INerdDinnerLogin entity.

CreateUser()

The CreateUser() method is used when a user registers on our site, the first part of this code validates based on the configuration settings (such as whether an email must be unique) and then creates a NerdDinnerLogin entity, adds it to the NerdDinnerContext and saves the changes to the BrightstarDB store.

GetUser()

The GetUser() method simply looks up a login in the BrightstarDB store, and returns a .NET MembershipUser object with the help of the ConvertLoginToMembershipUser() method mentioned above.

GetUserNameByEmail()

The GetUserNameByEmail() method is similar to the GetUser() method but looks up by email rather than username. It’s used by the CreateUser() method if the configuration settings specify that new users must have unique emails.

ValidateUser()

The ValidateUser() method is used when a user logs in to our web application. The login is looked up in the BrightstarDB store by username, and then the password is checked. If the checks pass successfully then it returns a true value which enables the user to successfully login.  

Part 4: Running the application

Press F5 to run the application. You will notice a [Log On] link in the top right hand corner of the screen. You can navigate to the registration page via the logon page.

Register

Choosing a username, email and password will create a login entity for you in the BrightstarDB store, and automatically log you in.

Logged In

The partial view that contains the login link code recognises that you are logged in and displays your username and a [Log Off] link. Clicking the links clears the cookies that keep you logged in to the website, and you can log on again by entering your username and password.

LogOn

Summary

In this tutorial we have walked through some simple steps to use a Custom Membership Provider to allow BrightstarDB to handle the authentication of users on your MVC3 Web Application.
For simplicity, we have kept the same structure of membership information as we would find in a default provider, but you can expand on this sample to include extra membership information by simply adding more properties to the BrightstarDB entity.
If you have any questions or queries, please post them in the BrightstarDB User Group.

As shown in the code above, all you need to do in the code is create a client instance (when using no parameters like this, the connection string is read from your web.config file). The client you get back is actually a BrightstarDB service client and is not tied to the store specified in your connection string, so you need to provide the store name as a parameter to ExecuteQuery (in this case “NerdDinner”). The result of the ExecuteQuery method is a stream containing the SPARQL results in XML format, so all you need to do is wrap this stream in a FileStreamResult and set an appropriate media type. The [ValidateInput(false)] decoration is required because SPARQL queries contain characters such as < and > which ASP.NET considers harmful, if you omit this attribute you will get an exception thrown from ASP.NET.

Now you can query the SPARQL endpoint like this:

http://localhost:49608/sparql?query=SELECT ?d ?o WHERE {?d a <http://brightstardb.com/namespaces/default/Dinner>}

BrightstarDB is a revolution in data solutions. It provides a native .NET, schema-free, NoSQL triple store with fabulous performance, and a complete, code first, Entity Framework with full LINQ capabilities.

In building BrightstarDB we wanted to deliver the ultimate tool to .NET developers to quickly build and deploy high performance persistent object-oriented and semantic web solutions.

We have now released the developer preview and are really excited to get feedback from developers. We believe the developer experience and database performance is really great but we’d like to hear what you think. If you have some time and are interested in working with the next generation of persistent data solutions then please register to get access to the developer preview.