After doing a little bit of research, I discovered that I could use Gmail to manage my contacts, which is a great solution because it integrates with iOS 4+ really well and also because it gets my contacts online.

This is optional, but if you already have contacts in your iPhone you’ll want to import them into Gmail. Unfortunately the easiest way to do this is using iTunes (after this is done if you have iOS 5+ installed you’ll only need iTunes to sync music and ringtones).

You can use iTunes to upload existing Contacts from your Apple device to Gmail. Only the following information can be uploaded:

• People’s names and job titles
• Company names
• Email and postal addresses
• Phone numbers
• IM names, including the type of service
• Notes

Other information, like custom ringtones and photos, are not uploaded. Please sync them to Outlook first.

Contact Upload Instructions

• Connect your iPhone, iPad, or iPod Touch to your computer using the USB cable.
• Open the iTunes application.
• Select your iPhone and click the Info tab.
• Check the Sync Contacts with option and select Google Contacts from the drop-down menu.
• Click Configure and enter your Google username and password.

• Press Apply to sync your device with iTunes.
• Once you’ve checked that your contacts are available on the web, disable iTunes Contacts sync with Google. If you don’t do this, you’ll see duplicate contacts on your phone.

Now that you have your iPhone contacts in Gmail, you can setup Gmail using an Exchange connection and specify that account for default contacts creation.

Getting Started

1. Open the Settings application on your device’s home screen.
2. Open Mail, Contacts, Calendars.
3. Press Add Account….
4. Select Microsoft Exchange. iOS 4.0+ allows multiple Exchange accounts. However, if you’re on a device that doesn’t let you add a second account, you could also use CalDAV to sync Google Calendar and IMAP to sync Gmail.

Enter Account Info

5. In the Email field, enter your full Google Account email address. If you use an @googlemail.com address, you may see an “Unable to verify certificate” warning when you proceed to the next step.
6. Leave the Domain field blank.
7. Enter your full Google Account email address as the Username.
8. Enter your Google Account password as the Password.

Notes about passwords:

• Be sure that you have a strong password for your Google Account.
• If you see an error message saying “Invalid Password”, you may need to unlock your account by solving a short CAPTCHA. Go to https://www.google.com/accounts/UnlockCaptcha.
• If you are a 2-step verification user, please use an application-specific password instead of your regular password in this field.

9. Tap Next at the top of your screen.
9a. Choose Cancel if the Unable to Verify Certificate dialog appears.
10. When the new Server field appears, enter m.google.com.
11. Press Next at the top of your screen again.

Enable Mail and Calendar

12. Select the Google services (Mail, Calendar, and Contacts) you want to sync. To receive and respond to meeting requests on your device, both Mail and Calendar need to be turned on, and New Invitations needs to be enabled in your Google Calendar settings.

To enable New Invitations, sign in to your Google Calendar using the web browser on your phone or computer. Go to Calendar Settings > Calendars > Click on the Notifications for the calendar you want to sync. Under Email check New Invitations (and any of the other Invitation settings you want enabled), and click Save.

13. Unless you want to delete all the existing Contacts and Calendars on your phone, select the Keep on my iPhone (or iPad or iPod touch) option when prompted. This will also allow you to keep syncing with your computer via iTunes.

If you want to sync only the My Contacts group, you must choose to Delete Existing Contacts during the Google Sync install when prompted. If you choose to keep existing contacts, it will sync the contents of the All Contacts group instead. If there are no contacts on your phone, the latter will happen — the contents of your All Contacts group will be synced.

Set Gmail as the default account for new contacts

To do this, select Settings  >  Mail, Contacts, Calendars  >  Scroll to the Contacts Section  >  Default Account  >  Change FROM On My iPhone TO (whatever you named your Gmail account).

Now, whenever you create a contact on your iPhone, it will automatically sync to Google!

