This turns out to be particularly useful if you have large sets of data in which the names can be dynamically mapped to the param names. It's suddenly a concise and simple matter to dynamically make large sproc calls.This procedure is simply called by passing in the name of the sproc that you want to examine. The sproc code is commented with an explanation of each return field.

This is compatible with Sql Server 2005 and 2008.

Example call:

EXEC    spStoredProcParamLookup @ipSprocName = 'spTestSproc'

Since HttpException exposes a GetHttpCode() method and WebException does not, the HTTP status code from the underlying service was being discarded by this library, which made it impossible for me to automate error handling by status code. The right way to solve this problem is to fix the library to throw HttpExceptions to preserve status codes. But the right now way was to use regular expressions to see when these exception messages contained a three-digit number starting with 4 or 5 (e.g. 401, 404, 500) and wrap it in my own HttpException so that the caller further up the chain can process it automatically.

Note that an exception message like 404 is not a valid credit card number would get erroneously treated as a 404 File Not Found exception. However, in this case where I know the library and the service involved I think it's safe to do. But I'm still going to fix the offending code ASAP!

    // C#
    try
    {
        // call the library that might throw the exception 
        // that ought to be an HttpException
    }
    catch(System.Web.HttpException) // it's already an HttpException, so throw it as-is
    {
        throw; 
    }
    catch(Exception ex) // any other exception
    {
        // If the exception message contains a 3-digit number starting
        // with 4 or 5, assume it's the correct HTTP status code. 
        // NOTE! Know your library to know if that's a safe assumption!
        Regex httpErrorRegex = new Regex("((4|5)\\d{2})(?!\\d)");
        if(httpErrorRegex.IsMatch(ex.Message))
        {
            int httpStatusCode = int.Parse(httpErrorRegex.Match(ex.Message)
                .Captures[0].Value);
            throw new HttpException(httpStatusCode, ex.Message, ex);
        }

        // No 3-digit HTTP error code found in the message, so default to a 500 error
        throw new HttpException(500, ex.Message, ex);
    }

If you save the bookmarklet to your browser's toolbar you simply click once, enter the ticket number, and you're in your ticket.

For my half of our application ecosystem I researched .NET's Base64 encoding/decoding support, got curious about character set encoding, and set out to write a universal encoder to make it simple, easy, and guaranteed safe to insert any kind of binary or text data into an XML document.

But first, a quick nano-refresher: Character encoding specifies how a string of bytes should be mapped to specific text characters. In the simplest case, ASCII, one byte maps to one of 256 possible characters. 65=A, 66=B, .... 90=Z, etc. In Unicode, two (or even four) bytes map to thousands or even (theoretically) billions of characters. So when my program reads four bytes from a text file, I need to know if it represents four 1-byte characters, two 2-byte characters, or one 4-byte character. It's actually even more complicated than that, but the basic problem is making sure I don't accidentally turn a 400-byte ASCII text file into 200 Japanese characters. Or vice versa. Or garbage.

Fortunately, .NET has robust support for character encoding, so all I have to do is load the correct encoding class and ask it to take care of this for me. If I know I will only ever need to deal with Unicode, that class is Encoding.Unicode, but for maximum flexibility I can call Encoding.GetEncoding(encodingName) and get any encoding by name. Like so:

public string GetStringFromFile(string myFilename, string encodingName)
{
    byte[] fileBytes = System.IO.File.ReadAllBytes(myFilename);
    System.Text.Encoding myEncoding = System.Text.Encoding.GetEncoding(encodingName);
    return myEncoding.GetString(fileBytes);
}

public void SaveStringToFile(string myFilename, string encodingName, string myString)
{
    System.Text.Encoding myEncoding = System.Text.Encoding.GetEncoding(encodingName);
    byte[] fileBytes = myEncoding.GetBytes(myString);
    System.IO.File.WriteAllBytes(myFilename, fileBytes);
}

