Petals ESB v3.0 is finally out (two years after the v2.0 release), there are many changes in this version but here are the main ones :

Petals ESB 3.0, includes a lot of improvements for users, as well as optimisations, and nice new features :
- Dynamic configuration, and hot-deployment of new nodes
- Redesigned webconsole for administration, and deleted statistics monitoring (based on OW2-OpenSUIT)
- SCA support: SCA engine (OW2-FraSCAti), and SCA designer (Eclipse)
- BPEL support: BPEL engine, and BPEL designer (Eclipse), with validation (based on a new BPEL engine!)
- WS Notification and WS-BorkeredNotification support (EDA)
- more and more things…

Integration with new Petals Camelia softwares :
- Petals Studio: Complete Eclipse development environment, for Petals ESB
- Petals Master: SOA Governance (OW2-Dragon)
- Petals View: Business flow monitoring based on Petals EDA feature (based on OW2-OpenSUIT)

We gave this release a name : Camelia.

Viele PC-Nutzer glauben, dass Dateien, die sie löschen dadurch tatsächlich vernichtet werden. Dem ist nicht so. Zum einen haben die meisten Betriebssysteme eine Sicherung gegen unabsichtliches Löschen eingebaut: Das Papierkorb-Verzeichnis, in das gelöschte  Dateien hinein verschoben werden. Und aus dem man sie – wie bei einem echten Mülleimer – wieder herausziehen kann. Aber auch das „Leeren“ des Papierkorbes führt nicht zur tatsächlichen Löschung der Dateien. Der Rechner markiert die durch die Dateien belegten Speicherbereiche seiner Festplatte lediglich als „frei verfügbar“. Früher oder später werden darauf neue Daten gespeichert, so dass dadurch die zuvor dort gespeicherten Daten überschrieben werden. Erst dann sind sie tatsächlich weg. Je nach Nutzungsintensität der Festplatte und der dort noch vorhandenen Speicherkapazität kann das Sekunden oder Monate bis Jahre dauern.

Wer wissen will, was sich auf seinem Rechner noch an bereits gelöschten aber wiederherstellbaren Daten befindet, kann mit Tools wie Piriform‘s kostenlosem Recuva nachschauen. Und die Datenreste auf Wunsch auch gleich endgültig beseitigen oder aber wiederherstellen lassen.

Zumindest für Dateien gibt es durchaus ein „Leben nach dem Tod“. Es sei denn, sie werden gleich „sicher gelöscht“, d.h. der von ihnen belegte Plattenplatz wird erst mit anderen Daten überschrieben und anschließend als „frei“ gekennzeichnet. Auch dafür gibt es Tools, wie z.B. das Programm Crap Cleaner. Es ist eine Art “Datenmüllabfuhr”, die den Rechner auf dem es installiert ist, von datentechnischen Gebrauchsspuren säubert und in der man auch sichere Löschverfahren einstellen kann.

Heute haben viele Nutzer aber Daten nicht nur auf ihrem eigenen Rechner sondern auch „in der Cloud“, d.h. bei Internetdiensten wie Facebook, XING oder Twitter. Und hier werden die Dinge jetzt kompliziert. Denn das Internet vergisst grundsätzlich erst mal nichts. Fast alles wird irgendwo gespiegelt, zwischengespeichert oder in Archiven und Backup-Systemen vorgehalten. Je länger es im Netz steht, desto wahrscheinlicher ist das. So werden z.B. meine Artikel in diesem Blog oftmals bereits nach wenigen Stunden von Suchmaschinen erfasst, wodurch sie meist auch in deren Cache landen.

In den meisten sozialen Netzwerken kann man eigene Daten zwar löschen. Aber es ist dadurch nicht sichergestellt, dass sie tatsächlich weg sind. Hochverfügbar laufende IT-Systeme haben meist mehrere Backups und identisch konfigurierte und mit aktuellen Datenbeständen versehene Ersatzsysteme, um bei Sabotage oder Plattencrash zügig darauf umschalten und weiterlaufen zu können. Und oft genug enthält das Kleingedruckte in den Nutzungsverträgen mit den Plattformbetreibern Klauseln, wonach man ihnen Verwertungsrechte an den persönlichen Daten einräumt. Was sie dazu veranlassen kann, diese dafür vor endgültiger Löschung zu sichern.

So warf kürzlich der Security-Newsletter von TrendMicro die durchaus berechtigte Frage auf:  „When You Delete Your Social Media and Smartphone Files — Are They Really Deleted?“ Um im Weiteren auf die grundsätzliche Problematik der Kontrolle und Verfügung über Daten auf ausgelagerten IT-Systemen zu verweisen. Ein Thema, dass nicht nur Rechenzentren in Konzernen sondern zunehmend auch Privatnutzer mit ihren Mobilgeräten und Web 2.0-Accounts betrifft. So sieht z.B. der Prototyp von Googles Netbook-Betriebssystem Chrome OS ein fast ausschließlich webbasiertes Arbeiten mit dem Rechner vor, so das praktische alles – Programme, Daten, Dienste – aus dem Internet bezogen wird.

As more consumer data moves onto cloud computing platforms like Gmail and Facebook, and closed platforms like Kindle and iPhone, deleting your data—whether old email messages, college photos on Flickr or personal posts on Facebook—becomes more complicated. In fact, you have to trust that these companies will delete your data when you ask them to. Unfortunately, many of these sites are more likely to make your data inaccessible than actually delete it. And even if you do manage to delete your files, copies are almost certain to remain in the companies’ backup systems.

Als Lösung dafür wird auf die Idee von Dateien mit zeitlich begrenzter Lebensdauer und anschließender Selbstzerstörung hingewiesen. Eine Idee, die im Zuge des Vanish-Projektes an der University of Washington entstand und bereits als quelloffene Referenzimplementierung vorliegt. Allerdings haben auch Konzepte wie „Vanish“ ihre Nachteile, so dass eine endgültige Lösung für das Problem noch aussteht.

