a

Go vote. Now.

    $(document).ready(function() {
        $('#transmit').transmit('http://mysite.com/upload/');
    });

While the plugin is still very much in its infancy and should be considered a work in progress, it is my opinion that it is easier to shake out bugs using an iterative development process. So, keeping that in mind, I’m hoping that a couple of you brave souls will wander over to googlecode and give it a try. Constructive feedback is very much appreciated.

a

Flickr style multiple file upload with jQuery

With this short tutorial, I’ll demonstrate how easy it is to configure UrlRewriteFilter for use within your Spring MVC application. I should mention that this technique will work well for just about any Java-based web framework, like JSF or Struts.

For those of you that want to skip to the end, I’ve created a small, functional sample application which demonstrates the techniques described in this tutorial. It can be downloaded here.

Getting started, we need to register the filter within our application’s web.xml file.

web.xml

    <!-- UrlRewriteFilter -->
    <filter>
        <filter-name>UrlRewriteFilter</filter-name>
        <filter-class>
            org.tuckey.web.filters.urlrewrite.UrlRewriteFilter
        </filter-class>
        <init-param>
            <param-name>logLevel</param-name>
            <param-value>WARN</param-value>
        </init-param>
    </filter>

    <!-- UrlRewriteFilter Mapping -->
    <filter-mapping>
        <filter-name>UrlRewriteFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

That out of the way, we can dig into the application itself. Let’s review an example controller class as it might exist in your application today.

SprocketsController.java

@Controller
public class SprocketsController {

    private final SprocketService service;

    @Autowired
    public SprocketsController(SprocketService service) {
        this.service = service;
    }

    @RequestMapping("/sprockets/list.do")
    public String list(ModelMap model) {
        model.addAttribute("sprockets", service.list());
        return "sprocket/list";
    }

    @RequestMapping("/sprocket/display.do")
    public String display(@RequestParam("sprocketId") int sprocketId, ModelMap model) {
        model.addAttribute("sprocket", service.find(sprocketId));
        return "sprocket/display";
    }

    @RequestMapping("/sprocket/edit.do")
    public String edit(@RequestParam("sprocketId") int sprocketId, ModelMap model) {
        model.addAttribute("sprocket", service.find(sprocketId));
        return "sprocket/edit";
    }
}

Our controller contains actions for displaying a list of sprockets, drilling down into each sprocket’s details and editing an individual sprocket. Each action is mapped to a URI path via the @RequestMapping annotation and, as you can see, all three defined here handle requests mapped to the *.do extension. The beauty of the solution I’m demonstrating here is that you should not need to make any changes to your application code at all. That in mind, let’s move on to the interesting part, configuring our application to respond to a REST style URL like http://localhost:8080/sprocket/1234/edit instead of what we’ve got now: http://localhost:8080/sprocket/edit.do?sprocketId=1234. You’ll need to create a new configuration file named urlrewrite.xml and make it available on the classpath. (For those with a distaste for XML based configuration, the latest version of the filter offers a means to generate the configuration via annotations. Details on that can be found here.) We’ll start our configuration by defining a few rules to handle the incoming requests.

urlrewrite.xml

    <rule>
        <from>^/sprockets/$</from>
        <to>/sprockets/list.do</to>
    </rule>
    <rule>
        <from>^/sprocket/([a-z0-9]+)/$</from>
        <to>/sprocket/display.do?sprocketId=$1</to>
    </rule>
    <rule>
        <from>^/sprocket/([a-z0-9]+)/edit$</from>
        <to>/sprocket/edit.do?sprocketId=$1</to>
    </rule>

Let’s take a look at what each one of these rules does. The first rule states that the UrlRewriteFilter should transparently forward each request for http://localhost:8080/sprockets/ to the existing application URL of http://localhost:8080/sprockets/list.do. The second and third rules handle the display and edit requests. These 2 rules define simple regular expressions that are parsed out and appended to the destination URI as query string parameters. If you have more than 1 query string parameter, you’ll need to use & XML entity. (It should be noted that you can use wildcard matching (*) instead, however it lacks some of the flexibility offered by regular expressions.)

