A Cup of Silverlight, RIA & Interoperability : Implementation

eclipse4SL : “DataGrid” Tutorial

Steve SFARTZ — Mon, 13 Oct 2008 15:11:00 GMT

Duration

20 minutes

Description

This tutorial demonstrates how to populate a DataGrid with dynamic data. When you press the Load Button, the DataGrid will be filled in, and eventually filtered if a filter has been specified. A pdf version of this tutorial is attached at the end of this post and accessible here.

Prerequisites

After installing eclipse4SL, you should have activated the Silverlight perspective by selecting one of them from the menu Window > Open Perspective > Other…. (for a detailed procedure, read the Hello World Tutorial).

Creating the Silverlight User Interface

We'll start by selecting the File->New menu item within Eclipse and use the eclipse4SL Silverlight Project menu to create a "Silverlight Web Project" , named DataGridTutorial.

Open the Page.xaml control, remove the Grid component.

Drag and drop the StackPanel container from the Palette, and add 4 components inside by drag and drop too :

a TextBock which Text value is “Filter :”
a TextBox which Text value is empty
a Button which Content value is “Load”
and our DataGrid which Width and Height are 380 and 230 respectively

<UserControl x:Class="DataGridTutorial.Page"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="400" Height="300"

xmlns:Controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data">

<Controls:DataGrid Width="380" Height="230"></Controls:DataGrid>

</StackPanel>

</UserControl>

Notice that as you have dropped a DataGrid on to the XAML code, a reference to the assembly containing the component is automatically added to the Silverlight project (System.Windows.Controls.Data). The following XAML rendering is displayed :

To obtain the arrangement and look & feel proposed at the beginning of the document, use a Canvas, and specific positions for the different components. Replace the StackPanel and its contents by the following XAML :

<UserControl x:Class="DataGridTutorial.Page"

xmlns:my="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="400"

Height="300">

<TextBlock Text="Filter :"

Canvas.Left="10" Canvas.Top="15" Width="100"></TextBlock>

<TextBox Text=""

Canvas.Left="60" Canvas.Top="10" Width="100"></TextBox>

<Button Content="Load"

Canvas.Left="180" Canvas.Top="11" Width="50"></Button>

<my:DataGrid

Canvas.Left="10" Canvas.Top="50" Width="380" Height="230"

RowBackground="Aquamarine"

AlternatingRowBackground="White"></my:DataGrid>

</Canvas>

</UserControl>

Let’s run the project, by creating a Run Configuration for our project as described in the HelloWorld Tutorial.

Adding behavior to the User Interface

Now, let’s assign names to the Filter and our DataGrid so that we can access them from our C# code behind. Add the property x:Name=”country” to the TextBox and x:Name=“grid” to our DataGrid. Moreover, we’ll add the AutoGenerateColumns property to the DataGrid so that it automatically adapts to the data source it is connected to.

<UserControl x:Class="DataGridTutorial.Page"

xmlns:my="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="400"

Height="300">

<TextBlock Text="Filter :"

Canvas.Left="10" Canvas.Top="15" Width="100"></TextBlock>

<TextBox Text="" x:Name="country"

Canvas.Left="60" Canvas.Top="10" Width="100"></TextBox>

<Button Content="Load"

Canvas.Left="180" Canvas.Top="11" Width="50"></Button>

<my:DataGrid x:Name="grid" AutoGenerateColumns="True"

Canvas.Left="10" Canvas.Top="50" Width="380" Height="230"

RowBackground="Aquamarine"

AlternatingRowBackground="White"></my:DataGrid>

</Canvas>

</UserControl>

Finally, we’ll add an event handler to the Click event on the button. Position your cursor right after the Content of the Button, and press CTRL – SpaceBar for Code Content Assist.

Select the Click event. After a second, a wizard is displayed that let you specify the name of the C# code behind associated with the button Click action.

Name it Button_Click and confirm. You are automatically directed to the code behind file Page.xaml.cs.

Let’s affect a static list to our DataGrid by setting its ItemsSource.

Copy and paste the following code :

using ...;

namespace DataGridTutorial