But now let's get back to my actual business problem, storing a PDF or other binary data in my XML document. Because the bytes I encounter are not supposed to represent character data, attempting to map them to characters may result in nonsense. For example, whether I decode the byte sequence 00 00 00 00 as ASCII, Unicode, or UTF-32, I get either one, two, or four null characters that will screw up string processing. Note that use of CDATA sections doesn't help. Only being very lucky about which byte sequences I encounter would avert disaster, and I don't like writing lucky code.

Enter Base64, which is designed for exactly this purpose: encoding arbitrary binary data into a string guaranteed to consist of only "safe" ASCII characters and decoding that string back to bytes with 100% fidelity later. Microsoft places Base64 functionality under the System.Convert class, not System.Text.Encoding because it's more of a conversion and translation process, not a direct byte-to-character encoding like those described above.

To read a file into a Base64 string:

public string GetBase64StringFromFile(string myFilename)
{
    byte[] fileBytes = System.IO.File.ReadAllBytes(myFilename);
    return Convert.ToBase64String(fileBytes, Base64FormattingOptions.InsertLineBreaks);
}

And to decode it and save it back to the filesystem:

public void SaveBase64StringToFile(string myFilename, string myString)
{
    byte[] fileBytes = Convert.FromBase64String(myString);
    System.IO.File.WriteAllBytes(myFilename, fileBytes);
}

I combined both "real" character encodings and Base64 encoding in my XmlFileEncoder class (attached) to provide unified access to both encodings when working with XML documents. If you know you're dealing with Unicode, simply call XmlFileEncoder.InsertFileIntoXmlDocument with the encoding UTF-16 and the file will safely be inserted as text. If you don't always know the file format, or you are dealing with binary files, simply call the same method with the encoding Base64. In either case, a new node will be added to contain your file data and the encoding attribute will record the encoding method so XmlFileEncoder.ExtractFileFromXmlDocument will use the correct character/Base64 decoding automatically.

The demo WinForms app starts up displaying an XML document with some UTF-16 data already encoded into it. Use the controls along the bottom to experiment with inserting differently encoded files (provided, or use your own) using different application character encodings. Some files will clearly look wrong in the XML when you select the wrong encoding. Others may look correct, or almost correct, but when you press the SaveEncodedFile to File button it will report Copy accuracy FAILED when it verifies against the source file. However, the files encoded and decoded using Base64 will always copy accurately. The only downside is that Base64 encoded data is always 1/3 bigger and much less human readable than the source.

You can find the source code here: XmlEncodingDemo.zip

Have a happy, healthy, and correctly encoded 2009!

[Event(name='complete', type='flash.events.Event')]

Since I wasn't seeing the event in the code hints list I looked at some inner Flex framework components like Button or TextInput to see what I was doing wrong. Everything matched but then I realized the only difference was that they used double quotes. Aha! Once I switched the above metadata example to the following, everything worked out:

[Event(name="complete", type="flash.events.Event")]

The complete event showed up in the code hints list when trying to add an event listener for my custom component. This isn't a complaint on Flex Builder, as I normally use double quotes--so I blame this on laziness and copying and pasting the metadata line but to others be careful and note to see the event (or any other metadata type e.g. styles) show up in the code hints list always use double quotes!

package com.arc90.example;

import java.util.logging.Logger;

public class LoggingExample1
{
	public static void main(String[] args)
	{
		Logger logger = Logger.getLogger(LoggingExample1.class.getName());
		
		String user = "dougb";
		int logins = 17;
		int purchases = 2;
		
		logger.info("User " + user + " has logged in " + logins + 
				" times and made " + purchases + " purchases.");
	}
}

Fortunately, the Java Logging API gives you the ability to parameterize your statements (similar to JDBC prepared statements) so that you can turn the above into something like this:

package com.arc90.example;

import java.util.logging.Level;
import java.util.logging.Logger;

public class LoggingExample2
{
	public static void main(String[] args)
	{
Logger logger = Logger.getLogger(LoggingExample2.class.getName());
		
		String user = "dougb";
		int logins = 17;
		int purchases = 2;

		// Single parameter
		logger.log(Level.INFO, "User {0} successfully logged in.", user);
		
		// Multiple parameters
		logger.log(Level.INFO, "User {0} has logged in {1} times and made {2} purchases.", 
				new Object[] {user, logins, purchases});
	}
}

