With so many tools available today to support continuous integration and deployment automation, why choose batch files? Why not—at the very least—leverage PowerShell? It all boils down to simplicity. Batch files are easily understood because there is an incredibly low barrier to entry. There are no external dependencies to bundle in because all necessary tools have been built into Windows/DOS for 20+ years; this pedigree means that most technology workers have at least a rudimentary understanding of the language or can pick it up quickly.

Dedicated tools like Apache Ant exist, but they largely focus on traditional code deployments, such as .NET, PHP, Python, etc.  However, database code tends to be an entirely different beast. Traditional code is generally self-contained into a series of scripts or binaries and can be replaced in whole; however, in database land some objects (such as tables!) need special logic to ensure the integrity of the data. Most items, such as views and stored procedures can be handled with a simple IF EXISTS / DROP/ CREATE replacement structure. With tables, we want to check IF [NOT] EXISTS / ALTER. Additionally, DBAs generally approach changes with a “least required” attitude. Only make changes which are absolutely necessary. To that end, some diligence is required on the part of the developer to ensure code is re-runable. I suggest a “three times” rule. All proposed changes should be evaluated after one, two, and three deployments to help ensure no unintended side effects crop up. To fix bugs, it’s best to contain changes in a single file per object or logical data change. This may vary by project.

The Code

That’s the theory. Here’s the substance [zip download] supporting automated database deployments with batch files:

• ReleaseName folder
  • Utilities (such as ascmd)
  • _Utility.bat file which controls deployment flow
  • Environment-specific variable batch files (i.e. DEV.bat, QA.bat, PROD.bat)
  • IssueNumber folder
    • _Installer.bat (Containing the installation instructions)
    • Supporting files (such as SupportingScript.sql and Supporting Package.dtsx)

Deploy an issue by calling the environment batch file with issue folder as first parameter. For example:
DEV.bat “C:\Issues\IssueNum1″ or PROD.bat “C:\Issues\IssueNum7″. Alternatively, drag & drop the issue folder on to the target environment. This approach allows you to string together large deployments by putting all the environment calls in a wrapper batch file. Also, give you the flexibility of deploying issues to multiple environments quickly (i.e. TEST and QA).

Advantages

• Streamlining (automating!) deployment by removing manual intervention and avoiding code duplication
• Issue-specific _Installer.bat requires no scaffolding—which means nothing to forget
• Environment parameters file requires only a single callout. If this is forgotten, there are no unexpected side-effects—the installation simply won’t run
• Deployment engineers can validate target issue & environment before continuing and can observe output for validation
• Working up the correct command-line syntax can be difficult
  • Mitigate by providing pre-defined examples
  • Could evaluate using helper functions to streamline
  • Passing variables to sqlcmd on the command line looks messy
  • Using sqlcmd variable substitution in scripts makes them unusable when run standalone
    • Mitigate by assigning value to variable in script header, making it easy to locate and change when running standalone
    • Can’t always easily do, i.e. specifying @command for msdbo.dbo.sp_add_jobstep. Would require re-woring script to build string in header then pass completed string to @command. Slight amount of overhead.

Drawbacks

• Working up the correct command-line syntax can be difficult
  • Mitigate by providing pre-defined examples
  • Could evaluate using helper functions to streamline
  • Passing variables to sqlcmd on the command line looks messy
• Using sqlcmd variable substitution in scripts makes them unusable when run standalone
  • Mitigate by assigning value to variable in script header, making it easy to locate and change when running standalone
  • Can’t always easily do, i.e. specifying @command for msdbo.dbo.sp_add_jobstep. Would require re-woring script to build string in header then pass completed string to @command. Slight amount of overhead.

Dear Representative,

As you’re undoubtedly aware, today many websites across the internet are taking up a “Stop SOPA” campaign in which many voluntarily refuse access to visitors to simulate the results of passing of PIPA/SOPA in its current form.

As a Software Engineer by trade, and writer & photographer in hobby, I understand and appreciate the need for copyright laws. However, as a citizen of Chicago, Illinois, United States of America, I also understand that the copyright law now represents the interests of mega-corporations instead of the common man.

