Enabling HTTPS in Azure via worker InstanceInput endpoints

Wow, what a rare and specific thing you might want to do - but we certainly did, and since there was nothing I could find in the Google Brain, I had to figure it out for myself...

In a nutshell, here's how to do it:

1. Create the endpoint via the role properties in your cloud service project. Since https is not an option, we need to select tcp:
   
   Also don't be deterred by the fact you can't select an SSL certificate here.
   
2. Upload your SSL certificate to your cloud service via the Azure portal, and also make it available via the Certificates tab in your role properties:
   
   
   
3. Now here's the trick, you need to bind the certificate to the internal port of the role (in this example, 10100). You can do this by running the netsh command as a startup task for the role.
   
   Create a batch file called bindcertificate.cmd in the root of your worker project. Ensure the file properties are Copy To Output Directory: Copy always.
   
   Add the following content to the file:
   
   @echo off
   
   REM   *** Bind the SSL certificate to the internal input endpoint (appid is irrelevant) ***
   
   netsh http add sslcert ipport=0.0.0.0:10100 certhash=4F66816E3856A3816246D17A77C62E4C66E641AF appid={00112233-4455-6677-8899-AABBCCDDEEFF} >> "%TEMP%\StartupLog.txt"
   
   REM   *** Exit batch file. ***
   
   EXIT /b 0
   
   Replace the port number with your private port, and the certhash with the thumbprint of your SSL certificate.
   
4. Finally, add the batch file as an elevated startup task in your ServiceDefinition.csdef:
   
   <Startup> <Task commandLine="startuptasks.cmd" executionContext="elevated" taskType="simple" /> </Startup>
   
5. In terms of setup, that's it. Now assuming you're using WCF to expose endpoints via the worker role, you can now create a binding with Transport security, e.g.:
   
   var endpoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["Search"].IPEndpoint.ToString();
   
   var host = new ServiceHost(yourImplementationHere);
   
   var binding = new WebHttpBinding(WebHttpSecurityMode.Transport);
   
   var ep = host.AddServiceEndpoint(
       typeof(IYourImplementation),
       binding,
       string.Format("https://{0}/YourEndpoint", endpoint));
   
   ep.Behaviors.Add(new WebHttpBehavior());
   
   host.Open();

You should now be able to access your endpoint externally, using your Azure DNS entry, along with the relevant external port, e.g.:

https://yourcloudservice.cloudapp.net:10106/yourendpoint  (role instance1)

https://yourcloudservice.cloudapp.net:10107/yourendpoint  (role instance 2)

Anthony.

Fixing Word Margins in Reporting Services 08

We don't use Report Services with SQL Server, but the Report Viewer control to render reports from Azure table Storage.

That said, I believe the rendering engine is the same in both cases - and in both cases the 08 version renders header & footer content outside of the document margins.

See this Microsoft Connect discussion on the issue, and Microsoft's good 'ol "its by design" response :)

There really is no workaround you can perform in the Reports themselves - as tricking the layout to work in Word will in turn break the layout in other formats like PDF.

So crazy idea time... since a .docx file is really just a .zip fie containing a bunch of xml settings, I thought I could write a function that could modify the header & footer attributes within the file.

Lo and behold it worked really well. It works for us since we just use the Report Viewer control, and not the full-fledged Reporting Services - as we are manually working with document streams etc.

Below is a code snippet of the function. Note that it requires SharpZipLib for the zip handling. We are still on .NET 4.0 but if you are on 4.5 you could swap this out with the new ZipArchive class in the .NET framework.

Anthony.

	private static Stream FixWordMargins(Stream document)
	{
	// Copy to a seekable stream for manipulation
	var zipStream = new MemoryStream();
	document.CopyTo(zipStream);
	zipStream.Position = 0;
	// A docx file is just a zip file, so open it
	var zipFile = new ZipFile(zipStream);
	// Look for document.xml, which contains the header & footer margins
	var documentXmlFilePath = "word/document.xml";
	var documentIndex = zipFile.FindEntry(documentXmlFilePath, true);
	if (documentIndex > -1)
	{
	// Load the entry into an XML document for manipulation
	var xmlDoc = new XmlDocument();
	xmlDoc.Load(zipFile.GetInputStream(zipFile[documentIndex]));
	// Update the page margin element
	var pgMarEls = xmlDoc.GetElementsByTagName("w:pgMar");
	if (pgMarEls.Count == 1)
	{
	var pgMarEl = pgMarEls[0];
	// Set the header margin based on the top margin
	var topAttr = pgMarEl.Attributes["w:top"];
	if(topAttr != null)
	{
	var headerAttr = pgMarEl.Attributes["w:header"];
	if (headerAttr == null)
	{
	headerAttr = xmlDoc.CreateAttribute("w:header");
	pgMarEl.Attributes.Append(headerAttr);
	}
	headerAttr.Value = topAttr.Value;
	}
	// Set the footer margin based on the bottom margin
	var bottomAttr = pgMarEl.Attributes["w:bottom"];
	if (bottomAttr != null)
	{
	var footerAttr = pgMarEl.Attributes["w:footer"];
	if (footerAttr == null)
	{
	footerAttr = xmlDoc.CreateAttribute("w:footer");
	pgMarEl.Attributes.Append(footerAttr);
	}
	footerAttr.Value = bottomAttr.Value;
	}
	}
	// Save the updated document.xml back to the zip file
	zipFile.BeginUpdate();
	var sds = new CustomStaticDataSource();
	var outStream = new MemoryStream();
	xmlDoc.Save(outStream);
	outStream.Position = 0;
	sds.SetStream(outStream);
	zipFile.Add(sds, documentXmlFilePath);
	zipFile.CommitUpdate();
	zipFile.IsStreamOwner = false;
	zipFile.Close();
	zipStream.Position = 0;
	}
	return zipStream;
	}

