The code should be silent

Using Firebird ISQL to create embedded database files

2011-12-19T11:58:00.007-05:00

ISQL is a command line tool that enables the execution of SQL statements either interactively or by input script file.

I was struggling to get ISQL to work with my Firebird Embedded database files until I stumbled upon a little nugget of information in one of my many google searches.

The problem was that ISQL wasn't using the embedded client! Doh!

The fix was simple! To get ISQL working the way I needed it to all I had to do was:

Copy isql.exe into the Firebird embedded directory.

Rename fbembed.dll to fbclient.dll

Now I can create and connect to embedded database files using the ISQL command line tool.

isql.exe" -q -i myDatabase.sql

where the file myDatabase.sql contains:
CREATE DATABASE 'TEST.FDB'
USER 'SYSDBA' PASSWORD 'masterkey'
PAGE_SIZE 8192
DEFAULT CHARACTER SET NONE;

CREATE ROLE RDB$ADMIN;

CREATE TABLE MYTABLE(
ID INTEGER NOT NULL,
NAME VARCHAR(500) NOT NULL
);

ALTER TABLE MYTABLE
ADD CONSTRAINT PK_MYTABLE_1
PRIMARY KEY (ID);

COMMIT;

Why did I want to do this?
My want was driven by a desire to have my build server create/modify database files for our product install. Treating the database creation scripts like code negates the need for a "Golden" database file that no one, other than myself, knows how to create.

Firebird embedded with .Net

2011-10-13T08:58:00.012-04:00

Here's a simple getting started with Firebird embedded

Step one: Download FireBird embedded and the .Net provider

There are numerous options available for download but I opted for the zip packages as only the assemblies and supporting files are needed.
http://www.firebirdsql.org/en/server-packages/
http://www.firebirdsql.org/en/net-provider/
http://www.firebirdsql.org/manual/ufb-cs-embedded.html#ufb-cs-embedded-windows

Step two: Create your database file

There are many administrative tools available for FireBird but I opted to use FlameRobin as its free. http://www.flamerobin.org/

In order to get flame robin to communicate with an embedded FireBird database there are a couple of steps required.
Copy the following FireBird embedded client files to the FlameRobin installation folder (Default C:\Program Files\FlameRobin)
fbembed.dll (Rename to fbclient.dll)
firebird.msg
icudt30.dll
icuin30.dll
icuuc30.dll

Register Server

Display name
leave hostname and port empty
Create a new database

Step 3: Create your .Net project.
Add a reference to the .Net Provider.
FirebirdSql.Data.FirebirdClient.dll
The files icudt30.dll and icuuc30.dll need to be in the build directory. Add them to the project (I added as a link as all my third party components live in a single place) and set to copy to output build directory.

Step 4: Write the code.

using System;
using FirebirdSql.Data.FirebirdClient;

namespace FirebirdClient
{
class Program
{
static void Main(string[] args)
{
var builder = new FbConnectionStringBuilder
{
UserID = "SYSDBA",
Password = "masterkey",
ServerType = FbServerType.Embedded,
Dialect = 3,
Database = @"C:\MyDatabases\MyDB1.fb"
};

using (var conn = new FbConnection(builder.ConnectionString))
{
conn.Open();

using (var cmd = new FbCommand("select * from MyTable", conn))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Console.WriteLine(string.Format("{0} {1}", reader["MyCol1"], reader["MyCol2"]));
}
}
}

Console.ReadLine();
}
}
}

Control catalog name when using AttachDBFilename

2010-09-28T09:15:00.003-04:00

I was using the AttachDBFilename and discovered that the database name ended up being the full path of the file being attached.

Setting InitialCatalog as well enable me to control the catalog name of the attached file.

var cb = new SqlConnectionStringBuilder {
IntegratedSecurity = true,
DataSource = ".\MyInstance",
AttachDBFilename = @"c:\mypath\mydb.mdf",
InitialCatalog = "mydb catalog name"
};

Visual studio designer hangs and fails to load ToolStripControlHost derived class

2010-09-23T15:36:00.003-04:00

I found a problem using a ToolStripControlHost derived class when the class is being built in the same solution as the form that uses the component.

When performing a rebuild the designer would freeze and wouldn't redraw the toolbar. The fix I discovered solves the problem where the designer disposes the object and then attempts to access it after the rebuild.

public class CustomButtonToolStripHost : ToolStripControlHost
{
public CustomButtonToolStripHost ()
: base(CustomToolStripButton())
{
}
///

Used to overcome a designer error when rebuilding the project.

private class CustomToolStripButton : Button // Replace with your control
{
///

Override CreateHandle to avoid exception if called when object is disposed.
/// This occurs when the designer updates after a rebuild.

protected override void CreateHandle()
{
if (!IsDisposed)
{
base.CreateHandle();
}
}
}
}