Während man das Dasein von gelöschten Dateien auf dem meisten Rechner also durchaus selbst endgültig beenden kann, erlangen ins Internet verlagerte Daten gewissermaßen eine Art „ewiges Leben“.

First Create Silverlight application

Start -> Programs -> VS2008 -> File -> New -> Project -> SilverlightApplication -> ByDefault application name is SilverlightApplication1 change name as SilverlightDB

Original article from

http://www.codeforasp.net/how-to-insert-data-into-database-using-silverlight.html

Step2: Design Registration form in Page.xaml

Silverlight Grid with 8 Rows and 2 Columns using grid RowDefinition and ColumnDefinition

<UserControl xmlns:controls=”clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Toolkit”  x:Class=”SilverlightDB.Page”

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

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

Width=”400″ Height=”300″>

<Border BorderBrush=”Black” BorderThickness=”1″ >

<Grid x:Name=”LayoutRoot” Background=”White” ShowGridLines=”False” >

<Grid.RowDefinitions>

<RowDefinition Height=”35″></RowDefinition>

<RowDefinition Height=”30″></RowDefinition>

<RowDefinition Height=”30″></RowDefinition>

<RowDefinition Height=”30″></RowDefinition>

<RowDefinition Height=”30″></RowDefinition>

<RowDefinition Height=”30″></RowDefinition>

<RowDefinition Height=”40″></RowDefinition>

<RowDefinition Height=”70″></RowDefinition>

</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width=”130″></ColumnDefinition>

<ColumnDefinition Width=”270″></ColumnDefinition>

</Grid.ColumnDefinitions>

<StackPanel Grid.Row=”0″ Grid.Column=”0″ Grid.ColumnSpan=”2″ Width=”400″ Background=”Gray” >

<controls:Label  FontSize=”14″ FontWeight=”bold” HorizontalAlignment=”Center”

Content=”Registration Form” Margin=”6,5,-5,5″></controls:Label>

</StackPanel>

<controls:Label Grid.Row=”1″ Grid.Column=”0″ Content=”FirstName” Margin=”10,5,5,5″ HorizontalAlignment=”Center”></controls:Label>

<TextBox Grid.Column=”1″ Grid.Row=”1″ Height=”25″ Width=”150″ HorizontalAlignment=”Left”></TextBox>

<controls:Label Grid.Row=”2″ Grid.Column=”0″ Content=”EmailID” Margin=”10,5,5,5″ HorizontalAlignment=”Center”></controls:Label>

<TextBox Grid.Row=”2″ Grid.Column=”1″ Height=”25″ Width=”150″ HorizontalAlignment=”Left”></TextBox>

<controls:Label Grid.Row=”3″ Grid.Column=”0″ Content=”PhoneNo” Margin=”10,5,5,5″ HorizontalAlignment=”Center”></controls:Label>

<TextBox Grid.Row=”3″ Grid.Column=”1″ Height=”25″ Width=”150″ HorizontalAlignment=”Left”></TextBox>

<controls:Label Grid.Row=”4″ Grid.Column=”0″ Content=”LoginName” Margin=”10,5,5,5″ HorizontalAlignment=”Center”></controls:Label>

<TextBox Grid.Row=”4″ Grid.Column=”1″ Height=”25″ Width=”150″ HorizontalAlignment=”Left”></TextBox>

<controls:Label Grid.Row=”5″ Grid.Column=”0″ Content=”Password” Margin=”10,5,5,5″ HorizontalAlignment=”Center”></controls:Label>

<TextBox Grid.Row=”5″ Grid.Column=”1″ Height=”25″ Width=”150″ HorizontalAlignment=”Left”></TextBox>

<Button Grid.Row=”6″ Grid.Column=”1″ Width=”100″ Height=”25″ HorizontalAlignment=”Left” Content=”Register”></Button>

</Grid>

</Border>

</UserControl>

Run the application

CREATE TABLE [dbo].[Registration](

[registerID] [int] IDENTITY(1,1) NOT NULL,

[FirstName] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[EmailID] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[PhoneNo] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[LoginName] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[Password] [varchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

CONSTRAINT [PK_Registration] PRIMARY KEY CLUSTERED

(

[registerID] ASC

)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]

) ON [PRIMARY]

Create Linq to SQL Classes

Right click in SilverlightDB.Web (see above figure)

-> Add -> New Item -> Linq to SQL classes ->

By Default Linq to SQL Classes (DataClasses1.dbml) change its name into Silverlight.dbml

-> Add -> Then it opens dbml Editor click ServerExplorer ->

Then it display Silverlight (database name in list of Databases)

Choose Silverlight

