Controlling TopShelf via REST interface + Dashboard

My recent update for the TopShelf enables the new Nancy-based REST interface and provides improvements to the current dashboard.

The new REST interface allows you to see what are the currently running services by sending a GET request to the dashboard URL (i.e. http://dasboard_url/services).

As a reply, you’re going to get a JSON block that contains small snippets of information about each seevice and shelf that is running inside the TopShelf process.

[...
   {
      "Name":"clock",
      "ServiceType":"Shelf",
      "CurrentState":"Running",
      "Action":"stop"
   }
...]

The most important piece of the block above is the URL-encoded Name of the service. You can use this name as an ID to control the service’s lifetime via HTTP GET requests, i.e.: start, stop, unload:

• /service/{name}/start
• /service/{name}/stop
• /service/{name}/unload

The latest addition to the control interface is the ability to upload shelves remotely by uploading a ZIP file with all the relevant bits of your service.

You can do the upload via the dashboard by navigating to the ZIP package or by dragging and dropping the shelf archive onto a designated area.

In addition, you can do it programmatically via file upload POST request. This sounds complicated, but, in fact, if you’re using .Net framwork, it may look as simple as this:

using (WebClient client = new WebClient())
{
     client.UploadFile("http://localhost:8087/service/upload", @"C:\Packages\clock.zip");
}

All the above functionality can be configured and fine-tuned via the new optional configuration settings that you can put in the TopShelf host configuration file:

<appsettings>
	<add key="ServicesLocation" value="Services" />
	<add key="DashboardUri" value="http://localhost:8087" />
	<add key="DashboardUploadsEnable" value="true" />
	<add key="DashboardUploadsPackageFolder" value="Packages" />
</appsettings>

Here is a short explanation of the settings:

• Services – contains a full or relative path of the shelves folder
• DashboardUri – defines a Uri (ip and port) that the dashboard module (and REST web service) will use to listen to the incoming requests
• DashboardUploadsEnable – this value controls if the uploads of the shelves are enabled (both through the dashboard and the REST service)
• DashboardUploadsPackageFolder – defines a temporary location where the ZIP archives of the shelves will be stored before unpacked into the shelves location (defined by the Services setting)

Putting SOAP to REST – Cape Code .NET User Group @ Hyannis, MA

I’d like to thank the Cape Code .NET User Group for giving me the opportunity to talk about SOAP and REST and, specifically, Todd Kittredge and Venture Hyannis for hosting the event.

I’ve posted the slide deck on the Slideshare:

 

[Update: 12/31/2009]

The landing page for the REST in WCF will point you to the location of the REST Starter Kit.

 

I’d like to remind you that everybody is invited to the upcoming Northeast Roadshow. You can find more information on Chris Bowen and Jim O’Neil blogs.

While these guys are working on the main Roadshow page, you can access their staging location for the near-final info.

Messaging Platform and Service Bus Resources

On the recent project we’ve put in place a messaging platform. Apparently my engineers had a vague understanding what that is. To save you the same trouble I’ve gathered a bunch of interesting resources that can help you get up to date:

Open source Service Bus implementations

• nServiceBux (NSB)
• MassTransit (MT)
• Rhino Service Bus

nServiceBus

• Udi Dahan and NServiceBus (Podcast)

MassTransit

• A First Look at MassTransit
• Producing and Consuming Messages using MassTransit and StructureMap
• MassTransit Endpoints
• MassTransit Samples (Ayende)
• Performance Counters Added to MassTransit

WCF (misc)

• A Developer’s Guide to the WCF REST Starter Kit
• WCF Templates and Tools

XML/JSON symmetric REST web services providers for Jersey

Many times I’ve been asked to provide a set of Web Services interfaces where both JSON and XML clients can communicate with the server. Primarily it’s done for a set of reasons:

1. XML is very convenient to use for inter-service communication.
2. JSON is great for AJAX (web) clients. It’s perfect for GWT too.

In the recent project we’ve been using XStream for all serialization aspects and, since it can serialize both to XML and JSON, it was plugged into Jersey as a provider too. Following you can see XML and JSON providers implemented using XStream library.

XML Provider (annotated to be a default provider, it’ll be used if no Content-Type or Accept headers provided):

Building GWT web clients [Part 4.1] – How to create an Azure RESTful web service?

Prerequisites: make sure that you have all the Azure SDK tools installed for your VS2008.

 

(1) Start by creating a new “Web Cloud Service” project in the Visual Studio. Give it a nice name.

(2) Add a new “WCF Service” to the WebRole project.

(3) Define a required contract:

The most important part here is to put attributes that will tell the WCF in what format to send/receive the message body (XML or JSON) …

[ServiceContract(Name = "service", Namespace = "http://www.igorshare.com")]
public interface IContactManagerService
{
    [OperationContract]
    [WebGet(UriTemplate = "/contacts", BodyStyle = WebMessageBodyStyle.Bare,
       ResponseFormat = WebMessageFormat.Json)]
    List GetAllContacts();

    [OperationContract]
    [WebGet(UriTemplate = "/contacts/{filter}", BodyStyle = WebMessageBodyStyle.Bare,
       ResponseFormat = WebMessageFormat.Json)]
    List GetContacts(string filter);
}

[DataContract]
public class Contact
{
    [DataMember]
    public string FirstName { get; set; }

    [DataMember]
    public string LastName { get; set; }

    [DataMember]
    public string Company { get; set; }
}

(4) Implement the service logic:
public class ContactManagerService : IContactManagerService
{
    private static readonly List Contacts = new List() { ... };

    public List GetAllContacts()
    {
        return Contacts;
    }

    public List GetContacts(string filter)
    {
        string f = filter.ToLower();

        var contacts = from contact in Contacts
                       where contact.FirstName.ToLower().Contains(f) 
                            || contact.LastName.ToLower().Contains(f)
                            || contact.Company.ToLower().Contains(f)
                       select contact;

        return contacts.ToList();
    }
}

(5) Configure it to be exposed as a RESTful service:
To make it REALLY, REALLY simple for you, do this trick:
a) Comment out the system.serviceModel section in the Web.config file
b) Add the Factory attribute to the .svc file