.Net button that doesn't take/steal focus

2010-09-23T15:32:00.003-04:00

This is a simple solution that I've came up with after some thinking:

public class MyButton : Button
{
public MyButton()
{
if (!DesignMode)
{
SetStyle(ControlStyles.Selectable, false);
}
}
}

Much easier than trying to handle mouse activation messages etc...

Isolation from database

2010-03-23T16:05:00.006-04:00

So I'm working on a legacy project and quite intent to re-factor the heck out of it. One of my goals was to make the code testable and to do that I had to rip out the dependency on the database/DataSet implementation.

To do this I created a data provider class and then implemented an iterator block and used the yield statement.

public override IEnumerable MyDataObjects
{
get
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
using (var command = new SqlCommand{CommandText = "...", Connection = connection })
{
using (var reader = command.ExecuteReader())
{
while (reader != null && reader.Read())
{
yield return new MyDataObject
{
//extract the column values
};
}
}
}
}
}
}

Now the consumer of the data doesn't know where the data is coming from and that's just fine!

foreach(var myData in provider.MyDataObjects)
{
//do stuff with the object
}

Get Facebook user's permission

2009-11-04T14:03:00.004-05:00

In using the Facebook developer toolkit it was necessary to ask the user for extended permission to publish to their wall server side.

The FbPermissions class is initialized with the required permissions. Calling the GetPermissionFromUser will display the facebook permissions dialog.

If all permissions were granted the dialog will not be invoked next time. This prevents a momentary flash of the permissions dialog if you're using AJAX to make server requests.

<script type="text/javascript">
function FbPermissions(options){
this.requiredPermissions = options["RequiredPermissions"];
}

FbPermissions.prototype.callback = function(e, successCallback, failureCallback){
if(e === false){
  if(failureCallback != null)
   failureCallback();
}
else if(e == null || e === ""){
  if(failureCallback != null)
   failureCallback();
}
else{
  if(successCallback != null)
   successCallback();

  //Simple length check should be sufficient
  if(this.requiredPermissions.split(',').length == e.split(',').length)
   this.requiredPermissions = "";
}
}

FbPermissions.prototype.GetPermissionFromUser = function(successCallback, failureCallback)
{
var me = this;
if(this.requiredPermissions != null && this.requiredPermissions.length != 0)
  FB.Connect.showPermissionDialog(this.requiredPermissions, function(e){me.callback(e, successCallback, failureCallback);});
else
  successCallback();
}

Usage

Using the class is simple. Just initialize the FbPermissions with the required permissions using a server side script block. Then invoke the GetPermissionFromUser function with a success and failure callback method.

var permissions = new FbPermissions({RequiredPermissions : '<%= Model.RequiredFacebookPermissions %>'});

function PostToWall(message) {
   permissions.GetPermissionFromUser(
   function(){/*Call your facebook application here*/},
   function(){alert('You must grant permission');})
  }
</script>

<a href="#" onclick="PostToWall('hi'); return false;">click me</a>

Selenium RC timing issues

2009-09-15T16:07:00.004-04:00

Even the best Selenium test will fall victim to timing issues which will cause tests to fail some what randomly.

This class attempts to isolate the test from timing issues by performing an automatic retry.

public static class SeleniumRetry
{
  public static void Invoke<TArg>(Action<TArg> action, TArg arg)
  {
   Invoke(() => action.Invoke(arg));
  }

  public static void Invoke<TArg1, TArg2>(Action<TArg1, TArg2> action2, TArg1 arg1, TArg2 arg2)
  {
   Invoke(() => action2.Invoke(arg1, arg2));
  }

  public static void Invoke(Action action)
  {
   var attempt = 0;
   const int maxAttempts = 5;
   while (true)
   {
    try
    {
     action.Invoke();
     break;
    }
    catch (Exception e)
    {
     Console.WriteLine(e.Message);

     if (++attempt > maxAttempts)
      throw;

     Thread.Sleep(500);
    }
   }
  }
}

Using the class is simple:
This scenario shows how to automate a dynamically loaded login form that is created when the PopupLogon link is clicked.

SeleniumRetry.Invoke(Browser.Click, "PopupLogon");

SeleniumRetry.Invoke(Browser.Type, "input_email", "fake@email.com");
SeleniumRetry.Invoke(Browser.Type, "password", "12345");