-> Right click choose Modify Connections (Modify ConnectionString by choosing ServerName : your server name

UserName : your username

Password : your password

Select Database: Silverlight

Then Expand Silvelright database to view tables in Server Explorer (View ->ServerExplorer)

Drag Registration table into Silverlight.dbml Editor then see Solution Explorer it creates Silverlight.dbml with two files

Silverlight.dbml.layout file

Silverlight.designer.cs file

Create WCF Service in Silverlight Project

Right click in SilverlightDB.Web (see above figure)

-> Add -> New Item -> choose Silverlight from Categories -> right side choose

Service-enabled WCF Service

Change Name: Service1.svc into Register.svc then click Add Button it generates below code

Register.svc.cs

using System.ServiceModel;

using System.ServiceModel.Activation;

using System.Collections.Generic;

using System.Text;

namespace SilverlightDB.Web

{

[ServiceContract(Namespace = "")]

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

public class Register

{

[OperationContract]

public void DoWork()

{

// Add your operation implementation here

return;

}

// Add more operations here and mark them with [OperationContract]

}

}

For inserting data using WCF and Silverlight

namespace SilverlightDB.Web

{

[ServiceContract(Namespace = "")]

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

public class Register

{

[OperationContract]

public void DoWork()

{

// Add your operation implementation here

return;

}

// Add more operations here and mark them with [OperationContract]

[OperationContract]

public void InsertData(string firstname,string emailid,string phoneno,string loginuser,

string password)

{

//SilverlightDataContext is Dbml file Silverlight.dbml //(SilverlightDataContext)

SilverlightDataContext db = new SilverlightDataContext();

//From Silverlight.dbml.cs file Registeration(sqlserver name table name row

//  [Table(Name="dbo.Registration")]

//public partial class Registration : INotifyPropertyChanging, INotifyPropertyChanged

//{

//    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);

//    private int _registerID;

//    private string _FirstName;

//    private string _EmailID;

//Registration from Silverlight.dbml table name

Registration row = new Registration()

{

FirstName = firstname,

EmailID = emailid,

PhoneNo = phoneno,

LoginName = loginuser,

Password = password

};

// Add the new object to the collection.

db.Registrations.InsertOnSubmit(row);

// Submit the change to the database.

db.SubmitChanges();

}

}

}

Add Web Service Reference to Silverlight Application (Pages like Page.xaml…)

Goto SilverlightDB in Solution Explorer -> choose Referenes -> click Add Service Reference

Then the below DailogBox Opens

Click Discover -> It display all WCF services which Created in Project we created only one WCF service i.e. Register.svc it displays all operations included in Register.svc

First it display Register.svc with expand and Collapse + symbol click (+) symbol . Now it displays Register webservice with expand and collapse click (+) symbol

Now it displays Register in Services and right side it displays Operations.

Operations

• DO Work
• Insert Data

Click Ok then it creates Service Reference all Silverlight Pages (page.xaml…)

It creates ServiceReference to Silverlight Application see below figure.

Insert Data into SqlServer using Silverlight Xaml file

Now goto Page.xaml (Registration form)

click in Submit Button right click

Click Navigate to Event Handler

<Button Grid.Row=”6″ Grid.Column=”1″ Width=”100″ Height=”25″ HorizontalAlignment=”Left” Content=”Register” Click=”SubmitRegister_Click” ></Button>

using SilverlightDB.ServiceReference1;

private void SubmitRegister_Click(object sender, RoutedEventArgs e)

{

RegisterClient webservice = new RegisterClient();

webservice.InsertDataAsync(txtFirstName.Text, txtEmailID.Text, txtPhoneno.Text, txtLoginName.Text, txtPassword.Text);

}

Explaination:

RegisterClient webservice=new RegisterClient()

Register is WCF service name

Client is ByDefault is Client Service

So Register+Client = RegisterClient

InsertDataAsync

InsertData = WCF service (Register.svc) Operation (Function) is assigned to insert data into database.

Async = ServiceReference to InsertData

So InsertData+Async = InsertDataAsync

Hit F5 to run the application

In one of my previous posts (Adding Registry Listener in PEtALS), I spoke about adding a registry listener in PEtALS ESB. In the current article, I want to introduce how I used this feature to implement a live monitoring Web application.

Here are the different modules which are used in this Live Monitoring Tool :

1. PEtALS ESB. The standard behaviour has been customized by adding a registry listener and a routing module (to be detailled below).
2. Monitoring layer. This layer is an independant process which embeds a WS-Notification engine.
3. A WS-notification subscriber. This is the module which will receive the notifications from the monitoring layer.
4. GWT based Web application used to display monitoring data.

PEtALS ESB Extensions

Registry Listener
The role of the registry listener is to register a new monitoring endpoint into the monitoring layer when a new endpoint is available within PEtALS.

Routing Module
Since modules can be added dynamically inside the PEtALS message router, we have created a module which timestamp the messages. Once the message exchange is complete, a message exchange report is sent to the monitoring layer.

Monitoring Layer

The monitoring is in charge of creating monitoring endpoints through a management API. Once a monitoring endpoint is created, it is also exposed as a Web service. This newly created Web service exposes a WS-notification subscribe operation.
Another role of the monitoring layer is to receive raw reports from the PEtALS ESB, to process the report in order to generate a WSDM payload which will be send to subscribers.

WS-Notification subscriber

The subscriber subscribes, receives and stores notifications from the Monitoring layer. That’s all for that module ;o)

GWT Based Web application

The GWT Web application uses comet in order to display live service response time. The data used to display response time is the one received and stored into the database and of course the server part of the Web application have access to this database.

As a result, we have a really nice live Web application (live means that the chart gives real time result and is updated automatically when messages are exchanged within PEtALS Service Bus). Here are some screenshots :

Live Response Time

SLA Violation

Need utils for fast testing of WCF or webservices?

