Chad Gallemore

Must Read Book: Rework

2010-03-22T23:18:00.002-05:00

I just finished reading Rework, by the guys from 37signals. This was an absolute joy to read and really inspiring. I won't go into a lot of detail, since the book is a really quick read, and I don't want to give a ton of stuff away. I will say this. If you're like me, and come from and Agile background, I think you will really enjoy the book. It's also inspired me to get of my ass and do some of the things I've been putting off, like writing on this blog. Do yourself a favor and pick this book up and give it a read.

Also, if you don't follow the 37signals blog, I would highly recommend that as well. There is a lot of good stuff that comes across there. I sound like I'm pimping this guys, I'm really not, it's just great reading.

It's Been A While

2010-03-22T22:34:00.003-05:00

Well, it's been over a year since I've written anything on this blog, so I figured I would put a few tidbits out there and hopefully it will lead to some posts of substance in the future.

First off, I've switched gears and have been working for Localbase Inc. for the last 9 months building a small business platform for the social web. We're pretty excited about the project and we are looking to launch in about 3-6 months. Until then, here's some stuff I've been doing over that time.

If you've read my posts before, you'll know that I was heavy into Java, and really into Groovy. I'm still a fan of Groovy, but since joining Localbase I've had the absolute pleasure of working with Python and Django. Our platform is being built on the Django framework, and I absolutely love it. I'm also really liking Python, although I do like Groovy's syntax a little better.
I'm beginning to love Javascript. For those of you that now me you're probably shocked right now. Nine months ago, I absolutely hated Javascript and would often volunteer to write tests or do documentation just so I didn't have to mess with it. Now, I find myself volunteering to do the client side work for our platform. Part of this is due to Dojo. The documentation isn't stellar, but I still love it anyways. The other part is this sweet little Javascript framework that we (I say we, but it was really Rob) created for Localbase. It makes my life very easy. Hopefully we can find some time in the future and contribute it back to the community.
I still love REST. During my time in the Java world, I worked with Jersey a lot, and absolutely loved it. I can't say that I've found the equivalent in the Python/Django world, but we have found won that works great and I really like it a lot. If you're in need of one for your Django project, check out Piston. Decent documentation, and really easy to use. Testing your REST services is super easy as well.
We switched from using Subversion to using Mercurial about 8 months ago. So much faster than Subversion. If you're thinking about switching to a distributed version control system, I would highly recommend it. We are using Bitbucket, and it's worked out great for us.
Yes, my Hawks lost to UNI in the second round. No, I haven't jumped of a cliff yet.

That's pretty much it in a nutshell. Hopefully this will inspire me to get off my ass and write some blog posts. I'm going to follow this up right now with a new post about a great book I just finished reading. It's definitely a two for one night.

Happy Birthday Marines

2008-11-10T08:47:00.002-06:00

233 years and counting......

Creating RESTful services with Jersey and Groovy

2008-10-23T22:24:00.005-05:00

It's been a while since I have put anything of substance on here, so I thought I would get back to it. I've been doing a lot of development with Groovy as of late, which I absolutely love. I wanted to combine that with another API that I really like, Jersey. Jersey is the open source JAX-RS (JSR 311) Reference Implementation for building RESTful Web services. So, for a simple service to create I decided on an Announcements service. This service when invoked would look for a file located in the User Home directory and create some HTML to return that would get rendered in the browser. This example also shows why I might want to use Groovy and Jersey together, as I will leverage Groovy's MarkupBuilder to generate the HTML that gets returned. I won't get into the details of how to setup Jersey as they have lots of samples that you can find here, and instead I'll just jump right in to what the source code would look like for my announcement service.


import javax.ws.rs.Path;
import javax.ws.rs.GET;
import javax.ws.rs.Produces

@Path("/announcements")
class AnnouncementService {
 def announcements = "announcements.txt"
 def errorReadingFileText = " - Error reading Announcements, Announcement File may not exist."
 def noAnnouncementsText = " - No Announcements for Today"

 @GET
 @Produces (value=["text/html"])
 String getHtmlResponse() {
     // Return some cliched textual content
     return getAnnouncements()
 }

 String getAnnouncements() {
     def announcement = new File(System.getProperty("user.home") + File.separator + announcements)
     def writer = new StringWriter()
     def result = new groovy.xml.MarkupBuilder(writer);
     result.html {
         body {
             h1(align: "center", "As of ${date()}")
             table(width: "100%", height: "100%") {
                 td {
                     if (!announcement.exists()) {
                         tr(errorReadingFileText)
                     } else if (announcement.text.length() <= 0) {                                    
                         tr(noAnnouncementsText)
                     } else {                                                                                                                                        
                         announcement?.eachLine {                                                                      
                             tr(" - $it")                                                           
                         }                                               
                     }                                       
                 }                                              
             }                       
         }               
     }               
     return writer.toString()        
  } 
}

As you can see from the code above that we annotate our class with the @Path annotation. This basically defines your jersey resource. So if you wanted to invoke this resource you URL would be something like http://localhost:8080/sample/announcements where sample is the name of your war you deployed to your application server. In the code you can also see that our method getHtmlResponse() has been annotated with @GET which tells Jersey to call this method when the HTTP Request is a GET Request. So given the same URL noted above, you could type that into a browser and hit enter and it will invoke the announcement resource with a GET request and invoke our method. One other thing to note is the @Produces annotation. This annotation defines the mime type to return your result. In our case we want the result to render as html so we set the type to text/html. This annotation is one that I had to do a little diffrent with Groovy. In Java the annotation would look like @Produces("text/html"), whereas in Groovy I have to specifically call out the value property and enclose the value in brackets like this, @Produces (value=["text/html"]). If I didn't enclose the property in the proper way I got this error when compiling:

Annotation list attributes must use Groovy notation [el1, el2]

The good thing is my IDE (I was using Netbeans) caught this before compile time, and I refrenced this issue to figure out how to get around it.

So, as you can see from my source code that the bulk of the work is taking place in the getAnnouncements() method. This was the reason that I wanted to use Groovy, I could very easily read a file, and based on the content create some html markup that would be returned to the browser. Not much to discuss here, except that MarkupBuilder is very cool. Alright, I think that's it, Good Luck. One last thing is I used Jersey 1.0 and Groovy 1.5.6 to work this example.

Rapid Web Application Prototypes with Maven and Groovy

2008-06-26T15:44:00.002-05:00

Utilizing both Maven and Groovy you can rapidly prototype web apps, and in this blog I'll walk you through exactly how to do that. First we are going to create a simple Maven web app project using the Maven Web App Archetype. If you don't have Maven installed already, go ahead and install it. Now let's create a directory called sandbox, and cd into that directory. Now let's create our project by issuing the following command:

mvn archetype:generate

When prompted to choose a number enter 18 (The Java web application archetype) and hit enter. Next you will be prompted for the groupId, enter com.sample and hit enter, for the artifactId enter sample and hit enter, for the version enter 1.0 and hit enter, and for the package name enter com.sample and hit enter. Confirm you project by entering "Y" and hitting enter. Once finsihed you will have a maven project ready to go for deployment. You should see a sample diretory that was created in /sandbox with a pom.xml file. The pom.xml file is what we will look at next.

Next we need to add the dependency for Groovy to our pom, as well as the Maven Groovy Plugin. We do this by adding the following inside the <build> element in the parent pom:


<plugins>
<plugin>
<groupId>org.codehaus.mojo.groovy</groupId>
<artifactId>groovy-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>compile</goal>
   <goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.0</version>
</plugin>
</plugins>

Now that we have the Groovy Plugin added, lets add the Groovy dependency to the pom as well by adding it inside the <dependencies> element of the pom:


<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>1.5.6</version>
</dependency>

Ok, let's save all that and make sure we can build everything. From /sandbox/sample issue the following command:

mvn clean install

You should now have a successful build, and you could actually deploy the war that gets created (in /sandbox/sample/target you will have sample.war) to an application server such as JBoss. Ok, lets get onto the cool stuff. Groovy has a concept that lets you write normal Java servlets in Groovy, called Groovlets. Groovlets are really easy to work with and have some nice features like implicit variables (e.g. request and response which are bound to the ServletRequest and ServletResponse). So what we are going to do is configure our webapp so that it can handle Groovlets and then create our first Groovlet. We are first going to edit our web.xml which is located at /sandbox/sample/src/main/webapp/WEB-INF/, go ahead an open that up and add the following between the <web-app> elements:


<servlet>
<servlet-name>GroovyServlet</servlet-name>
<servlet-class>groovy.servlet.GroovyServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>GroovyTemplate</servlet-name>
<servlet-class>groovy.servlet.TemplateServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>GroovyServlet</servlet-name>
<url-pattern>*.groovy</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>GroovyTemplate</servlet-name>
<url-pattern>*.gsp</url-pattern>
</servlet-mapping>

This configures your webapp to compile your .groovy files to bytecode and execute your script when called. Next we need to create our Groovlet and then we are done. So, in /sandbox/sample/src/main/webapp create a file called Sample.groovy. We are going to create a simple Groovlet that accepts an HTTP GET request and has a parameter called username. We will process the request and just print out the response. So, go ahead and open up the Sample.groovy file you opened and add the following:


def username = request.getParameter("username")
println "Hello ${username}"

That's it. Rember that the request variable is implicit, meaning it's already bound to the ServletRequest and ready for use. Now we can compile our war, and deploy it to your favorite application server and you are ready to roll. Once deployed navigate to http://localhost:8080/sample/Sample.groovy?username=Chad in your web browser and you should see the print out "Hello Chad".

This is a really nice way to rapidly prototype webapps. I first started looking into this when I needed a servlet that could access the file system and return XML based off my lookup. Obiously using Groovy's nice features that have been added to the JDK for working with Files, and the MarkupBuilder, this task was trivial. Give it a spin and let me know what you think.

Deploying Jersey REST services to Weblogic

2008-06-09T10:36:00.003-05:00

I recently had some trouble deploying a REST service using Jersey to Weblogic, specifically Weblogic 9.2. This had me stumped for quite a while as I could deploy my war to JBoss and Tomcat and it worked fine. Finally with an assist from the mailing list I was able to get past the problem and get the war to deploy. As Paul noted, the problem was that the default class scanning technique is not portable across servlet implmentations, so I needed to add the following to my web.xml (after the <servlet-class> element):


<init-param>
<param-name>com.sun.jersey.config.property.resourceConfigClass</param-name>
<param-value>com.sun.jersey.api.core.PackagesResourceConfig</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>*';' separated package names*</param-value>
</init-param>

This tells Jersey to use the package scanning instead of the class path scanning. Now all you have to do is insert your package names in the last param value (replace the *';' with your package name(s) seperated by ';').

For more detail on this issue see the issue that was filed with Jersey here.

Groovy SQL - That was easy

2008-05-29T15:52:00.006-05:00