That takes care of the inbound URLs, but we still have a problem. Within our application, we have a number of links which point to the old URL structure. No worries, UrlRewriteFilter tackles this issue with ease. By examining the response, the filter can rewrite the existing links defined within anchor tags, i.e. <a href=”<c:url value=’/sprockets/list.do’/>”>Return to the list.</a>. Let’s take a look at the rule definitions to handle this.

urlrewrite.xml

    <outbound-rule>
        <from>^/sprockets/list.do$</from>
        <to>/sprockets/</to>
    </outbound-rule>
    <outbound-rule>
        <from>^/sprocket/display.do\?sprocketId=([a-z0-9]+)$</from>
        <to>/sprocket/$1/</to>
    </outbound-rule>
    <outbound-rule>
        <from>^/sprocket/edit.do\?sprocketId=([a-z0-9]+)$</from>
        <to>/sprocket/$1/edit</to>
    </outbound-rule>

More or less, these outbound rules are just the inverse of the inbound rule definitions. All it takes is a simple regular expression to parse out the sprocketId. One common gotcha to note here is that you need to add the \ character before the start of the query string marked by the question mark. If you don’t do this, the filter won’t be able to process your links.

Pretty easy, right? With your rules in place, fire up your application and give it a try. You can always examine the status of the filter by visiting http://127.0.0.1:8080/rewrite-status. If you’re a bit hesitant to try this out on your own app, fret not, I’ve created a simple, yet functional sample application which you can use to experiment with. The example source code can be downloaded here.

a

RESTful URLs with Spring MVC and UrlRewriteFilter

a

Mac OSX + Subversion = Versions

The project consists of two main parts, the Jedia Networking Framework (JNF) and the Jedai Collaboration Suite (JCS). The Networking Framework delivers a development stack that “builds upon the services that most real-time applications need” such as user, stream and data management. The Collaboration Suite is a set of reusable components providing services such as authentication, text chat and video publishing and is designed to be used directly with the JNF. Leveraging these two pieces gives Red5 application developers a great deal of power and flexibility with a minimum of effort.

From the project developers themselves: “We have seen the need for this framework for quite some time, and here is our answer. Please, feel free to try it out and watch as it becomes a standard in real-time application development with Red5 and Flash.”

Check it out here: http://code.google.com/p/jedai/

a

Jedai Framework for Red5

Thank you for taking the time to read through my posts and link to them. Unfortunately, you have managed to offend me. Instead of linking to my post and providing a summary like most considerate bloggers would, you have chosen to copy the article in whole, download my sample code and republish it WITHOUT so much as a single line giving credit to me as the original author. To me, this is unacceptable. Please update your pingbacks to correctly specify me as the author or I’ll be forced to ban you from reading my blog.

Regards,
Carl Sziebert

a

Open letter to the Chinese blogger stealing my work…

a

13949712720901ForOSX

a

WTF: Apple ships Leopard without Java 6

First things first, you’ll want to make sure you have the latest code from Red5’s subversion repository. If you do not run against trunk, fear not, you’ll just need to create the scripts manually. Both versions are shown here:

Windows

@echo off

set JAVA_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=y

if not "%JAVA_HOME%" == "" goto launchRed5

:launchRed5
"%JAVA_HOME%/bin/java" -Djava.security.manager -Djava.security.policy=conf/red5.policy %JAVA_OPTS% -cp red5.jar;conf;bin;%CLASSPATH% org.red5.server.Standalone
goto finaly

:err
echo JAVA_HOME environment variable not set! Take a look at the readme.
pause

:finaly
pause

Unix

#!/bin/bash

JAVA_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=y"