You'll need to use the logger.log(...) method rather than the more convenient logger.fine(...), logger.info(...) (etc.) methods, but in the end it makes for much cleaner code.

    Unable to Connect to ssl://( your host name):443.
    Error #175113224: Unable to find the socket transport "ssl" - 
    did you forget to enable it when you configured PHP?

The problem lies in your version of OpenSSL and certain configuration parameters.

HTTPS relies on SSL to transport your data securely and PHP usually uses the OpenSSL implementation of SSL. Problems occur when your versions of OpenSSL are out of sync with each other.

The best option is to always keep ALL of your software 100% up-to-date at all times--but sometimes you are not able to do a full software update for one reason or another.

This is how to ensure OpenSSL works for you:

There are 4 required files for openSSL: libeay32.dll, ssleay32.dll, php_openssl.dll, and openssl.cnf.

libeay32.dll and ssleay32.dll are usually already installed in multiple places, but are usually in different versions. The safest thing to do is rename all the current files and copy in a known version. Make sure you have the most current version by installing the most current version from this site: Shining Light Productions

It is probably best to do a search for these files to see all the locations, but they usually live in the following places on a 64-Bit server:

     C:\Program Files (x86)\PHP
     C:\Program Files (x86)\Apache Group\Apache2\bin
     C:\Windows\SysWOW64

Go to all of these places and rename the files libeay32-old.dll and ssleay32-old.dll, respectively, then copy libeay32.dll and ssleay32.dll to those locations.

If it doesn't already exist, copy php_openssl.dll to:

     C:\Program Files (x86)\PHP\ext 

If you do not have php_openssl.dll, one place to find it is here.

If it doesn't already exist, copy openssl.cnf to:

     C:\Program Files (x86)\PHP\extra\openssl

Create directories if they do not already exist. If you do not have openssl.cnf, you can download PHP's default cnf file here.

Add the following line to php.ini:

     extension=php_openssl.dll

Make sure the following line is uncommented in httpd.conf:

     LoadModule ssl_module modules/mod_ssl.so

Restart Apache.

You're done!

The Apache httpd server will automatically ignore the double slashes, and treat the URL as if the double slash was a single slash. This is helpful; the server is giving the user what they want, even though they technically didn't ask for it correctly.

Reslet's Router class, however, isn't so forgiving. If you accidentally include a double-slash in the URL of a request, a Restlet application will probably return a 404 Not Found status code.

Thankfully, Restlet's request handling process is so flexible, we can easily add a Filter which will cause the application to ignore double slashes, just like httpd.

If your application uses a subclass of Restlet's Application class, then it is overriding the default getRoot() method to provide your own request handling Restlets.

A standard getRoot() might look something like this:

@Override
public Restlet getRoot()
{
       Router router = new Router();

       // Attach all the routes
       router.attach("path", ResourceClass.class);

       return router;
}

In order to remove double slashes from request URLs before they reach the router, we can create an anonymous Filter class and return it as the root of the application:

@Override
public Restlet getRoot()
{
       Filter doubleSlashFilter = new Filter() {
               @Override
               protected int beforeHandle(Request request, Response response) {
                       Reference ref = request.getResourceRef();

                       String originalPath = ref.getPath();

                       if (originalPath.contains("//"))
                       {
                               String newPath = originalPath.replaceAll("//", "/");
                               ref.setPath(newPath);
                       }

                       return Filter.CONTINUE;
               }
       };

       Router router = new Router();

       // Attach all the routes
       router.attach("path", ResourceClass.class);

       doubleSlashFilter.setNext(router);

       return doubleSlashFilter;
}

And that's it! The application will now ignore double slashes, and will successfully serve requests that accidentally include them.

Ever been on an internal network and wanted to share a file or two quickly? This little *nix script will let you do so in a snap. (And it works on Mac OS X, too!)

From the command line, just type:

python -c "import SimpleHTTPServer;SimpleHTTPServer.test()"