I got the chance today to get my hands dirty with GSQL (Groovy's Built in support for SQL), and I must say that it was rather easy. What I needed to do was connect to an embedded Derby database, parse a file, and populate the table with the results. Not to hard right. So, here is what my data looked like in the file I needed to parse:


2008/04/06,pubsubproxy,6166,4061
2008/04/07,pubsubproxy,6166,4061
2008/04/08,pubsubproxy,6170,4061
2008/04/09,pubsubproxy,6170,4061
2008/04/10,pubsubproxy,6170,4061
2008/04/11,pubsubproxy,6170,4061
2008/04/12,pubsubproxy,6170,4061
2008/04/13,pubsubproxy,6170,4061
2008/04/14,pubsubproxy,6170,4061

The best part about this was as I read each line in the file I added the data to the dataset for the table I was populating. The following shows a quick example of how to do this:


static parseData(path) {
println("parsing data for the following path: $path")
setDBSystemDir()
def loc = new File(path)

//Get an instance to the derby database
def sql = Sql.newInstance("jdbc:derby:dashboard;create=true", "org.apache.derby.jdbc.EmbeddedDriver")

//For Each line in the file, split the line based on the comma
loc.splitEachLine(',') {fields ->
   def pid = fields[1]
   def locResult = Double.parseDouble(fields[2])
   def tloc = Double.parseDouble(fields[3])
   def timeStamp = getDate(fields[0])

   //Get the linesofcode dataset from the database
   def ds = sql.dataSet("linesofcode")
   //Add the properties from the current line in the file to the dataset.
   ds.add(
           PID:pid,
           TIMESTAMP:timeStamp,
           LOC:locResult,
           TLOC:tloc,
   )
}
println "Done Parsing Data"
}

So as you can see the first thing I do is get a new instance to my database:

def sql = Sql.newInstance("jdbc:derby:dashboard;create=true",     "org.apache.derby.jdbc.EmbeddedDriver")

Next is the best part. I loop over each line in the file, splitting the line based of the "," and then dive right in poplulating my dataset with ds.add().

That was easy right? I thought so.

JavaOne Day Two - All about SOA

2008-05-08T01:30:00.002-05:00

As you can tell from my title I spent the bulk of my day attending sessions geared towards SOA. I have to say that the day started out fantastic when I attended the Integration Profile for Glassfish v3. This TS was given by Keith Babo and Andi Egloff of Sun and they did a phenomenal job of introducing us to Project Fuji, Sun's next generation integration runtime. I was pleasantly surprised to see when Keith gave the demo that they used a couple of the binding components that we, Gestalt, had developed. The good news is that Keith has put up a screencast of the demo he showed this morning that shows of Project Fuji, and also our RSS and XMPP components. Project Fuji and Glassfish ESB look very promising and I will be following them closely.

The rest of the day I spent my time going to various sessions on SOA. There is still a lot of talk about whether or not SCA is competing with JBI, or are they compliments. To be honest I'm still not sure my self, but we will see how it plays out.

I ended the day with the JBI 2.0 BOF. I really like the way the expert group is approaching this. They are doing a code first spec. What the heck does that mean? Basically what they are doing is going to be putting out code to the community implementing their ideas and gauges the communities feedback. Once they get the feedback they need then they will put it into the spec. I think this approach is better in that it will get the community involved in helping drive the specification, we just need to contribute and provide the expert group the feedback.

Well, that's a short and sweet for today, I'll try and get something up again tomorrow.

JavaOne - Day One

2008-05-07T10:04:00.002-05:00

I know it's a day late, but I thought I would try and get this down for anyone who cares. JavaOne kicked off with a bang in the morning with the General Session in the morning. We were all greeted with some rockin music and dancers performing on stage. Half way through James Goosling graced us with his presence and launched T-Shirts into the crowd. Rich Green of Sun gave the talk and really focused on Java and how it runs everywhere with sample from Amazon, Sony Ericson, a very cool Facebook application, and concluded with a demo from Neil Young (Yeah, the rocker Neil Young). All in all, it was a very good start to JavaOne.

After the General Session I started hitting up some of the technical sessions. I hit up JRuby at first to see how that project is progressing. I must say, it's coming along really nice. The biggest take away was the IDE support that NetBeans is providing, it's really nice and improving every day.

I was also fortunate enough to get invited to listen in on the JBI expert group. I must say I was rather impressed with what was discussed. The biggest take away was make sure you keep track of JBI and keep an eye on it over the coming months, I know I will be watching very closely.

The next session I went to was upcoming Java language changes. Some of the highlights were the following:

Multi-catch statements
Safe re-throw
Modular programming
Annotations enhancement

The biggest focus was on the additional support for annotations.

Next up was secure mashups with OpenAjax. This was of particular interest to me since my team is current working on some mashup technologies. The stuff that OpenAjax is putting out is definitely worth keeping tabs on.

Finally to end the day I attended the Grails in depth session. I know that I have a particulair interest in Groovy and Grails, but I've got to say that Grails freaking rocks. If your team is doing Agile development and need to get quick rapid proof of concepts done, then you really need to take a good hard look at Grails. With its use of industry standards such as Hibernate and Spring, and the 40+ plugins that have been developed you'd be almost crazy to start from scratch and have to write all of that stuff yourself.

All in all it was a good first day, now I've got to get ready for day two. I'll try and get that up tonight or first thing tomorrow morning.

Pre JavaOne

2008-05-06T08:52:00.002-05:00

Well, I'm fortunate enough to be in San Francisco for this years JavaOne confrence. I'm going to try and update my blog throughout the day on some of the highlights. Last night I went to the G2One meetup and listend to Guillaume Laforge give the state of the union on the Groovy and Grails community. There is a lot of excitement around booth of these communities and rightfully so. They are really cranking and getting a solid community behind them. Some interesting takeways from last night:

Groovy is going to be making several releases of the coming months, hoping to get to 2.0 by the end of the year.
Groovy has really been focusing on their performance and plans to improve it even more.
Grails has some really nice new features coming down the pipe for 1.1

Some other tidbids include

Look for support for Groovy/Grails in NetBeans 6.5
LinkedIn is using Grails to build one of their new services and been really happy with it and it's integration with their legacy systems.
Contegix has selected Grails as their platform of choice and talked about why.

It was a good start last night, and thanks to the G2One and NFJS folks for throwing a really nice function. More to come today on Day one at the concfrence.

Oh how I miss these days!!

2008-04-25T16:35:00.002-05:00

I sometimes miss the days of being in the Military (Semper Fi), and being in the desert with nothing to do, here is a nice little video of what happens when bordem sets in.

Groovy XMLSlurper

2008-04-21T13:36:00.004-05:00

If you know anything about Groovy, I'm sure you have seen the XML parsing features it brings to the table. Whether you have seen it or not it is definitely worth mentioning. I feel this is a great tool added to my Java tool chest.

Imagine you have the following XML:

<basketball team="Kansas" status="National Champions">
<player>
   <name>Brandon Rush</name>
   <position>Small Forward</position>
   <pts-per-game>13.5</pts-per-game>
   <rebs-per-game>6.2</rebs-per-game>
</player>
<player>
   <name>Mario Chalmers</name>
   <position>Guard</position>
   <pts-per-game>12.5</pts-per-game>
   <rebs-per-game>4.2</rebs-per-game>
</player>
<player>
   <name>Sherron Collins</name>
   <position>Guard</position>
   <pts-per-game>10.5</pts-per-game>
   <rebs-per-game>3.4</rebs-per-game>
</player>
<player>
   <name>Darrel Arthur</name>
   <position>Power Forward</position>
   <pts-per-game>14.2</pts-per-game>
   <rebs-per-game>6.9</rebs-per-game>
</player>
<player>
   <name>Darnell Jackson</name>
   <position>Power Forward</position>
   <pts-per-game>12.5</pts-per-game>
   <rebs-per-game>8.9</rebs-per-game>
</player>
</basketball>

Now that you have your XML you want to parse it and put it into a Player object. Let's go ahead and create our Player object:


class Player {
  String name
  String position
  double ptsPerGame
  double rebsPerGame

  def String toString() {
      return "Name: ${name}\r\nPosition: ${position}\r\nPoints Per Game: ${ptsPerGame}\r\nRebs Per Game${rebsPerGame}"
  }
}

Now that we have our Player class created, lets create a class that will consume the XML create a Player for each Player in the XML:


class ParsePlayers {
private List players

  ParsePlayers () {
      players = new ArrayList()
  }

  def Player[] parsePlayers() {
      def data = this.getClass().getResource("/players.xml").text
      def xmlSlurper = new XmlSlurper()
      def playersXml = xmlSlurper.parseText(data)

      playersXml.player.each {
          def player = new Player()

          player.name = it.name.text()
          player.position = it.position.text()
          player.ptsPerGame = Double.parseDouble(it.'pts-per-game'.text().trim())
          player.rebsPerGame = Double.parseDouble(it.'rebs-per-game'.text().trim())

          players.add(player)
      }
      return (Player[])players.toArray()
  }
}

So, as you can see above that is a pretty simple way to parse XML using XMLSlurper from Groovy. I don't know about you, but that makes working with XML a little bit nicer.

Groovy Stub's

2008-02-25T17:13:00.007-06:00

I've been getting the chance to use Groovy a lot more at work lately and it's allowed me to really dig deep into some of the features. One of those being the use of Stub's for Unit testing. This is a fantastic feature and really simple to use. Lets look at the following code below:



def Entries[] getFeed(feedUrl) {
        def url = new URL(feedUrl)
        def data = url.getText()

        def xmlSlurper = new XmlSlurper()
        def feed = xmlSlurper.parseText(data)

        if (feedType.toLowerCase() == "rss") {
            feed.channel.item.each { item ->
                def rssItem = new Entries()
                rssItem.title = item.title
                rssItem.link = item.link
                rssItem.description = item.description
                rssItem.date = item.pubDate
                println (rssItem)
                entries.add (rssItem)
            }
        } else {
            feed.entry.each { entry ->
                def atomEntry = new Entries()

                atomEntry.title = entry.title
                atomEntry.link = entry.link[0].@href
                atomEntry.description = entry.content
                atomEntry.date = entry.published
                entries.add (atomEntry)
            }
        }
        return (Entries[]) entries.toArray()
    }

This code is pretty straight forward in that we are taking a URL for an RSS feed and going to read the feed and create an Entries object for each entry in the feed (this is a great example of how to use Groovy to consume rss feeds). The problem with unit testing this is the following section:



    def url = new URL(feedUrl)
    def data = url.getText()

I needed a way to stub this out so I could isolate this code at the unit level. Using Groovy's StubFor was the perfect way, the following is what my unit test looked like:



    def void testAtomFeed() {
        def block = new RssDataBlock()
        block.engineURL = "http://bob.com"
        block.feedType = "atom"
        def urlStub = new StubFor(URL)
        urlStub.demand.getText {
            return "my mock data"
        }
        urlStub.use {
            def entries = block.getFeed("http://cnn.com")
            assertEquals("", block.generateOutput(),
                    "Title:${title}\r\nDescription:${description}\r\nLink:${link}\r\nPublished Date: ${date}")
        }
    }

The import thing that is going on is we are creating a Stub for the URL class (new StubFor(URL)), and intercepting when the getText() method gets called we are going to return our sample data set. To use the stub you simply call urlStub.use and in the closure you execute your test. As you can see above, I call getFeed() with my bogus URL; and then I assert that the output I was expecting (generateOutput()pretty prints my output for me) is equal to what I actually got.

This is very powerful and makes my life a whole lot easier. The more I use Groovy, the more I'm impressed (I've even been able to convert some of my co-workers :) ). Stay tuned, I plan on posting about Groovlets next......

A Socket Client for Groovy

2008-01-21T14:28:00.000-06:00

Groovy Rocks!! I needed a simple client that would write data to a socket to test this application I was working on so I wrote it in Java since I had done that before. My code looked like the following:


public static void main(String[] args) throws Exception {
        String data = "test data";
        InputStream is = new ByteArrayInputStream(data.getBytes());

        Socket socket = new Socket("localhost", 8282);
        PrintWriter pw = new PrintWriter(socket.getOutputStream(), true);
        BufferedReader bw = new BufferedReader(new InputStreamReader(
                    socket.getInputStream()));

        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String userInput;
        
        if ((userInput = br.readLine()) != null) {
            System.out.println("yeb");
            pw.println(userInput);
            pw.close();
            bw.close();
            br.close();
            socket.close();
            System.exit(200);
        }
    }

After I got done, I was curious how I could do this same sort of thing in Groovy. So, I spun up the Groovy Shell and away I went.....


s = new Socket("localhost", 8283)
s << "Groovy Rocks"
s.close()

... I type go in my groovy shell and I'm done. Seriously, 3 lines of code and a quick shell to test it out. Groovy is awesome.

Connecting jconsole to JBoss JMX server

2007-11-28T13:28:00.000-06:00

So I was working on integrating the JBI ant tasks to the Open ESB distribution for JBoss and I was having some issues connecting to the JMX server. So, I wanted to try something simple and see if I could connect jconsole to the JMX server first. Out of the box this does not work. You will have to add some system properties to your run.sh or run.bat file for this to work. It's pretty simple really, but took me a while to find. For this to work just add the following properties to you run.sh file:


# Enable the jconsole agent remotely on port 64850
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.port=64850"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.authenticate=false"
JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote.ssl=false"

