Serving Go using FastCGI on Windows Azure

One of the cooler features of Windows Azure is that you can spin up Linux virtual machines on it and run apps written in the language of your choice.

These are the steps I followed to create a Linux VM on Windows Azure, install nginx and Go on it and serve up a "Hello World" app using FastCGI.

First, I signed up a 3-month trial account on Windows Azure - you will need a Microsoft Account for this.

Next, I created a new Virtual Machine using New -> Compute -> Virtual Machine -> From Gallery.

I selected Ubuntu Server 12.04.1 -

I gave the new VM a name - GoMachine, selected a username and password and hit Next -

I selected VM type as Standalone and the DNS name as gopher.cloudapp.net -

Choose Availability Set as None -

Once the VM was provisioned, I SSH'd into it using PuTTy using the credentials I had set earlier -

I installed Go using the command - sudo apt-get install golang-go.

I installed nginx using the command - sudo apt-get install nginx.

Next, I created a directory called fcgi in which I created a file - fcgi.go -

	package main
	import (
	"fmt"
	"log"
	"net"
	"net/http"
	"net/http/fcgi"
	)
	func main() {
	l, err := net.Listen("tcp", ":9999") //listen on port 9999
	if err != nil {
	log.Fatal(err)
	}
	mux := http.NewServeMux()
	mux.HandleFunc("/hello", index)
	fcgi.Serve(l, mux)
	}
	func index(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello from Windows Azure! -- The Gopher")
	}

view raw gistfile1.go hosted with ❤ by GitHub

and compiled it using go build fcgi.go.

I edited the file /etc/nginx/sites-available/default to allow it to serve FastCGI and pointed it to 127.0.0.1:9999 where the fcgi app will listen. The server will also take requests directed to http://gopher.cloudapp.net.

	server {
	#listen 80; ## listen for ipv4; this line is default and implied
	#listen [::]:80 default_server ipv6only=on; ## listen for ipv6
	root /usr/share/nginx/www;
	index index.html index.htm;
	# Make site accessible from http://localhost/
	server_name localhost, gopher.cloudapp.net;
	location / {
	# First attempt to serve request as file, then
	# as directory, then fall back to displaying a 404.
	try_files $uri $uri/ /index.html;
	# Uncomment to enable naxsi on this location
	# include /etc/nginx/naxsi.rules
	fastcgi_pass localhost:9999;
	include fastcgi_params;
	}
	location /doc/ {
	alias /usr/share/doc/;
	autoindex on;
	allow 127.0.0.1;
	allow ::1;
	deny all;
	}
	}

view raw gistfile1.txt hosted with ❤ by GitHub

I started the fcgi application using ~/fcgi/fcgi& to run it in the background. I also restarted nginx using sudo service nginx restart for the new configuration  to take effect.

To test the app, I typed curl http://localhost/hello. It worked. However, curl http://gopher.cloudapp.net/hello didn't. To make this work, I had to create a new 'endpoint' for the VM in the dashboard -

I clicked on Add Endpoint, and created a new TCP endpoint on Port 80 -

Now, the web app is accessible from the outside world.

Update: - My 3 month trial has expired. So the above URL is not accessible any longer.

Querying Sharepoint on Office365 with Go

This code snippet shows how to query Sharepoint hosted on Microsoft's Office365 service. This was inspired by Luc Stakenborg's excellent Node-Sharepoint library.

	package main
	import (
	"fmt"
	"io/ioutil"
	"net/http"
	"log"
	"regexp"
	"strings"
	)
	//set credentials and site endpoint here.
	var options = map[string]string{
	"username": "user@mysite.onmicrosoft.com",
	"password": "mypassword",
	"endpoint": "https://mysite.sharepoint.com/_forms/default.aspx?wa=wsignin1.0",
	"siteservice": "https://mysite.sharepoint.com/_vti_bin/ListData.svc/",
	}
	func main() {
	getData()
	}
	//generate the saml xml string to be sent to the auth service.
	func generateSAML() string {
	content := `<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing" xmlns:u="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"><s:Header><a:Action s:mustUnderstand="1">http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue</a:Action><a:ReplyTo><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo><a:To s:mustUnderstand="1">https://login.microsoftonline.com/extSTS.srf</a:To><o:Security s:mustUnderstand="1" xmlns:o="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"><o:UsernameToken><o:Username>[username]</o:Username><o:Password>[password]</o:Password></o:UsernameToken></o:Security></s:Header><s:Body><t:RequestSecurityToken xmlns:t="http://schemas.xmlsoap.org/ws/2005/02/trust"><wsp:AppliesTo xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"><a:EndpointReference><a:Address>[endpoint]</a:Address></a:EndpointReference></wsp:AppliesTo><t:KeyType>http://schemas.xmlsoap.org/ws/2005/05/identity/NoProofKey</t:KeyType><t:RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</t:RequestType><t:TokenType>urn:oasis:names:tc:SAML:1.0:assertion</t:TokenType></t:RequestSecurityToken></s:Body></s:Envelope>`
	for key, val := range options {
	content = strings.Replace(content, "["+key+"]", val, -1)
	}
	return content
	}
	//send the saml and receive the auth token
	func getToken() string {
	saml := generateSAML()
	resp, err := http.Post("https://login.microsoftonline.com/extSTS.srf", "text/xml", strings.NewReader(saml))
	if err != nil {
	log.Fatal(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	token := regexp.MustCompile("<wsse:BinarySecurityToken Id=\"Compact0\">(.*?)</wsse:BinarySecurityToken>")
	return token.FindStringSubmatch(string(body))[1]
	}
	//send the auth token to the sharepoint site auth endpoint and receive auth cookies
	func getAuthCookies() []*http.Cookie {
	token := getToken()
	resp, err := http.Post(options["endpoint"], "text/plain", strings.NewReader(token))
	if err != nil {
	log.Fatal(err)
	}
	return resp.Cookies()
	}
	//send a request to the sharepoint list service using the auth cookies
	func getData() {
	client := new(http.Client)
	cookies := getAuthCookies()
	req, _ := http.NewRequest("GET", options["siteservice"], nil)
	req.Header = map[string][]string{
	"Accept": {"application/json"},
	}
	req.AddCookie(cookies[1]) //rtFa cookie
	req.AddCookie(cookies[2]) //FedAuth cookie
	resp, err := client.Do(req)
	if err != nil {
	log.Fatal(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
	}

view raw gistfile1.go hosted with ❤ by GitHub

Update: This no longer works. Office365 has now been upgraded to use Sharepoint 2013, which supports OAuth-based authentication. More details here - http://msdn.microsoft.com/en-us/library/fp142384.aspx

Knockout.js – Creating a table with a cell conditionally spanning multiple rows.

Creating HTML tables with conditional elements is a common scenario when creating user interfaces. This fiddle demonstrates how to create a table with a cell that conditionally spans multiple rows using Knockout.js.