If you didn’t answer something along the lines of “removes the photo from the User Account object in Active Directory”, you’re in the wrong place.

    ##--------------------------------------------------------------------------
    ##  FUNCTION.......:  Remove-ADPhoto
    ##  PURPOSE........:  Removes the picture stored in an Active Directory
    ##                    account.
    ##  REQUIREMENTS...:  PowerShell v2.0, Windows Server 2008 or newer Active
    ##                    Directory.
    ##  NOTES..........:
    ##--------------------------------------------------------------------------
    Function Remove-ADPhoto {
        <#
        .SYNOPSIS
         Removes the picture stored in an Active Directory account.
        .DESCRIPTION
         Clears the thumbnailPhoto attribute of the specified user's Active
         directory account
        .PARAMETER UserName
         The User logon name for the account the picture will be removed from.
         Alias: -un

        .EXAMPLE
         C:\PS>Remove-ADPhoto user1

         This example will clear the thumbnailPhoto attribute in Active
         Directory for the user account with the User logon name of "user1".

        .NOTES
         NAME......:  Remove-ADPhoto
         AUTHOR....:  Joe Glessner
         LAST EDIT.:  29NOV11
         CREATED...:  28NOV11
        .LINK

http://joeit.wordpress.com/

        #>

        [CmdletBinding()]
            Param (
                [Parameter(Mandatory=$True,
                    #ValueFromPipeline=$True,
                    #ValueFromPipelineByPropertyName=$True,
                    Position=0)]
                [Alias('un')]
                [String]$UserName
            )#End: Param

        ##----------------------------------------------------------------------
        ##  Search AD for the user, set the path to the user account object.
        ##----------------------------------------------------------------------
        $Searcher = New-Object DirectoryServices.DirectorySearcher([ADSI]"")
        $Searcher.Filter = "(&(ObjectClass=User)(SAMAccountName= $UserName))"
        $FoundUser = $Searcher.findOne()
        $P = $FoundUser | Select path
        Write-Verbose "Retrieving LDAP path for user $UserName ..."
        If ($FoundUser -ne $null) {
            Write-Verbose $P.Path
        }#END: If ($FoundUser -ne $null)
        Else {
            Write-Warning "User $UserName not found in this domain!"
            Write-Warning "Aborting..."
            Break;
        }#END: Else
        $User = [adsi]$P.path

        ##----------------------------------------------------------------------
        ##  Attach the picture to the AD account object (remove it if the
        ##  -remove switch is set).
        ##----------------------------------------------------------------------
        Write-Verbose "Removing photo from user account $UserName ..."
        $User.Properties["thumbnailPhoto"].Clear()
        #$User.Properties["jpegPhoto"].Clear()
        $User.CommitChanges()
        Write-Verbose "Attribute cleared!"
    }#END: Function Remove-ADPhoto

    ##--------------------------------------------------------------------------
    ##  FUNCTION.......:  Show-ADPhoto
    ##  PURPOSE........:  Shows the photo stored in in an Active Directory User
    ##                    Account.
    ##  REQUIREMENTS...:  PowerShell v2.0, Windows Server 2008 or newer Active
    ##                    Directory.
    ##  NOTES..........:
    ##--------------------------------------------------------------------------
    Function Show-ADPhoto {
        <#
        .SYNOPSIS
         Shows the photo stored in in an Active Directory User Account.
        .DESCRIPTION
         Reads the ThumbnailPhoto attribute of the specified user's Active
         Directory account, and displays the returned photo in a form window.
        .PARAMETER UserName
         The User logon name of the Active Directory user to query.

        .EXAMPLE
         C:\PS> Show-ADPhoto user1

         Displays the photo stored in the Active Directory user account with
         the User logon name of "user1".

        .NOTES
         NAME......: Show-ADPhoto
         AUTHOR....: Joe Glessner
         LAST EDIT.: 28NOV11
         CREATED...: 28NOV11
        .LINK

http://joeit.wordpress.com/

        #>
        [CmdletBinding()]
            Param (
                [Parameter(Mandatory=$True,
                    #ValueFromPipeline=$True,
                    #ValueFromPipelineByPropertyName=$True,
                    Position=0)]
                [Alias('un')]
                [String]$UserName
            )#End: Param

        ##----------------------------------------------------------------------
        ##  Search AD for the user, set the path to the user account object.
        ##----------------------------------------------------------------------
        $Searcher = New-Object DirectoryServices.DirectorySearcher([ADSI]"")
        $Searcher.Filter = "(&(ObjectClass=User)(SAMAccountName= $UserName))"
        $FoundUser = $Searcher.findOne()
        $P = $FoundUser | Select path
        Write-Verbose "Retrieving LDAP path for user $UserName ..."
        If ($FoundUser -ne $null) {
            Write-Verbose $P.Path
        }#END: If ($FoundUser -ne $null)
        Else {
            Write-Warning "User $UserName not found in this domain!"
            Write-Warning "Aborting..."
            Break;
        }#END: Else
        $User = [ADSI]$P.path

        ##----------------------------------------------------------------------
        ##  Build a form to display the image
        ##----------------------------------------------------------------------
        $Img = $User.Properties["thumbnailPhoto"].Value
        #$Img = $User.Properties["jpegPhoto"].Value
        [VOID][Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
        $Form = New-Object Windows.Forms.Form
        $Form.Text = "Image stored in AD for $UserName"
        $Form.AutoSize = "True"
        $Form.AutoSizeMode = "GrowAndShrink"
        $PictureBox = New-Object Windows.Forms.PictureBox
        $PictureBox.SizeMode = "AutoSize"
        $PictureBox.Image = $Img
        $Form.Controls.Add($PictureBox)
        $Form.Add_Shown({$Form.Activate()})
        $Form.ShowDialog()
    }#END: Function Show-ADPhoto

Well, that was a pretty good question, as I wasn’t quite sure why everyone in the company had pictures to begin with. As it turns out, I did it unintentionally.

Spiceworks (I think it was v5) introduced “People View” where you can have pictures for your users. Since I already had Spiceworks pulling user information from Active Directory, I just stored the pictures in the Active Directory User Account object (I used the thumbnailPhoto attribute which is what this function uses, though there is code in there for using the jpegPhoto attribute too if you prefer). I’m lazy like that.

The AD Schema was extended to facilitate this with Server 2008, so if you have a Server 2008 domain controller, or have extended your AD Schema in preparation for moving to Server 2008, you can now store pictures in AD User Account objects. Aaaaand shenanigans ensue in 3… 2… 1…

Well time moves on, and when I upgraded all my users to Office 2010, voila pictures in Outlook!

One of the things that came out of that whole fiasco was some (really hacked together and sloppy) PowerShell code that I used to get the pictures into Active Directory.

For whatever reason, I recently started going through my stack pile heap mountain dear god what is all this collection of PowerShell code and creating Functions out of anything that I might need to use again.

Thus I give you Add-ADPhoto:

    ##--------------------------------------------------------------------------
    ## FUNCTION.......: Add-ADPhoto
    ## PURPOSE........: Stores a picture in an Active Directory account.
    ## REQUIREMENTS...: PowerShell v2.0, Windows Server 2008 or newer Active
    ## Directory.
    ## NOTES..........:
    ##--------------------------------------------------------------------------
    Function Add-ADPhoto {
        <#
        .SYNOPSIS
         Stores a picture in an Active Directory account.
        .DESCRIPTION
         Starting with Server 2008, Microsoft has added the ability to store
         pictures in Active Directory User Accounts. To do this
         programmatically, the picture must be converted to a Byte Array, which
         this script will do for you.
         Pictures stored in Active Directory User Accounts are limited to 100KB
         in size, as defined in the AD Schema. If you are going to use this
         primarily for displaying photos in Outlook, you'll want to size the
         photos to 96x96 pixels first, as this is the exact dimentions of the
         GAL photo box in Outlook.
        .PARAMETER UserName
         The User logon name for the account the picture will be stored in.
         Alias: -un
        .PARAMETER File
         The full path and file name of the picture to be stored in the user
         account.
         Alias: -f
        .EXAMPLE
         C:\PS>Add-ADPhoto user1 c:\pic.jpg

         This example will set the jpegPhoto attribute in Active Directory for
         the user account with the User logon name of "user1" to the file
         "c:\pic.jpg".

        .NOTES
         NAME......: Add-ADPhoto
         AUTHOR....: Joe Glessner
         LAST EDIT.: 29NOV11
         CREATED...: 28NOV11
        .LINK

http://joeit.wordpress.com/

        #>

        [CmdletBinding()]
        Param (
            [Parameter(Mandatory=$True,
                #ValueFromPipeline=$True,
                #ValueFromPipelineByPropertyName=$True,
                Position=0)]
            [Alias('un')]
            [String]$UserName,
            [Parameter(Mandatory=$True,
                #ValueFromPipeline=$True,
                #ValueFromPipelineByPropertyName=$True,
                Position=1)]
            [Alias('f')]
            [String]$File
        )#End: Param

        ##----------------------------------------------------------------------
        ## Search AD for the user, set the path to the user account object.
        ##----------------------------------------------------------------------
        $Searcher = New-Object DirectoryServices.DirectorySearcher([ADSI]"")
        $Searcher.Filter = "(&(ObjectClass=User)(SAMAccountName= $UserName))"
        $FoundUser = $Searcher.findOne()
        $P = $FoundUser | Select path
        Write-Verbose "Retrieving LDAP path for user $UserName ..."
        If ($FoundUser -ne $null) {
            Write-Verbose $P.Path
        }#END: If ($FoundUser -ne $null)
        Else {
            Write-Warning "User $UserName not found in this domain!"
            Write-Warning "Aborting..."
            Break;
        }#END: Else
        $User = [adsi]$P.path
        ##----------------------------------------------------------------------
        ## Attach the picture to the AD account object.
        ##----------------------------------------------------------------------
        Write-Verbose "Byte Encoding jpg file..."
        If ($File -ne $null) {
            [Byte[]]$jpg = Get-Content $File -encoding byte
            Write-Verbose "Clearing thumbnailPhoto attribute for $UserName"
            $User.Properties["thumbnailPhoto"].Clear()
            #Write-Verbose "Clearing jpegPhoto attribute for $UserName ..."
            #$User.Properties["jpegPhoto"].Clear()
            Write-Verbose "Setting photo for $UserName to $File ..."
            $User.Properties["thumbnailPhoto"].Value = $jpg
            #$User.Properties["jpegPhoto"].Value = $jpg
            $User.SetInfo()
            Write-Verbose "Attribute set!"
        }#END: If ($File -ne $null)
        Else {
            Write-Warning "$File does not exist!"
            Write-Warning "Aborting..."
            Break;
        }#END: Else
    }#END: Function Add-ADPhoto

There are two companion functions for this, Show-ADPhoto, and Remove-ADPhoto, which will be posted separately in the very near future.

Turns out it’s a good thing I got one a couple of weeks before any of my users.

I keep my phone locked with a passcode, but with Siri enabled, that doesn’t mean the phone is secure.

There is a setting in iOS 5 phones with Siri enabled (at this point only the 4s) that allows Siri to be accessed while the phone is locked. This is a feature not a bug. With this feature enabled anyone who picks up your locked iPhone 4s can send email, text messages, make calls, even screw with your calendar. The potential for shenanigans is only limited by how well the unauthorized user knows Siri.

I was able to set an alarm for 3AM with the phone locked, so I can only imagine what someone that really knows how to use Siri could get up to.

Unfortunately Apple decided to set this to enabled by default. Apparently impressing your buddies is more important than securing your phone, even if you thought you had secured your phone by enabling a passcode lock.

Fortunately it’s a setting, so you can disable it. To do so, go to Settings>General>Passcode Lock, and turn the Siri setting to Off.

This means that you can’t use Siri when your phone is locked, but then neither can anyone else. I’m disappointed that Apple hasn’t yet made taking security seriously a priority, it would have been so easy to avoid this potentially serious security breach.

Before you can make use of a profile in PowerShell, you must enable the execution of scripts (this is disabled in PowerShell by default), by setting the Execution Policy to at least “AllSigned” (be aware that if you do this, you’ll have to be able to digitally sign your scripts before any will execute, including your profile script). You can find information on setting the PowerShell Execution Policy here.Once you have the Execution Policy set (I generally use RemoteSigned, but in a production environment, you should really be using AllSigned for maximum security), you need to set up your profile script.

PowerShell can store all kinds of useful things in the $profile variable (like aliases, functions, variables, or even extensions like snap-ins or modules), which is actually a PowerShell script that is executed when a console session is started (hence why you need to set the Execution Policy before you can make use of it). But the PowerShell Profile is not created automatically. To see if you have a PowerShell profile, open a PowerShell session, and type this command:

    test-path $profile

If it returned $true, you already have a PowerShell profile set up, if it returned $false, you do not (If you do skip to the “Editing your $profile” section below).

Creating a PowerShell Profile

If you do not already have a PowerShell Profile the first step is to create one. This can be easily done right from the PowerShell console. To create a profile script, type the following at the PowerShell console prompt:

    new-item -path $profile -itemtype file -force

This will generate the required file, and let PowerShell know that you are ready to use it.

Editing your $profile

Just having a PowerShell profile does nothing to change the way PowerShell behaves. To really make use of a PowerShell profile, you’ll need to add something to alter PowerShell’s default behavior. To edit the PowerShell profile type the following command at the PowerShell console:

    notepad $profile

This will open your $profile script for editing in NotePad. Ok, so now what do we put in there?

Really this is going to be personal preference. There are literally thousands of things you can put in a PowerShell profile script. For purposes of demonstration, we’ll set an alias. In the NotePad window that opened when we ran that last command, add this line:

    Set-Alias open 'explorer'

This creates an alias for Windows Explorer. Now save the file, and run this command at the PowerShell console:

    . $profile

This will reload your profile script (make sure there is a space between the “.” and “$profile”), and we can now make use of the alias. At the PowerShell console type the following:

    open c:\

If your $profile is working correctly, this should have opened the root of your C:\ drive in Windows Explorer. Now you can do the same thing without the $profile script directly in the console, but using the PowerShell Profile allows things you set there to persist between console sessions (you can test this by closing the PowerShell console and reopening it, the alias we just set should still work).

At my day job we recently replaced two aging plotters (a plotter is just a really big printer), with the “new hotness” plotter: the Xerox 6279. It looks nice, it’s got lots of features, but underneath it all, it’s still just an overgrown printer.

The CAD group made the decision on which plotter to buy, I only had two requirements:

• It must support Windows Server 2008 R2.
• It must be a new model (no “discontinued model” specials).

I really only care about the first requirement, but I don’t want to have the thing be obsolete (read ludicrously expensive to repair) in six months. So the Xerox rep assures our CAD group that the plotter is WS2008R2 compatible, and they buy it.

What he meant to say is that it is engineered for WS2008, but will work on WS2008R2. Since the CAD group are all on Windows 7 x64 machines, no problem getting them up and working with the new plotter. Unfortunately a couple of our Project Managers need access to the new plotter as well, and this is where things start to go awry. See our Project Managers are on Windows 7 x86 machines. And since Xerox did not write drivers for WS2008R2 (they were written for WS2008, and they even have an x64 driver), the driver does not support this correctly.

But I don’t blame Xerox for this (well not totally), I also blame Microsoft. See this should be a fairly simple operation, which goes something like this:

• On the Print Server, open Start > Administrative Tools > Print Management
• Right click the Shared printer
• Select the Sharing Tab
• Click the Additional Drivers… button
• Check the x86 checkbox
• Click the OK button

Windows will prompt you for the location of the driver, you select it, and you’re off to the races.

Not so much if you are doing this on Server 2008R2, using a driver that was not written specifically for Server 2008R2. After you point the wizard at the correct driver it asks you for ntprint.inf, but you won’t find it on WS2008R2.

Why? Because Windows needs the x86 version of the ntprint.inf file. And it doesn’t exist on Server 2008R2 (this is where I blame Microsoft).

Really Microsoft? Is it so hard to include a tiny (10KB) INF file somewhere in the OS?

So what’s the solution? Well Microsoft’s official solution is to do one of two things:

• Install the printer driver locally on one client (which should allow the print server to upload the correct driver automatically)
• Copy the ntprint.inf file from a 32 bit version of WS2008 (because everyone has one on their network amiright?) to the WS2008R2 print server.

The first option will work, but it’s not as straight forward as Microsoft would have you believe. Most of the time it doesn’t work automatically, and you have to export the driver, and then import it on the print server (which works approximately 50% of the time). Most frequently, you end up having to install the printer driver on each x86 client, because it just seems faster (if you only have one or two x86 clients, it may be initially faster to do it this way, but otherwise, or over time it’s not).

The second option is the Least Amount Of Administrative Effort, but what if you don’t have a 32 bit WS2008 install? You can also use  WS2003 (if you have one of those in 32 bit).

If you don’t have either, you can use method one, or you can install the WS2008 32 bit version trial in a VM. Seriously, this is the easiest way. I know this seems like it will take longer than installing the printer driver on the client machines, but remember you only have to do this once (as long as you keep the files we’re going to copy out of the OS) and then you use these files for any printer you’ll share from WS2008R2 with x86 clients.

Once you have a WS2008 x86 instance, navigate to C:\Windows\System32\DriverStore\FileRepository, and find a folder labeled “ntprint.inf_x86_neutral_xxxxxxxx” (the last string will be a random hex string). There may be more than one. Copy them all to a network share, or somewhere on the WS2008R2 machine.

When the WS2008R2 Print Management Additional Driver wizard asks you for the ntprint.inf file, point it to one of these folders, and it should find it in one of them.

You can now successfully install the network printer on x86 clients.

Or you could just get a bat and some friends to help you fix all your printer problems. Permanently.

Like nearly every administrator I know, I have a few scripts that I use to help me do my job easier and faster. Well ok, more than a few. Alright, alright, I have more scripts than most people have hair.

I have scripts that were written for an NT4 Alpha Cluster. I never get rid of them. I’ve lost more scripts than most people will ever have. I’ve forgotten more about most scripting languages than most people will ever know.

I find that the challenge is keeping track of them. If I could turn my computers, network storage, USB drives, and email upside down and shake them, enough scripts would fall out to fill the library of congress. Damned if I know where they’re all stored, but I know I have them.

Unfortunately, most of them are variants on the same script, or actually are the same script. Many times if I can’t find the exact script I am looking for, I’ll slap one together, do some quick testing, give it a unique name (you know something that makes it easy to know what it does, like “test74.vbs”), use it once or twice, and then forget what it was for.

Yes I’ll admit it, I have a problem. If there were an AA for scripters, I’d probably be the president of the local chapter.

Or at least I would have been before I started using Version Control software. About a month ago I was editing a script that I was having troubles with, accidentally overwrote something that broke it, and closed the editor. Not a big deal on small scripts, but this one was at about 1500 lines. It took me HOURS to figure out exactly where the code was that I’d overwritten, but I never did figure out exactly what I did that broke it (though I did get it working well enough to do what I needed it to do).

I’ve known about Version Control software for years (I worked at a software company once upon a time), I’ve even used Subversion before. I’d been meaning to set it up for myself for years, and this incident was the catalyst I needed to actually do it.

Keeping the LAOAE principle in mind, I wanted my repository to be available to me in all the places that I’d be likely to be working on a script, mostly at work and at home.

But I already have enough servers to admin, and I don’t really want to have to care for and update yet another thing on my work network, so I started looking for hosted subversion offerings. I’m not a software company, so I had to weed out the ones that wanted absurd monthly fees (and offered absurd feature sets). I just wanted hosted Subversion, I didn’t need team collaboration, or project management features. I thought about going Open Source with it (like github, or Google code) but decided that since I would be using it to also host code that belongs to my employer, it would probably be better to go with a commercial solution.

Did I mention that I didn’t really want to spend any money on this? Yeah, free is king in the land of the Sysadmin. There were several services that fit the bill, in the end I decided to use ProjectLocker. Their free offering gives you three users and 300MB of storage (even for my bloated script collection this is plenty) three Repositories, and three Projects (each project can have an unlimited number of files and folders), though for only $19/month you can move up to 15 users and 10GB of storage (full details of their offerings can be found here).

Oh and all of their plans offer both Git and Subversion, so whichever you are more comfortable with is available. I have used subversion in the past, so that’s what I chose to go with.

Now before I get any further in this post, I am going to write this with the assumption that you have at least a conceptual knowledge of how Version Control Systems (VCS) work. If you don’t and would like to, this free ebook is a great place to start (and really relevant, as it’s also the official documentation for Subversion).

Setting up a VCS for use with scripts

ProjectLocker (Subversion)

Initial setup of a ProjectLocker account is quick and easy:

1. Select your Service Level (Free is fine for me).
2. Select you term (Free is Always Free).
3. Enter a promotional code (optional).
4. Enter a Referral Source email address (if you have one, the referrer gets free storage space in small increments).
5. Click “Next Step”.
6. Agree to the Terms of Service (if you do), and select the “I am ready to setup my account” button.
7. The information on this page is pretty self explanatory, click the “Place My Order” button at the bottom when done

Save the Login URL on the resulting page! This is the URL you will use to access your repository (https://portal.projectlocker.com).

Log in to your repository and fill out the requested information (it helps keep the free offering available).

That’s pretty much it on the Subversion side, though you can set up users and additional projects if you like. Since I am using this to host my personal code, as well as code that belongs to my employer, I set up two projects: Personal_code and Work_code (I know, original right?).

Once you have a repository running, ProjectLocker will give you a URL to the repository, it’ll look something like this: https://pl3.projectlocker.com/TestCompany77/Personal_code/svn

This is what you’ll need to access the repository from a client, so write this down (bookmark it, whatever you have to do, you will need this)! (obviously use the one in your account, the one listed above won’t work for you)

I also set up a user account for the main IT email account at the office so that it has access to the Work project only. This way when or if I leave my current job, I can just hand off the login to the next person (or leave it with someone here) and they will be able to log in and access all of the scripts that are owned by the company, including being able to see all the changes I’ve made, and any comments I’ve made during the commit process.

TortiseSVN (subversion client)

So now that we have a repository, we need a subversion client. On Windows that leads us to TortiseSVN. There are others, and you are certainly welcome to use a different subversion client,  but TortiseSVN is the hands down leader of the pack for features and maturity. It’s also really easy to install and configure.

TortiseSVN is a command line interface to subversion, but it integrates with the Windows Shell. This means that there is no “program” window to access for settings and such, you access everything via context menus (right click).

Once you have it installed on a Windows computer, you’ll need to link it to your Repository. The easiest way I’ve found to do this is to use the TortiseSVN Repo-browser (you’ll want to get familiar with this tool anyway, as it is installed with TortiseSVN by default and you can use it to… well browse your repository).

Just right click on any file or folder, highlight the TortiseSVN entry, and select Repo-browser from the resulting menu:

In the Repo-browser window enter the URL for your subversion repository and click the OK button:

When the Repo-browser attempts to connect to your repository, it will ask you for a username and password, and if you want to store that credential in a file on your computer (that’s up to you):

Once you have entered the credentials, it will show you the contents of your repository:

Now TortiseSVN is ready to use! The Repo-browser interface is fully drag and drop, so you can just drop your script files and folders on the right pane, and it will upload them to subversion. You’ll need to enter a commit message, and once the upload completes, you have your first version of your files in subversion.

NotePad++ (text editor)

Now all we need is an editor that can make use of this, and we’re in luck. Perennial favorite NotePad++ has an extension for TortiseSVN. First, you’ll need to install NotePad++ (or open up the portable version on your USB drive). Once you have NotePad++ open, Select the Plugin Manager from the Plugins menu as shown here:

One of the reasons that I’ve been such a big fan of NotePad++ is it’s extensive selection of available plugins. In the Plugin Manager, just select the Tortise SVN plugin and click Install as shown in the image below.

This plugin requires two supporting plugins, which will automatically be selected for install, as shown here:

Once the installation is complete, NotePad++ will need to be restarted (it will tell you this and prompt you for the restart of the program). After NotePad++ is restarted, we are ready to start actually using our version control system!

If you’ve never used a VCS before, you’ll need to understand the concept of Working Sets and the Checkin/Checkout relationship. These topics are far outside the scope of this post, but if you are new to this, I’d really suggest reading the official Subversion documentation (or at least skimming it). You can find the official Subversion book here.

In order to work on any files stored in the repository, we first need to create a local copy of the repository, or a “Working Set”:

1. Create a folder where you want to store your Working Set. You can name it anything but “svn”, as this name is reserved for use by TortiseSVN. I usually choose something like C:\SOURCE, so it’s easy to remember.
2. Right click on the folder you just created and choose SVN Checkout from the context menu.

At this point, TortiseSVN is going to prompt you for some information about how you want the Working Set created, in the form of this window:

The only thing you really need to be concerned with here is the Revision section. You only want to change this if you don’t want the latest revision of the files in your repository (which is what HEAD revision means). If you need an earlier revision, select the Revision radio button, and then use the Show Log button at the right to search for the desired revision. If this is the first time you’ve set this up, or you want the latest revision, just click the OK button. After all the files from your repository are copied, you’re ready to start editing!

Up to this point, everything we’ve discussed has been pure configuration, something that you’ll do one time per computer, and that’s it.

Using the Version Control System

Here is an example of the typical workflow of editing a script without using a VCS:

1. Find the script (this is usually the hardest part).
2. Edit the script.
3. Save the file.
4. Pull your hair out because the 2500+ line script you just changed isn’t working right (hopefully you’ve never experienced this step).

Now here is an example of the typical workflow of editing a script using the VCS we just set up:

1. Open the file you want to edit from the Working Set in NotePad++. For this example I’ll use the file C:\Admin\Scripts\SOURCE\Shell\reboot.cmd from my local Working Set.
2. Make your changes in NotePad++, and save the file. If you do not save the file, there is nothing to commit to the repository.
3. From the NotePad++ Plugins menu, select Tortise SVN > TSVN – File commit, as shown in this image:

This tells TortiseSVN that you want to write the changes you’ve made to your repository, and it will prompt you to do so using the Commit window:

As you can see there are several options before you actually commit the file. In practice you’ll usually only need the Message area and the OK button. The Message area is basically a comment area for what these changes represent. The more verbose you are here, the easier it will be to understand the changes that were made in the revision, and it will also make it much easier to find a revision where a particular change was made. Once you click the OK button, TortiseSVN will commit your changes to the repository, as shown in this window:

Clearly you can see this is a slightly more complicated process, but the pay off totally worth it if something goes wrong.

How to figure out where you broke something after you’ve been using this for a while

The exact workflow that any given person uses will probably be slightly different than that used by any other person, so this is going to be a description of my particular workflow, and how I track things.

I’m writing a PowerShell Module (sshhh), and I have a function in it called Get-Sysinternals. When I first wrote this function, it would default to downloading all of the Sysinternals utilities. I’ve edited it and altered it several times since then, and I wanted the default behavior to be that it would only download updates to the tools if they were already installed on the local computer in a specific folder. I then later added some switches to change the default behavior, and somewhere along the line, I broke the default behavior.

To figure out what changed, I needed to see what the code looked like when the default behavior was changed. To do this I opened the file (AdminsArsenal.psm1) in NotePad++, and from the NotePad++ Plugins menu, I selected Tortise SVN > TSVN – File log.

This brings up a viewer for all of the Commit activity for the file, which looks something like this:

Scrolling through the commit messages, I find that at revision 76 I changed the default behavior.

What you’ll do at this point depends on how you want to handle this. You could right click the file in explorer, and select TortiseSVN > Update to revision…, if you just wanted to revert the file to a point where you know it worked. Personally I just wanted to see the code in revision 76, so I right clicked the revision I had highlighted, and selected Compare with working copy from the resulting context menu:

Now this particular example was not a great one to use, as I completely rearranged the functions in that module in a later revision so the compare is pretty sloppy, but you get the point.

You’ll also notice that in the Log Messages window, it shows the Author which makes it really easy to determine who made what changes to a given file if you have more than one person working on your scripts.

 ##--------------------------------------------------------------------------
 ##  FUNCTION.......:  Test-Ping
 ##  PURPOSE........:  Returns "True" of the host is pingable, or "False" if
 ##                    not.
 ##                    This uses the .NET NetworkInformation.Ping method.
 ##  ARGUMENTS......:  A computer name or IP address (just one at a time).
 ##  EXAMPLE........:  Test-Ping 127.0.0.1
 ##                    Test-Ping google.com
 ##  REQUIREMENTS...:  PowerShell 2.0
 ##  NOTES..........: 
 ##--------------------------------------------------------------------------
 function Test-Ping
 {
 <#
 .SYNOPSIS
 Determines if a given device is pingable from the computer where the
 function is used. This can only be used with one device at a time. For
 examples type:
 Get-Help Test-Ping -examples
 .DESCRIPTION
 This function uses the .NET NetworkInformation.Ping method to determine
 if a device is reachable using an ICMP echo message. The Function
 returns $true if the device is pingable, and $false if it is not (or if
 ICMP echo message replies are not returned).
 .EXAMPLE
 Test-Ping google.com
 Will return "True" if DNS is working in the environment that the script
 is run in, and the site is pingable.
 .EXAMPLE
 Test-Ping 127.0.0.1
 Will return "True" if the IPAddress is pingable.
 .EXAMPLE
 exampleScript.ps1
 ##-------------------------------------------------------------
 ## Contents of exampleScript.ps1
 ##-------------------------------------------------------------
 If (!(Test-Ping deadHost)) {
 Write-Host "Host 'deadHost' not Live!" -Fo Red
 }
 Else {
 Write-Host "Host 'deadHost' is Live!" -Fo Cyan
 }
 ##-------------------------------------------------------------

 Assuming that this script also contains the Test-Ping function, this
 script will return the string "Host 'deadHost' not Live!" (unless you
 have a device named "deadHost" in your environment for some reason).
 .NOTES
 NAME......:  Test-Ping
 AUTHOR....:  Joe Glessner
 LAST EDIT.:  18FEB11
 CREATED...:  17AUG10
 .LINK

http://joeit.wordpress.com/2011/02/23/powershell-functions-test-ping/

 #>
 param($ip)
 trap {$false; continue}
 $timeout = 1000
 $object = New-Object system.Net.NetworkInformation.Ping
 (($object.Send($ip, $timeout)).Status -eq 'Success')
 }

Save the code into a file called C:\test-ping.ps1

Open up powershell, and run this command:

. c:\test-ping.ps1

And hit ENTER (this is called “dot sourcing” by the way). Now run this command:

get-help Test-Ping

And hit ENTER again. Pretty cool eh? It also makes it much easier to remember how your functions are used from the command line, if you keep them all in one file, and then dot source that file.

And it’s so easy to use. In fact, even if you’ve never opened a PowerShell prompt before, you already know some stuff that you can use in it (assuming that you’ve opened a command prompt in the last twenty years). Go ahead and open up a PowerShell prompt (Win+R, type: powershell, and then hit ENTER, or just type powershell into the search box on the start menu).

Type: dir, and then hit ENTER.

Looks familiar right?

But try this, type:

get-alias dir, and hit ENTER.

You just ran a PowerShell cmdlet (pronounced “command let”).

And there are a ton more. And unlike some people I could name, Microsoft didn’t forget the other guys when they built PowerShell, try typing the following in the PowerShell Window: ls, and then hit ENTER. Yep they make it pretty easy to harness what you know, whether that be *NIX, or Win32.

One of the most awesome things about PowerShell is that you can extend it. Easily. And make the extension seamless. And Functions are pretty awesome. So expect to see more on this here.