SoapUI is a great tool for testing webservices (http://www.soapui.org/).

The built in WcfTestClient for VS Studio is another which works for both webservices as well as WCF services! It could be found under C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\WcfTestClient.exe in VS Studio 2008.

VPFW es un servidor proxy de Webservices XML/SOAP con las siguientes características:
- Validación de documentos XML / SOAP
- Tratamiento de peticiones SSL
- Compresión, Cache y balanceo de carga

.. mas info en http://www.ventusproxy.com/

Teman-teman, sekarang contoh project-nya uda bisa di download di sini

Projectnya agak beda sedikit dengan modifikasi tampilan saja,,,untuk kodingnya masih sama….

Untuk menjalankan project tersebut, gunakan GlassFish versi 2 dan untuk backup database-nya dapat di download di sini

Penjelasan bagaimana menambahkan fungsi sudah ada dalam MATERI WEB SERVICE LANJUTAN.pdf yang dapat di download di sini

Selamat mencoba! Semangat..

ingat besok senin TTS Web Service

GBU.  ^.^V

One problem I encountered in a project is to call several services (Webservice/SQL etc) via BizTalk before delivering a result back to a web application. By calling the services synchronously and letting the user wait meanwhile is not a good solution, however calling the services asynchronously seems like a better choice.

By using AJAX and exposing the services as webservices from BizTalk a great solution could be made. I made a test webservice with the following code:

namespace WebApplication1
{
    /// <summary>
    /// Summary description for WebService1
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")] //
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
    [System.Web.Script.Services.ScriptService]
    public class WebService1 : System.Web.Services.WebService
    {

        [WebMethod]
        public string HelloWorld()
        {
            return “Hello World”;
        }

        [WebMethod]
        public string HelloWorld2()
        {
            System.Threading.Thread.Sleep(5000);
            return “Hello World2″;
        }
    }
}

Note the 5 seconds sleep in the HelloWord2 method. Then I created and AJAX enabled web page, with the following code:

<%@ Page Language=”C#” AutoEventWireup=”true” CodeBehind=”Default.aspx.cs” Inherits=”WebApplication1.Default1″ %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd“>
<html xmlns=”http://www.w3.org/1999/xhtml“>
<head runat=”server”>
    <title></title>

    <script type=”text/javascript”>

        function pageLoad() {
        }

        function MyBtn_onclick() {
            ret1 = WebApplication1.WebService1.HelloWorld2(OnComplete1, OnTimeout, OnError);
            ret2 = WebApplication1.WebService1.HelloWorld(OnComplete2, OnTimeout, OnError);
        }

        function OnTimeout() {
            alert(“Timeout on webservice call”);
        }

        function OnError() {
            alert(“Error in webservice call”);
        }

        function OnComplete1(arg) {
            document.getElementById(‘MySpan2′).innerHTML = arg;
        }

        function OnComplete2(arg) {
            document.getElementById(‘MySpan1′).innerHTML = arg;
        }
    </script>

</head>
<body>
    <form id=”form1″ runat=”server”>
    <div>
        <asp:ScriptManager ID=”ScriptManager1″ runat=”server”>
           <!– Add a reference to the webservice, to be able to call it from javascript code above –>
            <Services>
                <asp:ServiceReference Path=”~/WebService1.asmx” />
            </Services>
        </asp:ScriptManager>
        <input id=”MyBtn” onclick=”return MyBtn_onclick()” type=”button” value=”Invoke” />
        <br /><br />
        <span id=”MySpan1″></span>
        <br />
        <span id=”MySpan2″></span>
    </div>
    </form>
</body>
</html>

When a user clicks on the Invoke button, the code invokes the both methods asynchronously. This means that the HelloWorld method returns its value before the HelloWorld2, even thought the HelloWorld2 is called before HelloWorld.

I just added a new feature to PEtALS ESB kernel in order to expose Fractal Components as Webservices in the PEtALS ESB kernel. As an example, let’s expose some PEtALS runtime information as Web service.

Here are the steps to follow :

1. Create your component interface and add JAXWS annotations

package org.ow2.petals.kernel.ws.api;

import java.util.Date;

import javax.jws.WebMethod;
import javax.jws.WebResult;
import javax.jws.WebService;

@WebService
public interface InformationService {

    /**
     * Get the container version
     *
     * @return
     * @throws PEtALSWebServiceException
     */
    @WebMethod()
    @WebResult(name = "version")
    String getVersion() throws PEtALSWebServiceException;

    /**
     * Get the container type : standalone, platform, quickstart...
     *
     * @return
     * @throws PEtALSWebServiceException
     */
    @WebMethod()
    @WebResult(name = "type")
    String getType() throws PEtALSWebServiceException;

    @WebMethod
    Date getLocalTime() throws PEtALSWebServiceException;

}

2. Implement your Fractal component

package org.ow2.petals.ws;

import java.util.Date;

import org.objectweb.fractal.api.Component;
import org.objectweb.fractal.fraclet.annotation.annotations.FractalComponent;
import org.objectweb.fractal.fraclet.annotation.annotations.Interface;
import org.objectweb.fractal.fraclet.annotation.annotations.LifeCycle;
import org.objectweb.fractal.fraclet.annotation.annotations.Monolog;
import org.objectweb.fractal.fraclet.annotation.annotations.Provides;
import org.objectweb.fractal.fraclet.annotation.annotations.Requires;
import org.objectweb.fractal.fraclet.annotation.annotations.type.LifeCycleType;
import org.objectweb.util.monolog.api.Logger;
import org.ow2.petals.jbi.management.admin.AdminService;
import org.ow2.petals.kernel.ws.api.InformationService;
import org.ow2.petals.kernel.ws.api.PEtALSWebServiceException;
import org.ow2.petals.tools.ws.KernelWebService;
import org.ow2.petals.util.LoggingUtil;

@FractalComponent
@Provides(interfaces = { @Interface(name = "webservice", signature = InformationService.class),
        @Interface(name = "service", signature = KernelWebService.class) })
public class InformationServiceImpl implements KernelWebService, InformationService {

    @Monolog(name = "logger")
    private Logger logger;

    private LoggingUtil log;

    @org.objectweb.fractal.fraclet.annotation.annotations.Service(name = "component")
    private Component component;

    @Requires(name = "adminService", signature = AdminService.class)
    private AdminService adminService;

    @LifeCycle(on = LifeCycleType.START)
    protected void start() {
        this.log = new LoggingUtil(this.logger);
        this.log.debug("Starting...");
    }

    @LifeCycle(on = LifeCycleType.STOP)
    protected void stop() {
        this.log.debug("Stopping...");
    }

    /**
     * {@inheritDoc}
     */
    public Component getComponent() {
        return this.component;
    }

    /**
     * {@inheritDoc}
     */
    public String getType() throws PEtALSWebServiceException {
        return "Platform";
    }

    /**
     * {@inheritDoc}
     */
    public String getVersion() throws PEtALSWebServiceException {
        return this.adminService.getSystemInfo();
    }

    /**
     * {@inheritDoc}
     */
    public Date getLocalTime() throws PEtALSWebServiceException {
        return new Date();
    }

}

In the implementation, the important points are :

1. The @Provides part. The KernelWebService.class interface MUST be named “service”. The ‘business’ interface to be exposed (here InformationService.class MUST be named “webservice”)
2. The Component field is mandatory (used by the webservice manager). Its accessor is mandatory too!
3. The implementation MUST implement KernelWebService and the interface you want to expose

The implementation will not be exposed as Web service if the previous points are not followed.

3. Add the component to the WebServiceManager component with the help of Fractal descriptors

For now, the Fractal composite used to expose Fractal components as Web services is defined in the Tools.fractal descriptor (located under your favorite petals distribution). Here are the important steps :

A. Instanciate the component
<component definition=”org.ow2.petals.ws.InformationServiceImpl” name=”InformationWebServiceImpl”/>

We were trying to use the google app engine for communicating with Weather web-service. there are some special problems; when I run the jar file in the web app engine container. I’m running into sever CLASSPATH issues. It is taking forever to resolve this. For the sake of continuing the blog let us throw the errors running into. Again here are the configuration files

Struts-config.xml

struts-config

Struts Forms

Struts-Action

The locationinput.do is a JSP file. YUI is being used for developing some drop downs and auto complete. We will keep the YUI discussion for another day. But on a high level weatherstation.jsp

WeatherStation.jsp

Upon submission of this page; the action class is invoked. Following screen print. Though I have not completed this action fully, it gives an overall idea.

WeatherStationInvokeAction

Delegate

The reason for using the JEE’s delegate pattern up here is; we are using the business objects that returns data/throws exception directly; isolation from action classes will give a cleaner separation.

Moving on, when running this application the error is

Error

Looking from the error; looks like it is a perfect storm of classpath issues. Have the JAXB working for parsing XML. Google app engine has a XML parser and on top of that; we are using JAX WS for webservices. All the culmination; yet to find a solution to resolve this and present a full sketch of an application. One quick update today is Ported everything to a JBOSS app server to see if that helps
Bummer, JBOSS does a proxy delegate that is again posing some CLASSPATH issues.
If there are any solutions to resolve this; please do put in your comments.

Is there a need for a android lib to handle webservice-calls?
(polls)

Here is a draft version of the interface of the Connector to the webservice:

public interface WebServiceConnectorI {

public String callMethod(String method, ArrayList params);
}


And here the class for the method-parameters:

public class MethodParameter {

}


I am finally back from the SOA4All project review @ Brussels where I showed a Distributed Service Bus based on PEtALS ESB deployed over the internet.

The first prototype of the SOA4All Distributed Service Bus has been deployed on 4 nodes (three in France at Toulouse, Antibes, Paris and one in Austria at Innsbruck). Each node was providing SOAP access to all the platform services bound to the bus (most of them were SOAP based Web services). It is good to note that response time was quite good between service consumers and providers (some optimizations to be performed to avoid remote checking before sending messages).

Note 1 : It is true that to allow the nodes communication, we opened all the required ports (actually 4 for SOAP/HTTP, JMX and raw TCP communication) but next step will be probably to just use the default HTTP port and this is a real challenge…

Note 2 : The new distributed technical registry (self developed) used to store service endpoints was used in the prototype. Good job

Após a solenidade dos 118 anos de instalação do Tribunal de Justiça, os desembargadores presentes assistiram, reunidos com uma comitiva nacional da Empresa de Correios e Telégrafos (ECT), uma breve apresentação realizada pelo juiz João Alexandre Dobrowolski Neto, da CGInfo, e do servidor da Comarca de Lebon Régis, Márcio Vicente Cruz sobre A.R. Digital.

A comitiva veio ao Estado para conhecer o projeto intitulado V-Post – responsável pela expedição de avisos de recebimentos digitais – e seu impacto no chamado processo eletrônico. A visita tem como objetivo conhecer detalhes de funcionamento do projeto, pioneiro no Brasil, e identificar a possibilidade de estendê-lo aos demais tribunais do país. O programa V-Post – Postagens Virtuais, parceria firmada entre ECT, Softplan e Poder Judiciário, visa agilizar, através da informatização, a expedição de documentos judiciais.

O A.R. Digital Autoenvelopável é fruto de um WebService entre o Judiciário catarinense e os Correios. Através de um protocolo de integração, as duas instituições trocam dados pela WEB. Em outras palavras, os respectivos sistemas conversam entre si. Graças a este produto somente este ano já foram expedidos, enviados eletronicamente aos correios, e por este impressos e envelopados mecanicamente, e diligenciados pelos carteiros, mais de 20 mil ofícios de citação na Unidade de Execução Fiscal da Capital.

O resultado dos esforços da ECT são cadastrados em sistema próprio e repassados ao Sistema de Automação do Judiciário (SAJ) através do WebService – inclusive com imagem digitalizada do A.R. que logrou sucesso. Todo este trabalho, que num processo comum consumiria exaustivos esforços de todo o Cartório, é realizado por apenas um servidor do Judiciário – e como atribuição residual, e não principal.

Em janeiro deste ano, o Judiciário catarinense e a Empresa Brasileira de Correios e Telégrafos (ECT/SC) assinaram um contrato que possibilitou o funcionamento do A.R. Digital Autoenvelopável. Já em junho, um termo assinado entre o Supremo Tribunal Federal, Conselho Nacional de Justiça, Superior Tribunal de Justiça, Conselho da Justiça Federal, Tribunal Superior do Trabalho, Conselho Superior da Justiça do Trabalho e a Advocacia-Geral da União, pede a elaboração e implementação do padrão nacional de integração de sistemas de processo eletrônico, por meio da tecnologia “WebService”.

Tribunal de Justiça de Santa Catarina »

Introduction

In the last post I had a short description on webservice security. In this post, we build a secure webservice and create a client to access it. For doing so, the same environment as in the Simple Webservice example is used. We will use Metro’s WSIT features to enable secrity for our webservice.

Creating the webservice

The steps for creating and deploying an unsecured webservice are described in this post. Follow these steps till Step 6 (we do not deploy the webservice yet). Now we need to make the webservice secure.

Generate Key Pair

In order to perform encryption and signature, the webservice and the client need a public-private key pair. The public key is wrapped inside a X509 certificate. In this example we do not use mutual certificates. The private key (or identity key) is with the webservice only. The public key (X509 certificate) is distributed to clients. What is encrypted using the public certificate, can only be decrypted using the private key and vice-versa. In this example, the private key is part of a KeyStore configured on the webservice, and the public certificate is part of a TrustStore configured on the client side.

To create a key-pair for use with this example, create a directory to keep the KeyStore and TrustStore in (call it <KEY_DIR>). Browse to this dir on command prompt and run
keytool -genkey -alias serviceKey -keypass mykeypass -keystore wsKeyStore.jks -storepass changeit -keyalg RSA -dname "CN=Tech Tips, OU=Blog, O=The Tech tips, L=DFW, ST=TX, C=US"

This creates the keystore with the private key in it. Now export the public certificate:
keytool -export -alias serviceKey -keypass mykeypass -keystore wsKeyStore.jks -storepass changeit -file publicCert.cer

and import the public certificate into a truststore:
keytool -import -alias publicCert -keystore wsTrustStore.jks -storepass changeit -file publicCert.cer

Specify Security Requirements

In order to convey their security constraints to clients, webservices can include their security specifications as part of the WSDL. This is done by making use of WS-Security Policy (WSSP) assertions. The clients who have access to the WSDL therefore know the security contract for accessing the webservice.

Instead of creating a custom way of specifying security requirements when creating a webservice, WSIT (part of metro stack) makes use of the already developed way (using WSSP assertions). In order to enable security for our webservice, all we need is a static WSDL-like definitions file which contains the desire WSSP assertions assigned to our endpoint. This file needs to have a special name ‘wsit-<fully qualified implementation class name>.xml‘.

In MetroWebserviceSample eclipse project’s WEB-INF directory, create a file named ‘wsit-test.metro.sample.TestService.xml‘. The contents of this file should be as follows:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.2-hudson-182-RC1. -->
<definitions targetNamespace="http://sample.metro.test/"
 xmlns:tns="http://sample.metro.test/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
 xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy">
 
   <wsp:Policy wsu:Id="TestService_Security_Policy">
  <wsp:ExactlyOne>
   <wsp:All>   
    <sp:SymmetricBinding >
     <wsp:Policy>
      <sp:ProtectionToken>
       <wsp:Policy>
        <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
         <wsp:Policy>
          <sp:WssX509V3Token10/>
          <sp:RequireDerivedKeys/>
          <sp:RequireIssuerSerialReference/>
         </wsp:Policy>
        </sp:X509Token>
       </wsp:Policy>
      </sp:ProtectionToken>
      
      <sp:AlgorithmSuite>      
       <wsp:Policy>
        <sp:Basic128/>
       </wsp:Policy>       
      </sp:AlgorithmSuite>
      
      <sp:Layout>      
       <wsp:Policy>
        <sp:Strict/>
       </wsp:Policy>       
      </sp:Layout> 
      <sp:IncludeTimestamp/>  
      <sp:EncryptBeforeSigning/>   
     </wsp:Policy>
    </sp:SymmetricBinding>
    <sp:Wss11>
            <wsp:Policy>
              <sp:MustSupportRefIssuerSerial/>
            </wsp:Policy>
          </sp:Wss11>
             <sc:KeyStore wspp:visibility="private"
              xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy"
              xmlns:sc="http://schemas.sun.com/2006/03/wss/server"
              location="<KEY_DIR>\wsKeyStore.jks"
              type="JKS" keypass="mykeypass"
              alias="serviceKey"
              storepass="changeit">
             </sc:KeyStore>
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 
 <wsp:Policy wsu:Id="TestService_Encryption_policy">
  <wsp:ExactlyOne>
   <wsp:All>    
    <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
     <sp:Body />
    </sp:EncryptedParts>      
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 <wsp:Policy wsu:Id="TestService_Signature_policy">
  <wsp:ExactlyOne>
   <wsp:All>
    <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
     <sp:Body />
    </sp:SignedParts>
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 
 
<portType name="TestService">
  </portType>
 
  <binding name="TestServicePortBinding" type="tns:TestService">
   <wsp:PolicyReference URI="#TestService_Security_Policy"></wsp:PolicyReference>
   <wsp:PolicyReference URI="#TestService_Encryption_policy"></wsp:PolicyReference>
   <wsp:PolicyReference URI="#TestService_Signature_policy"></wsp:PolicyReference>
  </binding>
 
  <service name="TestServiceService">
     <!-- Uncomment this section if above configured security is to be enabled -->
     <!-- -->
  
<port name="TestServicePort" binding="tns:TestServicePortBinding">
   </port>
  </service>
</definitions>

The above file has the minimum content required for this configuration (in other situations we can have the complete WSDL, plus the policy declarations and references). It enforces encryption of the SOAP body element followed by signing the encrypted body (EncryptBeforeSigning) for all messages (requests and responses). For the purpose of encryption and signing derived keys based on an X509 token are used. The location of the token is specified using Metro specific element.

Deploy the Webservice

Note that the element describing the location of X509 token (keystore etc) is not visible in the online WSDL.

Create the Client

In order to create a POJO client which does not run inside a container, the Metro libraries will be needed. As indicated in this post, download Metro and put the expand the contents (call this directory <METRO_HOME>).  For convinience the directory <METRO_HOME>/bin can be added to the environment variable Path, so that the tools wsgen and wsimport can be used without qualified location. For JDK 6 onwards, these tools are part of the jdk.

Create a directory for the client code <CLIENT_HOME>. This can as well be an eclipse Java project. However, the instructions here are for running the client without using eclipse.

While the webservice is running on Tomcat, on the command prompt run:
wsimport -d <CLIENT_HOME> -s <CLIENT_HOME> -p test.metro.sample.client http://localhost:8080/MetroWebserviceSample/test?wsdl
This will create the classes needed by the client, under the package structure test.metro.sample.client. Note that the classes are already compiled, so we will not recompile them.

In the directory <CLIENT_HOME>/test/metro, create a directory named client. Create a file TestServiceClient.java in this directory (so the package for this class is test.metro.client). The contents of TestServiceClient.java should be:

package test.metro.client;

import test.metro.sample.client.TestService;
import test.metro.sample.client.TestServiceService;

public class TestServiceClient {

 private String defaultGreeter = "TheTechTips";
 /**
  * @param args
  */
 public static void main(String[] args) {
  
  TestServiceClient client = new TestServiceClient();
  TestService service = new TestServiceService().getPort(TestService.class);
  System.out.println("Greeatings are...");
  if (args.length == 0) {
   System.out.println(service.greet(client.defaultGreeter));
  } else {
   for (String greeter : args) {
    System.out.println(service.greet(greeter));
   }
  }
 }

}

To compile the above class, browse to <CLIENT_HOME> directory on command prompt (for convinience) and run:
javac -cp %CLASSPATH%;.;<METRO_HOME>/lib/webservices-api.jar test/metro/client/TestServiceClient.java

Client Security Configuration

Similar to the wsdl-like file we created for securing the webservice, we need to specify where the client can find the security certificate to send proper requests to the service. The client config file should be named <service>Service.xml and placed in the META-INF directory. In addition, another xml file called wsit-client.xml is to be pesent in META-INF. The latter file imports the former.

Create a META-INF directory under <CLIENT_HOME>. Put files TestServiceService.xml and wsit-client.xml in the META-INF directory with following contents.

TestServiceService.xml

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.2-hudson-182-RC1. -->
<definitions targetNamespace="http://sample.metro.test/"
 xmlns:tns="http://sample.metro.test/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
 xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy">
 
 <wsp:Policy xmlns:sc="http://schemas.sun.com/2006/03/wss/client"
  xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy"
  wsu:Id="TestService_Security_Client_Policy">
  <wsp:ExactlyOne>
   <wsp:All>
      <sc:TrustStore wspp:visibility="private" location=
        "<KEY_DIR>\wsTrustStore.jks"
        storepass="changeit"
        peeralias="publicCert"/>

   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>

 
<portType name="TestService">
  </portType>
 
  <binding name="TestServicePortBinding" type="tns:TestService">
   <wsp:PolicyReference URI="#TestService_Security_Client_Policy"></wsp:PolicyReference>
  </binding>
 
  <service name="TestServiceService">
     <!-- Uncomment this section if above configured security is to be enabled -->
     <!-- -->
  
<port name="TestServicePort" binding="tns:TestServicePortBinding">
   </port>
  </service>
</definitions>

wsit-client.xml

<?xml version="1.0" encoding="UTF-8"?>
 <definitions
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
name="mainclientconfig">
    <import location="TestServiceService.xml" namespace="http://sample.metro.test/"/>
</definitions>

Run client

To run the client, execute (while command prompt is in <CLIENT_HOME> directory)
java -cp %CLASSPATH%;.;<METRO_HOME>/lib/webservices-api.jar;<METRO_HOME>/lib/webservices-rt.jar test.metro.client.TestServiceClient

The output will be something like
Oct 2, 2009 11:14:43 AM [com.sun.xml.ws.policy.jaxws.PolicyConfigParser] parseModel
INFO: WSP1049: Loaded WSIT configuration from file: file:<CLIENT_HOME>/META-INF/wsit-client.xml
Greeatings are...
Hello TheTechTips!

It’s long since I last wrote about technology use.

I am not a geek on myself but would like to share about my little idea to retreat currency rate from different country via web service using PHP and plug to javascript compiling with the helping hand of mighty j-Query.

Pre-requisites:
1.) I assumed you mater PHP, I assume you master below all.
2.) I have some syntax error and my code are unstructured, if you’re curiosity could kill a cat, try explore more yourself, ya; I learned that well and until today too.