Next, start JBoss and once it is started you can start jconsole by issuing the command jconosle from a command window. You can connect in one of three ways. If you are connecting locally just select the local tab, you will see the PID and the class for JBoss and select Connect. If you are connecting to remotely select the remote tab and enter the Host/IP and the Port (the one you entered in your run.sh file).

Contributing a patch back to an Open Source project

2007-11-12T10:29:00.000-06:00

I recently needed to contribute a patch back to an open source project I was working on, and since I wasn't familiar with using cvs from the command line I needed to research how to create a diff. I thought I would post my findings since it took me a while to find anything useful. First you will want to create a diff of the code you are contributing. For a single class you could do the following:

cvs diff -u myClass.java > myClass.diff

This creates a unified diff, which I have read most open source projects prefer, or the class you modified with what is current in CVS, and output the diff to myClass.diff.

If the class is not under CVS control, you can add the class and then run the following:

cvs diff -uN myClass.java > myClass.diff

If you have modifications to more than one class you can do a diff on the entire package by doing the following:

cvs diff -uN myPackage > myPackage.diff

This will recursively perform a diff on anything that is either added or under cvs control and write the output out to myPackage.diff.

You can also set how many lines of context you wish in your unified diff by doing the following:

cvs diff -u8N myClass.java > myClass.diff

Happy Birthday Marines - Semper Fi

2007-11-09T16:45:00.000-06:00

Don't forget to celebrate the best holiday of the year on Saturday November 10th, The 232 Birthday of the United States Marine Corps. If you need a little inspiration this weekend checkout General Conway's Marine Corps Birthday Message, this is just one of the several proud traditions that all Marines will be participating in this weekend. If you know a Marine, make sure and tell them Happy Birthday. Semper Fi.

soapUI - Great plug-in for IDEA

2007-11-05T20:56:00.000-06:00

I had used soapUI before, with Netbeans, but hadn't ever even looked to see if my preferred IDE IntelliJ IDEA had a plug-in. Today I was getting ready to run some tests and needed soapUI and I didn't want to start Netbeans, so I installed the soapUI plug-in for IDEA. It's great, and very simple to use. Some of you may have used the standalone version of soapUI before, but if your like me you always have your IDE up so why not just get the plug-in. If you haven't ever used soapUI and need a really great tool to send SOAP for testing purposes, it's a great tool and I highly recommend it.

I've been keeping my mouth shut!!!!

2007-10-30T12:30:00.000-05:00

Well since my beloved Wolverines started out 0-2, I've been keeping my mouth shut this football season. I think it's time I start to talk some smack again. My only fear is that once I do, my teams will fall a great defeat to a lesser opponent, but hey who cares.

So after Michigan's dismal start, they have now reeled off 7 wins in a row. Granted the Big 10 isn't so good this year, but we have been winning despites some critical injuries. Last week Big Blue pulled a win out with their starting running back and quarterback on the sidelines in street clothes. Buckeyes beware!

On another note, I never brag about my second favorite team, but this year I have to. The University of Kansas is playing some football. I don't care what everyone is saying about how weak their schedule is, that fact is they are 8-0. They have beaten Colorado, K-State, and Texas A&M on the road. Years past the we couldn't win a game on the road. You can say what you want about the Jayhawks and their weak schedule, but the fact remains that they have a damn good defense (5th in the Nation I believe), and an offense that can put points on the board against any team in the country. I'm not saying they are going to win the National Championship (For one, the BCS would never allow a team like KU to be in the title came, but that's a whole other topic for discussion), but I wouldn't be surprised if they rolled into Arrowhead Stadium on November 24th looking to win the Big 12 North and a shot at the Big 12 title.

With all the fun of college football, we sometimes forget that college basketball is right around the corner. My Jayhawks kick off the season on Thursday with an exhibition game against Pittsburg State. Rock Chalk Jayhawk.

I think it's going to be a good year for my Jayhawks, hopefully the basketball team can start out like the football team and end with a National Championship.

Ok, enough sports talk. I'll get back to blogging about tech stuff next time. I'm hoping to work through some more Groovy examples, and get some of those up here. Until next time....Rock Chalk Jayhawk...Go KU!

Two Minute Drill for Groovy

2007-10-10T12:28:00.000-05:00

I know I promised more on Groovy, and I will get some more examples up here. However, one of my co-workers, Joe Kueser, just posted a great blog about Groovy. Basically Joe's Blog, "What Makes Groovy So...Groovy?", is a two minute read that provides a great summary of a lot of the features in Groovy. Be sure to check out Joe's Two Minute Drill.

Converting Dom to Groovy Code

2007-10-06T09:28:00.000-05:00

I've been looking into and learning a little Groovy on the side. One of the things I'm most interested in is learning how to use the MarkupBuilder provided by Groovy. Essentially this, in my opinion, is a much better way to parse and construct XML. As a developer I use XML almost daily. First I'm looking at integrating this into my unit tests. Today I stumbled on the DomToGroovy class and found this pretty cool. I was trying to figure out how to construct XML using Groovy. I knew what the XML looked liked, so using the DomToGroovy class I could get a good idea what the Groovy code would look like that I needed to write. Below is a sample of how to do this, and I recommend the GroovyConsole to test with.


import javax.xml.parsers.DocumentBuilderFactory
import org.codehaus.groovy.tools.xml.DomToGroovy

def xmlExample = """
<jbi:message tns="http://j2ee.netbeans.org/wsdl/rssWsdl"                                     
              type="tns:rssWsdlOperationRequest" version="1.0"
              jbi="http://java.sun.com/xml/ns/jbi/wsdl-11-wrapper">
         <jbi:part>
             <entrylist xmlns="http://xml.netbeans.org/schema/1.0/extensions/rssbc">
                 <entry>
                     <title>Entry 1</title>                     
                     <link>http://localhost:8000/rss/feed/entry1<link>
                     <description>First Entry</description>
                     <publishdate>Dec 7, 1976</publishdate>
                 </entry>
                 <entry>
                     <title>Entry 2</title>                      
                     <link>http://localhost:8000/rss/feed/entry2<link>
                     <description>Second Entry</description>
                     <publishdate>Dec. 7, 1976</publishdate>
                 </entry>
             </entrylist>
         </jbi:part>
     </jbi:message>
"""

def builder     = DocumentBuilderFactory.newInstance().newDocumentBuilder()
def inputStream = new ByteArrayInputStream(xmlExample.bytes)
def document    = builder.parse(inputStream)
def output      = new StringWriter()
def converter   = new DomToGroovy(new PrintWriter(output))

converter.print(document)
println output.toString()

The output essentially shows you what the Groovy code would look like to construct the XML that we provided.


jbi:message(type:'tns:rssWsdlOperationRequest', version:'1.0',
  xmlns:jbi:'http://java.sun.com/xml/ns/jbi/wsdl-11-wrapper',
  xmlns:tns:'http://j2ee.netbeans.org/wsdl/rssWsdl') {
jbi:part) {
 EntryList(xmlns:'http://xml.netbeans.org/schema/1.0/extensions/rssbc') {
   Entry) {
     title('Entry 1')
     link('http://localhost:8000/rss/feed/entry1')
     description('First Entry')
     publishDate('Dec 7, 1976')
   }
   Entry) {
     title('Entry 2')
     link('http://localhost:8000/rss/feed/entry2')
     description('Second Entry')
     publishDate('Dec. 7, 1976')
   }
 }
}
}

I think this is a pretty slick way to quickly generate a code sample so that you can quickly get started. More to come on Groovy later......

The "I" in JBI is for Integration

2007-09-25T22:25:00.000-05:00

Just in case anyone was wondering....

I came across this article today which discusses integrating XMPP presence in J2EE, and as I am reading the whole time I'm thinking I could do this with JBI utilizing the XMPP Binding Component and the JMS Binding Component. Leveraging the BPEL Service Engine I could easily orchestrate everything and not have to write any code, just create a composite application and deploy it to my JBI Container (e.g. OpenESB) and I'm golden. The XMPP BC would handle receiving the presence notifications and utilizing BPEL we could pass that along to the JMS BC to be published to the topic or queue.

I get the feeling that most developers feel the need to always write code to come up with solutions to their problems, when in all actuality there might be a solution to your problem already. I have said it 100 times myself, "I'm not happy unless I'm in my IDE coding away".