Not only do I support the strikedown of SOPA-like legislation, so too do I support the reversal of the copyright extensions that companies have long lobbied for. It is with great irony that content producers who use public domain works to produce a derivative work (such as classical music in old Disney cartoons) work to battle the realization of old works entering the public domain after a sufficient length of copyright.

How better can an American contribute to the general welfare of society than contribute their intellectual property when they no longer can benefit from it? To place untenable limits on such actions is to legislate against 313 million Americans, just as passing SOPA to allow the take-down of whole internet sites without notice or due process is unfathomable.

Stop SOPA. Repeal unreasonable copyright extension.

Sincerely,

Taylor Gerring

To the extent possible under law, Taylor Gerring has waived all copyright and related or neighboring rights to Stop SOPA.
This work is published from: United States.

Dts.Variables["TheCurrentDate"].Value = DateTime.Date;

That little snippet of code will store the current date into a variable named “TheCurrentDate”. This is straightforward and there’s absolutely nothing wrong with the approach, however, there’s a simpler way to fetch this information without the need of adding a whole control flow item for such a minute amount of work. It’s brilliantly simple, only requires the creation of a variable, and can be added in about 10 seconds:

1. Create new variable with Data Type = DateTime
1. Set property EvaluateAsExpression = True
2. Set property Expression =

   DATEADD( "day", DATEDIFF( "day", (DT_DATE) "1900-01-01", @[System::StartTime]  ) , (DT_DATE) "1900-01-01" )

That’s it! The variable will contain the package start time with the time truncated, making it easier to compare dates directly. In fact, this method can be used to truncate the time portion of any DateTime Data Type. Simply replace @[System::StartTime] with another variable.

Want to know how it works? The inner DATEDIFF() function calculates the number of days since 1900. This value is supplied to the outer DATEADD() function, adding days forward from 1900, resulting in a DT_DBTIMESTAMP with the time rounded off. And we accomplished it with pure math—no messy string manipulation required! I borrowed the idea from the same expression in T-SQL: DATEADD(day, DATEDIFF(day, 0, getdate()), 0).

There’s one caveat to this: Because SSIS doesn’t have a native date-only variable type, the value technically contains the date at midnight. However, many tools—such as SQL Server—will implicitly convert to the requisite data type, making “2011-09-28 12:00:00 AM” equal to “2011-09-28″

• Attunity SSIS Oracle Connector v1.1
• After installation, you’ll need to enable the menu items in the Data Flow Source & Destination
• Create Data Flow Task
• Switch to Data Flow
• Pull the Toolbox out
• Right-click→Choose items…
• Activate the SSIS Data Flow Items tab
• Enable “Oracle Destination” and “Oracle Source”
• Oracle Instant Client Basic package
• Download and extract both 64-bit and 32-bit versions if you’re using a 64-bit OS
• Only need the 32-bit version if installing on 32-bit OS
• Installation location is up to you, but you’ll need to note it later. This tutorial assumes C:\oracle\ as the base location.
• For example, install the 64-bit package at “C:\oracle\instantclient_x64_11_2″ and the 32-bit package at “C:\oracle\instantclient_x86_11_2″

Once you have all the items installed, you’ll need to add a couple of registry keys with regedit so that the SSIS connector can find the Oracle Instant Client. Create the necessary keys and string values below where they don’t exist, updating files paths to point to where you extracted the items above (again, C:\oracle\ is assumed for this tutorial):

•  [HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE]
• New→String Value→Name = TNS_ADMIN→Value = C:\oracle\tnsnames.ora
• New→String Value→Name = ORACLE_HOME→Value
• For 64-bit OS: C:\oracle\instantclient_x64_11_2
• For 32-bit OS: C:\oracle\instantclient_x32_11_2
• [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ORACLE] (64-bit OS only)
• New→String Value→Name = TNS_ADMIN→Value = C:\oracle\tnsnames.ora
• New→String Value→Name = ORACLE_HOME→Value = C:\oracle\instantclient_x86_11_2

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ORACLE]
"TNS_ADMIN"="C:\\oracle\\tnsnames.ora"
"ORACLE_HOME"="C:\\oracle\\instantclient_x32_11_2"
 
[HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE]
"TNS_ADMIN"="C:\\oracle\\tnsnames.ora"
"ORACLE_HOME"="C:\\oracle\\instantclient_x64_11_2"

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE]
"TNS_ADMIN"="C:\\oracle\\tnsnames.ora"
"ORACLE_HOME"="C:\\oracle\\instantclient_x32_11_2"