(6) Build the service
 
You’re interested in 2 artifacts of the build:

.cscfg file – configuration for the Cloud Service deployment
.cspkg file – all the bits packaged (zipped)

 
At this moment you have 2 choices:

Run your project in the local Development Fabric (for testing and debugging), or …
Deploy it to the Azure Cloud (for staging or production)

 
To deploy your application to the cloud, do right-click on the CloudService project and select “Publish”.
Visual Studio will launch the Azure Service Developer Portal page. Log-in to your account, create a project and deploy your bits to the staging environment:

 
This is it!  You’re good to go. 
BTW: make sure that your application works in the staging environment and then you can push it to Production by just switching it with the Staging.
 

 
Note: Check out a great explanation about the difference between the WCF REST Configuration for ASP.NET AJAX and plain REST Services by Rick Strahl.
				

Building GWT web clients [Part 4] – How to connect GWT client to Azure web service?

Stay tuned …

Building GWT web clients [Part 3] – How to connect GWT client to JAX-RS Jersey server?

Stay tuned …

Building GWT web clients [Part 2.1] – How to control JSON output format from Jersey?

As you know that in XML you can represent the same data in variety of ways by using fields, names, attributes, etc..

The same is true to JSON. In many cases different serializers produce different JSON representation of the same objects.

JAX-RS (as well as Jersey) provide you control over what and how you want to serialize. This is accomplished via providers.

Here is an example of such provider (Note that the class should be marked with @Provider annotation):

@Provider
public class JAXBContextResolver implements ContextResolver<JAXBContext> { 
    private JAXBContext context;
    private Class<?>[] types = { ListDescription.class }; 

    public JAXBContextResolver() throws Exception {
        JSONConfiguration config = JSONConfiguration.natural().build();
        context = new JSONJAXBContext(config, types);
    } 

    public JAXBContext getContext(Class<?> objectType) {
        for (Class<?> type : types) {
            if (type == objectType) {
                return context;
            }
        }
        return null;
    }
}
Note that by creating an appropriate JSONConfiguration (JSONConfiguration.natural().build()) you, in fact, control the output JSON format. The JSONConfiguration class provide 4 different JSON formatters:

natural (Jackson)
mapped
mappedJettison
Badgerfish

Here is how the output will vary, depending on the choice of the configuration. Don’t forget that the class should be annotated with  A simple class (with fields (int)ID and (String)Name) added to an ArrayList and then returned back as a @GET return value:
@XmlRootElement
public class ListDescription
{
	public int ID;
	public String Name;
}

@GET
@Produces({MediaType.APPLICATION_JSON })
public List<DataListInfo> getAllLists()
{
	List<ListDescription> lists = new ArrayList<ListDescription>();
	ListDescription ls = new ListDescription();
	ls.ID = 1;
	ls.Name = "Test";
	lists.add(ls);
	return lists;
}
This is what you’ll get from each configuration (respectively):
mappedJettison:
{"listDescriptions":{"listDescription":{"ID":1,"Name":"Test"}}}

mapped:
{"listDescription":{"ID":"1","Name":"Test"}}

natural (jackson):
[{"ID":1,"Name":"Test"}]

Badgerfish:
{"listDescriptions":{"listDescription":{"ID":{"$":"1"},"Name":{"$":"Test"}}}}

				

Building GWT web clients [Part 2] – How to expose REST-full JAX-RS service with Jersey on Tomcat server?

In the previous article (Part 1) we’ve seen how to create a web-based REST-full client (and an appropriate server) by using GWT. GWT is not providing any “standard” REST (if you can use this word in REST context at all) interface, but, merely, exposes the server-side logic via a proprietary GWT RPC interface.

Today, the most common REST standard is the JAX-RS specification. By implementing your code along the JAX-RS guidelines you can be rest assured that you can easily switch one REST-RX library with another.

As of today there are a couple of JAX-RS libraries used by the Java community:

1. Jersey
2. Restlet
3. Portlet
4. etc…

On the other hand, being a big fan of Spring, I was hoping that Spring will provide the JAX-RS support in it’s Spring v3 release, but, looking at the M3 drop, I have realized that it’s nowhere near that promise (check my discussion on the StackOverflow).

For this post I’m going to use Jersey JAX-RS implementation. Let’s start with creating

Building fat GWT web clients [Intro] – How to create a GWT RPC client?

After months of working (mainly fighting with quirks of Java) with GWT I’ve accumulated so much knowledge on the topic so, I feel, it starts spilling over. I’m planning to convert this spill into a series of articles on how to build fat REST-full GWT web fat clients both on Java and .NET.

Here is the list of topics I’ll cover:

1. Building GWT fat client
2. Java REST-full Web services
3. .NET REST-full Web services
4. Internationalization and localization
5. IOC/DI
6. Unit testing and integration testing of all the components of the system
7. Build automation
8. and much, much more …

Here is a draft list of technologies I’ll be using:

1. GWT
2. Eclipse
3. Spring
4. Jersey
5. Tomcat
6. XStream
7. AJAX
8. JSON/XML
9. WCF
10. JUnit/TestND/NUnit
11. Selenium
12. Ant
13. TeamCity
14. and much, much more …

For starters, let’s see how to create a simple GWT fat client that talks to the REST-full Web services. As an example,