What you need doing above:
1.) Internet connection of course.
2.) Apache, php with nusoap.dll enabled if I not mistaken the dll name .
3.) javascript jQuery copy no matter what version.
4.) Price list covered by div / span or any wrapper.
5.) a url http://www.webservicex.net/CurrencyConvertor.asmx?wsdl

Steps:
1.) Do your PHP nusoap to post variable to the 5.) url. Or you can just copy my code below:

#name this code get-currency.php
#for a list of currency code refer to this url: http://www.webservicex.net/WCF/ServiceDetails.aspx?SID=18
#thanks to W.Lai for this code contributions
$from = ‘MYR’;$to = ‘USD’;$sUrl = ‘http://www.webservicex.net/CurrencyConvertor.asmx?WSDL’;$client = new SoapClient($sUrl, array(‘trace’ => 1));$a = $client->ConversionRate(array(“FromCurrency” => $from, “ToCurrency” => $to));$johnny = $a->ConversionRateResult;print $johnny;

2.) for example now you can retreat this USD currency rate,  you can write a sample html to retreat like below:
/*partial of your html code like below*/
<div id=”Price1″ rel=”230.00″>230.00</div><div id=”Price3″ rel=”4500.00″>4500.00</div><select id=”currencyBox”><option value=”">Select your currency</option><option value=”USD”/>US Dollar<option value=”CNY”/>Chinese Yuen</select></html>