This setup allows you the choice of either using the names defined in TNSNAMES.ORA at the location specified in the registry above OR specifying the server inline in the format of <server.name.trb:port/service>. For example: <servername.path.to.tld:1521/ORA10DEV> (without the angle brackets). That’s really it! The process is much more streamlined than it was just a short while ago. Two installations and a couple regedit tweaks and you should be all set!

What made sense for us was to be able to supply the name of a principal, a “like name” for the database, and the role that they should have. What the “like name” allows us to do is apply a permission to a series of databases based on name. For example: ideaexcursion1, ideaexcursion2, ideaexcursion3 can all be set by supplying the paramater ideaexcursion%. This increases the complexity by forcing us to use a cursor in the proc, but reduces the number of actions we need to manage.

exec dbo.pr_SetGroupPermissions
      @principal = 'domain\principalname'
    , @db_likename 'ideaexcursion%'
    , @addrole 'db_owner'

This snippet will—as you’ll soon see—give domain\principalname the db_owner role in any databases that match LIKE ideaexcursion%. Here’s the magic behind the stored procedure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

create proc dbo.pr_SetGroupPermissions @principal sysname, @db_likename sysname, @addrole sysname, @printonly bit = 0
as
declare
          @database sysname
        , @cmd nvarchar(max)
 
declare csr_dbname cursor for
select name from sys.databases where state = 0 and name like @db_likename
 
open csr_dbname
 
fetch next from csr_dbname
into @database
 
while @@fetch_status = 0
begin
 
        set @cmd = '
USE '+quotename(@database)+'
 
IF EXISTS (SELECT * FROM sys.server_principals WHERE name = N'''+@principal+''')
BEGIN
        IF NOT EXISTS (SELECT * FROM sys.database_principals WHERE name = N'''+@principal+''')
                CREATE USER '+quotename(@principal)+' FOR LOGIN '+quotename(@principal)+'
        ELSE
                ALTER USER '+quotename(@principal)+' WITH LOGIN = '+quotename(@principal)+'
 
        EXEC dbo.sp_addrolemember N'''+@addrole+''', N'''+@principal+'''
END
'
 
        print @cmd
        if @printonly = 0
                exec(@cmd)
 
        fetch next from csr_dbname
        into @database
 
end
 
close csr_dbname
deallocate csr_dbname

And here’s a few notes on what the code does:

• Line 1: Parameter declaration. Notice that there is an optional @printonly param if you’d like to see the resulting code, but not execute it
• Line 7-8: Set up the cursor. On line 8 is the trick that allows us to use a “like name” to simplify the rules. Also, note that we check for “state = 0″ in the predicate, which corresponds to those with a state of ONLINE. If we didn’t check this, we would potentially attempt to execute commands against databases in RESTORING, RECOVERING, RECOVERY_PENDING, SUSPECT, EMERGENCY, or OFFLINE states
• Line 18-30: The main code which will be evaluated and executed. There are several parts to it to accommodate a variety of situations:
  • Line 19: Switch context to the correct database, since we’re executing within the confides of dynamic SQL. Also, the name is qualified with quotename(), which means that it should not be qualified when being passed in
  • Line 21: Validate that the user or group exists, otherwise we will get an error when trying to set it. Since we’re concerning ourselves with permission to a database, and not an instance, we don’t bother creating a user if it doesn’t exist. This is probably smart from a security perspective
  • Line 23-24: Check if the principal exists within the specific database. If not, create the user
  • Line 26: If the user already exists, fix any mismatched SIDswith ALTER USER. This is the preferred way to fix mismatched a mismatched SIDwhich was previously handled by sp_change_users_login, which has since been deprecated
  • Line 28: Assume database login is not valid and add the user or group to the specified role
• Line 32:  Always print the commands to be executed
• Line 33-34: Execute the code, unless the @printonly parameter has been specified

There you have it. A proc that grants specific roles to a principal across your entire database instance.

select db_name() [database_name]
        , dbpm.name, dbpm.type_desc, dbpm.create_date, dbpm.modify_date
        , dbpr.name, dbpr.type_desc
from sys.database_role_members dbrm
left join sys.database_principals dbpm
        on dbrm.member_principal_id = dbpm.principal_id