//First click selects the button, second performs action.
SeleniumRetry.Invoke(Browser.Click, "submitBtn");
SeleniumRetry.Invoke(Browser.Click, "submitBtn");

Automatically start and stop SeleniumRC with NUnit

2009-09-10T17:04:00.003-04:00

You can use NUnit and SeleniumRC to run automated functional tests of your website. This is a simple class that starts selenium at the beginning of a unit test suite and shuts it down when done.

using System.Diagnostics;
using System.Net;
using NUnit.Framework;

[SetUpFixture]
public class SeleniumRcSetup
{
private readonly Process SeleniumRC = new Process();
[SetUp]
public void StartSelniumRc()
{
const string pathRelativeToProjBinDebug = @"path to your selenium installation";
SeleniumRC.StartInfo.FileName = "java";
SeleniumRC.StartInfo.Arguments = string.Format("-jar {0}selenium-server.jar", pathRelativeToProjBinDebug);
SeleniumRC.Start();
}
[TearDown]
public void StopSeleniumRc()
{
var r = WebRequest.Create("http://localhost:4444/selenium-server/driver/?cmd=shutDown");
r.GetResponse();
SeleniumRC.WaitForExit(5000);
SeleniumRC.Close();
}
}

Using XmlSerializer without rendering document declaration or namespace

2009-09-09T15:12:00.010-04:00

Using xmlSerializer to serialize an object will by default add the xml namespace and document declaration. <strong>Example</strong>:

<?xml version="1.0" encoding="Windows-1252"?>
<node xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" uID="12345">
...
</node>

But if all you want is to write out the xml fragment like:
<node uid="12345">
...
</node>

You need to configure the serializer before you use it. The following code will not render the document declaration or namespace.

public void SerializeWithNoDeclarationNoNamespace<T>(TextWriter writer, T theObject)
{
var settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineHandling = NewLineHandling.Replace,
NewLineChars = Environment.NewLine,
OmitXmlDeclaration = true
};

using (var xmlWriter = XmlWriter.Create(writer, settings))
{
var xmlnsEmpty = new XmlSerializerNamespaces();
xmlnsEmpty.Add("", "");

new XmlSerializer(typeof(T)).Serialize(xmlWriter, theObject, xmlnsEmpty);
}

writer.WriteLine("");
}

iTunesConnect crash reports

2009-07-31T10:45:00.005-04:00

One nice feature of iTunesConnect is that you get crash reports from real users. You can use the symbolicatecrash script to map the crash report to line numbers in your code.

symbolicatecrash attempts to be very clever at finding the symbol files based on the applicaton GUID found in the crash report. Unfortunately even if you use a revision control system, get the exact revision of the code you released to the iTunes store and re-build, symbolicatecrash wont find the debug symbols because the applications GUIDs don't match.

In a pinch you can break open the symbolicatecrash script file, brush up on your Perl skills and force it to use the symbol file created by the re-build.

But for all future releases you can just have Hudson archive the debug symbol files for you and life will be much easier.

zip -r -T -y "myApp_ProdSymbols.zip" "myApp.app.dSYM"

iPhone app distribution made easy - Part 4

2009-07-17T16:52:00.017-04:00

Introducing Subversion
One of the most important items for any kind of software development is a version/revision control system. There are many flavors of version control systems and many arguments for and against each one. Ultimately they all provide the ability to track changes in code over time and provide the ability to manage development paths. For the purpose of this post I'll be referencing SubVersion (http://subversion.tigris.org/).

Introducing Hudson
Hudson is a continuous integration build system that enables easy tracking and running of builds. Hudson can be downloaded from https://hudson.dev.java.net/ and is very easy to get started and can be run on the Mac with the following command "java -jar hudson.war".

Hudson is integrated with subversion so builds can be triggered by subversion code commits. Builds can also be launched manually. One of the great strengths of Hudson is that it manages all the build numbers and build artifacts for you so you don't have to think about it.

Basic steps
The steps to get Hudson building your iPhone applications are quite simple and follows the format:

Create a new hudson job

Point Hudson to your subversion repository

Create a build step to run the build scripts developed earlier in Part 2 and Part 3.

Instruct Hudson to save the build output.

Example Build step
The following build step starts by creating some variables for build folders etc using some of Hudson's built in environment variables. It then builds the AppStore and AdHoc distributions.

PROJDIR=${WORKSPACE}/myApp
ADHOC_BUILDDIR="${PROJDIR}/build/myAppAdHoc/DistributionAdHoc-iphoneos"
APPSTORE_BUILDDIR="${PROJDIR}/build/myAppAppStore/DistributionAppStore-iphoneos"
BASEFILENAME="${JOB_NAME}_${BUILD_NUMBER}(rev-${SVN_REVISION})"