3.) in your javascript of course you first call jQuery  file, then you configure jQuery  regular expression selector to convert their currency using jQuery base AJAX $.get like below:
<script type=”text/javascript”>
$(document).ready(function(){
$(‘#currencBx’).change(function(){
var val = $this.value;
$(“div[id^=Prce]“).each(function(i){$(this).html(‘<i>Loading ‘+val+’ currency rate..</i>’;});
$.get(‘get-currency.php?from=MYR&to=’+val,{}, function(data, textStatus){if(textStatus==’success’){$(“div[id^=Prce]“).each(function(i){$(this).html(parseFloat(data) * parseFloat($(this).attr(‘rel’)); });}});});});</script>

4.) Done, then when you use the select box and change the value, it will grab the currency from webservicex and compile the new exchange rate to the screen without refershing, just by this simple code.

今日、TwitterのTLを眺めていたら、Mac界の大御所？nobiさんが、日本企業の思考停止具合とともに、その企業環境と社員モチベーションの荒廃具合について言及されていました。まさにその通りですよね。しかして、その文末に、（以下、引用です）
「前略・・・日本人で活躍してるのは建築家、デザイナー、芸術家、スポーツ選手など組織属さぬマエストロが多・・・」

・・・うぐぐ。い、痛い。
建築家は確かに組織に属してないよな、一般社会的理解では。
マエストロとして？、がんばるにはそうしたそもそもの立ち位置もあるよね、と思った次第。
改めて色々考えさせられました。うんうん。

