I found a few online resources that outlined the process, but none of them were exactly what I needed, so I decided to write this post to go over the steps in detail. Hopefully this helps!

The steps we are going to take:

• Create a KeyPair, Security Group and Elastic IP in AWS
• Create a new Micro instance (64-bit Linux) in AWS
• Connect to the new instance using SSH
• Install a few tools on our new instance
• Create directories for repositories and auth settings
• Configure apache for servicing SVN requests
• Try it out

Getting Set Up in AWS

The first step is to login to the AWS Management Console.

1. On the left side of the screen under Network and Security, select KeyPairs.
2. Create a new Key Pair called SVN – this will create the key pair and initiate a download. Store this key in a safe place – i.e. do not lose it!

Next, click on Security Groups (under Network and Security)

1. Click Create Security Group
2. Call it Web (Linux) and set the description to Subversion and HTTP
3. Once it’s been created, select the new group and click the Inbound tab (bottom of the screen)
4. Add three inbound rules, SSH (22), HTTP (80), HTTPS (443)
5. Apply your changes

Ok, now we have the “firewall” rules setup and a KeyPair (used to connect via SSH) to connect to an instance. Now we need to create a new server instance in EC2.

1. On the left menu under Instances, select instances
2. From the toolbar select Launch Instance
3. Choose Launch Classic Wizard and click continue
4. From the QuickStart tab, choose Basic 64-bit Amazon Linux AMI
5. On the next screen, set the Number of Instances to 1, the Instance Type to “Micro” and click Continue
6. From the Advanced Instance Options screen, leave all the defaults and click continue
7. Add any tags you want and click continue
8. On the next screen, select the KeyPair we created earlier and click continue
9. From the Configure Firewall screen, select the Security Group we created earlier
10. Click next/continue until the instance is created

We now want to connect and Elastic IP to our instance (this must be done every time you start the instance…Amazon doesn’t automate this at all).

1. From the left menu under Network and Security, select Elastic IPs
2. Click Allocate New Address from the toolbar and click Yes when prompted
3. Right click on the new IP address and select “associate” from the menu
4. Select your new instance from the list

The last step would be to create an A record on your DNS server for the new IP. For the purposes of this article I’m going to assume that you’ve done this step, however while going through the rest of this post, you can simply replace <domain> with your Elastic IP address supplied by Amazon and get the same results.

Connecting to Your New Instance

Now that we’ve got the server all setup in AWS, we need to connect to our new server and install some applications that will make things a little easier to work with.

There are loads of SSH applications out there that will let you use SSH from Windows (my preference is Putty – and it’s free). If you’re connecting from a Mac or any ‘nix system, SSH is already built-in. For this article, I’ll assume we’re using a Mac/Nix installation. If you’re using Windows, check out this post on connecting to EC2 with Putty.

Connecting from a Console

1. If you’re using a Mac, you will need to open a terminal (Applications->Utilities->Terminal)
2. If you’re using Nix, I assume you know how to open a terminal window
3. cd to the directory where you saved the KeyPair file (.pem) we created ealier
4. Change the permissions of this file (to stop SSH from complaining about it): sudo chmod 600 <keypair>
5. Type command: ssh -i <keypair> ec2-user@<domain> where <keypair> is the KeyPair file we created ealier and <domain> is to host you pointed to the Elastic IP (can be an IP address if you like)
6. The first time you connect, you might get a warning about trusting a certificate…type or select yes when prompted

You’re In! Now what?

Now that we’re connected to the instance, we need to install a few things. I should note, I’m a big fan of emacs, so I always install it. If you’re not familiar with Unix editors, stick to pico to keep things simple. For the remainder of this article, I’ll use the word editor to refer to your preferred editor of choice on Linux.

Run the following commands to install subversion and svnserve.

sudo yum install mod_dav_svn subversion

Next we’re going to create a few new folders:

sudo mkdir -p /data/svn/repos /data/svn/logins /data/svn/scripts
sudo chown -R apache.apache /data/svn