{

public partial class Page : UserControl

{

/**

* Event handler of <code>Button.Click</code>.

private void Button_Click(object sender, RoutedEventArgs arg1) {

grid.ItemsSource = new string[] { "Eclipse Tools for Silverlight",

"is an open source project",

"delivered by SOYATEC",

"and funded by Microsoft" };

}

public Page()

{

InitializeComponent();

}

Run the application again, and press the Load Button.

Loading and filtering multi-dimensional data

The following code defines a Customer class composed of a Name, Company and a Country. After initializing an Array of Customers, we will filter it with the Filter if it has been specified.

Notice that we use the Linq technology to filter the contents (Silverlight 2 embeds the Linq to Object and Linq to XML frameworks). Replace the contents of Page.xaml.cs by the following code :

public partial class Page : UserControl

{

// Internal Class

public class Customer

{

public string ContactName { get; set; }

public string Company { get; set; }

public string Country { get; set; }

public Customer() { }

}

// Initialize list of customers to display in the Grid

Customer[] customers = new Customer[] {

new Customer { ContactName = "Stève Sfartz", Company = "Microsoft", Country = "France" },

new Customer { ContactName = "Vijay Rajagopalan", Company = "Microsoft", Country = "United States" },

new Customer { ContactName = "Yves Yang", Company = "Soyatec", Country = "France" }

};

public Page()

{

InitializeComponent();

}

private void Button_Click(object sender, RoutedEventArgs e)

{

// Retreive Filter set in the Silverlight UI

string filter = country.Text.Trim();

// Display filtered results in Grid if the filter is not empty

if (String.IsNullOrEmpty(filter)) {

grid.ItemsSource = customers;

}

else {

// Filter

var selection = from c in customers where c.Country == filter select c;

// Display in Grid

grid.ItemsSource = selection.ToArray<Customer>();

}

Run the project and click the Load Button.

Enter France as a Filter and Click on the Load Button again

Author

Steve SFARTZ works for Microsoft France as an Architect Evangelist, with expertise in Enterprise Architecture, Interoperability, SOA & Cloud Computing.

You’ll find further guidance about Silverlight & Java interoperability on A Cup of Silverlight.
If you can read french, you may check one of my other blogs : Think Big mais pas trop..., SOA & Interop @Microsoft France, Cloud Computing @ Microsoft France.

eclipse4SL : “Hello World” Tutorial

Steve SFARTZ — Mon, 13 Oct 2008 15:10:00 GMT

Duration

30 minutes

Description

This tutorial is inspired from Scott Guthrie Silverlight 2 Series, adapted from Visual Studio to the eclipse4SL environment. A pdf version of the tutorial is attached at the end of this post and accessible here.

Prerequisites

After installing eclipse4SL, activate the Silverlight perspective by selecting one of them from the menu Window > Open Perspective > Other….

Note : eclipse4SL proposes 2 perspectives :

· Eclipse style : the project explorer is docked on the left, the palette is docked on the right

· Visual Studio style : it is the opposite.

Creating a New Silverlight Application using eclipse4SL

We'll start by selecting the File->New menu item within Eclipse and use the New Silverlight Project menu to create a "Silverlight Web Project" :

First time through you need to click other and scroll down to the Silverlight folder.

Note : eclipse4SL proposes 2 types of Silverlight projects :

· the “Silverlight Project” should be used to create Silverlight Application (ie, it does not comprise a Web Site which hosts the Silverlight application),

· whereas the “Silverlight Web Project” option comprises 2 Eclipse projects : one which holds the Silverlight Application while the second one is the Web application which hosts the Silverlight code.

We'll name the project "Hello World Tutorial".

When we click the "Finish" button, eclipse4SL will create two related projects :

· a Silverlight client application (HelloWorldTutorial)

· and a Web application (HelloWorldTutorial.Web).

Note : Both projects conform to the standard Silverlight project hierarchy tied by the .NET Build command. This architecture allows us to switch back and forth between Eclipse, Visual Studio and Expression Blend. This is a important characteristic of eclipse4SL that make it easier to work in a Mixed environment.

Let’s run the application right away to get an instant Microsoft Silverlight touch J

From the Eclipse Run options, select “Run Configurations...”. In the Snapshot below, no configuration pre-exists (no launch history).

Select "Silverlight Web App" and create a new Launch Configuration by clicking the icon at the top left, name the configuration HelloWorldTutorial, and select the HelloWorldTutorialTestPage.html from the HelloWorldTutorial.Web project as the Start page.

Click Apply and Run…

A browser window opens and displays an empty screen. The snapshot shows Internet Explorer and FireFox since both are supported on Windows. In the next section, we’ll add components to the user interface, so far, it’s empty. Notice that if you right-click on the blank surface, the Silverlight runtime menu is displayed.

Note: Silverlight Applications can be used with any web-server (should it be IIS or Tomcat on Windows,or Tomcat on Mac or Linux) and hosted within static HTML files or any server-side generated page (including .Net, PHP, Java, Python, Ruby, etc). For this HelloWorld tutorial we won't be writing any server-side code.

Understanding What Is In a Silverlight Application

By default a newly created Silverlight application project contains a Page.xaml and App.xaml file, as well as code behind class files (which can be written in VB, C#, Ruby or Python) that are associated with them:

XAML files are XML text files that can be used to declaratively specify the UI of a Silverlight or WPF application (Windows Presentation Foundation that is the Rich Desktop technology corresponding to Silverlight in the Browser). XAML can also be used more broadly to declaratively represent .NET objects (Workflows..)

The App.xaml file is typically used to declare resources, such as brush and style objects that are shared across the application. The Application code-behind class for the App.xaml file can be used to handle application level events - like Application_Startup, Application_Exit and Application_UnhandledException.

The Page.xaml file is by default the initial UI control that is loaded when the application activates. Within it we can use UI controls to define our user interface, and then handle events off of them within the Page code-behind class.

When we build our HelloWorld project, Eclipse will by default compile the code and .XAML markup into a standard .NET assembly file, and then package it and any static resources (like images or static files we want to include in it) into a " HelloWorld.xap" file on disk :

".xap" files (pronounced "zap") use the standard .zip compression algorithm to minimize client download size. Our "Hello World" Silverlight application should be about 4KB in size (in fact it is 130 Ko in M1, see below).

Note : Some controls are implemented in assemblies that if used are redistributed in the application's .xap file (which will increase an application's size above the 4kb base size). All of the controls used in the HelloWorld application are in the core Silverlight 2 runtime - which means that the total download size of the finished application will probably only be in the 6-8kb range (so very small and fast).

The October 2008 community preview (M1) of eclipse4SL embeds a set of extended controls (contained in the System.Windows.Controls.Data.dll library). The eclipse4SL dev team had to take this extreme shortcut to deliver on time. This will be fixed for M2.

To host and run a Silverlight 2 application, you can add an <object> tag into any standard HTML page (no JavaScript required) that points to the .xap file. Silverlight will then automatically download the .xap file, instantiate it, and host it within that HTML page in the browser. This works cross browser (Safari, FireFox, IE, etc) and cross platform (Windows, Mac, and Linux).

Learning how to Add Controls and Handle Events

Right now our Hello World application doesn't do anything, and when it is run it brings up an empty page.

We can change this by opening up the Page.xaml file in the project and adding some content to it, by dragging the “Button” from the eclipse4SL Palette to the Page.xaml source XML code.

Note : Drag & Drop onto the rendering surface is not implemented. You should drag the UIElement to the XAML code area.

We'll begin by changing the background of the grid and by declaring a Button control within it. We'll give the button an "x:Name" attribute value of "MyButton" - which will allow us to programmatically reference it within our code-behind class. We'll also set its Content, Width and Height properties:

Note: Html tags Content, Width and Height are case sensitive. If you write height or width instead, you’ll get a 100% progress bar at run time and a blank screen but no further warning.

When we run the application our button will then show up in the middle of the page with "Push Me" content text like below:

To add behavior to our button we can add a "Click" event handler to it. We can do this in source view by typing the event name “Cl...” and using Code Completion (Ctrl + Space Bar).

Choose the Click event. Then a wizard is displayed to assist in the delegate method development.

We can then either type a new event handler method name to use, or optionally use the default naming convention :

eclipse4SL will then automatically create a stub event handler implementation in our code-behind class file.

We can use this event handler to update the Button's content with a new message when it is clicked:

/**

* Event handler of <code>ButtonClick</code>.

private void ButtonClick(object sender, RoutedEventArgs arg1) {

MyButton.Content = "Pushed";

}

After making the change above we can re-run the application and push the button again, and now its content is updated with a "Pushed!" message:

Next Steps

We still have a little more work left to-do before our application is done... :-)

Our next step will be to setup the overall UI layout structure of our application, and arrange more controls within it. Using layout management. This article from Scott Guthrie has not be ported yet to eclipse4SL. If you wish to contribute, this is your opportunity.

Author

Steve SFARTZ works for Microsoft France as an Architect Evangelist with expertise in Enterprise Architecture, Interoperability, SOA & Cloud Computing.

How-To : Silverlight accessing Java SOAP services (Part 2 – No Cross Domain : Tomcat/Eclipse)

Steve SFARTZ — Thu, 14 Aug 2008 16:52:00 GMT

The HowTo series demo Silverlight accessing Web Services in various configuration. In this post, we will demonstrate you a SOAP service consumed by a Silverlight client application where the Site of Origin hosts the Web Services. This scenario is categorized as a D2D scenario without cross-domain policy.

The SOAP service Eclipse project and the Silverlight Eclipse project are available as an attachment to this post.

Technical Environment

SOAP services are built with the JAX-WS and JAX-B Api and hosted in Tomcat
The Silverlight application is also hosted in Tomcat

Because the Site of Origin and the Web Service reside in the same host, no Cross Domain policy is required.

Hosting the Web Service in Tomcat

In case you haven’t done the How-To : Silverlight accessing Java SOAP services (Part 1 – Cross Domain : IIS + Tomcat), you can directly import the SOAP-Sum service Eclipse project into your Eclipse Workspace.

Export it as a WAR in %TOMCAT_INSTALL%/webapps folder
go to http://localhost:8080/SOAP-SumService/services/sum (assuming that Tomcat is running on port 8080) to access the service.

Hosting the Silverlight Application using a Servlet

In the REST way, we showed you how to host a Silverlight Application using a JSP. Now we are going to host a Silverlight application using a Servlet

In Eclipse, create a new dynamic web project named Silverlight-SOAP-SumService_NOSSL
In WebContent folder, add a folder named ClientBin and copy in the latter, the xap file in the attachment. The Silverlight Application is already configured to access the SOAP service at http://localhost:8080/SOAP-SumService/services/sum?wsdl.
Add a Servlet named SilverlightServlet to a package ‘servlet’ and add the following code :

Instance of Silverlight plugin :

private void responseHandler(HttpServletResponse response) throws IOException{

    PrintWriter pw = response.getWriter();

    pw.println("" +

            "<div id=\"silverlightControlHost\">" +

            "    <object data=\"data:application/x-silverlight,\"" +

            "             type=\"application/x-silverlight-2-b2\"" +

            "             width=\"100%\" height=\"100%\">" +

            "       <param name=\"source\" value=\"ClientBin/SOAP-Sum.xap\"/>" +

            "       <param name=\"background\" value=\"white\" />" +

            "       <a href=\"http://go.microsoft.com/fwlink/?LinkID=115261\"" +

            "          style=\'text-decoration: none;\'>' +

            "         <img src=\"http://go.microsoft.com/fwlink/?LinkId=108181\""+

            "              alt=\"Get Microsoft Silverlight\"" +

            "              style=\'border-style: none\'/>' +

            "        </a>" +

            "    </object>" +

            "    <iframe style='visibility:hidden;height:0;width:0;border:0px'>' +

            "</iframe>" +

            "</div>");

    pw.close();

protected void doGet(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException {

    responseHandler(response);

    super.doGet(request, response);

Export the project as a WAR file in %TOMCAT_INSTALL%/webapps folder.
Go to http://localhost:8080/Silverlight-SOAP-SumService_NOSSL/SilverlightServlet (because In the web.xml file located in WebContent/WEB-INF directory, the servlet is configured to handle every requests made on /SilverlightServlet/*)

Silverlight will access the SOAP-Sum service without cross-domain

- Ronny Kwon

Tip : Serving JSPs and Servlets from IIS through Tomcat

Steve SFARTZ — Tue, 12 Aug 2008 17:21:00 GMT

This tip is about making IIS as a front end to Tomcat hosting Servlets and JSPs on the back end. This architecture allows the hosting of JAX-WS or Restlet services in Tomcat while Silverlight clients are hosted in IIS without facing cross-domain issues.

The configuration files and the connector (isapi_redirect.dll) are available as an attachment to this post. Before continuing, you must download the Zip archive and unzip it to C:\Program Files\Apache Software Foundation

The following is inspired from

The Apache Tomcat Connector - Webserver HowTo : IIS HowTo

Pre-requisites

From this point, we assume that

IIS 5.1 is installed on a Windows XP SP2 Professional Edition
Apache Tomcat 6.0.16 is installed and working properly on the same OS

The Tomcat installation directory is C:\Program Files\Apache Software Foundation\Apache Tomcat 6.0.16

You have unzipped the archive, you must have the following directory : C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector

Configuring the ISAPI Redirector

Open the Registry Editor, Run—>regedit

Create a new registry key names “HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0”

The following screenshot shows you the different values you have to create in the previous created key

name	value
extension_uri	/jakarta/isapi_redirect.dll
log_file	C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\log\isapi_redirect.log
log_level	info
worker_file	C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\conf\workers.properties.minimal
worker_mount_file	C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\conf\uriworkermap.properties

Open the IIS Management Console
add a new Virtual Directory to the Default Web Site

Alias must be set to “jakarta”
Directory must be set to isapi_redirector.dll location C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\bin
Allow Execute permission

Now let’s add a new ISAPI filter

open the properties dialog of the Default Web Site, in the ISAPI Filters tab, click add to add a new filter.
Set the filter name to “jakarta”
Executable is the exact location of the isapi_redirect.dll : C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\bin\isapi_redirect.dll
Restart the IIS Server then check for the jakarta filter, an up-green arrow has appeared

Also start Tomcat server.

In a Web Browser, ensure that http://localhost:8080/examples/jsp/index.html is accessible :

It’s normal, this page is served by Tomcat (assuming that it is running on port 8080)

Now access to this page within IIS (in our case, we set IIS port to 81), by default port 80 is used.

Go to http://localhost:81/examples/jsp/index.html. A similar page is displayed.

Try to execute a jsp example :

Configuring the URL mapping

In the C:\Program Files\Apache Software Foundation\Jakarta Isapi Redirector\conf directory you will find two configuration files :

workers.properties.minimal : it describes the host(s) and port(s) used by Tomcat processes.
uriworkermap.properties : it maps URL-Path patterns to workers

In the uriworkermap.properties you will find the mapping of URL to be handled by the workers declared in workers.properties. An example of URL mapping:

default.worker=ajp13

/docs=$(default.worker)
/docs/*=$(default.worker)
/examples=$(default.worker)
/examples/*=$(default.worker)
/host-manager=$(default.worker)
/host-manager/*=$(default.worker)
/manager=$(default.worker)
/manager/*=$(default.worker)

In this configuration, every request on /examples/* will be handled by the Tomcat process, that’s how we managed to serve JSPs and Servlets from IIS through Tomcat. You may add your own URL patterns... if you do so, don’t forget to restart the Tomcat Server.

- Ronny Kwon

Tip : Cross Domain Policy when Self-Hosting your Services

Steve SFARTZ — Mon, 11 Aug 2008 15:24:00 GMT

This tip is about self hosting of services with the .Net WCF or Java Restlet framework. Cross-domain access is mandatory here since the Site of Origin does not host the services.

Self hosting a service represents a quick & easy way to expose a Web Service for tests purpose. Yet, customization is extermely limited since self hosting does not provide you all the capabilities of Web Servers such as delivering static content (cross domain policy file).

The first thing you need to know is that when Silverlight attempts to access services in cross-domain, it will send a HTTP GET method on http://<domain:port>/clientaccesspolicy.xml or http://<domain:port>/crossdomain.xml (in case clientaccesspolicy.xml wasn’t found). If you plan to self host your Web Service, you will agree that there is no possible way to host a physical Cross Domain policy file at the root of the Web Server.

You must handle this request through your Service implementation. It usually matches the /clientaccesspolicy.xml or /crossdomain.xml URI pattern.

WCF way (inspired from Carlo’s blog)

Self-hosted Service

class Program

    static void Main(string[] args)

        // URI of the Service

        Uri uri = new Uri("http://localhost:8081/");

        // create a new WebServiceHost specifying the implementation of the Service

        // and the specified uri to bind with

        WebServiceHost host = new WebServiceHost(

                new REST_ItemsServiceLibrary.ItemsREST(),

                uri);

        // add the Service Endpoint specifying the Service Interface

        host.AddServiceEndpoint(typeof(REST_ItemsServiceLibrary.IItemsREST),

                                new WebHttpBinding(), "");

        // open the WebServiceHost

        host.Open();

        Console.WriteLine("Service hosted at {0}", uri.OriginalString);

        Console.ReadLine();

        // close the WebServiceHost

        host.Close();

Handling cross-domain file requests

As we said earlier, we have to manage the /clientaccesspolicy.xml, specify in the Service Interface that HTTP GET method on the URI /clientaccesspolicy.xml will be handled by GetSilverlightPolicy();

[OperationContract]

[WebGet(UriTemplate ="/clientaccesspolicy.xml")]

Stream GetSilverlightPolicy();

this also applies to /crossdomain.xml

Finally, in your Service implementation, return a clientaccesspolicy.xml content:

public Stream GetSilverlightPolicy()

    string result = @"<?xml version=""1.0"" encoding=""utf-8""?>

<access-policy>

    <cross-domain-access>

        <policy>

            <allow-from http-request-headers=""*"">

                <domain uri=""*""/>

            </allow-from>

            <grant-to>

                <resource path=""/"" include-subpaths=""true""/>

            </grant-to>

        </policy>

    </cross-domain-access>

</access-policy>";

    return StringToStream(result);

Stream StringToStream(string result)

    WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml";

    return new MemoryStream(Encoding.UTF8.GetBytes(result));

Restlet way

Self-hosted Service

public static void main(String[] args) {

    try {

        // Create a new Component.

        Component component = new Component();

        // Add a new HTTP server listening on port 8182.

        component.getServers().add(Protocol.HTTP, 8182);

        // Attach the sample application.

        component.getDefaultHost().attach(

                new FirstResourceApplication(component.getContext()));

        // Start the component.

        component.start();

    } catch (Exception e) {

        // Something is wrong.

        e.printStackTrace();

Handling cross-domain file requests

Following the same philosophy as the WCF way, we need to handle HTTP GET method on /clientaccesspolicy.xml file request :

In the Application implementation you must bind the URI pattern with the Ressource that will handle it :

Finally, implement the ClientAccessPolicy class, specially the HTTP GET method within getRepresentation method :

package firstResource;

import java.io.IOException;

import org.restlet.Context;

import org.restlet.data.MediaType;

import org.restlet.data.Request;

import org.restlet.data.Response;

import org.restlet.resource.DomRepresentation;

import org.restlet.resource.Representation;

import org.restlet.resource.Resource;

import org.restlet.resource.Variant;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

public class ClientAccessPolicy extends Resource{

    public ClientAccessPolicy(Context context, Request request,

            Response response) {

        super(context, request, response);

        getVariants().add(new Variant(MediaType.TEXT_XML));

    @Override

    public Representation getRepresentation(Variant variant){

        if (MediaType.TEXT_XML.equals(variant.getMediaType())) {

             try {

                DomRepresentation representation = new DomRepresentation(

                      MediaType.TEXT_XML);

                // Generate a DOM document representing the list of

                // items.

                Document d = representation.getDocument();

                Element accesspolicy = d.createElement("access-policy");

                d.appendChild(accesspolicy);

                Element crossdomainaccess = d.createElement("cross-domain-access");

                accesspolicy.appendChild(crossdomainaccess);

                Element policy = d.createElement("policy");

                crossdomainaccess.appendChild(policy);

                Element allowfrom = d.createElement("allow-from");

                allowfrom.setAttribute("http-request-headers","*");

                Element domain = d.createElement("domain");

                domain.setAttribute("uri", "*");

                allowfrom.appendChild(domain);

                Element grantto = d.createElement("grant-to");

                Element resource = d.createElement("resource");

                resource.setAttribute("include-subpaths","true");

                resource.setAttribute("path", "/");

                grantto.appendChild(resource);

                policy.appendChild(allowfrom);

                policy.appendChild(grantto);

                d.normalizeDocument();

                // Returns the XML representation of this document.

                return representation;

             } catch (IOException e) {

                e.printStackTrace();

          return null;

- Ronny Kwon

How-To : Silverlight accessing Java REST services (Part 2 – No Cross Domain : Tomcat/Eclipse)

Steve SFARTZ — Wed, 06 Aug 2008 11:43:00 GMT

The HowTo serie demoes Silverlight accessing Web Services in various configuration. In this post, we will demonstrate a REST service consumed by a Silverlight client application where the Site of Origin hosts the Web Services. This scenario is categorized as a D2D scenario without cross-domain policy.

The XAP package, the REST service Eclipse project and the Silverlight Eclipse project are available as an attachment to this post.

Technical Environment

REST services are built with the Restlet framework and hosted in Tomcat
The Silverlight application is also hosted in Tomcat

Because the Site Of Origin and the Web Services reside in the same host, no Cross Domain policy is required.

To successfully install the technical environment, please take the following step :

Build the scenario detailled in HowTo : Silverlight accessing Java REST services (Part 1 - Cross Domain : IIS + Tomcat)

If you don’t feel like doing the previous step, the XAP package available as an attachment contains a Silverlight client which is configured to access a REST service at http://localhost:8080/Restlet-servletfirstResource/items.

The REST service is also available as an attachment to this post allows to do a GET and POST method to get a list of items or to insert a new one.

Download the attachment and unzip it. There are two needed parts : the Silverlight XAP package and the Restlet Eclipse project.

Host the REST service with Tomcat

Import the Reslet-servletfirstResource project into your Eclipse workspace :

go to File –> Import
Then chose General—>Existing Projects into Workspace
Select the root directory, Browse to the Restlet-servletfirstResource folder, then click on Finish. The Restlet-servletfirstResource has now been imported into your workspace

Run the project on Tomcat Server. check that http://localhost:8080/Restlet-servletfirstResource/items is accessible you should get the following result :

Host the Silverlight application in an Eclipse project running on Tomcat

Create a new Dynamic Web Project

Press Ctrl+n to go to the New Wizard Project, under Web select Dynamic Web Project.
Call it REST-SilverlightClient and ensure that the Target Runtime is set to Apache Tomcat 6.0
If Eclipse prompts you to switch to J2EE perspective, accept it.

In the REST-SilverlightClient project, create the WebContent\ClientBin folder and copy the XAP package into it.
Now we need to host it through an Active X control :

Right click on WebContent folder and select New—>JSP, call it index
Edit index.jsp, in the Head part put the following script that catches Silverlight Error.

 <script type="text/javascript">

     function onSilverlightError(sender, args) {

         var appSource = "";

         if (sender != null && sender != 0) {

             appSource = sender.getHost().Source;

         var errorType = args.ErrorType;

         var iErrorCode = args.ErrorCode;

         var errMsg = "Unhandled Error in Silverlight 2 Application " +  appSource + "\n" ;

         errMsg += "Code: "+ iErrorCode + "    \n";

         errMsg += "Category: " + errorType + "       \n";

         errMsg += "Message: " + args.ErrorMessage + "     \n";

         if (errorType == "ParserError")

             errMsg += "File: " + args.xamlFile + "     \n";

             errMsg += "Line: " + args.lineNumber + "     \n";

             errMsg += "Position: " + args.charPosition + "     \n";

         else if (errorType == "RuntimeError")

             if (args.lineNumber != 0)

                 errMsg += "Line: " + args.lineNumber + "     \n";

                 errMsg += "Position: " +  args.charPosition + "     \n";

             errMsg += "MethodName: " + args.methodName + "     \n";

         throw new Error(errMsg);

 </script>

In the Body part, instantiate a Silverlight control by adding the following HTML code, ensure that the param named “source” has is value set to the XAP package URI relative to index.jsp Web Page:

<div id="silverlightControlHost">

    <object data="data:application/x-silverlight,"

            type="application/x-silverlight-2-b2"

            width="100%" height="100%">

        <param     name="source" value="ClientBin/REST-JavaServiceItem.xap"/>

        <param     name="onerror" value="onSilverlightError" />

        <param     name="background" value="white" />

        <a     href="http://go.microsoft.com/fwlink/?LinkID=115261"

            style="text-decoration: none;">

               <img src="http://go.microsoft.com/fwlink/?LinkId=108181"

                 alt="Get Microsoft Silverlight"

                 style="border-style: none"/>

        </a>

    </object>

    <iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe>

</div>

Run the project on Tomcat Server and the Silverlight control will appear in the Eclipse Web Browser :

The great thing about that is that you will be able to test your REST Service and the Silverlight application without running multiple Development Environments.

- Ronny Kwon

How-To : Silverlight accessing Java SOAP services (Part 1 – Cross Domain : IIS + Tomcat)

Steve SFARTZ — Mon, 04 Aug 2008 18:35:00 GMT

The How-To series demo Silverlight accessing Web Services in various configuration. In this post, we will demonstrate a SOAP service consumed by a Silverlight client application. This scenario can be categorized as a D2D scenario with a cross domain policy.

Both the Silverlight and SOAP service are available as an attachment to this post. Since Metro libraries are too large, you will need to copy all jar files from metro\lib\ folder into WebContent\WEB-INF\lib project folder. Steps are described below.

Technical environment

SOAP services are built with JAX-WS and JAX-B APIs and hosted in Tomcat.
The Silverlight application is hosted under the Visual Studio embedded Web Server code name “Catalina” (which delivers a subset of the IIS capabilities)

Requirement

For this How-To, we use the Metro framework which contains both JAX-WS and JAX-B APIs which will be used to develop SOAP Services in JAVA.

Configuring Tomcat

Download the jar file from https://metro.dev.java.net/1.2/ and launch it. A “metro” folder has been created at the jar location. metro\lib folder contains all the needed libraries for the Java SOAP service development and Tomcat configuration. Here is a good link that describes how to configure your Tomcat server http://blogs.sun.com/arungupta/entry/metro_on_tomcat_6_x

Implementing the SOAP / RPC service

In Eclipse, create a new Dynamic Web Project called “SOAP-SumService”
copy all jar files from metro\lib\ folder into WebContent\WEB-INF\lib project folder.
Create a package called “service” and add a new Java class called “ServiceSumImpl” to this package.
Add a xml file to WebContent\WEB-INF called “sun-jaxws.xml”.

Your project structure now looks like this :

Implementation of the Web Service endpoint

In ServiceSumImpl.java, import the following libraries :

Declare the class as a Web Service endpoint with the following annotations, for more informations about annotations refer to this site.

The only method that our service exposes is getSum. It returns the sum of two integers. But we want this method to be known over the service as “SumTwoInt”. Within the annotations we can configure all these parameters.

Now build the project to generate the bytecode as the WSGen tool need it.

Generation of the required artifacts for the Web Service deployment and invocation

For this step, Metro provides a generation tool called “wsgen”.

Open a Windows Command Prompt : Start->Run and type “cmd”
set a METRO as a path variable to metro\bin folder (in our case it is C:\metro\bin path)

Go to your build project folder (by default in Eclipse: ProjectName\build\classes). In our example it is the SOAP-SumService\build\classes folder

Type the following command line to generates the artifacts in the project “src” folder.

%METRO%\wsgen –cp . service.ServiceSumImpl –s ../../src

Refresh the Project Explorer and observes that two java files have been generated

They represent the message that will be shared in the Web Service process

Configuring the Web Service Deployment

To configure the deployment, we need to instantiate a Servlet that will handles JAX-WS Web Services requests.

In web.xml, add a Servlet element. We use a pre-existing Web Service Servlet :

<servlet>

    <servlet-name>jaxservlet</servlet-name>

    <servlet-class>

        com.sun.xml.ws.transport.http.servlet.WSServlet

    </servlet-class>

    <load-on-startup>1</load-on-startup>

</servlet>

This servlet will handle every requests on /services/* URI, so let’s map to it with its name:

<servlet-mapping>

    <servlet-name>jaxservlet</servlet-name>

    <url-pattern>/services/*</url-pattern>

</servlet-mapping>

To provide the right context, we need a listener (which also already exists):

<listener>

    <listener-class>

        com.sun.xml.ws.transport.http.servlet.WSServletContextListener

    </listener-class>

</listener>

Finally, we need to expose the endpoint ServiceSumImpl within an URI, for example /services/sum.

Edit the sun-jaxws.xml file and add the following elements :

<?xml version="1.0" encoding="UTF-8"?>

<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">

    <endpoint

        name="sum"

        implementation="service.ServiceSumImpl"

        url-pattern="/services/sum"/>

</endpoints>

Save all files, then Run the project on the Tomcat Server
Right click on the project node : Run As –> Run on Server

The service is now hosted on Tomcat at http://localhost:8080/SOAP-SumService/services/sum?wsdl

Enabling Cross Domain Access

Since the SOAP service and the Silverlight application reside on different hosts, we need to overpass the Cross Domain Issue. Create at the root of the SOAP service host, a clientaccesspolicy.xml file with the following content :

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<access-policy>

    <cross-domain-access>

        <policy>

            <allow-from http-request-headers="*">

                <domain uri="*"/>

            </allow-from>

            <grant-to>

                <resource include-subpaths="true" path="/"/>

            </grant-to>

        </policy>

    </cross-domain-access>

</access-policy>

Consuming a SOAP service with Silverlight

Now that the Web Service is exposed, we are going to generate the client proxy to consume the Web Service with Silverlight.

Open Visual Studio 2008 and create a new Silverlight Project called SOAP-Sum and paste the following XAML code in Page.xaml to obtain a simple interface that will manipulate the web service.

<UserControl x:Class="SOAP_Sum.Page"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Width="400" Height="300">

    <Canvas x:Name="LayoutRoot" Background="White">

        <TextBox Text="0" x:Name="_int1" Width="50" Height="20"

                          Canvas.Top="10" Canvas.Left="30" TextChanged="_TextChanged"/>

        <TextBlock Canvas.Top="10" Canvas.Left="95" Text="+"/>

        <TextBox Text="0" x:Name="_int2" Width="50" Height="20"

                          Canvas.Top="10" Canvas.Left="120" TextChanged="_TextChanged"/>

        <TextBlock Canvas.Top="10" Canvas.Left="175" Text="="/>

        <TextBlock x:Name="_result" Canvas.Top="10" Canvas.Left="190" Text=""/>

    </Canvas>

</UserControl>

Add a Service Reference
Right click on References then chose Add a Service Reference

In Address field, type the Sum service address then click Go (it should be http://localhost:8080/SOAP-SumService/services/sum?wsdl).

We actually have the Sum service named ServiceSum and one operation exposed as SumTwoInt, this is exactly what we did parameter in “Implementation of the Web Service endpoint” (see above)

In Namespace field, type ServiceSum : this is how the service will be accessible through the Silverlight project. Click OK. In the Solution Explorer you see the ServiceSum reference in Service References.

Implementation of the client proxy

In Page.xaml.cs, add an import to SOAP-Sum.ServiceSum reference library.

   1:  using SOAP_Sum.ServiceSum;

Now we need to handle the TextChanged event in _TextChanged method :

Instantiate a client proxy
```
ServiceSumClient client = new ServiceSumClient();
```
Add an event handler corresponding to the operation we are going to use so we can get the result
```
client.SumTwoIntCompleted += 
```
```
   new EventHandler<SumTwoIntCompletedEventArgs>
```
```
      (
```
```
         client_SumTwoIntCompleted
```
```
      );
```
Use Async operation to send our two integers.
Operations are made asynchronous so Silverlight UI won’t freeze
```
client.SumTwoIntAsync(a,b);
```

The whole method looks like this :

   1:  private void _TextChanged(object sender, TextChangedEventArgs e)

   2:  {

   3:      // check if fields contain some text

   4:      if (_int1.Text == "" || _int2.Text == "") return;

5:

   6:      int a = int.Parse(_int1.Text);

   7:      int b = int.Parse(_int2.Text);

8:

   9:      // generate a client proxy to the Web Service

  10:      ServiceSumClient client = new ServiceSumClient();

  11:      client.SumTwoIntCompleted += new EventHandler<SumTwoIntCompletedEventArgs>(client_SumTwoIntCompleted);

  12:      client.SumTwoIntAsync(a,b);

  13:  }

Then we can process the result in the event handler

void client_SumTwoIntCompleted(object sender, SumTwoIntCompletedEventArgs e)

    _result.Text = e.Result.ToString();

Run the project and type some integers in the text boxes : Silverlight is consuming a JAX-WS SOAP service.

- Ronny Kwon

How-To : Silverlight accessing Java REST services (Part 1 - Cross Domain : IIS + Tomcat)

Steve SFARTZ — Wed, 30 Jul 2008 15:42:00 GMT

The HowTo serie demoes Silverlight accessing Web Services in various configurations. In this post, we will demonstrate a REST service consumed by HTTP GET and POST requests issued from a Silverlight client application. This scenario can be categorized as a D2D scenario with a cross domain policy.

The Silverlight example described below is available as an attachment to this post.

Technical environment

REST services are built with Restlet and hosted in Tomcat
The Silverlight application is hosted under the Visual Studio embedded Web Server code name "Catalina" (which delivers a subset of the IIS capabilities)

Because the Site of Origin and the Web Services reside in different hosts, a Cross Domain policy is required at the Services host’s root (/clientaccesspolicy.xml">http://<serviceshostname:port>/clientaccesspolicy.xml)

Implementation of the REST service

To get an overview of the Restlet framework, complete the tutorials : First Steps and First Resource.

Service development with Restlet can be summarized as follow :

The Application class is the entry point to the Restlet service. It binds a URI to a specific Resource.
The Resource class describes how the service behaves on a specific URI invokation.

After completing the tutorials above, deploy the firstResource service as a Servlet hosted by Tomcat.

Invoke the Restlet service with the URI http://localhost:8080/Restlet-servletfirstResource/items. Assuming that Tomcat is running on port 8080 and that your Restlet project name is Restlet-servletfirstResource, you get the following response :

  <?xml version="1.0" encoding="UTF-8" standalone="no" ?>

  <items>

     <item>

        <name>item1</name>

        <description>description of item1</description>

     </item>

   </items>

Enabling Cross Domain Access

Since the REST service and the Silverlight application are hosted in different hosts, we need to overpass the Cross Domain Issue. Create at the root of the REST service host, a clientaccesspolicy.xml file with the following content :

<?xml version="1.0" encoding="UTF-8"?>

<access-policy>

    <cross-domain-access>

        <policy>

            <allow-from http-request-headers="*">

                <domain uri="*"/>

            </allow-from>

            <grant-to>

                <resource include-subpaths="true" path="/"/>

            </grant-to>

        </policy>

    </cross-domain-access>

</access-policy>

Consuming a REST service with Silverlight (GET method)

We chose the WebClient API to request the REST service, and LINQ to process the XML response. XmlReader is another parsing option, and Serialization (Xml or DataContract) is another one.

Invocation of the REST service

First of all, in your UserControl, declare a MyItem class that will map the XML response elements.

   1:  public class MyItem

   2:  {

   3:      public string myName { get; set; }

   4:      public string myDescription { get; set; }

   5:  }

   1:  // List of Items

   2:  IEnumerable<MyItem> Items = null;

Now, let's send a HTTP GET method request to /items URI so we can retrieve every items

   1:  private void getAction()

   2:  {

   3:      WebClient webclient = new WebClient();

   4:      webclient.DownloadStringCompleted +=

   5:        new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);

   6:      webclient.DownloadStringAsync(new Uri("http://localhost:8080/Restlet-servletfirstResource/items"));

   7:  }

Processing the XML results

Let’s process the results using LINQ support for XML :

   1:  void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)

   2:  {

   3:      if (e.Error == null)

   4:      {

   5:          XDocument xmlItems = XDocument.Parse(e.Result);

   6:          // use LINQ to XML to parse the response

   7:          Items = from child in xmlItems.Element("items").Descendants().ToList()

   8:                  // restrict the selection to item children

   9:                  where child.Name.LocalName=="item"

  10:                  select new MyItem

  11:                      {

  12:                          myName = (string)child.Element("name"),

  13:                          myDescription = (string) child.Element("description")

  14:                      };

  15:      }

  16:  }

Sending Data to a REST service with Silverlight (POST method)

Use the WebClient to send a HTTP POST request to the /items URI, by adding two parameters : name = "Foo" and description = "Bar" :

   1:  private void postWebClient()

   2:  {

   3:      WebClient webclient = new WebClient();

   4:      webclient.UploadStringAsync(

   7:        new Uri("http://localhost:8080/Restlet-servletfirstResource/items"),

   8:        "name=Foo&description=Bar"

   9:      );

  10:  }

Warning : Notice that if you try to hit the same URI several time with the HTTP GET method, the results do not get refreshed but remain the same. Further explanations about this caching issue are available here.

- Ronny Kwon

Limitations when accessing REST services from Silverlight

Steve SFARTZ — Wed, 30 Jul 2008 12:35:00 GMT

As explained in What are those SOAP/RPC and XML/REST styles ?, the REST support in Silverlight has several limitations :

Only the "Content-Type" HTTP header can be accessed from the Silverlight client code.
The WebClient works fine in most scenarios, yet turn to HttpWebRequest if you need to control the response flow.
HTTP methods are limited to POST and GET (no PUT, nor DELETE support) - see below
You may encounter Browser Caching issues - see below

1. Manipulating a REST service model is done via 4 basic HTTP methods: GET, POST, PUT, DELETE . The last two methods are not yet supported by Silverlight :

2. Cache issue

You request data from a REST service by invoking a URI with the WebClient class. As all service communications are async in Silverlight, you process the result through an handler.

   1:  WebClient client = new WebClient();

   2:  client.DownloadStringCompleted +=

   3:  new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);

   4:  client.DownloadStringAsync(new Uri(“http://foo.org/service/items”));

You may experience that the same data gets always retrieved, even when modified on the service side. To solve this problem :

either set the Cache Control with "no-cache" value on the service side,
or ensure that subsequent calls are made with differents URI (so that the results do not get cached). This is mandatory if the REST framework on the service side does not support cache header customization, as it is the case for the Restlet framework (as of July 2008, Jerome Louvel is working on it).

client.DownloadStringAsync(new Uri(“http://foo.org/service/items?cache=" + DateTime.Now));

- Ronny Kwon

D2D scenario : Developer Environment

Steve SFARTZ — Mon, 28 Jul 2008 17:17:00 GMT

This scenario is typically used in development phase when you are building a Silverlight rich client that connects to new business Logic. It is mandatory that the business logic is new to ensure you have enough control to enforce a configuration where the Site Of Origin and the Services Host reside on the same node. If you face a configuration where you need to interface with Business Logic exposed by existing Web Services from a distinct node or requiring protocol adaptation, turn to the B2E scenario.

As listed in Silverlight scenarios for Rich Internet Applications, the following constraints apply to the Developer Environment scenario :

No infrastructure security constraints since this is a dev/test env (No HTTPS, no DMZ)
No protocol adaptation is necessary as we develop brand new services here (ie, messages format & exchange protocol correspond to the Silverlight client capabilities, they can be directly consumed)
Authentication & authorization may need to be handled if required at production/deployment time : this point is covered in the B2E scenario.
A cross domain security file is needed if the Site Of Origin does not host the Web Services, as in interoperability scenarios where the Site of Origin and the Web Services rely on two different technologies.

We plan to experiment the following configurations :

SOAP/ RPC style (operation oriented)
1. Mixed configuration : IIS for Site of Origin + Tomcat and JAVA-WS for Web Services
  - with a cross-domain policy
  - or by servicing Web services request from IIS through the Tomcat connector for IIS
2. Full Java configuration : Tomcat for Site of Origin + JAVA-WS for Web Services
3. Full Windows configuration : IIS for Site or Origin + WCF services (SOAP style) for Web Services
  - with a cross-domain policy
  - or with the IIS built-in integration of WCF services through SVC resources
XML/ REST style (resource oriented)
1. Mixed configuration : IIS for Site of Origin + Tomcat and the Restlet framework for Web Services
  - with a cross-domain policy
  - or by servicing Web services request from IIS through the Tomcat connector for IIS
2. Full Java configuration : Tomcat for Site of Origin + Restlet for Web Services
3. Full Windows configuration : IIS for Site of Origin + WCF services (REST style) for Web Services