A smart guy made a very good web service that gives you all the values you need from the BNR (National Bank of Romania) , you can use it like I did.
Include e web service reference in your Visual Studio project , then you use a code like this to get all the info you need ,for your project.`
Link to your web service here
The code to get the currency is down here:
Curs c = new Curs();
double d=c.getlatestvalue(“eur”);
Console.WriteLine(d);

Have fun using it

When generating client with the CXF (2.2.2 in this case, should apply to all…) Java API without any configuration file, here is the way to set the client timeout :

package org.ow2.petals.kernel.ws.client;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.apache.cxf.transport.http.HTTPConduit;
import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
import org.ow2.petals.kernel.ws.api.RuntimeService;

public class Main {

    private void createService() {
        long timeout = 10000L;
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        factory.setServiceClass(RuntimeService.class);
        factory.setAddress("http://localhost:9999/service/Runtime");
        RuntimeService runtimeService = (RuntimeService) factory.create();

        Client client = ClientProxy.getClient(runtimeService);
        if (client != null) {
            HTTPConduit conduit = (HTTPConduit) client.getConduit();
            HTTPClientPolicy policy = new HTTPClientPolicy();
            policy.setConnectionTimeout(timeout);
            policy.setReceiveTimeout(timeout);
            conduit.setClient(policy);
        }
    }
}

Note that here the RuntimeService class is my JAXWS annotated class.

When considering securing web-service invocations, there are many levels of security that cane be applied. The outermost levels can be viwed as

1. Protocol level security: The security mechanisms used for regular request/response for the particular protocol. For example, Basic Authentication and SSL certificates for HTTP. These mechanisms only ensure that the messages are secured till they reach the protocol (say HTTP) destination. After that, when the actual SOAP message is un secured till it reaches the actual Web service endpoint.
2. SOAP message security: In this case the messages are to be secured all the way to the endpoint beyond the protocol level. This is specified by the WS-Security specifications.

WS-Security Specification

The WS-Security specification 1.0 was released in 2002. The next version 1.1 was released in 2006. It specifies how to enhance SOAP messages to secure the information exchange.

From the WS-Security specification (http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wss#overview):

“WS-Security describes enhancements to SOAP messaging to provide quality of protection through message integrity, message confidentiality, and single message authentication. These mechanisms can be used to accommodate a wide variety of security models and encryption technologies.”

The WS-Security spec provides SOAP extensions that can be used when building secure web-services. There are three main aspects of security:

1. Message AuthenticationWS-Security provides a way of associating security tokens with SOAP messages. These tokens (like Basic Authentication or SSL certificates for HTTP) can be used to identify the sender of the message. The specification does not require use of any particular token. Two commonly used tokens are Username tokens and X509 tokens. Other tokens like Kerberos tokens can also be used. These tokens can be included directly in the SOAP message header, or an indirect reference to the token can be sent using digital signature or encryption.
2. Message Integrity Message integrity ensures that the message was not tampered with on its way from the sender to the receiver. WS-Security provides a way to include XML digital signatures in the SOAP message header to help verify integrity. Exactly what parts of the message are signed or what digest/algorithms are used is left to be decided by the web-service provider.
3. Message ConfidentialityMessage confidentiality means that on the wire, the message should not be readable. WS-Security specifies how the full message or parts of the message can be encrypted and sent so that they are unreadable to attackers. This will use XML encryption and the encryption related information is exchanged in the SOAP header. Either the whole message can be encrypted (like HTTPS transport encryption), or parts of the message are encrypted. Again, the encryption algorithms to be used, the way of exchanging keys (or tokens) is to be decided by the web-service provider. 

In the next post, I am going to create a secure web services using JAXWS implementation Metro and create client for the service. Explaining the various types of security in more detail.