Now we need to create a subversion account to use for connecting to a repository. To do this we are going to create a new auth file and the create a script to handle adding new users in the future. To do this, run the following commands:

cd /data/svn/logins
sudo htpasswd -cm svn-auth-conf

We should now make the login file a little more secure by running sudo chmod 600 svn-auth-conf. Next, we’re going to create a script called create_user.sh that we can use to add user’s in the future. This will make sure that we don’t forget the commands and also ensure that we don’t accidentally include -c again which will create a new file (overriding anything existing) – bad.

Using your editor, create the following script (in /data/svn/scripts), save it to a file called create_user.sh and then run sudo chmod +x create_user.sh to add execute rights to the file.

#!/bin/bash
user_name="$1"
auth_file="../logins/svn-auth-conf"

if [ "$user_name" = "" ]; then
    echo -n "Enter user name: "
    read user_name
fi

chmod 700 $auth_file
if [ $? -eq 0 ]; then
    htpasswd -m $auth_file $user_name
    chmod 600 $auth_file
fi

We can use this script by passing in a username or allowing the script to prompt us for one:

sudo ./create_user.sh davidmuto
#or
sudo ./create_user.sh

Now we need a script that allows us to create repositories. The reason we make this a script is to save us from retyping the same commands every time we create a repo (very prone to error). Here’s a script that will create a repository and set all of the necessary permissions on the files for being served by apache.

#!/bin/bash
repo_name="$1"
path_to_repo=""

if [ "$repo_name" = "" ]; then
    echo -n "What should the repo be called?: "
    read repo_name
fi

path_to_repo="../repos/$repo_name"
svnadmin create $path_to_repo
if [ $? -eq 0 ]; then
    sudo chown -R apache.apache $path_to_repo
    sudo chcon -R -t httpd_sys_content_t $path_to_repo
    echo "Successfully create repo '$path_to_repo'"
else
    echo "Could not create repository $path_to_repo"
fi

The Final Step!

Our last step it to set up the apache config file for servicing subversion repo requests.

1. Navigate to /etc/httpd/conf.g
2. Using your editor open the subversion.conf file for editing (much be run using sudo, e.g. sudo emacs subversion.conf or sudo vi subversino.conf)
3. Add the following Location element to the file
   

   <Location />
     DAV svn
     SVNParentPath /data/svn/repos
     AuthType Basic
     AuthName "My Subversion Realm"
     AuthUserFile /data/svn/logins/svn-auth-conf
     Require valid-user
   </Location>
   

4. Restart the apache service: sudo service httpd restart

Testing it Out

Now let’s run through the process of creating a new repo and connecting to it.

1. Navigate to /data/svn/scripts
2. Create a user (if needed): sudo ./create_user.sh [user_name]
3. Create a new repo: sudo ./create_repo.sh [repo_name]
4. Using your favourite subversion client, checkout your new repo at http://<domain>/<repo_name>

I hope this posts helps someone in need. If you guys notice anything I’ve missed, please feel free to let me know and I’ll update this post as needed.

Happy Coding!

At first everything was working perfectly. I was using JSONKit and NSOperation to download and process the information. That was until I had to get a DateTime object…which resulted in an epic fail!

It turns out that WCF Data Services publish DateTime objects as a new Date object represented by the time in milliseconds (not seconds) since January 1, 1970. Anyone familiar with EPOCH dates knows about January 1, 1970 right?

The problem isn’t so much in that it publishes dates from a known time, rather that it does it in the least accessible way! The value is rendered out (in JSON) as “\/Date(1311836400000)\/” – yeah..I know, right?

So now I had to figure out a nice way to parse this very custom date format in Objective-C. This led me to the shocking (and borderline unacceptable) realization that objective-c (lower case to drive the point home) has no support for regular expressions. There’s no punch-line to this joke…for real. No support for regex. A Unix-based OS has a development language that has no support for something that is natively supported (see the * below)!

To start, I decided to add a category to the NSDate object that would allow me to work with these ridiculous strings.

NSDate+OData.h

#import <Foundation/Foundation.h>

@interface NSDate (OData)