view raw gistfile1.cs hosted with ❤ by GitHub

Xero API .NET Client - Implementing your own ITokenRepository

We recently integrated our FoodStorm product with Xero, and we decided to use their .NET API. Most of it is pretty straightforward - except for dealing with access tokens in .NET as their documentation is lacking somewhat.

So here is a bit of a brain-dump of my experiences...

To perform any API operation, you need to first instantiate a Session. In our case we have Partner access, so we need to create a XeroApiPartnerSession. The constructor requires an ITokenRepository (it also requires Certificates - but that's for another blog post!).

So since you can't create an instance of an Interface, you need to create your own class that implements ITokenRepository, and inside that class it's up to you to deal with the loading & saving of access tokens.

When I first saw this, I thought it was overkill - why couldn't I just pass in my access token?!? But I delved more into the API I learned that access tokens expire after 30 minutes - even with Partner access. This means you need to Renew your access token periodically. The good news is that if you implement an ITokenRepository, all this complexity is fully handed by the .NET API, so it's a pretty good design after all.

So onto creating a Token Repository... The ITokenRepository interface looks like this:

	public interface ITokenRepository
	{
	AccessToken GetAccessToken();
	RequestToken GetRequestToken();
	void SaveAccessToken(AccessToken accessToken);
	void SaveRequestToken(RequestToken requestToken);
	}

view raw gistfile1.cs hosted with ❤ by GitHub

As you can probably guess, you need to make the Get methods return your tokens, and your Set methods need to save the tokens. My initial idea was just to Serialize the AccessToken and RequestToken classes to a file - easy peasy - until I realised those classes weren't marked as Serializable...

So that meant I would need to store the values of the properties in the Set methods, and then re-create the classes in the Get methods. And that's what I did:

	public class TokenRepository : ITokenRepository
	{
	private readonly string _consumerKey = "YOUR_CONSUMER_KEY";
	public AccessToken GetAccessToken()
	{
	var data = GetTokenData();
	return new AccessToken
	{
	ConsumerKey = _consumerKey,
	Token = data.Token,
	TokenSecret = data.TokenSecret,
	CreatedDateUtc = data.CreatedDateUtc,
	ExpiresIn = data.ExpiresIn,
	SessionHandle = data.SessionHandle,
	SessionExpiresIn = data.SessionExpiresIn
	};
	}
	public RequestToken GetRequestToken()
	{
	var data = GetTokenData();
	return new RequestToken
	{
	ConsumerKey = _consumerKey,
	Token = data.RequestToken,
	TokenSecret = data.RequestTokenSecret
	};
	}
	public void SaveAccessToken(AccessToken accessToken)
	{
	var data = GetTokenData();
	data.Token = accessToken.Token;
	data.TokenSecret = accessToken.TokenSecret;
	data.CreatedDateUtc = accessToken.CreatedDateUtc;
	data.ExpiresIn = accessToken.ExpiresIn;
	data.SessionExpiresIn = accessToken.SessionExpiresIn;
	data.SessionHandle = accessToken.SessionHandle;
	EditTokenData(data);
	}
	public void SaveRequestToken(RequestToken requestToken)
	{
	var data = GetTokenData();
	data.RequestToken = requestToken.Token;
	data.RequestTokenSecret = requestToken.TokenSecret;
	EditTokenData(data);
	}
	private XeroTokenData GetTokenData()
	{
	var dataJSON = ""; // Implement your own code here to retrieve token data from DB etc.
	var serializer = new JavaScriptSerializer();
	return serializer.Deserialize<XeroTokenData>(dataJSON);
	}
	private void EditTokenData(XeroTokenData data)
	{
	var data = new JavaScriptSerializer();
	var dataJSON = serializer.Serialize(settings);
	// Implement your own code here to save dataJSON to your DB etc
	}
	[Serializable]
	public class XeroTokenData
	{
	public string Token { get; set; }
	public string TokenSecret { get; set; }
	public DateTime CreatedDateUtc { get; set; }
	public string ExpiresIn { get; set; }
	public string SessionExpiresIn { get; set; }
	public string SessionHandle { get; set; }
	public string RequestToken { get; set; }
	public string RequestTokenSecret { get; set; }
	}
	}

view raw gistfile1.txt hosted with ❤ by GitHub

For simplicity sake, I decided to serialise all the required properties to my own JSON object, as I didn't see the need for specific DB columns etc - but that's up to you. However note that ALL of the properties I am save & loading here are required! If you miss any (which I initially did), things will not work correctly within the API.

Anthony.