for JAVA in "$JAVA_HOME/bin/java" "/usr/bin/java" "/usr/local/bin/java"
do
  if [ -x $JAVA ]
  then
    break
  fi
done

if [ ! -x $JAVA ]
then
  echo "Unable to locate java. Please set JAVA_HOME environment variable."
  exit
fi

# start red5
exec $JAVA -Djava.security.manager -Djava.security.policy=conf/red5.policy $JAVA_OPTS -cp red5.jar:conf:$CLASSPATH org.red5.server.Standalone

Make sure you’ve got the file permissions set correctly on Unix platforms. If not, updating the file permissions is as simple as chmod 755 red5_debug.sh. Double check to insure that your application is installed in the Red5 webapps directory and configured properly. If not, you’ll need to deploy it now. Start the server from the console. Don’t expect to see the normal server log statements just yet. The only statement we are interested in at this point is “Listening for transport dt_socket at address: 8787“. You should be seeing something like this:

Next, we’ll need to create a debugging profile in Eclipse. Start it now if it is not already running and make sure that your project is open in the workspace. Mine looks something like this:

Find the small bug icon in the Eclipse toolbar, click it and choose “Open Debug Dialog…“. Select the “Remote Java Application” entry in the list, then right click and choose “New“. By default, Eclipse will name this debugging profile after the class you currently have selected in the editor. I’ve changed it to reflect the name of the project I’m working with at the moment. The only other changes we need to make are to alter the default port number from 8000 to 8787 and check the “Allow termination of remote VM” box. The second step here is not really necessary, but I like having the option to kill the remote server from Eclipse. Here’s what you should have:

Click “Apply“, then “Debug“. Eclipse has now attached a socket listener to the remote JVM and Red5 should be starting in the console window you opened earlier, complete with all of the standard logging output shown here:

If you’ve never opened the debugging perspective in Eclipse before, it should prompt you to do so. If not, select “Window –> Open Perspective –> Debug“. Select the line at which you would like to set a breakpoint and double click in the gutter. The debug perspective should have appeared and you should see your breakpoint:

At this point you’ll need to start the execution path of your application. Fire up your flash or flex app and connect to Red5. For this example, I’ve opened a browser and pointed it at the broadcast SWF of my stream recording tutorial. Given that you are using the same project I am, you should see this (Sans my ugly mug, of course.):

Upon triggering your breakpoint, your application will cease to respond and Eclipse should come into focus. The debugger will highlight the line of code next in the execution tree. You’ll see something like the following:

That’s it! You are now debugging your Red5 application. If you aren’t sure what to do next, I would suggest that you read this article over at IBM’s developerWorks.

With these startup scripts, it is even possible to debug Red5 itself. You’ll need to have the latest code checked out from Subversion and the project open in Eclipse. Start the server in the same manner, create or open the debug profile and start debugging.

1. http://osflash.org/red5 For those that aren’t up on Red5, it is a robust Flash Media Server alternative written entirely in Java that supports multi-user video chat, video streaming and real-time, multi-player gaming.

2. www.eclipse.org Eclipse is an open source community whose projects are focused on building an open development platform comprised of extensible frameworks, tools and runtimes for building, deploying and managing software across the lifecycle.

a

Remote debugging Red5 applications

I’ll jump right in by creating a simple ApplicationAdapter subclass. This step isn’t really necessary, however I feel that it is good practice when creating Red5 applications. As your application grows in functionality, you’ll have the most essential building block ready to go.

Application.java

public class Application extends ApplicationAdapter {

	...

	/**
	 * Delegate method used to accept/reject incoming connection requests.
	 *
	 * @param conn
	 * @param params
	 * @return true/false
	 */
	@Override
	public boolean roomConnect(IConnection conn, Object[] params) {
		log.debug("New connection attempt from " + conn.getRemoteAddress() + "...");
		// Insure that the listeners are properly attached.
		return super.roomConnect(conn, params);
	}

