Sergei Meleshchuk - Random Notes

Simplest WCF REST Web Service

Sergei B. Meleshchuk — Thu, 25 Jan 2018 01:52:08 GMT

WCF allows to create a web site exposing WCF service and service endpoints. REST Web Service does not use SOAP, but returns data as JSON or XML instead. WCF service is a DLL which should be hosted in a desktop application, or IIS. This post is about how to create a very simple WCF REST Web Service hosted in IIS. Practical problems are:

What is the simplest Service.svc file such that the service will be hosted in IIS;
What is the simplest Web.Config file, given that our beloved bindings such as binding="basicHttpsBinding" and such won’t work with REST services (those are for SOAP envelopes). We need webHttpBinding instead!
How to manage whether the service will return JSON or XML;
How to map which parts of the URL map to which service method arguments.

Usual part

Usual interface and implementation could be in two files, or in one file. File IService1.cs

using System.ServiceModel;
using System.ServiceModel.Web;

namespace SimplestWcfWebService
{
  [ServiceContract]
  public interface IService1
  {
    [OperationContract]
    [WebGet(UriTemplate = "Ping",
    ResponseFormat = System.ServiceModel.Web.WebMessageFormat.Json)]
    string Ping();

    [OperationContract]
    [WebGet(UriTemplate = "Bounce/{value}",
    ResponseFormat = System.ServiceModel.Web.WebMessageFormat.Json)]
    string Bounce(string value);
  }
}

File Service1.svc.cs

namespace SimplestWcfWebService
{
  public class Service1 : IService1
  {
    public string Ping()
    {
      return "Ping!";
    }
    public string Bounce(string value)
    {
      return $"You entered: {value}";
    }
  }
}

That’s basically all the code.

Set up IIS hosting

File Service1.svc

<%@ ServiceHost Language="C#" Debug="true" Service="SimplestWcfWebService.Service1"
                Factory="System.ServiceModel.Activation.WebServiceHostFactory"
                CodeBehind="Service1.svc.cs" %>

What is important here is the Factory attribute. Presence of this attribute will trigger, when processing the first REST request, creation of a host object living in IIS. The host will be hosting your custom DLL, which will be processing the requests.

Web.config file

Cool news is that the Web.config can be just empty: the below content is sufficient. File Web.config

Finishing VS project

Nothing else, actually. You need to have references in the .csproj file. File SimplestWcfWebService.csproj




Debug
AnyCPU


2.0
{5FE2D554-CC0D-4349-B112-2F4FBFE0E7EF}
{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}
Library
Properties
SimplestWcfWebService
SimplestWcfWebService
v4.7.1
True
true
true








true
full
false
bin\
DEBUG;TRACE
prompt
4


pdbonly
true
bin\
TRACE
prompt
4



























Service1.svc









Web.config


Web.config



10.0
$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)








True
True
38062
/
http://localhost:38062/
False
False


False

Setting up IIS site

If your project files are in C:\GitHub\sergeim\web\SimplestWcfWebService\SimplestWcfWebService, do, using the IIS manager:

Right-click on Default Web Site and “Add Application”
Set Alias as SimplestWcfWebService, and Physical path as C:\GitHub\sergeim\web\SimplestWcfWebService\SimplestWcfWebService
Click OK

Now, if you enter in Chrome browser, the URL http://localhost/SimplestWcfWebService/Service1.svc/bounce/Hi%20there then you will get the page "You entered: Hi there" And this is how Chrome renders the JSON-formatted response. Edge behaves similarly: Now, from another machine, enter URL http://b88h11-32/SimplestWcfWebService/Service1.svc/bounce/Hi%20there and you get same rendering "You entered: Hi there" However, IE behaves a little differently. Anyway, due to your actual web service consumer will be the code, the code will have to parse the JSON from the response. Thus we don’t care too much about variations in browser rendering.

Tracing application via ETW in .NET 4.5

Sergei B. Meleshchuk — Sat, 07 Sep 2013 00:37:09 GMT

Starting with .NET FX 4.5, use of ETW for logging becomes really practical. The ETW has numerous advantages over writing traces (logs) to text files, and over tracing options available in earlier FX versions. Not only it’s faster than anything else, it’s also reliable: you are not losing the last trace record if your application crashes.

You are also not losing a single trace record, if your computer blue-screens. This options requires some setup. Other (and numerous) advantages are discussed elsewhere.

You can also change tracing levels, tracing groups without restarting the application. The list of virtues goes on.

Problem

There is a practical difficulty: How to start using the ETW in FX 4.5 with at least minimal functionality. Like mimic the trace records written to a log file with e.g. Console.WriteLine.

Basic Tracing – Code Side

I want to write two lines (records, log entries, traces) to a trace (to a log), which would be the ETW-based log. I am only interested in writing strings. I don’t care, at the moment, about setting trace levels, trace groups (markers of groups of tracing statements). Nothing special.

How do I do this?

Pick up a name for your trace method. For example, “Trace”. We will also need a name for the “tracing class” – the class, which will contain the method “Trace”. For example, let the class name be the “Tracer”.
Now, code the tracing support class – the Tracer:

private class Tracer : EventSource