left join sys.database_principals dbpr
        on dbrm.role_principal_id = dbpr.principal_id
order by
        dbpm.name, dbpr.name

This is handily fantastic and works well when you’re just managing access to a single database. What about if you want to audit logins for the entirety of the database instance? Unfortunately, we have to rely on database cursors to build a query and execute it. The concept is easy, but the details can be a little tricky to manage. Here’s what I came up with:

declare @cmd nvarchar(max) = '', @dbname sysname
 
declare csr_dbname cursor for
select quotename(name) from sys.databases where state = 0
 
open csr_dbname
 
fetch next from csr_dbname
into @dbname
 
while @@fetch_status = 0
begin
        set @cmd = @cmd + '
select '''+@dbname+''' [database_name]
, dbpm.name [principal_name], dbpm.type_desc [principal_type], dbpm.create_date [principal_create], dbpm.modify_date [principal_modify]
, dbpr.name [role_name], dbpr.type_desc [role_type]
from '+@dbname+'.sys.database_role_members dbrm
left join '+@dbname+'.sys.database_principals dbpm
        on dbrm.member_principal_id = dbpm.principal_id
left join '+@dbname+'.sys.database_principals dbpr
        on dbrm.role_principal_id = dbpr.principal_id
        union all
        '
 
        fetch next from csr_dbname
        into @dbname
 
end
 
close csr_dbname
deallocate csr_dbname
 
set @cmd = left(@cmd, len(@cmd) - 12)
 
exec(@cmd)

There are a couple hacky things in this solution that could be factored out, but I’m keeping it simple. Here’s the walkthrough:

• Line 1: Declare and initialize necessary variables. Note that we’re combining declaration and initialization in a single step. If you’re not using SQL Server 2008, you’ll have to separate the initialization with a distinct “set @cmd = ”” command
• Line 3-4: Declare the query which defines the cursor. On line 4, we limit state = 0, because otherwise we might get databases in restoring or offline mode. Additionally, QUOTENAME() is used to ensure the input is sanitized for string concatenation. If you wanted to limit the scope of your databases, do it here.
• Line 6-12: Standard cursor setup
• Line 13-23: Build the query we’ll eventually use to scan all databases. We inject the database name from the cursor into the query to three-part qualify it, effectively neutralizing the current database context. Also, there’s a “union all” at the end that we’ll need to take care of later on
• Line 25-31: Standard cursor tear-down
• Line 33: Chuck the last “union all” from the query, lest it be dangling and we receive a parse error. If we were targeting re-usability, it would be smart to put the “union all” in a separate variable, rather than calculating the length of a literal
• Line 35: Execute the  query. We could optionally print the results here, but they’re typically longer than what Management Studio will display before truncating

It’s all quite simple and easy to toss into a stored procedure if you want to audit on a regular basis. Setting up a SQL Server Agent job to run monthly and return the results in an email would be straightforward enough. One of the issues I ran into and did not address was the sorting, which you may have noticed is absent in the extended script. This could be rectified by using “exec insert” notation, thought the results aren’t always dependable.

First, let’s take a trip down memory lane to the first three versions of the iPhone. Some of the loudest clamor from users rang to the tune of “WE WANT MULTITASKING!” As is typical Apple fashion, they didn’t bother hacking together some barely passable solution, botching the wonderful user experience they’ve cultured. Instead, they told users that it’ll be ready “when it’s ready”.

Copy & Paste is a superb example of this rhetoric. Since introduction of the first iPhone, everyone knew this functionality would eventually arrive on iPhone OS (the name of the operating system before being renamed to iOS). The outstanding questions were “When?” and “How?” In the end, most would agree that the current implementation is both effective and elegant.

If we look back to the introduction of multitasking in iOS 4, it was again on Apple’s terms. Instead of allowing applications to run wild in the background, they were able to multitask in specific, approved ways. Touted as the simplest option to implement, one of those approved methods for achieving multitask-awareness was app suspend/resume.

Suspend/Resume

The concept of suspend/resume is quite prevalent today. Probably the most obvious example is the low power “sleep” mode that most modern laptops support. Desktops typically support this mode as well, though users are probably less cognizant of it.