So my last thought....

Before you get knee deep in code (I know it's fun), check out some of the components that are available and see how you can use JBI to integrate solutions for your problems. Remember the "I" in JBI is for Integration.

XMPP BC - More Development on the way

2007-09-10T22:15:00.000-05:00

We are set to add some more enhancements to the XMPP BC, but first a quick recap of what we added last month:

Group Chat capabilities

Join
Invite
Kicks
Leave
Send/Receive Messages

Send/Receive Complex Types

Here is what we have in the works for this month:

More Group Chat capabilities

Create/Destroy Groups
Presence Notifications (Allows a consumer to monitor the status of members in the room)

Upgrading to the latest Smack API (3.0.4)

Stay tuned for more updates, you can get the latest release here.

Silverlight - The death of the browser

2007-09-05T13:14:00.000-05:00

At least mine anyways. So I was reading one of the Flex evangelists blogs about Silverlight 1.0 being released, and I thought I would see what all the hoopla was about. So I went to MLB.com and checked out some videos. What a mistake that was. First you will have to install Silverlight, no big deal I've had to install the Flash Player before as well. Once I get that installed and restart my browser, it took 2-3 minutes for my browser to load everything, and the whole time my processor is pegged at 100%. I waited patiently and finally was able to play a movie, and of course instead of showing the highlights immediately Microsoft had to pat themselves on the back. Finally the highlights started, and the quality was terrible. I couldn't hardly read the score because it was fuzzy, and it the actual footage looked choppy. I've seen enough, I try and go back to Google Reader and now my browser isn't responding, I had to kill the process and start a new session. Nice job Microsoft. First impressions are the most important, and my first impression of Silverlight is to go uninstall it as fast as I installed it.

Flex and Real Time Collaboration

2007-09-04T14:52:00.000-05:00

I stumbled upon this interesting Video Podcast from Dereck DeMoro of Jive Software in which he discusses the benefits of switching to Flex while developing the Spark Web Client. A few key points that he mentioned was that they were developing a desktop application (Spark) that was written in Java (Swing in particular) and a Web client that was written in HTML and JavaScript. He mentions how they wanted to mimic the two applications to provide the same user experience, and how they struggled to do this. Once they switched gears and started developing with Flex they were able to have one code base that utilized for the web application and the desktop application. For the web app, you just embed the swf into an HTML file, and for the desktop application they leveraged Adobe AIR (formerly Apollo). He talked about how this greatly simplified their development efforts, as well as things like testing since they only had to test one baseline.

Another key thing he mentions is the easy transition he and his team had (They were all Java developers with no Flash or Flex experience) in transitioning to Flex. I've had to opportunity to program in Actionscipt and it is very similar to Java, in fact I would bet most Java Programmers could pick it up in no time.

Sometimes I get the feeling that Java developers don't want to try something different, they just want to stick to what they know. To me, if it's better I don't care, and in my opinion Flex is better.

The Big House wasn't so Big on Saturday

2007-09-04T08:30:00.000-05:00

Yes, I am a die hard Michigan Wolverines fan, and yes I've been getting phone calls, emails, and text messages from friends I haven't talked to in quite some time rubbing salt in my wounds. Maybe Saturday's loss to Appalachian State was a wake up call for a very talented senior laden football team, or maybe it's a start to a very disappointing season. I guess we will have to wait and see, but as most Michigan Fans will say if we can beat Ohio State at the end of the year then who cares if we lost to that 1-AA team in September.

At least Team USA annihilated Argentina (Led by Bron and Melo, I think we definitely take the gold for coolest names), and American Sprinters dominated at the World Championships (Tyson Gay was awesome), the USA is looking good for Beijing.

Team USA

2007-08-29T10:18:00.000-05:00

I've been watching USA Basketball play in the FIBA Americas Tournament, and I must admit I've been impressed. Years passed Team USA looked like what they were, a bunch of spoiled overpaid kids. Not this team. They are playing with a lot of passion, and I think will get us back to the top. Kobe Bryant has especially impressed me. He is one the most people consider a selfish ball hog, but has taken on the role of defensive stopper. I have watched several games where he has just shut down the other teams best player, kudos Kobe. Anyways, make sure to tune in, we have Argentina coming up soon.

Bridging the Gap - XMPP to SIP Group Chat

2007-08-22T13:11:00.000-05:00

As noted in one of my earlier blogs, we have been enhancing the XMPP BC to be able to participate in Group Chat Sessions. During this process we thought we would also show how you can utilize JBI to be a convergent platform and bridge gaps across protocols. To do this, we thought we would show how a SIP User Agent (e.g. an xlite soft phone) could participate in an XMPP Group Chat session. Brian O'Neill's blog talks a little more about utilizing JBI as a convergent communication platform, and provides a use case here.

Enough with the fluff, on with the demo. I've uploaded the Netbeans Projects here that I will be discussing in this blog so you don’t have to create them from scratch. Below is a list of prerequisetes in order to run the demo:

- You will need to get the latest OpenESB installer

o This comes with Netbeans, Glassfish, and the JBI Components you will need to run the demo.

- Set up an Openfire XMPP Server

o You can go here for a demo on how to setup Openfire

o You will need to get an XMPP client (e.g. Spark or Pidgin)

§ You can go here to see a demo of how to setup Spark

§ You will need to create one user in Openfire with the username sipua and password sipua (This is defined in the XMPP WSLDs

- Set up a SIP User Agent/SIP Server

o We used XLite for the demo, but you should be able to utilize just about any SIP UA and SIP Server.

o Login as a user (e.g. chad)

- Edit the XMPP WSDL

o Edit all xmpp WSDLs to reflect the correct domain (the domain of your Openfire server) and the correct groupChat name (e.g. A@conference.OpenFireDomain). Both attributes can be found in the xmpp:address section of the WSDL.

- Edit the SIP WSDL

o Edit all sip WSDLs to reflect the correct proxyDomain (sip:address section of the wsdl) (the domain of your SIP server)

- Edit the BPEL Process

o Click on Assign3 and edit the String A@conference.b-0498.int.gestalt-llc.com to be the groupChat name you defined in your XMPP WSDL’s earlier.

o Click on Assign1 and edit the String chad@10.9.5.62 to be whatever user you are logged in as (e.g. mySipUserAgent@mySipServerDomain).

You should be all set now. You will need to recompile the Composite Application by right clicking (in Netbeans) on SIPAndXMPPCA module and selecting “Clean and Build”. You are now ready to deploy your application. Follow the following steps to deploy and run the test.

- Start Glassfish

o In Netbeans Click Window à Services à Servers à Right click on Sun Java Application Server à Click Start.

- Start Openfire

o With an XMPP client (e.g. Spark or Pidgin (or Both)) log in, you may have to create an account first.

- Start SIP Server and SIP User Agent

o Using a SIP UA (e.g. XLite) log in as the user you defined in the Bpel Process above (e.g. chad@10.9.5.65).

- Ensure JBI Components are installed and started

o In Netbeans navigate to Window à Services à Sun Java System Application Server 9 à JBI

§ Under Service Engines verify the following Component is installed and started

· sun-bpel-engine

§ Under Binding Components verify the following Component is installed and started

· gestalt-sip-binding

· gestalt-xmpp-binding (uninstall this component by right clicking on the component and selecting "uninstall". We need to ensure you have the latest XMPP BC, you can find it here. Download the xmppbc.jar and install it by righ clicking on Binding Components and selecting Install New Binding Component. After Installation, make sure you start the XMPP BC (Right click and select Start).

o If the components are not there, you can download them here.

- Deploy the SIPAndXMPPCA by right clicking on the project and selecting “Deploy Project”

- Once deployed, you should be able to use your Spark or Pidgin clients and join the Conference room that was created (e.g. A). You should see yourself in the room as well as the user sipua. You can now send a message to the group and your SIP UA will receive the message. Have your SIP UA respond and see the message appear in the Group Chat.

So a quick recap of what we accomplished. First, we were able to create an application that could bridge two protocols that normally couldn’t speak to each other (See screenshot below). Second, we did this without writing one line of code. Yes, you read that correct. To do this application from scratch all you have to do is configure it, and then tell BPEL how to orchestrate it. Netbeans provides a nice way to do this with their toolkit support (automatically generating WSDL’s and leveraging the design view for the BPEL process to drag and drop activities on the screen)

If you have any questions feel free to shoot us an email by using our mailing lists (SIP BC, XMPP BC), or leave a comment on my blog.

Google Rocks

2007-08-18T23:13:00.000-05:00

I'm all the time checking out Google Labs to see what cool thing they have come up with next. I'm a big fan of Google and some of the tools they have put out. I thought I would share some of the ones that I consider must haves, I use these on a daily basis.

- Google Reader: Fabulous tool for managing all of your favorite RSS Feeds. Manages the feeds through a very simple and easily to read web interface. Doesn't matter if you are at work or home all you have to do is log in and you can view it, unlike desktop applications like RSS Owl. Also allows you to star your favorite reads or share with others, providing a unique RSS Feed URL for others to view your shared items.

- Google Desktop: Google has mastered the art of indexing and searching, Google Desktop does this for your desktop. This tool will index your entire hard drive and emails so that you can quickly search for items you know you have, but can't seem to find.

- Blogger: I got into blogging several months ago and settled on Blogger mainly because it was a Google product and I can utilize my same Google login. I've been really happy with the ease of managing my blog, if you are thinking about blogging I would highly recommend Blogger.

- iGoogle: Customize your experience with Google. iGoogle allows you to customize your Google Home page to add things that you are interested in.

So those are the items that I use every day, here are some items that I have been playing around with that are pretty cool.

- Google Pages: Are you wanting to create a personal web page, but you don't know how to write HTML, don't want to pay for hosting or a domain name, or don't know how to use FTP? Google Pages could be for you. With your Google account you create a custom made web page and publish that page to your unique Google pages URL. You don't have to understand HTML, FTP, and you don't have to pay for a domain name or hosting services.

- Google 411: Are you tired of paying fees to use 411 and then paying extra to connect? Check out Google's 411 service, 1.800.GOOG.411. I've used it and it works great, and best of all it's Free.

So to sum it all up, Google Rocks. My wife calls me a geek every time I mention a new cool Google tool I find, but I can't help it, I guess I'm an addict. Anyways, you can find all of these tools on Google Labs. Last thing, Google is more than a search engine; make sure you are utilizing all of the tools they have available, they are Free.

My Sports Praise

2007-08-16T13:27:00.000-05:00

Since I ranted about some things that tick me off about sports, I thought I would share some recent examples why at the end of the day I absolutely love sports.

- My Cardinals are making a charge in the dog days of August proving that teamwork and heart can perceiver all obstacles.
- Rick Ankiel - If you do not know who he is, use Google and read his story. Fantastic, welcome back.
- High School Football - It is 100% American, the purest form of athletics (no money, tv ratings, etc.) just good competition.
- Tiger Woods - I am not that big of a golf fan, but you have to relish watching greatness.

I could go on and on, but there is no need to do that. See you on the field!!!!!!!!!!

New Enhancements for the XMPP Binding Component

2007-08-14T21:53:00.000-05:00

We have some new enhancements for the XMPP Binding Component coming down the pipe this month. Already in place is the ability to join, leave, and send messages to group chats. You can join a group chat upon deployment or you can dynamically join/leave groups at runtime. Also in the works for this month are enhancing the XMPP BC to handle complex types. You can view the documentation for the WSDL Extensions here.

My Sports Rant

2007-08-01T16:35:00.000-05:00

So, my favorite time of year is quickly approaching......Football Season. Lately I have been catching up on where my teams stand, and as usual someone is holding out for more money. This is my biggest problem with Pro Sports in general, causing me to be a bigger College sports fan. I get sick and tired of seeing athletes hold out for more money cause they have had a couple of good seasons. What happens if you have a bad couple of years, should the team be allowed to negotiate your contract down to what you deserve, oh no that is not how it works. I am a Chiefs fan, and as most sports fans know, Larry Johnson is holding out for more money. I can see where he is coming from in a way. He has been one of the best backs, if not the best, the last couple of years, and he does not make nearly as much as some of the other backs in the league, e.g. LT, Shaun Alexander, Edge, etc. My beef with all of this is what ever happend to honoring your contract. You are still making a lot of money, more than 90% of the people out there will make in a lifetime. Teams have to honor the contract no matter what, unless they want to cut you. At the end of the day I do not really blame the athletes, I blame the agents. Most of the time I think they ruin what is good about sports, they are not in this for the athletes, they are in it for themselves. Just this morning they were talking about Brady Quinn holding out for more money because he thought he should have been drafted higher, sorry buddy you did not so you get pick 22 money. Now go prove yourself on the field and get that money the next contract, what a novel thought .... proving yourself and earning that money.

I will get off my soap box now.......

Utilizing Installation Descriptor Extensions in JBI

2007-07-30T12:33:00.000-05:00

JBI provides a means to add extensions to your Installation Descriptor (jbi.xml). These extensions can be used for a variety of different things, like configuration for your component. Working examples of components utilizing this feature check out the OpenESB HTTP Binding Component or ServiceMix HTTP Binding Component . Recently I needed to use this feature to add some configuration type attributes to the component we were developing. The first thing you will need to do is add the extensions to your installation descriptor. As noted in the API, the Installation Descriptor Extensions are located at the end of the <component> element of the installation descriptor, something like the following:


<component>
....
The rest of the jbi.xml
....
<config:Configuration>
    <config:Port>8888</config:Port>
    <config:Location>localhost</config:Location>
</config:Configuration>
</component>

During bootstrap init() the InstallationContext is passed in, this object gives you access to the Installation Descriptor Extensions, via installationContext.getInstallationDescriptorExtensions (Which returns a DocumentFramgment containing all Extensions). At this time you need to store the values in an object so that you can access them during the Components init(). The best way to achieve this is to use JMX. So the first thing you will need to do is Create an Interface that defines your MBean, and then create your class that will implement that interface. Something like the following:


public interface ConfigExtensionsMBean {
public void parseConfigExtensions(DocumentFragment documentFragment);
public String getLocation();
public int getPort();
}

Now we need to write our concrete class that implements this interface, something like the following:


public class ConfigExtensions implements ConfigExtensionsMBean {

private int port;
private String location;

public enum Attributes {Location, Port};

public String getLocation() {
 return location;
}

private void setLocation(String location) {
 this.location = location;
}

public int getPort() {
 return port;
}

private void setPort(String port) {
 this.port = new Integer(port);
}

public void parseConfigExtensions(DocumentFragment frag) {
 //Parse the DocFrag here and call the setters for the port and location.
}
}

So now we have the Interface and the Concrete class, we just have to use it now. So the first thing we need to do is in your Bootstrap classes init() method we need to get the Installations Service Description Extensions and create our MBean and register that MBean in our MBean server, this should look something like the following:


public void init(InstallationContext context) {
ConfigExtensionsMBean mBean = new ConfigExtensions();
DocumentFragment doc = context.getInstallationDescriptorExtension();
mBean.parseConfigExtensions(doc);

MBeanServer mBeanServer = context.getContext().getMBeanServer();
ObjectName mBeanName = context.getContext().getMBeanNames().createCustomComponentMBeanName("MyMBean");
try {
 if (!mBeanServer.isRegistered(mBeanName) {
     ObjectInstance oi = mBeanServer.registerMBean(mBean, mBeanName);
 }
} catch (Exception e) {
 e.printStackTrace();
}
}

So what we just did was read the extensions, parse them and call the setters, and registered the mBean for future use. So now our new component is ready to be initialized and needs access to that mBean. The following is how you can access them during ComponentLifeCycle.init(ComponentContext context):


public void init(ComponentContext context) {
MBeanServer mBeanServer = context.getMBeanServer();
 ObjectName mBeanName = context.getMBeanNames()
                                      .createCustomComponentMBeanName("MyMBean");

 try {
     host = (String) mBeanServer.getAttribute(mBeanName,
             ConfigExtensions.Attributes.Location.toString());
     port = (Integer) mBeanServer.getAttribute(mBeanName,
             ConfigExtensions.Attributes.Port.toString());
 } catch (Exception e) {
     log.warning("Exception getting mBean Attributes: " + e);
     e.printStackTrace();
 }
}

So, there you have it, an example of how to utilize the Installation Descriptor Extensions from your jbi.xml.

Patterns and Matchers - java.util.regex Package

2007-07-24T19:18:00.000-05:00

Recently I got the oppurtunity to utilize the java.util.regex package, which I had never used before, and found it very simple and handy to work with. As I look to do on my blog, I will share a simple example of how to match character sequences against patterns specified by regular expressions utilizing the Java API. So, as TDD goes we will write the test first and then develop our code against our unit test. If your not familiar with unit testing, you will need to download JUnit. Ok, we will start by creating our new test class.


import junit.framework.TestCase;
import java.util.List;

public class ProcessorTest extends TestCase {
    String testData =
   <test><name>Chad</name>Bob<name></name></test>;

    public void testProcessor() {
        Processor processor = new Processor();
        List list = processor.processMessage(testData);
        assertEquals("List was not correct size", 2, list.size());
        assertEquals("Name did not match", "Chad", list.get(0));
        assertEquals("Name did not match", "Bob", list.get(1));
    }
}

This will obviously fail since we haven't created our Processor class yet, so lets go ahead and create our new Class, and then we can run our unit test to verify that our code is doing what we want it to do.


import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.List;
import java.util.ArrayList;

public class Processor {

    public List processMessage(String text) {
        String pattern1 = <\\w*?name>>;
        String pattern2 = </\\w*?name>;
        List result = new ArrayList();
        Pattern p1 = Pattern.compile(pattern1);
        Pattern p2 = Pattern.compile(pattern2);
        Matcher m1 = p1.matcher(text);
        Matcher m2 = p2.matcher(text);
        while ((m1.find()) && (m2.find())) {
            result.add(text.substring(m1.end(), m2.start()));
        }
        return result;
    }
}

Now we can run our unit test again and our test will pass. So this is just a simple example of how to use the Matcher and Pattern class provided as part of the JDK, and how to utilize Unit Testing to test your code.

Using Grizzly to read TCP Packets

2007-07-23T12:17:00.000-05:00

Recently I had the need to be able to listen on a port and read TCP packets that were sent from a logger (java.util.SocketHandler), and I wanted to utilize the Grizzly framework to do this. With some help from the Grizzly team I was able to accomplish this and thought I would share what I did. The first thing I had to do was write a main that could connect to a port and receive TCP packets, it looked something like the following:

public class TCPProcessor {
public static void main(String[] args) throws Exception {
  int port = Integer.getInteger(args[0]);

  Controller controller = new Controller();
  TCPSelectorHandler tcpHandler = new TCPSelectorHandler();
  final MyProtocolFilter filter = new MyProtocolFilter();                                                                                                 

  tcpHandler.setPort(port);
  controller.setProtocolChainInstanceHandler(new DefaultProtocolChainInstanceHandler() {
      public ProtocolChain poll() {
          ProtocolChain protocolChain = protocolChains.poll();

          if (protocolChain == null) {
              protocolChain = new DefaultProtocolChain();
              protocolChain.addFilter(new ReadFilter());
              protocolChain.addFilter(filter);
          }

          return protocolChain;
      }
  });
  controller.addSelectorHandler(tcpHandler);
  controller.start();
}
}

Now that I have my main listening, I need to write the Filter that will handle the processing of the data packet. With the ProtocolChain, the ReadFilter will read the TCP packets and pass it to the next filter in the chain, which is were I need to process my data. My filter will look something like the following:

public class MyProtocolFilter implements ProtocolFilter {
public boolean execute(Context context) {
   final WorkerThread workerThread = ((WorkerThread)Thread.currentThread());
   String message = "";
   ByteBuffer buffer = workerThread.getByteBuffer();
   buffer.flip();

   if(buffer.hasRemaining()) {
       byte[] data = new byte[buffer.remaining()];
       int position = buffer.position();
       buffer.get(data);
       buffer.position(position);
       message = new String(data);
   }
   System.out.println("New message being read, message is: " + message);
   buffer.clear();
   return false;
}

   public boolean postExecute(Context context) throws IOException {
       return true;
   }
}

So now you could whip up a test to send some data over TCP and the Processor will read the packets and print the message out.

Fun in the Sun!!!!

2007-07-19T03:33:00.000-05:00

I am currently in Mexico on vacation with my wife and daughter and thought I would share some photos. This is the first vacation we have had a chance to take with our daughter, and she has had just a great time. You can tell by the picture that she has thoroughly enjoyed the tropical drinks, I think she likes eating the pineapple more than drinking the drink though.
I have to admit, she has been quite good the entire trip, we drove from Missouri (a 24 hour drive) and I was worried about her ridding in the car that long, thank goodness for portable DVD players. In the meantime, we have just had a great time relaxing in the sun and playing in the ocean. Back to the real world next week.

New Enhancements for the RSS Binding Component

2007-07-05T11:39:00.001-05:00

We have recently added some new enhancements to the RSS Binding Component. We now provide support for subscribing and receiving notifications from secure feeds that use Basic Authentication, and the ability to subscribe to multiple feeds at the same time during runtime. Be sure to check out the RSS WSDL Extensiblity elements for definitions on how to create the WSDL. If you have any questions feel free to contact me or use the mailing list from the project site.

Your One Stop Shop for JBI Components

2007-06-12T15:04:00.001-05:00

Are you in the need for a certain JBI Component, but don't know where to download it at? Here is a great place to download the binaries for the component you need. Don't forget to check out the wiki for demo's and descriptions of the components.

XMPP to RSS Demonstration

2007-06-11T14:28:00.000-05:00

As noted in my last blog, I have been working on some open source binding components. We recently finished the RSS Binding Component and I wanted to get one of the demonstrations we did out here as an example of how you can use JBI to tie multiple protocols together that would normally be somewhat difficult to do. So in this demonstration I use the XMPP BC to send instant messages, and take that message and publish it as an RSS Feed. You can download the Netbeans project here. Prerequistes to build this application are as follows:

OpenESB Installer this comes with Netbeans, Glassfish with JBI Runtime, and JBI Components
Wildfire XMPP Server: for instructions on how to set up go here.
Spark XMPP IM Client: For instruction on how to set up go here.
XMPP Binding Component installed
RSS Binding Component installed
File Binding Component installed
BPEL Service Engine Installed

All of the Binding Components and the Service Engines come with the OpenESB installer. If you happen to be missing one you can find and download the component you need from here.

You will want to edit the WSDL's to fit your needs. First look at the fileWsdl.wsdl. You will notice that in the address section (file:address) you will be writting a file to you User Home/mag16AOC directory. You can edit this if you wish, and write the file where ever. Next look at the message (file:message) section of the WSDL and notice the file will be called mission100.xml. You can re-name the file if you wish.

Next look at the rssPublish wsdl, you will want to edit the feedUrl in the rss:address section to be specific to your machine (i.e. http://localhost:64801/feed/mag-16_aoc/mission_100). What this means is once you deploy this application and start sending instant messages, the messages will be published to the above link and you can view them using an RSS Reader (i.e. RSSOwl), or you can navigate to that link in a web page and view it there. Next look at the rssSubscribe wsdl. You will want to edit the rss:address section to be the same feedUrl you used above. What this does is subscribes to this feed and every time there is a new post you will get notified and the entry will be written to the file we described above.

Finally lets take a look at the xmppWsdl. You will need to edit the xmpp:address section to update the domain (i.e. localhost).

You can now clean and build the module in netbeans by right clicking on the project and selecting clean and build. With a successfull build you will want to right click on the XMPPtoRSSDemoCompApp and clean and build that. You are now almost ready to deploy these and test. You will first need to create a user for your spark client (This is assuming you have followed the instructions on how to setup Spark and Wildfire). Make sure you Wildfire server is running and start your Spark client. You will need to select "Accounts" and create a new user (i.e. bob, server is localhost). Once logged in you will want to pull up your Wildfire server Admin page and add a user. This user must be the same that is defined in the xmppWsdl (i.e. username = mag-16_aoc, passworkd mag-16_aoc), once this user is created you will want to add him as a contact in your buddy list for your Spark client. You are now ready to deploy and test.

Start the server in Netbeans ( Window --> Runtime --> Servers --> Right Click on Sun Java System Application Server 9 and select Start). Once the server is running you will see a Tab that says JBI, expand that and verify that under Binding Components you see the RSS Binding Component, XMPP Binding Component, File Binding Component, and under Service Engines verify you see BPEL SE. If those are in place you are ready to deploy your Composite Application. Right Click on the XMPPtoRSSDemoCompApp and select Deploy. Once successful you will see the buddy you added in your Spark client (mag-16_aoc) come online (i.e. turn green). You are now ready to send instant messages and have those messages published to an RSS Feed. Send a couple of messages and then navigate to the feedUrl you defined and verify the feed is being published. You can also verify your subscribe is working by navigating to the file and verifying that the file is being written to the location described in your fileWsdl.

So in short what we have done using JBI is the capability to "mash" two protocols together that could normally not happen, at least easily. This is a great example of how to take simple IM client and disseminate information to a large group of people. If you have any questions feel free to email me or use the mailing list on our project site for the RSS BC or XMPP BC

New RSS Binding Component on java.net

2007-06-06T12:30:00.000-05:00

As I have noted in some of my other blogs, I have been fortunate enough to be working on a team lately that has been developing and open sourcing some JBI components to java.net. This last month we developed a RSS Binding Component that is now available for download and use. Feel free to check it out and feel free to let us know what you think or if you have any questions. You can contact us at the following email address:

dev@rss-bc.java.net

Also, feel free to check out our other Binding Components, XMPP, SIP, and UDDI, that we developed a couple of months ago. For questions about these components you can contact us at the following:

dev@uddi-bc.java.net
dev@xmpp-bc.java.net
dev@sip-bc.java.net

The project sites contain documentation on how to use the components as well as demonstration videos that will walk you through creating a component application. For a complete list of binding components available see the JBI Components WIKI

Java Threading - ScheduledExecutorService

2007-05-18T15:22:00.000-05:00

Today I stummbled upon something I had not done, this may be old hat for some of you, but none the less I thought it was pretty cool and thought I would share. I was working on a class that needed to kick off a thread, so i started down the path I knew and created a class that implemented Runnable, created the run method, and it looked something like the following:


public class MyThread implements Runnable {
    private Boolean running;
 
    public MyThread(Boolean running) {
        this.running = running;
    }

    public void run() {
     while (running) {
            process();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }
    
    public void process() {
     //Do someting cool here
    }
    
    public void setRunning(Boolean running) {
     this.running = running;
    }
}

public class ExecuteThread {
    private Boolean running = true;
    private MyThread myThread;

    public void activate() {
        myThread = new MyThread(running);
        Thread thread = new Thread(myThread);
        thread.start();
    }

    public void deactivate() {
        myThread.setRunning(false);
    }
}

Using the ScheduledExecutorService provided in the java.util.concurrent package you can handle the execution of a thread and control the initial delay, delay, and the unit of time with one method call. Something like the following:


public class MyThread implements Runnable {
    public MyThread() {
    }

    public void run() {
        process();
    }

    public void process() {
        //Do something cool here
    }
}

public class ExecuteThread {
    private MyThread myThread;
    private final ScheduledExecutorService scheduler =
        Executors.newSingleThreadScheduledExecutor();

    public void activate() {
        myThread = new MyThread();
        scheduler.scheduleWithFixedDelay
          (myThread, 0, 10, TimeUnit.SECONDS);
    }

    public void deactivate() {
        scheduler.shutdown();
    }
}

Again, this might be old news for some of you, but I thought this was a very effective way to handle threading and it really cleaned up my code in the end.

Creating a Binding Component Deployment Plug-In for Netbeans

2007-05-10T21:28:00.000-05:00

Recently I have had the pleasure of working on a team developing and open sourcing to java.net some binding components for JBI. One of the tasks we had to complete was integrating our binding components into netbeans. One of the things netbeans provides is a WSDL wizard, so when you are creating new modules the wizard lets you select the type of binding you will be using, and based off that binding will give you a base template of your wsdl with some default values of attributes you need to provide. When I first started I had no idea on how to create a plug in for netbeans. So, this will cover how to create a Binding Component Deployment Plugin. The first thing you will need to get is the
OpenESB installer for netbeans.

Once you have Netbeans installed you will want to create a new project by doing the following

Select File --> New Project
Under Categories select --> JBI Components
Under Projects select --> Binding Component Deployment Plugin and click next
Name your plugin (i.e. NewBCPlugin)
define your source package (i.e. com.company.netbeans.modules.wsdlextensions.newbc)
Define your component Name (i.e. newbc).
Edit your WSDL Extension

Define your Namespace (i.e. http://schemas.company.com/jbi/wsdl-extensions/newbc/)
Define your prefix (i.e. newbc)

And click Finish

Once that is finished you will have a Source Packages directory, and under there you will have two packages something like the following:

com.company.netbeans.modules.wsdlextensions.newbc

Bundle.properties
layer.xml
newbcWsdlExt.xsd

com.company.netbeans.modules.wsdlextensions.newbc.resources

You will need to edit the layer.xml file. You will need to update the last section to be something like this.

You will also need to update the schema to fit your needs for your Binding Component. You will next need to add this wsdl.xsd to the com.company.netbeans.modules.wsdlextensions.newbc package. Once you have added this xsd make sure you add it as an import to the newbcWsdlExt.xsd file.

That should be a good starting point for you on that package. Next we will neeed to create a new package called com.company.netbeans.modules.wsdlextensions.newbc.template,and create the following files under that package:

Bundle.properties
NewBCTemplateProvider.java
template.xml

First lets edit the Bundle.properties. This property file defines what type of extensions your wsdl will provide (i.e. transport). It should look something like the following:


NewBCTransport=NewBC Transport
NewBCMessage=NewBC Message
http_//schemas.company.com/jbi/wsdl-extensions/newbc/=NewBC

TEMPLATEGROUP_name=NewBC
TEMPLATEGROUP_prefix_newbc=newbc
TEMPLATE_name_NewBCTransport=NewBC Transport

Next we are going to edit the NewBCTemplateProvider.java, this class is pretty straight forward and should look like the following:



package com.company.netbeans.modules.wsdlextensions.newbc.template;

import java.io.InputStream;
import org.netbeans.modules.xml.wsdl.ui.
spi.ExtensibilityElementTemplateProvider;
import org.openide.util.NbBundle;

public class NewBCTemplateProvider
extends ExtensibilityElementTemplateProvider {

 static final String templateUrl =
   "/com/company/netbeans/modules/wsdlextensions/newbc
/template/template.xml";

 public InputStream getTemplateInputStream() {
   return NewBCTemplateProvider.class
.getResourceAsStream(templateUrl);
 }

 public String
getLocalizedMessage(String str, Object[] objects) {
   return NbBundle.getMessage
(NewBCTemplateProvider.class, str, objects);
 }
}

For this code to compile you will have to update your libraries by doing the following:

Right click on your project --> Properties
Select Libraries
Add the following libraries
- WSDL UI (You will need to edit this library and select use Implementation Version)
- Utilities API

Next we will look at creating the template.xml; this is the file where you add any attribute that is defined in your NewBCExt.xsd to include default vaules. Once this plugin
is installed these default values show up as properties in the WSDL Editor. Your template.xml should look something like this.

Finally you well need to add META-INF/services directory which should be located under your src directory (newbc/src/META-INF/services). This should contain a file called

org.netbeans.modules.xml.wsdl.ui.spi.
ExtensibilityElementTemplateProvider

and it should say the following:

com.gestalt.netbeans.modules.wsdlextensions.newbc.
template.NewBCTemplateProvider

Now you are at a point you can test the plugin. You will need to right click on the project and perform a clean and build. Next you will need to test, right click the project and select "Install in Target Platform". This will start a new instance of Netbeans with your plugin installed. Once it is started create a new project and under Service Oriented Archietecture select BPEL Module. Once the project is created right click on Process Files and select create new WSDL Document. Click next through the Wizard until you get to selecting the type of binding. Here you will want to select the drop down box called Binding Type and select your new plugin (If it isn't showing up in the list there is something missing).

If you would like a complete netbeans example project just like we did here, you can download the zip here