- (id)initWithODataString:(NSString *)dateString;
- (NSString *)toODataQueryFormat;

+ (NSDate *)dateFromString:(NSString *)dateString;

@end

NSDate+OData.m

#import "NSDate+OData.h"

@implementation NSDate (OData)

- (id)initWithODataString:(NSString *)dateString
{
    return [[NSDate dateFromString:dateString] retain];
}

- (NSString *)toODataQueryFormat
{
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss"];

    NSString *formattedDate = [formatter stringFromDate:self];
    [formatter release];

    return formattedDate;
}

+ (NSDate *)dateFromString:(NSString *)dateString
{
    NSInteger startIndex = [dateString rangeOfString:@"("].location;
    NSInteger endIndex = [dateString rangeOfString:@")"].location - startIndex;
    long long ticks = [[dateString substringWithRange:NSMakeRange(startIndex + 1, endIndex)] longLongValue];

    NSDate *date = [NSDate dateWithTimeIntervalSince1970:(ticks / 1000)];
    return date;
}

@end

The code above allows me to get an NSDate from the crazy OData DateTime string and also convert an NSDate to another (quite different) format used by OData to query based on a DateTime value.

To get an NSDate from the OData string, I am substring’ing the value between the two brackets. This value is then converted to a long long value (twice on purpose for you .NET developers out there). The NSDate has a static method called dateWithTimeIntervalSince1970: that will return an (autoreleased) NSDate object with the value of the time (in seconds) since January 1, 1970.

To get the date to the query format used by OData (see OData URI Conventions), we need to take an NSDate and get it into the format “yyyy-MM-dd’T'HH:mm:ss” for example, “2011-07-29T18:15:00″.

I hope this information helps someone, as I was unable to find a simple example online anywhere (although I will concede that my googling skills could use some work).

* Please don’t take this as a complete knock to Objective-C. The language is quite easy to work with and definitely robust…just lame on the regex front!

Essentially I have an enumeration of field types. I wanted to display the names of those fields in a drop down list, but be able to make some of them prettier. Here is the enumeration:

public enum FieldType
{
    Text = 1,
    HTML = 2,
    [Display(Name = "Date/Time")]
    DateTime = 3,
    Number = 4,
    [Display(Name = "Dropdown List")]
    DropdownList = 5
}

Now I need a way to show the items in a drop down list, and set the selected one (from the Model) to selected. I decided the easiest way would be to use an editor template. So I created the FieldType editor template (under /Views/Shared/EditorTemplates) using the code below:

@model FieldType
@using System.ComponentModel.DataAnnotations
<select name="@ViewData.TemplateInfo.GetFullHtmlFieldName(string.Empty)"> 
@foreach (var name in Enum.GetNames(typeof(FieldType))) {
    <option selected="selected" value="@name">@DisplayName(name)</option>
}
</select>

@helper DisplayName(string name) {
    var attr = typeof(FieldType).GetField(name).GetCustomAttributes(typeof(DisplayAttribute), false).FirstOrDefault() as DisplayAttribute;

    if (attr != null)
    {
        @attr.Name
    }
    else
    {
        @name
    }
}

Now when I want to render a FieldType property of an object, I can just use the Html.EditorFor extension as I would for any other object:

</pre>
<div class="editor-label">@Html.LabelFor(model => model.Type)</div>
<div class="editor-field">@Html.EditorFor(model => model.Type)
 @Html.ValidationMessageFor(model => model.Type)</div>
<pre>

And Voila!

If for some reason you cannot name your editor template the same as the type, you can supply the name of the template to the EditorFor method using one of the overloads provided.

Happy coding!

After a bit of hunting and looking through the web.config files underneath the views folder (in each Area), I found that this can be accomplished by adding the following to the root web.config file:

<configSections>
    <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
      <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
    </sectionGroup>
  </configSections>

  <system.web.webPages.razor>
    <pages pageBaseType="System.Web.Mvc.WebViewPage">
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Routing" />
      </namespaces>
    </pages>
  </system.web.webPages.razor>

Now you can add any namespaces you require under the new razor namespaces section.