As mentioned above, iOS introduced a similar suspend/resume capability, but at an application level. Assuming the application is interrupted — whether it is user or system driven — it can smartly store the current state, allowing the user to bring the application back to focus and continue precisely where they left off. There is no need for the application to completely reload; instead, it can rotate into view and instantly resume.

To this end, I initially micro-managed open applications on the iPhone 4, but I soon realized that resistance was futile. Even if I restarted the phone, recently-used applications were still listed in the multitask springboard. It’s like a “Recent Documents” list where the latest few items were already cached and available for immediate use. Brilliant.

As part of the recent “Back to the Mac” announcement in October 2010, a preview of OS X 10.7, codenamed Lion was presented. The entire lead-up to the demo explained how mobile features of iOS were eventually making their way back into the rest of the Mac ecosystem. One of these features highlighted was application resuming.

Interestingly enough, after hyper-analysis it was noted the dock no longer exhibits markers to indicate which applications are active. I suspect this was intentional. Just as users of multitasking-capable iOS devices need not think about application management, nor should OS X users.

The interesting piece of the current iOS puzzle is that it never requires the user to manage what is running, nor would they care. If memory is exhausted, the application silently quits. During the next launch, it may take a few additional seconds to reload from a cold start, but users are hardly aware of this. I give credit for this to…

Flash memory/Solid State Disks

Just as we can hibernate a computer and commit the contents of RAM to disk, so could we with individual applications. And because SSD’s are clearly destined to replace mechanical drives in the consumer space, we need not worry about load times as has historically been the case.

Take a look at the latest MacBook Air. A full cold boot has gone from several minutes to mere seconds. That kind of improvement is astounding. Apple took this approach a step further (or actually, a step back depending on how you view the situation) and created a new state between hibernate and sleep where the computer “slumbers” in just a couple seconds and returns from this state in the same amount of time. Furthermore, the laptop can hold this state for up to 30 days. If an entire OS can but brought in and out of such a deep state of rest, what kind of performance can we expect to see from a similar feature on a per-application basis?

Let’s say you’re working on a presentation in Keynote. You decided to load Photoshop to edit an image you want included in the slideshow. Would anyone care if the state of Keynote was swapped/paged out of RAM? In days of yore with slow 5400RPM hard drives, perhaps. In modern times, where SSD‘s easily read above 100 MB/sec, probably not.

Limitations

Don’t misunderstand, this prospect isn’t for everyone. I don’t expect 12-core Mac Pros loaded with 32GB of RAM to take advantage of this feature. No, this is not a feature that will permeate throughout the entire Mac ecosystem. Instead, it’s a feature for the masses. There’s a reason why the Fall 2010 refresh of the MacBook Air came only in 2GB and 4GB configurations. It’s for those of us that want an iPad-like experience for light content creation.

It means less emphasis on hardware. It means less dependence on application management. It means less user confusion. OS X 10.7 is destined to make productivity a “set & forget” affair. And I welcome our new Lion overlords.

static void MapContainerTest(Args _args)
{
    Map                     custNotesMap;
    Container               custContainer;
    CustTable               custTable;
    SalesSourceSystemId     admarcSystemId = "DPRADM";
    Container               conCustDetails;
    str                     admarcAccountId = "000123456";
    ;
 
    custNotesMap = new Map(Types::String, Types::Container);
    while select AdmarcAccountId, RecId, TableId, dataAreaId, PartyId from custTable where custTable.AdmarcSystemId == admarcSystemId
    {
        custContainer = conNull();
        custContainer = [custTable.RecId, custTable.TableId, custTable.dataAreaId, custTable.PartyId];
 
        custNotesMap.insert(custTable.AdmarcAccountId, custContainer);
    }
 
    if (custNotesMap.exists(admarcAccountId))
        conCustDetails = custNotesMap.lookup(admarcAccountId);
    else
        error("Customer not found.");
 
    info(strfmt("RecId: %1", conpeek(conCustDetails, 1)));
    info(strfmt("TableId: %1", conpeek(conCustDetails, 2)));
    info(strfmt("dataAreaId: %1", conpeek(conCustDetails, 3)));
    info(strfmt("PartyId: %1", conpeek(conCustDetails, 4)));
}

In fact, it’s pretty fast and I’m using similar caching technique all over the place to speed up large jobs.