echo Building AppStore release
cd "${PROJDIR}"
xcodebuild -target "myAppAppStore" -configuration "DistributionAppStore" -sdk iphoneos2.1
cd "${APPSTORE_BUILDDIR}"
zip -r -T -y "${BASEFILENAME}_AppStoreApp.zip" "myApp.app"

echo Building AdHoc release
cd "${PROJDIR}"
xcodebuild -target "myAppAdHoc" -configuration "DistributionAdHoc" -sdk iphoneos2.1
cd "${ADHOC_BUILDDIR}"
zip -r -T -y "${BASEFILENAME}_AdHocApp.zip" "myApp.app"

The output zip file name will include the build number & subversion revision number for easy reference.

Example: myApp_13(rev-99619)_ProdApp.zip

Example artifacts archive
Hudson has the ability to perform wild card searches when looking for build artifacts. The following will search both the AdHoc and AppStore build folders for their output files.

myApp/build/**/*.zip

Conclusion
So hopefully you are now inspired or atleast aware of how you can make your own iPhone development easier.

iPhone app distribution made easy - Part 3

2009-07-17T16:38:00.004-04:00

Now that we've built the distributions with xcodebuild it seems a shame to use Finder to compress the app bundle for submission to the App Store.

So lets use the "zip" command line utility to compress the app bundle:

zip -r -T -y "myApp_AppStoreDistribution.zip" "myApp.app"

The important option to note here is the "-y" option that stores symbolic links as the link. This is important because the app bundle contains symbolic links to the code signature folder.

If the symbolic links don't exist the application will not be accepted and iTunesConnect will complain with an error like:

The binary you uploaded was invalid. The signature was invalid, or it was not signed with an Apple submission certificate...

Now all that is left for us to do is formalize the build process and we're good to go. Next time I'll introduce the continuous integration engine called Hudson.

iPhone app distribution made easy - Part 2

2009-07-17T16:26:00.007-04:00

Being able to build various distributions in the XCode IDE is great but you have to think about what you're doing very carefully. Thankfully the 3.0 version of the SDK comes with an improved command line build utility called "xcodebuild".

Here's an example of how to build the AppStore distribution:

xcodebuild -target "myAppAppStore" -configuration "DistributionAppStore" -sdk iphoneos2.1

As you'll notice the target, configuration and the sdk to use are being specified. Note: The sdk option is new for the 3.0 sdk and can take either the name or path of the sdk to use.

You can view all of the installed sdks by running the following command:

xcodebuild -showsdks

So now we have the ability to build the distributions without thinking about it. We could put this in a script and call it a day but lets not stop there. Next time we'll zip up the app bundle for submission to the AppStore or AdHoc users.

iPhone app distribution made easy - Part 1

2009-07-17T09:40:00.003-04:00

This is the first in a multi part series that will explore one approach to making iPhone app distribution a single click operation. The purpose is to take the thought out of generating a distribution and leave you free to concentrate on the real work. There are some prerequisites that I'll assume you have completed:

Registered for the iPhone developer program.
Created you unique AppID.
Requested your code signing certificate.
Created your distribution profiles for iTunes store and AdHoc.
Installed these items on your development machine.

Armed with these items we'll begin by setting up the project.

Creating distribution configurations

Using the "project info" window's "configurations" tab duplicate the Release configuration twice. I named the two configurations "DistributionAdHoc" and "DistributionAppStore" but you're free to come up with your own convention.

The next step is to assign the "code signing identity" to the corresponding distribution profile. Do this in the "build" tab.

Creating the AdHoc target

The only difference with the AdHoc target is that it has the iTunesArtwork file so that iTunes will display the application icon. The application icon for the iTunes for the AppStore distribution will actually come from the iTunes store.

Create a new target by selecting the projects current target and duplicate it. Rename the target to something that indicates that its the AdHoc target. Add the iTunesArtwork file to the "Copy Bundle Resources" step of the target.

Note: The iTunesArtWork file is a 512x512 png file with no extension in the root of the app bundle.

One step closer

So now you should be able to select the Target, Configuration and SDK and build your specific distribution.

Next time we'll use the command line build utility xcodebuild to take the thought out of building.

Giving back

2009-07-16T19:46:00.000-04:00

Apart from some rather niche forums (XP Embedded for example, don't know what XPE is? I did say niche) I'll admit to taking a lot of knowledge but rarely giving anything back.

I hope to rectify this by sharing tips and tricks that I've learned along the way.