Interesting Stuff for June 2016


To find which version of Windows you are running, enter the following commands in the Command Prompt or Powershell:

wmic os get caption
wmic os get osarchitecture
  • Web Development:
  • svg-sprite –  a low-level Node.js module that takes a bunch of SVG files, optimizes them and bakes them into SVG sprites
  • Grumpicon – The tool processes a set of SVG files, generates PNG fallback images for legacy browsers, and exports a demo page showing how to use the final icons.
  • svgo – SVG Optimizer is a Nodejs-based tool for optimizing SVG vector graphics files.
  • Android Development
  • jsonschema2pojo – Generate Plain Old Java Objects from JSON or JSON-Schema.
  • Android Design Time Layout, display values in the designer, but not included in the build.
  • Android Studio Project Site





CVS to Git Migration

I have recently been migrating our old CVS repository over to Git so we can finally eliminate any need to see CVS ever again.  To do this I am using cvs2git which I downloaded directly from …. and installed.

Since the CVS repository is on and old Linux machine and the Git Repository is running on a new Windows Server 2012 instance I used a directory share on the Linux box to allow the Windows box to see the export files and wrote these two batch files, cvsx (CVS Export) and loadGit:


Export the CVS repository using cvs2svn to a blobfile and a dumpfile needed to import in to GIT.  I did find that the “–fallback-encoding=utf_8” was required as well.

This takes one argument which is the project name in our local CVS repository.

cd ~/cvs2svn-2.4.0
mkdir /home/huffman/GIT_Import/$1
./cvs2git -v --fallback-encoding=utf_8 --blobfile=/home/huffman/GIT_Import/$1/git-blob.dat --dumpfile=/home/huffman/GIT_Import/$1/git-dump.dat --username=huffman /cvsroot/$1


The loadGit is a simple batch file that creates a new Git repository and loads the blobfile and dumpfile data to populate the repository.  The batch file is run from the GIT repository home and relies on mapping the Z: drive to the linux network folder.

It also takes one argument which is the project name which will also be the repository name:

git init --bare %1.git
pushd %1.git
if EXIST git-marks.dat (
 del git-marks.dat
git fast-import --export-marks=git-marks.dat < Z:\%1\git-blob.dat
git fast-import --import-marks=git-marks.dat < Z:\%1\git-dump.dat

With these scripts I was easily able to migrate the repositories and put an end to CVS for our group.


CVS to GIT Migration: Invalid Change Text

While migrating one of our CVS repositories, I got the following error:

ERROR: The command 'cvs -Q -R -f -d :local:/cvsroot co -r1.1.2.1 -p -kb snapRETAIL_Archive/Server/Db/scripts/Programmability/Functions/FN_GetBinType.sql' failed with exit status=1
and the following output:
cvs checkout: Dropping data: pos>vec->text.nlines
cvs [checkout aborted]: invalid change text in /cvsroot/snapRETAIL_Archive/Server/Db/scripts/Programmability/Functions/FN_GetBinType.sql,v

After some detective work, I determined that the problem was an improperly formatted CVS(RCS) file with the following format:


@file FN_GetBinType.sql was initially added on branch Branch_1_1_0_4.
@*** empty log message ***
@d1 1
a1 29

What is happening is the 1.1 version of the code has been created with an empty file.  Then the version is attempting to update that revision by deleting one line of text and then adding the following 29 lines of new text.  However, since the 1.1 version didn’t actually have any lines of text this operation fails.  I’m not sure how this was caused, but I do recall similar issues when a file is added to a branch that is not on the main development line.

The simple solution in this case was changing the original text to be a single line.


I did try removing the deleted text, but this caused the same error.  Presumably the update expects existing text.

Jenkins – Create a Windows Visual Studio Project

This is a walk through of the configuration for the Jenkins Build for the Zebra Commerce Project.  As a prerequisite, the Jenkins server should already be installed and ready to build, refer to Jenkins – Windows Setup.

The Zebra Commerce build will perform the following tasks:

  • Monitor the Git repository for and changes (every 15 minutes)
  • Clone the Zebra Commerce Git Respository
  • Clean the Workspace to ensure a clean build
  • Run the Zebra Commerce Build script with the -NGIT flag (since Git is handled by the Jenkins Script)
  • Install the CoreFull version of ZebraCommerce to the local server
  • Create the Zebra Commerce Database for the Build
  • Import the Engineering Data Set

This configuration will create a full installation of the build that can then be used by the development team for testing.

Getting Started

The first step to creating a new build configuration is to create the project.  If this is the first project, simply select “create new jobs” to create the first project.  Otherwise, select “New Item”.

Next you will enter the Project Name and type of a project.  In this case it will be a “FreeStyle project” which is the standard to start from.


A form is then displayed that allows you to configure all of the details of the project, starting with a description of the project. JenkinsZC_1a_ProjectNameAndDescription

Source Code Management

For this project, we are using Git for our SCM and will be monitoring the repository every 15 minutes for any changes.  If there is a change, we will automatically begin a new build.

In the Source Code Management section of the Project Configuration form, select Git for the type of SCM.  If Git is not an available option, the Git Plugin has not been installed, you will need to go back to the plug-in manager and add it.

When adding git you need to add the repository URL and the Credentials.


By default Jenkins runs as the Local System Account so you can add the private key there, but I think a cleaner solution is to add the key directly through Jenkins.

JenkinsZC_1b_AddGitCredentialsNext we set up a few additional behaviors:

  • Set clone timeout to 60 minutes.  We do this because Zebra Commerce is a very large project and will time out at the 10 minute default.
  • Clean before checkout, so we always have a clean repository and don’t accidentally distribute objects from another build (we actually do this again later due to a bug in git).
  • Create a  new tag in the repository for each build.


Unfortunately the version of git that I am using has a problem with properly cleaning the repository, it does fails to delete a directory which has files that also need to be deleted, so we need to do an extra git clean.  To do, use the pre-scm-buildstep plugin to add an additional build step under the build section, “Add build step” and select “Execute Windows batch command”.  Add the command “git clean -fdx”.


By default, the project workspace is located in the Program Files, this is a bit hidden and also causes problems with long file names.  To move it change the directory in the Advanced Project Options.

JenkinsZC_1i_MoveBuildRepositoryWe then set the build triggers, in this case it will poll Git every 15 seconds to look for changes to the repository and will invoke a build if one occurs.

The SCM configuration is complete, so now is a good time to run a test build and ensure that it is working thus far.  Select Build Now and the build will begin.JenkinsZC_1g_TestBuildSCMOnly

You can also view the console output of the build while it is progressing but either the menu for the striped building indicator or selecting console output on the menu for the build on the status page.JenkinsZC_1h_TestBuildSCMOnlyRunning

Run the Build

Now we setup the actual steps for the build.  In the case of ZebraCommerce this will be running a Perl script in the build directory.  This is done with the an “Execute Windows batch command” under the Build section.

One thing to be careful of is the path when running as Local System User, you may want to set it here as well, e.g. “set Path=%PATH%;c:\windows\system32;C:\Windows\Microsoft.NET\Framework\v3.5”


Install the Build

Once the build is successful, we now automatically install the software in to a test environment.  This consists of:

  • Installing the Full version of the application
  • Restart the Data Import Services
  • Create the Database
  • Import the Test Data

This is accomplished by creating another “Execute Windows batch command” under the build section with all of the tasks.


Archiving Artifacts

Finally, once the build is successfully completed and the application is installed, we need to archive an artifacts that we want to maintain long-term.  The way Jenkins works is that there is a work space that is used to create each build and there is also a separate area for those artifacts to keep longer term.  These artifacts are available for download from the Jenkins web interface.

In this case we will keep the installation files for the application which Zebra Commerce places in the bin directory, during the build.  This is created in the “Post-build Actions” section with the “Archive the artifacts option’.  In this case the bin directory does not yet exist, so we receive a warning, but once the build is completed it will work.


Jenkins Windows Setup

I’m in the process of setting up a Jenkins Build Server for my teams Window projects.  It will be hosted internally on a Windows Server 2012 Virtual Machine and provide continuous integration, deployment, and testing for our team.

Now that the server is ready, the first step is to download Jenkins for Windows.  This is conveniently available on the Jenkins home page.


The download contains a setup.exe and jenkins.msi files which provide a very painless installation process.  Simply run the setup.exe and the setup wizard will begin.


Select Next to begin the setup.Jenkins_Install2_Destination_Folder

Select your installation directory, and then the Next button.


Now select the Install button and the installation will begin.  After a minute, the Jenkins setup will be completed.


Now that the installation is finished, select the Finish button and Jenkins will be ready to begin.Jenkins_Install6_Initial_Page

Adding Plugins

Jenkins has an extensive set of plugins to provide tools for all types of integration and configuration.  For this installation we will need support for the Git Plugin and the pre-scm-buildstep plugins.

ImageMagick – Update the Icon on a Directory of Screenshoots

Recently our company has update their logo which means that all of the screenshots of our application that we have recently done, need to be updated.  So our choice was to re-cut all the screen shots or do modified all of the screen shots.   Of course we chose to convert them all with ImageMagick.  While we were at it, we might as well crop all the images.

The goal – Convert images like this:


To images like this:NewLogoLogin

The Process:

  1. Take one new screen rip, and extract the new logo:
    convert -crop 32x32+9+51 +repage NewLogoLogin.png NewLogo.png


  2. Overlay the new image on each screen shot in the directory, and place it in to a new directory.
    mkdir new
    for %a in (*.png) DO composite -geometry +9+51 %a new\%a


  3. Crop the new images and place the in a final directory.
    mkdir final
    for %a in (*.png) DO convert -crop 320x320+8+50 %a final\%a




Interesting Stuff for November 2015



  • Why Scala? … by a hilarious Indian guy




  • Windows Sysinternals – PsTools:
    • PsExec – execute processes remotely
    • PsFile – shows files opened remotely
    • PsGetSid – display the SID of a computer or a user
    • PsInfo – list information about a system
    • PsPing – measure network performance
    • PsKill – kill processes by name or process ID
    • PsList – list detailed information about processes
    • PsLoggedOn – see who’s logged on locally and via resource sharing (full source is included)
    • PsLogList – dump event log records
    • PsPasswd – changes account passwords
    • PsService – view and control services
    • PsShutdown – shuts down and optionally reboots a computer
    • PsSuspend – suspends processes
    • PsUptime – shows you how long a system has been running since its last reboot (PsUptime’s functionality has been incorporated into PsInfo)
    • Running as the “Local System Account” for testing service account access:
      PsExec -i -s cmd.exe

Interesting Stuff for October 2015

A list of random interesting things I’ve seen over the last month or so.

Image Processing:


  • Dependency Walker ( Provides a utility to determine the dependencies of a Microsoft module.  Also distributed in older Microsoft VS.
  • The windows “where” command works like the Unix “which” command to find the path of an executable name.
  • Run multiple commands from a cmd shell (





Jenkins, formerly known as Hudson, is an extensible open source continuous integration server that simplifies the process between development and deployment.

I am installing it for our Windows development environment running Git, MSBuild and perl scripts to do the build.  Here are some things that helped getting it working.