Guest Additions

Probably the most common need is to install guest additions. Because the virtual machines are running in headless mode, there’s no menu to easily select “Install Guest Additions”. However, this option merely automates the mounting of an ISO. We can replicate this functionality from the command line. Note that the path to the ISO may vary depending on your host environment.

#run this on your host
VBoxManage storageattach "LAMP1" --storagectl "IDEController" --port 1 --device 0 --type dvddrive --medium /usr/share/virtualbox/VBoxGuestAdditions.iso
#run these commands on the guest
#install packages necessary to build and install the additions
sudo apt-get install build-essential linux-headers-`uname -r`
#run the Guest Addtions installation and reboot
sudo mount /media/cdrom
sudo /media/cdrom/VBoxLinuxAdditions-x86.run

If you’d like to mount another disc, you’ll need to eject the ISO first.

#unmount the disc in the guest
sudo umount /media/cdrom
#instruct VirtualBox to emulate an empty drive
VBoxManage storageattach "LAMP1" --storagectl "IDEController" --port 0 --device 0 --type dvddrive --medium emptydrive

Shared Folders (guest additions neccessary for shared folders)

Shared folders are a common way to transfer files between guest and host. First, you’ll need to successfully install guest additions. Once done, adding is easy as following the below template. Just customize the VM name, share name and host path.

VBoxManage sharedfolder add "LAMP1" --name "dropbox" --hostpath ~/Dropbox/

Changing the MAC address

This is probably not a common need, but if you’ve got IP addressed reserved for certain devices, you’ll need to ensure the MAC address stays the same between VM setups and tear-downs. The change from auto-generated is easy.

#First, check the current MAX address
VBoxManage showvminfo "LAMP1"|grep NIC\ 1:
#Now, set the MAC address to whatever you want
VBoxManage modifyvm "LAMP1" --macaddress1 0800279859FF

USB support

I’m not sure how many people use USB support in headless mode, but if you need to mount a device directly in the guest OS, VirtualBox provides that ability. Permission settings borrowed from http://wiki.flexion.org/VirtualBox.html

#Add proper permissions to USB device
printf "none /proc/bus/usb usbfs devgid=%s,devmode=664 0 0" $(grep vboxusers /etc/group | cut -f3 -d':') | sudo tee -a /etc/fstab
VBoxManage modifyvm "LAMP1" --usb on --usbehci on

VM Management with VBoxTool

By far, the best tool I’ve used for automated VM management is VBoxTool. It’s really just a collection of scripts to automate tasks, but the killer feature is the autostart and autosave of virtual machines on boot and shutdown. While it facilitates other aspects of VM management, those two alone make it worth the trouble of configuring it.

mkdir ~/vboxtool
cd ~/vboxtool
wget "http://downloads.sourceforge.net/project/vboxtool/vboxtool/0.4/vboxtool-0.4.zip?use_mirror=kent" -O vboxtool-0.4.zip
unzip vboxtool-0.4.zip
cd script
chmod 755 vboxtool*
sudo chown root:root vboxtool*
sudo mv vboxtool /usr/local/bin
sudo mv vboxtoolinit /etc/init.d
sudo update-rc.d vboxtoolinit defaults 99 10
sudo mkdir -p /etc/vboxtool
cd /etc/vboxtool
#Configure /etc/vboxtool/machines.conf to register machines with VBoxTool
echo 'LAMP1,3391' | sudo tee -a machines.conf
#Configure /etc/vboxtool/vboxtool.conf to indicate which user that machines should start under
printf "vbox_user='%s'" $(whoami) | sudo tee -a vboxtool.conf
vboxtool autostart

If for some reason you ever decide to remove VBoxTool, you’ll need to unregister it from boot with the below command.

update-rc.d -f vboxtoolinit remove

VBoxWeb

Although the VBoxWeb project still has some rough edges and the blog isn’t updated often, it holds a lot of promise. If you’d like to check it out, use the following commands to download and install it. Full guide available on their own website.

sudo apt-get install python-simplejson subversion
svn checkout http://vboxweb.googlecode.com/svn/trunk/ vboxweb-read-only
cd vboxweb-read-only
python VBoxWebSrv.py adduser $(whoami)
#Below starts VBoxWeb in the background
python VBoxWebSrv.py &