{

public void Trace(string message)

{

WriteEvent(1, message);

}

3. Do the needed tracing in the application:

private void Run()

{

var log = new Tracer();

Console.WriteLine(log.Guid);

int testCount = 100;

for (int i = 0; i < testCount; i++)

{

var data = string.Format("This is line {0}", i);

log.Trace(data);

}

This is it. Nothing else is needed.

Basic Tracing – Other Side: “logman”

Run the program. Change the number or repetitions to one million. Run gain. It will be instantaneous. This is because there is no actual logging. Logging should have been activated first.

To activate logging, in the elevated command prompt, type (in one line):
logman create trace mytrace -p {da97437f-63db-5ccd-8c1f-2e8598d8df67} -o c:\mylogs\mytrace.etl -ets

To stop logging, type
logman stop mytrace –ets

Now, change the number of repetition again to a million. Again, it is almost instantaneous. While the sustained rate is typically lower, it’s still very, very fast.

The “logman” utility is part of the OS; no need to install it. The logman is not the only utility to control the logging – there are many other ways, including XPERF, and many more. The logman is probably the least amount of hassle. Of course, you can script the logman invocations, or control the logging from code.

Now: How to view the resulting trace?

Decoding ETL File

There are two ways. This section describes the first way, not very convenient, but readily available in the OS.

The trace (log) result is in the binary format. Each log line not only contains your data, but, in addition, a set of items like high-resolution timestamp, process and thread identifier, log level and what was earlier named, in ETL, “flags” – a lot extended though.

Anyway, there is need to decode the binary ETL file – that is, to convert to a textual form.

To convert the ETL file into textual (XML) representation, enter

tracerpt c:\mylogs\mytrace.etl

The tracerpt utility has many more options. In particular, it allows to select from a set of output formats.

DecodeEtl3

The second way [to decode ETL files] is to use a custom decoder.

For example, there is a DecodeEtl3 utility, which can be downloaded from http://sergeim.azurewebsites.net. It can only decode the ETL “version 3” files – the files which we are working with (emitted by .NET FX 4.5 EventSource). Another limitation is that this utility can only decode the trace records created by the WriteEvent(1, message) overload – the one we used in the above example. The output looks like below:

DecodeEtl3.exe trace3.etl

08/29/2013-20:01:36.309579 PID:0x3A94 TID:0x1DBC This is line 0

08/29/2013-20:01:36.309582 PID:0x3A94 TID:0x1DBC This is line 1

08/29/2013-20:01:36.309584 PID:0x3A94 TID:0x1DBC This is line 2

The DecodeEtl3 has a set of options, like “/short”:

DecodeEtl3.exe /short trace3.etl

This is line 0

This is line 1

This is line 2

Custom Post-Authentication in Federated Authentication Scenarios

Sergei B. Meleshchuk — Tue, 20 Aug 2013 12:01:00 GMT

With .NET Framework 4.5 the federated authentication is comparatively easy, the biggest work being preparation of the configuration file as a part of a setup.

“Plain” federated authentication

Basically, there is no need to write code, except modifications of the configuration file, and some onboarding process, which depends on authentication provider (aka identity provider, or STS)and may be very simple. Below is a short overview of what happens during federated authentication.

The application receives the first GET request from a user. The request is intercepted by the federation Http modules, then redirected to identity provider (STS), then redirected back to your application via POST from STS, where the POST carries some 50K encrypted authentication data. The federation Http modules decrypt and validate the authentication data, write authentication cookies (or references to cookies, which is the default in case of FX 4.5). Then the http authentication module triggers a redirect to itself, so that to receive almost original GET request, this time the request having been authenticated, as proved by authentication cookies. Further interaction between the client and your application goes on, for a while, without trips to STS. No code needs be developed to support the federated authentication as described above.

Post authentication

Now what if an application needs to perform additional checks, like custom validation of client certificates, or checks against the local AD (aka resource AD, or RP AD)?

Those post-authentication additional checks (steps) are such that if they fails, the whole authentication should be nullified. That is, the user’s authenticated status should be annihilated, and the STS should be notified so that it will forget the user.

By far the trickiest parts, in post-authentication, implementation-wise, are:

- Where to insert the call to the post-authentication procedure (implementing the post-authentication checks), so that the checks will happen at the earliest possible time, when the very temporary status of being authenticated can’t do any harm.

- How to prevent the federation Http modules from writing the authentication cookies into the response to the client. The cookies should be suppressed, even though the STS already endorsed (authenticated) the user.

Where to insert the post-authentication checks

As mentioned earlier, the STS authenticates the user, then redirects the auth data to the application via POST. The application receives the POST, the POST containing the set of claims from the STS. This set is packaged within an approx. 50 K blob. The only place to call post-authentication code is where the blob is decrypted (by Federation authentication infrastructure) and de-serialized. It is at this point the set of claims in clear is available to the post-authentication code.

So, where is this place? Well, it’s well hidden, and nearly impossible to find, unless you had the (quite a bit of) time to read most of ADFS documentation …

Derive from WSFederationAuthenticationModule

First, derive a class from the “System.IdentityModel.Services.WSFederationAuthenticationModule”, let it be FedAuthenticationModule:

public class FedAuthenticationModule : WSFederationAuthenticationModule

Override the OnAuthenticateRequest

Next, override the method, and, critically important, don’t forget to call the base class:
protected override void OnAuthenticateRequest(object sender, EventArgs e)
{
base.OnAuthenticateRequest(sender, e);
}

Now the Magic Part

And it is here where the magic starts happening. The base.OnAuthenticateRequest calls the OnSessionSecurityTokenCreated, for which *you* also supply an override:
protected override void OnSessionSecurityTokenCreated(
SessionSecurityTokenCreatedEventArgs args)

OnSessionSecurityTokenCreated

This override (callback, as old-timers name it) is the sweet spot to do additional authentication work. This is because it is at this point the authentication blob from the STS has been fully decrypted and deserialized into a set of claims, being now easily accessible from your supplementary post-authentication code.

In the OnSessionSecurityTokenCreated override, you call your post-authentication code:

var token = args.SessionToken;
var success = PostAuthChecks(token);

Here, depending on the success of the PostAuthChecks, either accept the almost-completed authentication, or force it to fail.

How to force the authentication to fail

Now, the STS already authenticated the user. We want, however, to hard-stop the authentication procedure “on track”, so that the user will a) never knows about success and b) cannot take advantage of authentication success, from the STS point of view.

In other words, we need to suppress the default behavior of the Session Authentication Module: write the authentication cookies to the response to the user.

How to Suppress Writing the Authentication Cookies

If the post-authentication checks fail, the best place to suppress writing the auth cookies into the response is right in the OnSessionSecurityTokenCreated override:

args.WriteSessionCookie = false;

The full code looks like below:

protected override void OnSessionSecurityTokenCreated(
SessionSecurityTokenCreatedEventArgs args)
{
     Wpp.Trace(Wpp.TL_VERBOSE, Wpp.TF_COMPONENT, "OnSessionSecurityTokenCreated");
     var token = args.SessionToken;
     var success = PostAuthChecks (token);
     if (success)
     {
         // one of 2 cases: 1) login and SC names match OR 2)
            names don't match, but after second connect to STS and filling in the name-
            matching SC into the
         // credentials dialog, the names became matching. Also case 3) - dev
            mode without certificate and without SC.
         Wpp.Trace(Wpp.TL_INFO, Wpp.TF_COMPONENT,
            "User successfully authenticated, will create the FedAuth cookie shortly");
     }
     else
     {
         // cases include:
         // 1) first connect to STS resulted in SC and login names mismatch
         // 2) all failure cases, including case when user failed
               to provide credentials on second connect to STS
         Wpp.Trace(Wpp.TL_WARN, Wpp.TF_COMPONENT,
            "OnSessionSecurityTokenCreated: Blocking creation of FedAuth cookie");
         // Suppress serializing the token reference into the cookie format,
            and attaching
            the cookie to the response
         args.WriteSessionCookie = false;
     }
}

Amazing C++

Sergei Meleshchuk — Thu, 30 Jun 2011 01:52:57 GMT

Somewhat subconsciously, in a hurry, I wrote the below statement

char command[MAX_QUERY_SIZE] =
"select top 300 "
    "log.InsertsType, log.Inserts, log.Id, log.ProcessId, "
    "log.ThreadId, log.Level, log.MessageNumber, "
    "log.Time, log.MessageGuid, comp.Component, "
    "pool.Fqdn as Pool, machine.Fqdn as Machine "
"from cls.dbo.Log log, cls.dbo.Component comp, "
    "cls.dbo.Fqdn pool, cls.dbo.Fqdn machine "
"where log.ComponentId = comp.Id and log.PoolId = pool.Id and "
    "log.MachineId = machine.Id "
    "and not (comp.Component like '%test%')";

built, run. All fine.

A day later the statement caught my eye. I thought something is wrong with it; how come it even compiles? Is it really a valid statement?