	/**
	 * Delegate method which logs connection/client/user disconnections.
	 *
	 * @param conn
	 */
	@Override
	public void roomDisconnect(IConnection conn) {
		log.debug("Connection closed by " + conn.getRemoteAddress() + "...");
		// Call the super class to insure that all listeners are properly
		// dismissed.
		super.roomDisconnect(conn);
	}
}

As you can see, there isn’t much to it, just a couple of logging statements to track new connections to the application. Next, I’ll define a simple service bean to handle the NetConnection calls to start and stop the stream recordings.

StreamManager.java

public class StreamManager {

	...

	/**
	 * Start recording the publishing stream for the specified
	 * IConnection.
	 *
	 * @param conn
	 */
	public void recordShow(IConnection conn) {
		log.debug("Recording show for: " + conn.getScope().getContextPath());
		String streamName = String.valueOf(System.currentTimeMillis());
		// Get a reference to the current broadcast stream.
		ClientBroadcastStream stream = (ClientBroadcastStream) app.getBroadcastStream(
				conn.getScope(), "hostStream");
		try {
			// Save the stream to disk.
			stream.saveAs(streamName, false);
		} catch (Exception e) {
			log.error("Error while saving stream: " + streamName, e);
		}
	}

	/**
	 * Stops recording the publishing stream for the specified
	 * IConnection.
	 *
	 * @param conn
	 */
	public void stopRecordingShow(IConnection conn) {
		log.debug("Stop recording show for: " + conn.getScope().getContextPath());
		// Get a reference to the current broadcast stream.
		ClientBroadcastStream stream = (ClientBroadcastStream) app.getBroadcastStream(
				conn.getScope(), "hostStream");
		// Stop recording.
		stream.stopRecording();
	}

	...
}

This is where the meat of the application lies. The broadcast client starts recording the stream by calling streamManager.recordShow() and stops it by calling streamManager.stopRecordingShow(). In the example broadcast application, I’ve added a button to the Stage and created a simple onClick function to invoke the server-side methods.

BroadcastController.as

        /**
	 * Handle the record button click events.
	 */
	private function onClick(ev:Object):Void {
		// Record the stream by triggering a server event.
		if (ev.target.label == "Record") {
			// Tell the remote server to start recording.
			conn.call("streamManager.recordShow", null);
			// Re-label the button.
			button.label = "Stop";
		// Stop recording the stream.
		} else if (ev.target.label == "Stop") {
			// Tell the remote server to stop recording.
			conn.call("streamManager.stopRecordingShow", null);
			// Re-label the button.
			button.label = "Record";
		}
	}

Take note, the name of the recorded stream differs from that of the publishing stream. I am using a simple timestamp as a unique name for each new FLV. It is even possible to reuse an existing FLV and append new video data to it. Simply change the second argument of the stream.saveAs() method call to true while reusing the same stream name. Check the streams directory of the recorder application for the output files. Reviewing the FLVs is as easy as opening them up with an FLV player[1].

While this is an interesting bit of functionality, the possibilities are much greater. Consider, for example, a security application that needs to record video when the camera detects movement and also needs to have a unique file for each incident. With some minor tweaks to this example, you’ve got exactly that. In addition, it would be quite easy to extend this application to extract a JPEG preview snapshot from each FLV using FFMPEG[2].

The example source code for this post can be downloaded here.

1. http://www.wimpyplayer.com Wimpy Desktop FLV Player is a free cross platform (Mac and PC) standalone Flash Video FLV player for you, which will allow you to watch your FLV and SWF videos from your desktop. Check it out.

2. http://ffmpeg.mplayerhq.hu/index.html FFmpeg is a complete solution to record, convert and stream audio and video. It includes libavcodec, the leading audio/video codec library. FFmpeg is developed under Linux, but it can compiled under most operating systems, including Windows.

a

Server-side stream recording with Red5