alias webshare='python -c "import SimpleHTTPServer;SimpleHTTPServer.test()"'

I'm using a Canvas so the top portion of my MXML item renderer looked like:

Easy, but not quite there. You see the Flex List component seems to add some default spacing around the left and bottom parts of each item renderer from the List edge. You can see this in the following screenshot (I've changed the colors so the edges stand out):

As you can see, there is whitespace between the left edge and the starting point of the border and our selection highlight seems to be out of place. This is undesirable but there is an easy fix. It seems the List component has some default left and bottom padding set, so simply override it with nothing. Here I'm setting the rules globally to all List components, but you can replace it with the style name for a specific one if needed:

After applying that snippet of CSS, we now have an item renderer where the selection highlight is in line with the left edge of the List and the next item. You can see the result below:

• Make use of the label/input value pair tags. Have the label for the attribute equal its corresponding input's id. This allows the user to activate its control by clicking on the text. Example below:

  <label for="fn">First Name</label>
  <input type="text" id="fn" class="text_input">
  

• Give each input type="text" a class.

  IE6 does not recognize attribute selectors. So, if you style the input selector (ie. input { border: 1px solid #CCC; }), and the form contains radio buttons or checkboxes, IE6 will apply that particular style to all inputs.

  

• To adjust label width, float the label, then give it a width. Differentiate floating from from non-floating labels with <p>s and <div>s.

  Example:

  <style type="text/css" media="screen">
         #myform p label { float: left; width: 9em; }
  </style>
  <p>
         <label for="s_addrs">Shipping Address</label>
         <input type="text" name="some_form" value="s_addrs" id="s_addrs" class="text_input">
  </p>
  
  <div>
         <input type="checkbox" value="" id="check_saddrs" class="text_input">
         <labe for="check_saddrs">Check if shipping address is different from personal</labe>
  </div>

• Make sure you are careful when using the universal reset rule - * { padding: 0; margin: 0; }. This affects browser form elements. Below is a screenshot differentiating the padding on the right side of a select tag when the reset rule is not-applied/applied on Firefox 2.
  

I believe that these steps are a great starting point when creating forms. Good luck!

Here's an example of how it's done. The first code block is the pre-Generics way. It still works, but results in a compiler warning. The second block is the new Generics way that doesn't generate the warning.

package com.arc90.example;

/**
 * Demonstrates use of Class.forName(...) with Java Generics
 */
public class GenericsExample
{
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		/*
		 * This gives the compiler warning:
		 * "Class is a raw type. References to generic type Class<T> should be parameterized"
		 */
		Class c1 = Class.forName("com.arc90.blog.InstantiateMe");
		ImplementMe i1 = (ImplementMe) c1.newInstance();
		System.out.println(i1.getClass().getName());
		
		/*
		 * This gives no compiler warning
		 */
		Class<? extends ImplementMe> c2 = Class.forName("com.arc90.blog.InstantiateMe").asSubclass(ImplementMe.class);
		ImplementMe i2 = c2.newInstance();
		System.out.println(i2.getClass().getName());
	}
}

To try this yourself you'll need to create two additional classes; An empty interface named ImplementMe and an empty class named InstantiateMe that implements ImplementMe.

But that’s not really so elegant. It doesn’t really support any object-oriented design patterns. It’s ugly. So what is a better solution? Use inheritance! Your controller classes don’t have to directly extend Zend_Controller_Action. Instead, write a parent class for all of your controllers that extends Zend_Controller_Action.

Let’s move on with an example. Say you’re writing an application that requires all actions to authenticate. If you only had one controller, you could put this check in public function init() and it would be executed before each action is called. But this application isn’t so basic. It’s pretty complex and your architecture requires you to have multiple controller classes. So, instead, create a new class called App_Controller_Action (or namespace it however you’d like). Put it in your include path, the same way you have the Zend Framework set up: App/Controller/Action.php (this way it will autoload the same way the Zend Framework classes load).

Now all of your controller classes should be children of this class.

I’m sure you can find tons of other examples where this pattern can be useful in your applications. If you need any more help with this drop me a line at davidh@arc90.com. If you have anything to add, comment below. Have fun coding!

In Restlet 1.1, which is currently at Release Candidate 1, you can now configure an application completely within the Spring application context. This means that the only Java classes you will need to create are one for starting the application, and one for each of the resources in your class. Although the Restlet authors prefer specifying the configuration in code, I like specifying it in an external, non-compiled configuration file, and this provides a great way to do that.

Now on to the code! A single-resource application can be configured with only three files: One XML file for defining the Spring beans, one class for defining the resource, and finally, one class for instantiating the Spring context and starting the application.

Spring Application Context

This defines all the Spring beans (Java Object instances) that are needed to run the application. In a non-Spring configured application these would all be instantiated in your main application class.

• exampleResource: A standard Resource. In a normal application you would define many resources in the attachments map.
• restletRouter: Determines how resource URLs map to resource classes.
• exampleApplication: Associates the router with an application.
• restletServer: Defines the protocol and HTTP port for the internal server.
• restletComponent: Associates the server and application. This is the object that will be used to start the server.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

    <bean name="exampleResource"
        class="com.arc90.example.ExampleResource" scope="prototype" />
   
    <bean name="restletRouter"
        class="org.restlet.ext.spring.SpringRouter">
        <property name="attachments">
            <map>
                <entry key="/example">
                    <bean class="org.restlet.ext.spring.SpringFinder">
                        <lookup-method name="createResource" bean="exampleResource"/>
                    </bean>
                </entry>
            </map>
        </property>
    </bean>
   
    <bean id="exampleApplication"
        class="org.restlet.Application">
        <property name="root" ref="restletRouter"/>
    </bean>
   
    <bean id="restletServer"
        class="org.restlet.ext.spring.SpringServer">
        <constructor-arg value="http" />
        <constructor-arg value="8182" />
    </bean>
   
    <bean id="restletComponent"
        class="org.restlet.ext.spring.SpringComponent">
        <property name="server" ref="restletServer" />
        <property name="defaultTarget" ref="exampleApplication"/>
    </bean>
</beans>

Resource Class

This is just a simple resource that displays "It worked!" when it is accessed through GET.

package com.arc90.example;

import org.restlet.Context;
import org.restlet.data.MediaType;
import org.restlet.data.Request;
import org.restlet.data.Response;
import org.restlet.resource.Representation;
import org.restlet.resource.Resource;
import org.restlet.resource.ResourceException;
import org.restlet.resource.StringRepresentation;
import org.restlet.resource.Variant;

/**
 * Handles requests for the example resource
 */
public class ExampleResource extends Resource
{
	public void init(Context context, Request request, Response response)
	{
		super.init(context, request, response);
		getVariants().add(new Variant(MediaType.TEXT_PLAIN));
	}

	public Representation represent(Variant variant) throws ResourceException
	{
		return new StringRepresentation("It worked!", MediaType.TEXT_PLAIN);
	}	
}

Application Class

This class contains the main method for starting the application. It instantiates the Spring application context, where creates instances for the beans defined in application-context.xml. To start the application, the component bean is retrieved from the application context, then its start() method is called.

package com.arc90.example;

import org.restlet.ext.spring.SpringComponent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Launches the Restlet application
 */
public class ExampleApplication
{
	/**
	 * Get the restlet component from Spring, then starts it
	 * @param args
	 */
	public static void main(String[] args)
	{
		ApplicationContext context = 
			new ClassPathXmlApplicationContext(new String[] { "application-context.xml" });
		
		try
		{
			SpringComponent component = (SpringComponent) context.getBean("restletComponent");
			component.start();
		}
		catch (Exception e)
		{
			throw new RuntimeException(e);
		}
	}
}

So here's how one adds a custom HTTP header to a Restlet Response:

Form responseHeaders = (Form) getResponse().getAttributes().get("org.restlet.http.headers");

if (responseHeaders == null)
{
    responseHeaders = new Form();
    getResponse().getAttributes().put("org.restlet.http.headers", responseHeaders);
}

responseHeaders.add("X-Some-Header", "the value");