So, after a little research I found that yes, this is one of the official ways to initialize an array of characters. Albeit being used quite rarely: people reasonably prefer either “char* command” variation, OR lstrcpy[A], OR StringCchCopy[A]. But yet, the block initializer works too(!) and it is the language-compliant construction.

So, what is the resulting machine code? Actually, it’s very, very good – I would not write better by hand. First, the text constant is copied, very efficiently, to the “command” field. This is done by hardware loop command, and at each loop iteration a block of four bytes is moved.

Then, the remaining part of the “command” buffer is filled with zero bytes via the old good memset. Here is what is happening in detail. Just great.

PS: This is MS C/C++ compiler, included in VS 2010.

000d4351 b967000000    mov ecx,67h
000d4356 be786c0e00    mov esi,offset clsview!`string' (000e6c78)
000d435b 8dbdb0fbffff lea edi,[ebp-450h]
000d4361 f3a5          rep movs dword ptr es:[edi],dword ptr [esi]
000d4363 66a5          movs word ptr es:[edi],word ptr [esi]
000d4365 684a020000    push 24Ah
000d436a 6a00          push 0
000d436c 8d854efdffff lea eax,[ebp-2B2h]
000d4372               50 push eax
000d4373 e8c3cdffff    call clsview!ILT+310(_memset) (000d113b)

Isn’t the C++ great, and the VC 12.0 compiler real great? I think yes.

Unzip file via java.util.zip package from .NET code

Sergei Meleshchuk — Sun, 05 Apr 2009 01:07:00 GMT

Unzip file via java.util.zip package from .NET code

This week I had to modify a legacy java application that does quite a bit of unpacking of various zip files. Actually the file extensions are .EAR, .WAR, .JAR; those are all zip files. The target application will run under JRE 1.6.0_12.

I had to find a way to code the logic in .NET, but still I need a number of files unzipped (then modify various manifests and descriptors and zip into .EARs again).

Unfortunately, .NET/C# libraries do not have access to a direct equivalent of java.util.zip.* package. I considered few options, including new deflation namespace in .NET 3.5, a number of zlib-based options, use of J# namespace, and using interop to native code which in turn will JNDI to java.util.zip, purchasing a zip command line license, etc.

Finally, I ended up with the simplest solution that works great for my needs; the needs/constraints being:

- Performance hit of 100 milliseconds per unzip operation is fine

- Need 100% same behavior as the one that Sun’s java has

The solution is:

- Write small console java application, which will implement the needed unzip operations. My small java application takes

o []

- Somehow build this application

- Use this application from the .NET code. I set a small function for that.

The following 1) briefly describes the small java application; this one is actually doing the zip/unzip operations, 2) describes how to build it and 3) shows the .NET part of the code.

The java console application which actually unzips

First, we define needed imports, with the zip-related ones:

import java.io.File;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.IOException;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipInputStream;

Next, need few variables:

File fileToUnpack = null;

ZipFile zip = null;

String targetDirName = null;

String entryName = null; // will stay null if unzip whole file

Then we retrieve command-line arguments, validate them (like the zip/ear/war/jar file exists), and open the zip container. We are still in Sun’s java world.

try

{

zip = new ZipFile(fileToUnpack);

}

catch (java.util.zip.ZipException e)

{

log("Cannot open zip file: " + e.toString());

return;

}

catch (java.io.IOException e)

{

log("Cannot open zip file: " + e.toString());

return;

}

In case the command line requested unzipping the whole file, the code path is below. Note few things like normalizing the output path…; if you miss this, you end up with the directory which is only partially functional. Also note the handling of the isDirectory case. The “streamToFile” code will follow.

if (entryName == null) // unpack whole file

{

Enumeration en = zip.entries();

while(en.hasMoreElements())

{

ZipEntry entry = (ZipEntry)en.nextElement();

if (entry.isDirectory())

{

log("directory ignored: " +

entry.toString());

continue;

}

InputStream stm;

try {stm = zip.getInputStream(entry);}

catch (java.io.IOException e)

{

log ("Cannot get input stream for '" + entry.toString() + "' in zip file '" + fileToUnpack.getAbsolutePath());

return;

}

String targetFilename = targetDirName + "/" + entry.toString();

// create dir if needed

int lastSlash = targetFilename.lastIndexOf("/");

if (lastSlash > 0)

{

String dirName = targetFilename.substring(0, lastSlash);

new File(dirName).mkdirs();

}

// Copy zip entry to output directory

targetFilename = targetFilename.replace('/','\\');

streamToFile(stm, targetFilename);

}

Now the function that actually copied a zip entry to the file.

private static void streamToFile(InputStream stm, String targetFilename)

{

FileOutputStream stmOut = null;

byte[] buffer = new byte[copyBufferSize];

int bytecount;

try {stmOut = new FileOutputStream(new File(targetFilename));}

catch (java.io.IOException e)

{

log("Error opening output file '" + targetFilename + "': " + e.toString());

System.exit(101);

}

try

{

while ((bytecount = stm.read(buffer)) > 0)

{

stmOut.write(buffer, 0, bytecount);

}

stmOut.close();

}

catch (java.io.IOException e)

{

log("Error writing output file '" + targetFilename + "': " + e.toString());

System.exit(101);

}

We are almost done with java part, but not completely. The by far the most difficult part remains, at least for me: building the executable. I chose to package the result into the file that I named “main.jar”.

There is a build tool which is similar to MSBUILD. While I did not find many MSBUILD features in ant (like automatic resolution of dependencies between projects), it’s very likely I don’t know enough about ant. Anyhow, the ant works great for me.

Building java application

xml version="1.0"?>

target>

path>

target>

<javac srcdir="." destdir="classes"

classpathref="classpath">

classpath>

javac>

target>

<jar

destfile="lib/main.jar"

basedir="classes"

manifest="MANIFEST.MF"

filesonly="yes">

jar>

target>

delete>

target>

project>

Testing java application

I grabbed few different ZIP, JAR, EAR files and run the program from the command line test script, which I named run.cmd:

m:\jdk1.6.0_12\bin\java -jar lib\main.jar utils.zip.Main %*

For example, I run like:

run unittest3\lib\EXML.jar unittest5

Now .NET part

This is by far the easiest of course. The following is simple testing code, with the procedure to actually call the java unzip as a part of it (what I am saying, this is not the final code; this works great).

Declaration is:

namespace J2eePack

{

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Text;

class Program

{

private const string jzip = @"…"; // this is the location of lib\main.jar

. . .

Now, let’s call couple of un-zipping functions. Only the bold part is interesting:

private const string testEar = @"I:\lm\service\se\lm8\private\service-next\private\ops\test\JZIP\unittest\deployable.ear";

private const string exmlJar = @"I:\lm\service\se\lm8\private\service-next\private\ops\test\J2eePack\J2eePack\unpack2\lib\EXML.jar";

private const string exmlOut = @"I:\lm\service\se\lm8\private\service-next\private\ops\test\J2eePack\J2eePack\unpack2\lib\EXML";

private const string targetSubDir = "unpack2";

// Target location

string current = Assembly.GetExecutingAssembly().GetModules()[0].FullyQualifiedName;

current = Path.GetDirectoryName(current);

string targetDir = Path.Combine(current, targetSubDir);

// Unpack

Unzip(testEar, targetDir);

Unzip(exmlJar, exmlOut);

// test result

string[] files = Directory.GetFiles(targetDir, "*", SearchOption.AllDirectories);

foreach (string file in files)

{

Console.WriteLine(file);

}

The actual code that is doing all the work (by calling the java console program) is:

///

/// Build and execute %java_home%\bin\java.exe -jar [loc]\lib\main.jar utils.zip.Main [file to unzip] [targetDir];

///

/// Full or relative path to the file to unzip

/// The directory to which the zip file will be unzipped to. The directory will be created if missing.

/// true if no erros detected.

/// Note that the example code below allows only 5 seconds for the callee to complete. Modify this to meet the

/// production requirements. Also, note that the below example does not check the exit code of the java proccess.

/// Please add a line when building the production code.

///

private static bool Unzip(string jar, string targetDir)

{

// java exec

string javaHome = Environment.GetEnvironmentVariable("java_home");

if (javaHome == null)

{

Console.WriteLine("cannot obtain java_home");

// javaHome = @"M:\jdk1.6.0_12";

Environment.ExitCode = 101;

return false;

}

string java = Path.Combine(javaHome, @"bin\java.exe");

// arguments

string args = " -jar " + jzip + @"\lib\main.jar utils.zip.Main " + jar + " " + targetDir;

Console.WriteLine(args);

// shell out

Process shell = new Process();

shell.StartInfo.FileName = java;

shell.StartInfo.Arguments = args;

shell.StartInfo.UseShellExecute = false;

shell.Start();

bool ok = shell.WaitForExit(5000);

if (!ok)

{

Console.WriteLine("Error");

return false;

}

return true;

}

Azure storage viewer

Sergei Meleshchuk — Wed, 24 Dec 2008 16:31:00 GMT

Azure storage viewer

(see http://blogs.msdn.com/sergeim for updates)

Contents

Introduction. 1

System requirements. 1

Sample screenshots: 1

Installation. 3

Step 1. Install and start the Viewer. 3

Step 2. Modify configuration file. 4

Step 3. Start browsing your storage. 5

Introduction

If you have registered for Azure Services at http://www.microsoft.com/azure/register.mspx, you may want to explore what is in your storage – your queues, blobs and tables. You can use the “Azure storage viewer” to browse your storage. To a limited extent, you can also add and delete objects in Azure storage (under your account, of course).

The two screen shots below show messages in one of the queues, and contents of a small table.

Azure storage viewer supports both mouse and keyboard navigation. It can be used as a learning tool, or as a content browser for small experimental projects.

System requirements

I tested on Windows 2003 SP2, Vista x32 and x64, Windows 2008 x64 (Standard and DC). I was admin on all machines. Viewer doesn’t need to run elevated.

Sample screenshots

Installation

Step 1. Install and start the Viewer.

The installation is ClickOnce-based. Type

start http://meleshchuk.members.winisp.net/quince/default.htm

in the command window (or click the URL), then click install.

Note: if you already have .NET FX 3.5 SP1 installed, you can just start the Azure storage viewer by typing http://meleshchuk.members.winisp.net/quince/quince.application - the IE understands the “.application” file type.

If you don’t have FX 3.5 SP1, then you will be prompted to install it. Installation of the FX will start automatically. It takes quite a while.

The viewer will start and display the “credentials dialog”. Next, modify configuration file. See next step.

Step 2. Modify configuration file

When the viewer detects connection problem (with the storage), it brings up the “credentials dialog”. Either click “Edit credentials” or “Edit in notepad”. The first option will read configuration file and fillin the two text boxes with current values; copy-paste your account and shared key. The second option opens the configuration file, which looks like below. You can also open configuration file at any time by clicking “Edit Configuration” button.

Change yellow entries to you account and shared key values that you received when signing up to Azure services. Save configuration file (CTRL+S) in case you selected the option to edit the configuration file.

Click OK. You data should be displayed now.

Disclaimer: It is the ClickOnce install generator that placed the viewer under Microsoft group, and I did not figure out yet how to change the group name to something more modest.

. Disclaimer: It is the ClickOnce install generator that placed the viewer under Microsoft group, and I did not figure out yet how to change the group name to something more modest.

xml version="1.0" encoding="utf-8" ?>

<add key = "AccountSharedKey"

value="3SV+JU1S+wDiHPrNEIeOOk2b4Z…u5zPBGbB8CV+t6RfQ=="/>

appSettings>

. . .

Step 3. Start browsing your storage.

Most of the tree view entries present a context menu when right-clicked. Like below.

Pure viewing, however, can be done by just using keyboard arrows.

Typical screenshot of the just started viewer is shown below.

Left pane updates as the selection of the tree items changes:

Accessing Azure storage with Raw REST API

Sergei Meleshchuk — Wed, 10 Dec 2008 20:31:00 GMT

Accessing Azure storage with Raw REST API

Sergei Meleshchuk - blog

Contents

Introduction. 1

Example. 2

Client code: read a message from a queue. 2

CurrentMessageList. 6

MessageBase. 6

Introduction

Azure SDK defines [Raw] REST API, and supplies a client library which isolates a developer from REST API. The client library is a good thing.

Sometimes, however, you may want much thinner layer (than the client library) on top of REST API. The reasons include:

- You want to understand the Azure REST API, without tearing your way thru the code of the client library,

- You want to really understand the client library code, and need to start with a much simpler version of it.

I describe here what is probably the thinnest possible layer on top of the Azure REST API. This “Mini storage library” is easy to learn and understand, and it can be used on its own to access the Azure storage. I am totally ignoring (in this post) the needs of table storage. I chose to concentrate on queue and blob storage operations instead.

The “mini library” a very small number of short functions, which you can completely inline if you want. The class structure is close to absent as well.

Example

I will show how to read a message from the queue storage. The code is, sure, more lengthy then in case of using the client library. However, this code if very close “to the metal”, and you can factor out the boilerplate part very easily. I did not do this intentionally.

The code is followed by the description of the missing parts – the small set of small functions.

Client code: read a message from a queue

private void LibReadOne(object sender, RoutedEventArgs e)

{

TimeSpan elapsed;

// Read configuration data: service URI, account name, access key

string queueName = "registration2";

QueueBase queue = new QueueBase(queueName);

string date = DateTime.UtcNow.ToString("R", CultureInfo.InvariantCulture);

string method = "GET";

string suffix = queueName + "/" + "messages";

string signature = BuildSignature(method, date, queue.Account,

queue.Key, suffix);

suffix += "?numofmessages=1&visibilitytimeout=5";

Uri uri = BuildUri(method, queue, suffix);

HttpWebRequest request = BuildRequest(method, uri, queue.Account,

signature, date);

DateTime starting = DateTime.Now;

XmlDocument doc = ExecuteRequest(request, out elapsed);

Trace("ExeReq time {0}\n", DateTime.Now - starting);

lock (CurrentMessageListLock)

{

/*List*/

CurrentMessageList = DecodeMessages(doc);

}

//Trace("Decode time {0}\n", DateTime.Now - starting);

if (CurrentMessageList != null)

foreach (MessageBase mm in CurrentMessageList)

Trace("[MessageText] {0}\n", mm.MessageText);

else

Trace("[No messages]\n");

}

Missing parts

Below are all the class definition, and low-level functions, needed for the above code to work.

QueueBase

class QueueBase : ServiceEndpoint

{

public string QueueName { get; set; }

public QueueBase(string queueName)

{

this.QueueName = queueName;

base.BaseUri = new Uri(ConfigurationSettings.AppSettings["QueueStorageEndpoint"]);

base.Account = ConfigurationSettings.AppSettings["AccountName"];

base.Base64Key = ConfigurationSettings.AppSettings["AccountSharedKey"];

}

ServiceEndpoint

public class ServiceEndpoint

{

public Uri BaseUri { get; set; }

public string Account { get; set; }

public string Base64Key { private get; set; }

public byte[] Key

{

get { return Convert.FromBase64String(Base64Key); }

}

BuildSignature

string BuildSignature(

string method,

string date,

string accountName,

byte[] sharedKey,

string suffix)

{

string signPart1 = string.Format(CultureInfo.InvariantCulture,

"{0}\n{1}\n{2}\n{3}\n{4}\n/",

method, // 0 - HTTP Method, like GET

string.Empty, // 1 - "Content-MD5" header value. Leave blank.

string.Empty, // 2 - Content type, like MIME. Leave blank.

string.Empty, // 3 - Legacy "date" header. Leave blank.

"x-ms-date:" + date); // 4 - Azure form of date header.

string signPart2 = accountName + "/" + suffix;

string signatureString = signPart1 + signPart2;

byte[] signBytes = System.Text.Encoding.UTF8.GetBytes(signatureString);

byte[] hash = new HMACSHA256(sharedKey).ComputeHash(signBytes);

string signature = System.Convert.ToBase64String(hash);

return signature;

}

BuildUri

Uri BuildUri(string method, ServiceEndpoint svc, string suffix)

{

string accountUriString = string.Format(

CultureInfo.InvariantCulture,

"{0}{1}{2}.{3}",

svc.BaseUri.Scheme,

Uri.SchemeDelimiter,

svc.Account,

svc.BaseUri.Host);

string divisorToken = suffix.Contains('?') ? "&" : "?";

string uriString = string.Format(CultureInfo.InvariantCulture,

"{0}/{1}{2}{3}",

accountUriString,

suffix,

divisorToken,

"timeout=30");

Uri uri = new Uri(uriString);

return uri;

}

BuildRequest

static HttpWebRequest BuildRequest(

string method,

Uri uri,

string accountName,

string signature,

string date)

{

HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(uri);

request.Timeout = 30 * 1000;

request.ReadWriteTimeout = 30 * 1000;

request.Method = method;

request.ContentLength = 0;

request.Headers.Add("x-ms-date", date);

string AuthHeaderValue = string.Format(CultureInfo.InvariantCulture,

"SharedKey {0}:{1}",

accountName,

signature);

request.Headers.Add("Authorization", AuthHeaderValue);

return request;

}

ExecuteRequest

XmlDocument ExecuteRequest(

HttpWebRequest request,

out TimeSpan elapsed)

{

DateTime startTime = DateTime.Now;

elapsed = TimeSpan.MinValue;

try

{

using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())

{

if (response.StatusCode == HttpStatusCode.OK)

{

using (Stream stream = response.GetResponseStream())

{

elapsed = DateTime.Now - startTime;

XmlDocument doc = new XmlDocument();

try

{

#if (DIRECTPARSE)

byte[] data = new byte[10000];

int length = stream.Read(data, 0, 10000);

string dataString = Encoding.UTF8.GetString(data, 0, length);

#endif

doc.Load(stream); // doc = output param

stream.Close();

response.Close();

return doc; // indicate success

}

catch (XmlException xe)

{

stream.Close();

response.Close();

throw xe;

}

else

{

string errorMessage = response.ToString();

throw new InvalidOperationException("Retcode wrong " + errorMessage);

}

catch (WebException we)

{

if (we.Response != null)

{

HttpWebResponse resp = (HttpWebResponse)we.Response;

string description = resp.StatusDescription;

if (description != null)

{

throw new InvalidOperationException(description);

}

throw new InvalidOperationException(we.ToString());

}

DecodeMessages

List<MessageBase> DecodeMessages(XmlDocument doc)

{

List<MessageBase> readMessages = null;

MessageBase msg;

XmlNodeList messagesNodes = doc.SelectNodes("//QueueMessage");

if (messagesNodes.Count == 0)

{

return null;

}

readMessages = new List<MessageBase>();

foreach (XmlNode messageNode in messagesNodes)

{

msg = new MessageBase();

msg.MessageId = messageNode.SelectSingleNode("MessageId").FirstChild.Value.Trim();

Debug.Assert(msg.MessageId != null);

if (messageNode.SelectSingleNode("PopReceipt") != null)

{

msg.MessagePopReceipt = messageNode.SelectSingleNode("PopReceipt").FirstChild.Value.Trim();

Debug.Assert(msg.MessagePopReceipt != null);

}

string base64 = messageNode.SelectSingleNode("MessageText").FirstChild.Value.Trim();

byte[] messageBytes = Convert.FromBase64String(base64);

msg.MessageText = Encoding.UTF8.GetString(messageBytes, 0, messageBytes.Length);

readMessages.Add(msg);

}

return readMessages;

}

CurrentMessageList

List<MessageBase> CurrentMessageList;

MessageBase

class MessageBase

{

public string MessageId { get; set; }

public string MessageText { get; set; }

public string MessagePopReceipt { get; set; }

}

How to do ETW logging from .NET application

Sergei Meleshchuk — Wed, 10 Dec 2008 18:39:00 GMT

How to do ETW logging from .NET application

Sergei Meleshchuk - blog

Contents

Introduction. 1

Sessions and providers. 1

Sample tracing application. 1

Starting tracing session. 2

Stopping and decoding tracing session. 3

Introduction

ETW, Event tracing for Windows, provides strategic benefits like:

- You can log to same file from different threads and processes,

- Extremely fast,

- Tailing log records never lost, even your application crashes without warning,

- You can turn tracing on and off, change level or set of tracing components, without restarting the application

- And so on.

There is a small penalty – namely, you have to decode trace files.

.NET 3.5 provides tracing facilities for ETW. This post is a short reference of how to use the ETW in .NET.

Sessions and providers

You application will be the ‘trace provider’ (see example code about how to advertize the provider). Exposing provider is not enough to start tracing: you have to use one of the ETW command line utilities to actually enable tracing. Of course, this can be done from code; in the latter case you need some interop-ing and I am not writing about this here.

Now, to set up ETW tracing, you have to:

- Author application appropriately:

o Register the listener, all as usual

o Create trace session via e.g. logman utility

o Start session

To decode the trace file, you have to:

- Close tracing session via logman utility

- Decode the log file via another utility, tracerpt.

The remaining part of this post provides details.

Sample tracing application

using System;

using System.Diagnostics;

using System.Diagnostics.Eventing;

namespace EtwSample

{

class Program

{

private static Guid providerId =

new Guid("{A11a0820-c24b-428c-83e2-26b41091702e}");

static void Main(string[] args)

{

EventProviderTraceListener listener =

new EventProviderTraceListener(providerId.ToString());

TraceSource source =

new TraceSource("MyProvider", SourceLevels.All);

source.Listeners.Add(listener);

source.TraceData(

TraceEventType.Warning | TraceEventType.Start, 2,

new object[] { "abc", "def", true, 123 });

/* Uncommen below if you want more fancy logging ...

source.TraceEvent(

TraceEventType.Warning, 12, "Provider guid: {0}",

new object[] { providerId });

source.TraceInformation(

"string {0}, bool {1}, int {2}, ushort {3}",

new object[] { "abc", false, 123, (UInt32)5 });

* */

for (int i = 0; i < 100; i++)

{

source.TraceInformation(

"This is sample trace record " + i);

}

source.Close();

}

Starting tracing session

1. Pre-create logging directory, such as c:\logs

2. On Vista or Server 2008, open elevated command window and type:

logman create trace mysession -o c:\logs\mylog -p "{A11a0820-c24b-428c-83e2-26b41091702e}"
where the GUID is the same you have in the code line
private static Guid providerId.
Other (red) parts of the command are arbitrary names.

3. Start tracing session using the command (for example):
logman start mysession

Stopping and decoding tracing session

1. Stop session via command
logman stop mysession

2. Decode log file
tracerpt c:\logs\mylog_000001.etl

As a result of the decoding, you have, in the current directory, 2 files:

dumpfile.xml – contains your decoded trace file

Summary.txt – some statistical information

Request authorization in Azure SDK

Sergei Meleshchuk — Wed, 10 Dec 2008 16:07:00 GMT

Request authorization in Azure SDK

Sergei Meleshchuk - blog

Introduction

Azure storage requires all client REST requests be “signed”. The storage server validates the signature. The server will reject the request if it is not properly signed.

The goal of this post is to explain how the client-side signing works. That can help when troubleshooting 403 error codes. In addition, you can sign your requests entirely bypassing the client library of the Azure SDK.

Shared key authentication (authorization) in Azure

Client (that is, you) receives a “key”, in a form of Base64 string. The key is sent to you when you sign for Azure services.

The client code takes certain parts of the request in a specific order, and builds (from those parts) a string. I refer to this string as to “signature string”. This string will be the argument to the signing algorithm, the latter computes the “signature”. This computed signature is sent, along with the request, to the server. Needless to say, the shared key itself is not sent.

Thus, the client-side signing procedure is:

- Build a “signature string”, from which the actual signature will be computed,

- Compute signature, using the “signature string” as an argument, and using the shared key

- Send the resulting signature in a form of additional request header.

Building the signature string

By far the most interesting part of the whole signing exercise are rules of building the signature string. I start by listing parts of the request, which go into signature string.

There are two parts.

The first part is the “suffix” of the request URL, which is everything that follows the hostname part of the URL, without the query params starting with “?”.

For example, if the URL is

“http://accountname.queue.core.windows.net/queuename/messages?numofmessages=1&timeout=30”

Then the suffix part for signature is:

“queuename/messages”.

Part 2 is composed of HTTP request header values, but not all of them. There are two groups of headers that do participate: 1) legacy headers like date, MD5, content type, and 2) Azure-specific headers, which are headers with names starting with “x-ms-”. For example, “x-ms-date”.

For queue and blob storage, the first group can be ignored.

The second group is, in general case, sorted by ascending header name, and concatenated. However, because in all practical cases, we only need one header (which is “x-ms-date”), I ignore the multi-header case here. The gain is extreeme simplicity of the resulting code.

The signature string needs the value of current time, in UTC, and in standard format. The time is to be retrieved by the code:

string date = DateTime.UtcNow.ToString(

"R",

CultureInfo.InvariantCulture);

Now, here is the code that builds the signature string:

string signPart1 = string.Format(CultureInfo.InvariantCulture,

"{0}\n{1}\n{2}\n{3}\n{4}\n/",

method, // 0 - HTTP Method, like GET

string.Empty, // 1 - "Content-MD5" header value. Leave blank.

string.Empty, // 2 - Content type, like MIME. Leave blank.

string.Empty, // 3 - Legacy "date" header. Leave blank.

"x-ms-date:" + date); // 4 - Azure form of date header.

string signPart2 = accountName + "/" + suffix;

string signatureString = signPart1 + signPart2;

The resulting signature string looks like below.

"GET\n\n\n\nx-ms-date:Mon, 01 Dec 2008 05:17:57 GMT\n/accountname/queuename/messages"

Building the signature from signature string

This is easy part. All the needed code is:

byte[] signBytes = System.Text.Encoding.UTF8.GetBytes(signatureString);

byte[] hash = new HMACSHA256(sharedKey).ComputeHash(signBytes);

string signature = System.Convert.ToBase64String(hash);

return signature;

The first line converts the signature string to byte array; this is needed because the actual hash-computing code works on byte arrays.

The second line computes the hash.

And the third and the last line just convert the signature to Base64.

Note: the “sharedKey” used in line 2 is computed, once, from the Base64 shared key your received by the code like below, also straightforward:

public byte[] Key

{

get { return Convert.FromBase64String(Base64Key); }

}

How do we actually sign the HTTP request

Azure SDK uses an Azure-specific HTTP header, with the name “Authorization”. Don’t be confused by “authorization” vs. “authentication” – the actual use as per now is for authentication of the client. And authentication/authorization header value is computed as below:

string AuthHeaderValue = string.Format(CultureInfo.InvariantCulture,

"SharedKey {0}:{1}",

accountName,

signature);

Now we all we need to build needed headers for signed HTTP REST request:

request.Headers.Add("x-ms-date", date);

request.Headers.Add("Authorization", AuthHeaderValue);

The End

Prepare VM: Add ISO Programmatically . Hyper-V, C# version

Sergei Meleshchuk — Fri, 06 Jun 2008 05:00:00 GMT

Prepare VM: Programmatically Add ISO. Hyper-V, C# version

[Sergei Meleshchuk. http://blogs.msdn.com/sergeim/]

Imagine I want prepare VM fully automatically (programmatically, via code). Say I need a fully functional VM. That is, OS and applications loaded, ready for use. Why adding (mounting) ISO is important here?

Here is why. To set up a VM, I need 3 or 4 steps:

- Create VM

- Add (mount) installation disk. That is, add ISO

- Boot from this ISO image

- Next depends on ISO. If this is normal OS image, you will need to finish installation with some manual actions. However, ISO may contain PXE which will just do un-attended installation from say network share or via WDS (this is for future post).

About this document

I outline steps (of adding ISO), briefly comment on implementation of each step, than provide complete code.

Credits

Inspired by James O’Neill’s PowerShell code. See his site.

Steps outline

Step 1 will be grabbing an empty “template” of the ISO image. This template is pre-existent in Hyper-V WMI-based management infrastructure.

Step 2 is to obtain management object representing our VM; the VM is likely to be just created. We only need this VM object to get access to the disk controller. To cut down number of command line parameters, we will hard-code the controller ID: it will be 1 (naturally).

Step 3 will be obtaining the controller object. That is, the WMI object representing controller 1 on specific VM.

Step 4, somewhat lengthy to explain. There is a pre-existing disk object for each disk controller 1 on each VM. This disk object has parent field, which is the controller’s identifier in WMI meaning of the word “identifier”. That is, the parent field is the WMI object path, usually pretty long string. Thus we will search for the disk object by scanning controllers, and comparing their Path with the parent field in each disk object. Little clumsy, yet I don’t know of another way.

Step 5. Here important work starts. We set values on template (from step 1). There will be 2 values to set: a) path to ISO image, which we originally obtain from the command line and b) the disk object from step 4.

Step 6 is to ask the management service to add the template (from step 4) to the VM (from step 2).

Step 0. Preparation

Use abbreviations and get data from command line. This is simple.

using MO = ManagementObject;

using MBO = ManagementBaseObject;

using MOS = ManagementObjectCollection;

. . .

const string CONTROLLER_ID_1 = "1";

string vmDisplayName;

string iso;

// e.g. @"H:\ISO\Virtual Server 2008\amd64fre.iso";

// get arguments

if (args.Length < 2)

{

Console.WriteLine("usage: addiso ");

return;

}

vmDisplayName = args[0];

iso = args[1];

Step 1. Get ISO template object

One line:

MO moTemplateRasd = GetISOTemplate();

- where the GetISOTemplate we have to write ourselves:

private MO GetISOTemplate()

{

string where;

MO capability = GetWmiObject(

"MsVM_AllocationCapabilities",

"ResourceType = 21 and ResourceSubType = 'Microsoft Virtual CD/DVD Disk'");

AssertWmi(capability);

// -- MsVM_SettingsDefineCapabilities

where = string.Format(

"valuerange=0 and Groupcomponent = \"{0}\"",

FixPath(capability.Path.Path));

Log(capability.Path.Path);

Log(where);

MO define = GetWmiObject("MsVM_SettingsDefineCapabilities", where);

string partComponent = define["partcomponent"] as string;

Log("*{0}", partComponent);

// -- MsVM_ResourceAllocationSettingData for IDE drive (RASD/IDE)

MO component = new MO(partComponent);

Logc("COMP", "#{0}", component.Path.Path);

// this ws the one we want to set parent of

DumpMO("COMP", component);

return component;

}

Step 2. Get VM object.

This is straight:

MO moVmComputerSystem = GetVM(vmDisplayName);

string vmGuidName = moVmComputerSystem["name"] as string;

with the GetVM function being:

MO GetVM(string vmElementName)

{

string where;

where = string.Format(

CultureInfo.InvariantCulture,

"elementname='{0}'",

vmElementName);

MO theVm = GetWmiObject("msvm_computersystem", where);

return theVm;

}

Step 3. Get controller.

This is little difficult. We look for controller, having a) VM object and b) controller ID, which is traditionally (at the time of writing) 1.

MO moControllerRasd = GetController(moVmComputerSystem, CONTROLLER_ID_1);

GetController is our function that we have to write. The code is below.

MO GetController(MO theVm, string controllerId)

{

string vmName = theVm["name"] as string;

string where = string.Format(

CultureInfo.InvariantCulture,

"resourceSubtype='{0}' and instanceId Like 'Microsoft:{1}%' and address='{2}'",

"Microsoft Emulated IDE Controller",

vmName,

controllerId);

MO moControllerRasd = GetWmiObject("MsVM_ResourceAllocationSettingData", where);

return moControllerRasd;

}

Step 4. Get disk object – child of the controller

MO moDiskRasd = GetControllerChild(

vmGuidName,

moControllerRasd.Path.Path);

Again, the GetControllerChild is what we have to write:

MO GetControllerChild(string vmName, string controllerPath)

{

string where = string.Format(

CultureInfo.InvariantCulture,

"parent Like '%Microsoft:{0}%'",

vmName);

MOS childrenDisks = GetWmiObjects(Constants.RASD_CLASS, where);

foreach (MO disk in childrenDisks)

{

string parentPath = disk["parent"] as string;

if (parentPath != null)

{

if (parentPath.Equals(controllerPath, StringComparison.OrdinalIgnoreCase))

{

DumpMO("child", disk);

return disk;

}

throw new InvalidOperationException("Cant locate child drive for controller " + controllerPath);

}

Step 5. Update template

// Step 5. Now actual work:

// - update template with disk resource data (by setting template's parent), and

// - set ISO location

moTemplateRasd["parent"] = moDiskRasd.Path.Path;

moTemplateRasd["connection"] = new string[] { iso };

moTemplateRasd.Put();

Step 6. Ask the management service to apply filled-in template

MO moManagementService = GetMsVM_virtualSystemManagementService();

MBO mboCallInParams = moManagementService.GetMethodParameters("AddVirtualSystemResources");

mboCallInParams["TargetSystem"] = moVmComputerSystem;

string componentText = moTemplateRasd.GetText(TextFormat.WmiDtd20);

mboCallInParams["ResourceSettingData"] = new string[] { componentText };

ManagementBaseObject mboCallOutParams = moManagementService.InvokeMethod(

"AddVirtualSystemResources",

mboCallInParams,

null);

Full code

// auth: Sergei Meleshchuk, June 2008.

// Based in part on powershell code by James O'Naill

using System;

using System.Management;

using System.Globalization;

namespace Hyperv.Misc

{

using MO = ManagementObject;

using MBO = ManagementBaseObject;

using MOS = ManagementObjectCollection;

class MainAddISO3

{

static void Main(string[] args)

{

AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Oops);

MainAddISO3 main = new MainAddISO3();

main.AddISO(args);

}

private void AddISO(string[] args)

{

const string CONTROLLER_ID_1 = "1";

string vmDisplayName;

string iso; // e.g. @"H:\ISO\Virtual Server 2008\6001.18000.080118-1840_amd64fre_Server_en-us_VL-KRMSXVOL_EN_DVD.iso";

// get arguments

if (args.Length < 2)

{

Console.WriteLine("usage: addiso ");

return;

}

vmDisplayName = args[0];

iso = args[1];

// Step 1. Get template (of type: MsVM_ResourceAllocationSettingData)

MO moTemplateRasd = GetISOTemplate();

// Step 2. Get VM (needed when locating controller, of type msvm_ComputerSystem)

MO moVmComputerSystem = GetVM(vmDisplayName);

string vmGuidName = moVmComputerSystem["name"] as string;

// Step 3. Get disk controller (of type: MsVM_ResourceAllocationSettingData)

MO moControllerRasd = GetController(moVmComputerSystem, CONTROLLER_ID_1);

// Step 4. Get Disk - the RASD object to which the controller is a parent

MO moDiskRasd = GetControllerChild(

vmGuidName,

moControllerRasd.Path.Path);

// Step 5. Now actual work:

// - update template with disk resource data (by setting template's parent), and

// - set ISO location

moTemplateRasd["parent"] = moDiskRasd.Path.Path;

moTemplateRasd["connection"] = new string[] { iso };

moTemplateRasd.Put();

// Step 6. Now really actual work: Add actual resource from info in the template

MO moManagementService = GetMsVM_virtualSystemManagementService();

MBO mboCallInParams = moManagementService.GetMethodParameters("AddVirtualSystemResources");

mboCallInParams["TargetSystem"] = moVmComputerSystem;

string componentText = moTemplateRasd.GetText(TextFormat.WmiDtd20);

mboCallInParams["ResourceSettingData"] = new string[] { componentText };

ManagementBaseObject mboCallOutParams = moManagementService.InvokeMethod(

"AddVirtualSystemResources",

mboCallInParams,

null);

DumpMBO("AddVirtualSystemResources:", mboCallOutParams);

// Check result here

}

// Main helpers

#region helpers

MO GetVM(string vmElementName)

{

string where;

where = string.Format(

CultureInfo.InvariantCulture,

"elementname='{0}'",

vmElementName);

MO theVm = GetWmiObject("msvm_computersystem", where);

return theVm;

}

MO GetController(MO theVm, string controllerId)

{

string vmName = theVm["name"] as string;

string where = string.Format(

CultureInfo.InvariantCulture,

"resourceSubtype='{0}' and instanceId Like 'Microsoft:{1}%' and address='{2}'",

"Microsoft Emulated IDE Controller",

vmName,

controllerId);

MO moControllerRasd = GetWmiObject("MsVM_ResourceAllocationSettingData", where);

return moControllerRasd;

}

MO GetControllerChild(string vmName, string controllerPath)

{

string where = string.Format(

CultureInfo.InvariantCulture,

"parent Like '%Microsoft:{0}%'",

vmName);

MOS childrenDisks = GetWmiObjects(Constants.RASD_CLASS, where);

foreach (MO disk in childrenDisks)

{

string parentPath = disk["parent"] as string;

if (parentPath != null)

{

if (parentPath.Equals(controllerPath, StringComparison.OrdinalIgnoreCase))

{

DumpMO("child", disk);

return disk;

}

throw new InvalidOperationException("Cant locate child drive for controller " + controllerPath);

}

private MO GetMsVM_virtualSystemManagementService()

{

return GetWmiObject("MsVM_virtualSystemManagementService", null);

}

private MO GetISOTemplate()

{

string where;

MO capability = GetWmiObject(

"MsVM_AllocationCapabilities",

"ResourceType = 21 and ResourceSubType = 'Microsoft Virtual CD/DVD Disk'");

AssertWmi(capability);

// -- MsVM_SettingsDefineCapabilities

where = string.Format(

"valuerange=0 and Groupcomponent = \"{0}\"",

FixPath(capability.Path.Path));

Log(capability.Path.Path);

Log(where);

MO define = GetWmiObject("MsVM_SettingsDefineCapabilities", where);

string partComponent = define["partcomponent"] as string;

Log("*{0}", partComponent);

// -- MsVM_ResourceAllocationSettingData for IDE drive (RASD/IDE)

MO component = new MO(partComponent);

Logc("COMP", "#{0}", component.Path.Path);

// this ws the one we want to set parent of

DumpMO("COMP", component);

return component;

}

#endregion helpers

#region generic wmi helpers

static string FixPath(string path)

{

string result = path.Replace("\\", "\\\\").Replace("\"", "'");

Console.ForegroundColor = ConsoleColor.DarkYellow;

Log("FixPath returns\n" + result);

Console.ResetColor();

return result;

}

private MO GetWmiObject(string classname, string where)

{

MOS resultset = GetWmiObjects(classname, where);

if (resultset.Count != 1)

throw new InvalidOperationException(

string.Format(

"Cannot locate {0} where {1}",

classname,

where));

MOS.ManagementObjectEnumerator en = resultset.GetEnumerator();

en.MoveNext();

MO result = en.Current as MO;

if (result == null)

throw new InvalidOperationException("Failure retrieving " + classname + " where " + where);

return result;

}

private MOS GetWmiObjects(string classname, string where)

{

string query;

ManagementScope scope = new ManagementScope(@"root\virtualization", null);

if (where != null)

{

query = string.Format(

"select * from {0} where {1}",

classname,

where);

}

else

{

query = string.Format(

CultureInfo.InvariantCulture,

"select * from {0}",

classname);

}

ManagementObjectSearcher searcher = new ManagementObjectSearcher(

scope,

new ObjectQuery(query));

ManagementObjectCollection resultset = searcher.Get();

return resultset;

}

void AssertWmi(MO mo)

{

if (mo == null)

throw new NullReferenceException("dfasd");

}

void AssertNotNull(string tag, object o)

{

if (o == null)

throw new NullReferenceException("AssertFailed with tag " + tag);

}

#endregion generic wmi helpers

// -- end of main helpers

// ---- Logging functions -----

#region logging

private static void Log(string message, params object[] data)

{

Console.WriteLine(message, data);

}

private static void Logc(string title, string message, params object[] data)

{

Console.ForegroundColor = ConsoleColor.Green;

Console.Write(title);

Console.ResetColor();

Console.WriteLine(message, data);

}

private static void DumpMO(

string message,

MO mo,

params object[] data)

{

Console.ForegroundColor = ConsoleColor.White;

Console.WriteLine(message, data);

Console.ResetColor();

PropertyDataCollection props = mo.Properties;

foreach (PropertyData prop in props)

{

Log("{0:20} {1}", prop.Name, prop.Value);

}

private static void DumpMBO(

string message,

ManagementBaseObject mo,

params object[] data)

{

Console.ForegroundColor = ConsoleColor.White;

Console.WriteLine(message, data);

Console.ResetColor();

PropertyDataCollection props = mo.Properties;

foreach (PropertyData prop in props)

{

Log("{0:20} {1}", prop.Name, prop.Value);

}

#endregion logging

// expection handler

private static void Oops(object sender, UnhandledExceptionEventArgs e)

{

Console.BackgroundColor = ConsoleColor.White;

Console.ForegroundColor = ConsoleColor.Black;

Exception ex = e.ExceptionObject as Exception;

Log(ex.Message);

Console.ResetColor();

Log(ex.ToString());

}

} // class MainCreateVm

class Constants

{

internal const string DefineVirtualSystem = "DefineVirtualSystem";

internal const string ModifyVirtualSystem = "ModifyVirtualSystem";

internal const uint ERROR_SUCCESS = 0;

internal const uint ERROR_INV_ARGUMENTS = 87;

internal const string RASD_CLASS = "MsVM_ResourceAllocationSettingData";

}