Syrstad

Rest, DI containers and unit testing

2016-05-10T21:10:00.000+02:00

It's been a while since the last post now. Been quite busy with a large understaffed project i'm working on. But now I have something to share, at last.

As the world are moving to REST services (and luckily we have a proper way to describe the services we create with swagger), we still write a lot of boilerplate code and implementing clients for services that others (in the team, our organization or 3rd party vendors). Unit testing suffers as the service implementations are strongly tied to the Http context and request response scope.

With this as a backdrop I tried to create a tool that can wrap an interface without any ties to the http stuff we usually have in webapi, and still retain the flexibillity of it. I guess I got a bit carried away.

So to the solution:

A small package that generates a client over the contract and enables service generation over the same interface.

Code you say? Lets roll..

The interface:

[IRoutePrefix("api")]
public interface ITestApi
{
[Route("test/{id}")]
[HttpGet]
string Apply1([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Path)]string name);

[Route("test2/{id}")]
[HttpGet]
string Apply2([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Path)]string name, [In(InclutionTypes.Header)]string item3);

[Route("test3/{id}")]
[HttpGet]
string Apply3([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Path)]string name, [In(InclutionTypes.Header)]string item3, [In(InclutionTypes.Header)]string item4);

[Route("put1/{id}")]
[HttpPut]
void Put([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Body)] DateTime timestamp);

[Route("test5/{id}")]
[HttpGet]
Task ApplyAsync([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Path)]string name, [In(InclutionTypes.Path)]string item3, [In(InclutionTypes.Path)]string item4);

[Route("put2/{id}")]
[HttpPut]
Task PutAsync([In(InclutionTypes.Path)] string id, [In(InclutionTypes.Body)] DateTime timestamp);
}

As you can see, the interface is decorated with some of the known and loved attributes from WebApi,

like Route, HttpGet and HttpPost, and some new like the InAttribute. This workes like the FromUri and FromBody with the addition of Header.

You can still use the FromBody and FromUri attributes, the tool converts them to In internally.

And note the IRoutePrefixAttribute vs RoutePrefixAttribute in webapi. RoutePrefixAttribute is limitet to classes only, so to make this work i had to create a new attribute that maps to RoutePrefixAttribute.

To make a service you have to apply a DI container and register the implementation of the interface.

After that you only need 2 lines of code to wrap the interface behind a WebApi controller.

The service:

    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            ServiceFactory.CreateServiceImplementationForAllInCotainingAssembly();
            ServiceFactory.FinalizeRegistration();

            this.LoadBindingConfiguration();
           
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }
    }

The generated service:

[RoutePrefix("api")]

public class TestApiController : ServiceWrapperBase
{
    // Methods
    public TestApiController(ITestApi implementation) : base(implementation)
    {
    }

    [Route("test1/{id}"), HttpGet]
    public HttpResponseMessage Apply1([FromUri] string id, [FromUri] string name)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, name };
            ParameterWrapper[] wrapperArray = base.GatherParameters("Apply1", fromWebMethodParameters);
            string message = base.implementation.Apply1((string) wrapperArray[0].value, (string) wrapperArray[1].value);
            return base.CreateResponse(HttpStatusCode.OK, message);
        }
        catch (Exception exception)
        {
            return base.CreateErrorResponse(exception);
        }
    }

    [HttpGet, Route("test2/{id}")]
    public HttpResponseMessage Apply2([FromUri] string id, [FromUri] string name, string item3)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, name, item3 };
            ParameterWrapper[] wrapperArray = base.GatherParameters("Apply2", fromWebMethodParameters);
            string message = base.implementation.Apply2((string) wrapperArray[0].value, (string) wrapperArray[1].value, (string) wrapperArray[2].value);
            return base.CreateResponse(HttpStatusCode.OK, message);
        }
        catch (Exception exception)
        {
            return base.CreateErrorResponse(exception);
        }
    }

    [Route("test/{id}"), HttpGet]
    public HttpResponseMessage Apply3([FromUri] string id, [FromUri] string name, string item3, string item4)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, name, item3, item4 };
            ParameterWrapper[] wrapperArray = base.GatherParameters("Apply3", fromWebMethodParameters);
            string message = base.implementation.Apply3((string) wrapperArray[0].value, (string) wrapperArray[1].value, (string) wrapperArray[2].value, (string) wrapperArray[3].value);
            return base.CreateResponse(HttpStatusCode.OK, message);
        }
        catch (Exception exception)
        {
            return base.CreateErrorResponse(exception);
        }
    }

    [HttpGet, Route("test/{id}")]
    public Task ApplyAsync([FromUri] string id, [FromUri] string name, [FromUri] string item3, [FromUri] string item4)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, name, item3, item4 };
            ParameterWrapper[] wrapperArray = base.GatherParameters("ApplyAsync", fromWebMethodParameters);
            Task messageTask = base.implementation.ApplyAsync((string) wrapperArray[0].value, (string) wrapperArray[1].value, (string) wrapperArray[2].value, (string) wrapperArray[3].value);
            return base.CreateResponseAsync(HttpStatusCode.OK, messageTask);
        }
        catch (Exception exception)
        {
            return Task.FromResult(base.CreateErrorResponse(exception));
        }
    }

    [HttpPut, Route("test/{id}")]
    public HttpResponseMessage Put([FromUri] string id, [FromBody] DateTime timestamp)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, timestamp };
            ParameterWrapper[] wrapperArray = base.GatherParameters("Put", fromWebMethodParameters);
            base.implementation.Put((string) wrapperArray[0].value, (DateTime) wrapperArray[1].value);
            return base.CreateResponse(HttpStatusCode.OK, null);
        }
        catch (Exception exception)
        {
            return base.CreateErrorResponse(exception);
        }
    }

    [HttpPut, Route("test/{id}")]
    public Task PutAsync([FromUri] string id, [FromBody] DateTime timestamp)
    {
        try
        {
            object[] fromWebMethodParameters = new object[] { id, timestamp };
            ParameterWrapper[] wrapperArray = base.GatherParameters("PutAsync", fromWebMethodParameters);
            Task messageTask = base.implementation.PutAsync((string) wrapperArray[0].value, (DateTime) wrapperArray[1].value);
            return base.CreateResponseVoidAsync(HttpStatusCode.OK, messageTask);
        }
        catch (Exception exception)
        {
            return Task.FromResult(base.CreateErrorResponse(exception));
        }
    }
}

The implementation bases it's http status codes on the exception type the implementation creates (a really limited amount of mappings at the moment)

The client:

[Fact]
public async Task GeneratorTest()
{
var service = ProxyFactory.CreateInstance("http://localhost/Stardust.Interstellar.Test/");
try
{
var res =await service.ApplyAsync("test", "Jonas Syrstad", "Hello", "Sample");
output.WriteLine(res);
}
catch (Exception ex)
{
throw;
}
try
{
await service.PutAsync("test",DateTime.Today);
output.WriteLine("Put was successfull");
}
catch (Exception ex)
{
throw;
}
}

To create and instantiate the rest client you only need one line of code (in the simplest scenarios) and you are good to go accessing the service. Wrapping the client in a container it will work nicely with any DI container

and you can easily mock the remote service when unit testing the client application.

This tool is available on nuget and feedback is more than welcome.

I do have some ideas on which features to add next, but feedback can change the priorities.

Nuget:

Install-Package Stardust.Interstellar.Rest

Cheers

/J

How to programmatically configure WCF services and clients at runtime pt. 3.

2013-11-12T11:01:00.000+01:00

In this post, we’ll go into some details about WCF and WIF (Windows Identity Foundation). I have to admit that I used some time to get the demo to work (with both azure acs and ADFS). However, it seems that Azure ACS does have a big short coming for this type of scenario, it does not support ActAs (or identity delegation if you like). Which in a SoA context is vital to ensure end-to-end security for messages and features of the UI.

Please note that the code provided is _not_ production ready.

The two scenarios we are looking at:

1. Identity federation: enable claims based authentication on wcf services by dynamically configuring WCF and WIF. Ideal for active clients like thick clients and background services.

2. Identity delegation: allows a user identity to be reused by a trusted service account. Ideal for passive clients like web browsers.

Because ACS does not support ActAs we end up with a slightly more complex example that I initially imagined. Here is how this sample works:

The end user authenticates with Azure ACS (in the sample ACS is configured to authenticate with Facebook, google, Microsoft or Yahoo!) while the web server authenticates the service account with ADFS only. Both the user and the service account must have valid users that is authenticated.

Time for code (enough with the abstract stuff).

First we need to add a new binding builder for the secure binding.

internal class SecureBindingBuilder : IBindingBuilder

{

private bool IsClient;

public Binding CreateBinding(string serviceName)

{

System.Net.ServicePointManager.ServerCertificateValidationCallback =

((sender, certificate, chain, sslPolicyErrors) => true);

var secureBinding = new WS2007FederationHttpBinding(WSFederationHttpSecurityMode.TransportWithMessageCredential)

{

Name = "secure",

TransactionFlow = false,

HostNameComparisonMode = HostNameComparisonMode.StrongWildcard,

MaxBufferPoolSize = int.Parse(GetWsValue(serviceName, "MaxBufferPoolSize")),

MaxReceivedMessageSize = int.Parse(GetWsValue(serviceName, "MaxReceivedSize")),

MessageEncoding = (WSMessageEncoding)Enum.Parse(typeof(WSMessageEncoding), GetWsValue(serviceName, "MessageFormat")),

TextEncoding = Encoding.GetEncoding(GetWsValue(serviceName, "TextEncoding")),

ReaderQuotas = XmlDictionaryReaderQuotas.Max,

BypassProxyOnLocal = true,

UseDefaultWebProxy = false,

};

SetSecuritySettings(serviceName, secureBinding);

return secureBinding;

}

private void SetSecuritySettings(string serviceName, WSFederationHttpBinding secureBinding)

{

secureBinding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Basic256;

secureBinding.Security.Message.NegotiateServiceCredential = false;

secureBinding.Security.Message.EstablishSecurityContext = false;

secureBinding.Security.Message.IssuedKeyType = SecurityKeyType.BearerKey;

secureBinding.Security.Message.IssuedTokenType = null;

EndpointIdentity identity = EndpointIdentity.CreateDnsIdentity((new Uri(AddressHelper.GetIssuerName(serviceName)).DnsSafeHost));

secureBinding.Security.Message.IssuerAddress = CreateIssuerAddress(serviceName,identity);

if (IsClient) secureBinding.Security.Message.IssuerBinding = CreateIssuerBinding(serviceName);

else

secureBinding.Security.Message.IssuerMetadataAddress = new EndpointAddress(new Uri(AddressHelper.GetStsMetadataAddress(serviceName)),identity);

}

private EndpointAddress CreateIssuerAddress(string serviceName,EndpointIdentity identity)

{

if(IsClient)

return new EndpointAddress(new Uri(AddressHelper.GetStsActAsAddress(serviceName)));

return new EndpointAddress(new Uri(AddressHelper.GetIssuerName(serviceName)));

}

private static Binding CreateIssuerBinding(string serviceName)

{

return BindingFactory.GetBindingBuilder("stsbinding").CreateBinding(serviceName);

}

private static string GetWsValue(string serviceName, string valueName)

{

var inheritFrom = GetSecureValue(serviceName, "InheritFrom");

return ConfigurationReader.Reader.GetValue(ExpressionBuilder.GetEndpointConfigValue(serviceName, inheritFrom, valueName));

}

private static string GetSecureValue(string serviceName, string valueName)

{

return ConfigurationReader.Reader.GetValue(ExpressionBuilder.GetEndpointConfigValue(serviceName, "secure", valueName));

}

public void SetClientMode(bool isClient)

{

IsClient = isClient;

}

Note that we use the WS2007FederationHttpBinding which has most of the binding elements for WIF added. The first line in CreateBinding is added only to allow connections over SSL with self signed certificates, this should be removed in production code or made optional though the configuration framework.

For WIF to hook properly into the WCF framework we need to do some configuration on the service host. Create a helper method in HostFactory called Configure to make this independent of the service implementation.

public static void Configure(ServiceConfiguration config)

{

var serviceName = GetServiceName(config.Description.ServiceType);

config.IdentityConfiguration = new IdentityConfiguration()

{

TrustedStoreLocation = new StoreLocation(),

AudienceRestriction = { AudienceMode = AudienceUriMode.Always },

SaveBootstrapContext = true,

IssuerTokenResolver = new IssuerTokenResolver(),

CertificateValidationMode = X509CertificateValidationMode.None,

};

config.IdentityConfiguration.AudienceRestriction.AllowedAudienceUris.Add(new Uri(GetSecureValue(serviceName, "Audience")));

config.IdentityConfiguration.IssuerNameRegistry = CreateIssuerNameRegistry(serviceName);

config.UseIdentityConfiguration = true;

}

private static ConfigurationBasedIssuerNameRegistry CreateIssuerNameRegistry(string serviceName)

{

var registry = new ConfigurationBasedIssuerNameRegistry();

registry.AddTrustedIssuer(GetSecureValue(serviceName, "Thumbprint"), GetSecureValue(serviceName, "IssuerName"));

return registry;

}

We need to run this code from the service implementation (to me it seems that this is convention based) by adding the following code in DemoService.svc.cs

public static void Configure(ServiceConfiguration config)

{

HostFactory.Configure(config);

}

When this is done we need some way to get security tokens from ADFS. By isolating the needed code in a TokenManager class, we reduce the number of changes needed in the ServiceProxyContainer class.

public class TokenManager

{

private readonly string ServiceName;

private readonly string UserName;

private readonly string Password;

private readonly SecurityToken BootstrapToken;

public TokenManager(string serviceName, string username,string password)

{

UserName = username;

Password = password;

ServiceName = serviceName;

}

public TokenManager(string serviceName,SecurityToken bootstrapToken, string username, string password)

{

UserName = username;

Password = password;

ServiceName = serviceName;

BootstrapToken = bootstrapToken;

}

public SecurityToken GetToken()

{

var channel = CreateChannel();

var rst = CreateIssueNewRequest();

return GetSecurityToken(channel, rst);

}

private RequestSecurityToken CreateIssueNewRequest()

{

var rst = new RequestSecurityToken

{

RequestType = RequestTypes.Issue,

KeyType = KeyTypes.Bearer,

AppliesTo =

new EndpointReference(

ConfigurationReader.Reader.GetValue(

ExpressionBuilder.GetEndpointConfigValue(

ServiceName, "secure", "Address")))

};

return rst;

}

private static SecurityToken GetSecurityToken(WSTrustChannel channel, RequestSecurityToken rst)

{

RequestSecurityTokenResponse rstr = null;

var token = channel.Issue(rst, out rstr);

return token;

}

private WSTrustChannel CreateChannel()

{

var stsBinding = CreateStsBinding();

var trustChannelFactory = new WSTrustChannelFactory(stsBinding, AddressHelper.GetStsAddress(ServiceName))

{

TrustVersion =

TrustVersion

.WSTrust13

};

trustChannelFactory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode =

X509CertificateValidationMode.None;

trustChannelFactory.Credentials.UserName.UserName = UserName;

trustChannelFactory.Credentials.UserName.Password = Password;

trustChannelFactory.Endpoint.Behaviors.Add(new MustUnderstandBehavior(false));

var channel = (WSTrustChannel)trustChannelFactory.CreateChannel();

return channel;

}

private Binding CreateStsBinding()

{

return BindingFactory.GetBindingBuilder("stsbinding").CreateBinding(ServiceName);

}

public SecurityToken GetTokenOnBehalfOf()

{

var channel = CreateChannel();

var rst = CreateDelegateTokenRequest();

return GetSecurityToken(channel, rst);

}

private RequestSecurityToken CreateDelegateTokenRequest()

{

var rst = new RequestSecurityToken

{

RequestType = RequestTypes.Issue,

KeyType = KeyTypes.Bearer,

AppliesTo =

new EndpointReference(

ConfigurationReader.Reader.GetValue(

ExpressionBuilder.GetEndpointConfigValue(

ServiceName, "secure", "Address"))),

ActAs = new SecurityTokenElement(BootstrapToken)

};

return rst;

}

As you can see, we reuse the binding builder for the STS binding both in the client and the service. This set up the communication with, in this case, ADFS.

Create a new channel factory based on this binding, and set the client credentials. Regardless whether we are using delegate tokens or direct logon the channel will be the same. In the sample code we do not perform certificate validation. After the channel is configured and created, we create a request and call the Issue method on the channel. The token we receive will be used when we create the service channel in the container.

As a last step we need to modify the ServiceProxyContainer:

Add to methods to get security tokens:

private SecurityToken GetToken()

{

var manager = new TokenManager(ServiceName, UserName, Password);

return manager.GetToken();

}

private SecurityToken GetTokenOnBehalfOf()

{

var manager = new TokenManager(ServiceName,GetTokenFromBootstrap(), UserName, Password);

return manager.GetTokenOnBehalfOf();

}

And create the channel that uses the issued security token:

public T GetClient()

{

if (Client == null)

{

if (BootstrapContext != null) Client = ClientFactory.CreateChannelWithIssuedToken(GetTokenOnBehalfOf());

else if (UseSecureChannel) Client = ClientFactory.CreateChannelWithIssuedToken(GetToken());

else Client = ClientFactory.CreateChannel(new EndpointAddress(Url));

}

return Client;

}

Handling the tokens in this way makes it a lot easier to do debugging and to inspect the tokens before they are sent to the service.

This is basically it.

I have added a simple MVC app to show delegation in action. While the console application is mainly the same.

Some help with setting up ADFS to forward name identifier in the issued token.

http://social.msdn.microsoft.com/Forums/vstudio/en-US/2fbd4acf-358e-4bf3-abf6-fc2c9daa20ca/incoming-name-id-format-for-incoming-claim-type-name-id-in-adfs-v20

I hope you enjoyed these posts, I might add some samples on MSMQ and Net.TCP if you are interested. However, it should be easy to add this using the sample code provided as a template.

Wcf, wif and azure acs

2013-09-18T16:48:00.001+02:00

After struggling with federated identity with wcf services for a couple of days I finally got it to work. The documentation for wif 4.5 was, to say the least, really thin. Got some tips from tinktecture and other blogs and are ready to do the next post in the Wcf series. Hope you find it useful

How to programmatically configure WCF services and clients at runtime pt. 2.

2013-09-11T16:06:00.002+02:00

In this post we will add support for a more advanced configuration management and really take control of WCF. We will also add support for REST service endpoints.

Centralized configuration – the simple version

For our “late configuration” of WCF, we want to add a shared configuration store that all components in our system utilizes. In this example, we will use XML and xpath to create a versioned configuration store with inheritance. With inheritance, we mean that data is inherited from the parent data set unless it is overridden in the children. A configuration set represents a runtime environment like dev, test or prod.

The basic structure

The xml file consists of one or more ConfigurationSet, which may contain as many services as needed. A service consist of one or more endpoints with the appropriate binding configuration settings.

When we are reading from the file we use the value from the first set that has a value in the requested node.

public string GetValue(string expression)

{

return GetValueFromVersion(expression, Version);

}

private string GetValueFromVersion(string expression, string version)

{

if (string.IsNullOrEmpty(version)) return null;

var expr = CreatExpression(expression, version);

var iterator = Navigator.Select(expr);

if (iterator.MoveNext())

return iterator.Current.Value;

if (expression == "ParentSet") return null;

return GetValueFromVersion(expression, GetParent(version));

}

public IEnumerable GetValues(string expression)

{

var expr = CreatExpression(expression, Version);

var iterator=Navigator.Select(expr);

var list=new List();

while (iterator.MoveNext())

{

list.Add(iterator.Current.Value);

}

return list;

}

private XPathExpression CreatExpression(string expression, string version)

{

var expr = Navigator.Compile(FormatExpression(expression, version));

return expr;

}

//Creates an xpath expression by combining an incoming expression part with the set selector query

private static string FormatExpression(string expression, string version)

{

var expr = string.Format("ConfigurationSets/ConfigurationSet[SetName='{0}']/{1}", version, expression);

return expr;

}

To make it easy to create the needed expressions we create our own little expression builder.

public static class ExpressionBuilder

{

public static string GetEndpointNames(string serviceName)

{

return string.Format("Services/EndpointConfig[ServiceName='{0}']//Endpoint/EndpointName", serviceName);

}

public static string GetEndpointConfigValue(string serviceName, string bindingName, string attributeName)

{

return string.Format("Services/EndpointConfig[ServiceName='{0}']//Endpoint[EndpointName='{1}']/{2}", serviceName, bindingName, attributeName);

}

public static string GetClientEndpoint(string serviceName)

{

return string.Format("Services/EndpointConfig[ServiceName='{0}']/ActiveEndpoint", serviceName);

}

With this, we have the necessary code to read config settings and use it in our configuration code.

First we create a helper class that loads and initializes our configuration store. Note that this helper should include some kind of caching mechanism that allows the application to get new settings without restart.

internal static class ConfigurationReader

{

internal static VersionedDocumentReader Reader;

static ConfigurationReader()

{

Reader = new VersionedDocumentReader();

Reader.Load(ConfigurationManager.AppSettings["ConfigPath"]);

Reader.SetVersion(ConfigurationManager.AppSettings["ConfigSet"]);

}

To make it easier to configure and name the services we add a new attribute that sets the service name on the interface. We access this attribute instance at runtime using reflection and read the service name. If the service interface doesn’t have this attribute set we use the interface name as the service name.

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false, Inherited = true)]

public sealed class ServiceNameAttribute : Attribute

{

public string ServiceName { get; private set; }

public ServiceNameAttribute(string serviceName)

{

ServiceName = serviceName;

}

Changes to the code.

We need to pass the service name to the binding creators so they can find the correct settings to use during configuration of the binding.

public interface IBindingBuilder

{

Binding CreateBinding(string serviceName);

}

Then we add a helper method to the binding builders to read data from the configuration store and inject the binding name.

private static string GetValue(string serviceName,string valueName)

{

return ConfigurationReader.Reader.GetValue(ExpressionBuilder.GetEndpointConfigValue(serviceName, "basic", valueName));

}

public Binding CreateBinding(string serviceName)

{

return new BasicHttpBinding

{

Name = "basic",

AllowCookies = false,

HostNameComparisonMode = HostNameComparisonMode.StrongWildcard,

MaxBufferPoolSize = int.Parse(GetValue(serviceName,"MaxBufferPoolSize")),

MaxReceivedMessageSize = int.Parse(GetValue(serviceName, "MaxReceivedSize")),

MessageEncoding = (WSMessageEncoding)Enum.Parse(typeof(WSMessageEncoding), GetValue(serviceName,"MessageFormat")),

TextEncoding = Encoding.GetEncoding(GetValue(serviceName, "TextEncoding")),

ReaderQuotas = XmlDictionaryReaderQuotas.Max,

BypassProxyOnLocal = true,

UseDefaultWebProxy = false

};

}

And we add a new class for creating a REST binding

internal class RestBindingBuilder:IBindingBuilder

{

public Binding CreateBinding(string serviceName)

{

var binding = new WebHttpBinding(WebHttpSecurityMode.None)

{

AllowCookies = false,

HostNameComparisonMode = HostNameComparisonMode.StrongWildcard,

MaxBufferPoolSize = int.Parse(GetValue(serviceName, "MaxBufferPoolSize")),

MaxReceivedMessageSize = int.Parse(GetValue(serviceName, "MaxReceivedSize"))

};

return binding;

}

private static string GetValue(string serviceName, string valueName)

{

return ConfigurationReader.Reader.GetValue(ExpressionBuilder.GetEndpointConfigValue(serviceName, "rest", valueName));

}

For the WebHttpBinding to work we need to do some additional changes to the code, I will comment this when we get to these parts later.

We also need to read the address from the configuration store by changing the AddressHelper class to take the service name and use this to look for the value in the xml file.

internal static string GetFormattedAddress(string bindingType,string serviceName)

{

return String.Format(ConfigurationReader.Reader.GetValue(ExpressionBuilder.GetEndpointConfigValue(serviceName, bindingType, "Address"))) + "/" + bindingType;

}

Update ServiceConfigurationImp to get the service name and pass it to the binding builders.

Add a method called GetServiceName. You need to get the service interface from the service type. I have done this the quick and dirty way her and assuming that the serviceType only implements one service interface. It the interface is decorated with the ServiceName attribute we use the value from it, else we use the name of the serviceType.

private string GetServiceName(Type serviceType)

{

var attrib = serviceType.GetInterfaces()[0].GetAttribute();

if (attrib == null) return serviceType.Name;

return attrib.ServiceName;

}

Update the GetBindingTypes to read from the configuration store and not the config file as in the previous post.

private static IEnumerable GetBindingTypes(string serviceName)

{

var bindingTypes = ConfigurationReader.Reader.GetValues(ExpressionBuilder.GetEndpointNames(serviceName));

return bindingTypes;

}

Update CreateEndpoint to support WebHttpBinding, where we set the default response format to json.

private static ServiceEndpoint CreateEndpoint(Binding binding, EndpointAddress address, ContractDescription cd)

{

if (binding is WebHttpBinding)

return new WebHttpEndpoint(cd, address)

{

HelpEnabled = true,

DefaultOutgoingResponseFormat = WebMessageFormat.Json,

Binding = binding

};

return new ServiceEndpoint(cd, binding, address);

}

This is basically the changes needed for the service side of WCF.

On the client side we only need to do one small change in ServiceClientContainer. It also needs to get the service name from the attribute and we need to get the active client binding from the configuration store.

private string GetServiceName()

{

var serviceType = typeof(T);

var attrib = serviceType.GetAttribute();

if (attrib == null) return serviceType.Name;

return attrib.ServiceName;

}

internal ServiceClientContainer()

{

ServiceName = GetServiceName();

BindingType = GetBindingType();

Url = AddressHelper.GetFormattedAddress(BindingType,ServiceName);

}

To enable support for rest we change the Initialize method

public ServiceClientContainer Initialize()

{

ClientFactory = CreateChannelFactory(ServiceName, Url);

if (ClientFactory.Endpoint.Binding is WebHttpBinding)

ClientFactory.Endpoint.Behaviors.Add(new WebHttpBehavior());

return this;

}

Updating the config files

There are just a few things we need to change in the config files for the client and service. We need to add references to the location of the xml configuration file and which set to use.

Download the code here: http://jmp.sh/b/k0b3LRA0jxOz83L4baQ8

How to programmatically configure WCF services and clients at runtime pt. 1.

2013-09-03T10:31:00.000+02:00

Windows Communication Foundation (WCF) is a framework from Microsoft that helps developers build (web) services. WCF serves as an abstraction layer and allows the developer to focus on _what_ to build, not on all the how’s, if’s and but’s. Choosing transport, protocol and security is done later [config time].

In this post, we will look into how to configure WCF programmatically and postpone the choices to run-time. Note that the service needs to recycle in order to obtain new config settings.

One challenge we meet in software development is configurations sets that change from development, test and production environments. Getting all the endpoints and settings correct in each environment is time consuming and error prone.

One solution is to centralize the configuration and introduce environmental variables to the server images. Let us say that we create a windows server image and inject an appSettings value for environment e.g. development. And we also might want to add a value that can resolve the correct url’s for the services and endpoints needed in a given environment. Add these settings to the machine.config file of your server image, this will make the settings available to all services and applications running on the server.

<add key="Environment" value="Dev" >
<add key="UrlPrefix" value="Dev." >
var endpointUrl=String.Format(“http://{0}MyService.MyCompany.com/Service.svc”,ConfigurationManager.AppSettings[“UrlPrefix”]);

This neat little trick makes deployment easy and no configuration transformation is needed. However, you are still stuck with the wcf configuration from your development environment, unless you use config transformations. Config transformations are still a static approach, changing the settings means that you need to change the transformation and update the config file in your service and the service clients.

This is where we will start to play with WCF and configuring this runtime.

The service:

In this post we’ll only cover .svc hosted services. First you need to create a service host factory, which is responsible for creating the service host. During creation of the service host you can configure the service and the available endpoints.

Please note that the sample code uses the really poor man’s IoC (switch - new), in real life scenarios change this to your preferred IoC container. In my production version of this, I use a custom lightweight IoC container.

Service Host Factory

To be able to configure the service at runtime you need to create a new service host factory. Do this by overriding ServiceHostFactory’s CreateServiceHost method. In this method you can control all aspects of the service you are hosting.

protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)

{

var serviceHost = new ServiceHost(serviceType, baseAddresses);

var configurator = CreateConfigurator();

configurator.ConfigureServiceHost(serviceHost, serviceType);

SetBehavior(serviceHost);

return serviceHost;

}

First you create the service host, just ‘new up’ the WCF default implementation. We will add the endpoints to this later.

To prepare for more advanced scenarios in later posts we will create an interface to handle the configuration of the endpoints. Create an interface, IServiceConfiguration, with a method called ConfigureServiceHost.

After the endpoints have been added to the service host, we want to set some behavior for the service, like open and close timeout values.

Building the endpoints

Each endpoint has its own binding, all bindings share the same base type, Binding. This allows us to create an abstraction over this using an interface, IBindingBuilder.

var bindingTypes = ConfigurationManager.AppSettings["bindingTypes"].Split(';');

var contractDescription = ContractDescription.GetContract(serviceType.GetInterfaces()[0]);

contractDescription.Namespace = "http://demo.wcf.org/" + serviceType.Name;

foreach (var bindingType in bindingTypes)

{

var bindingBuilder = GetBindingBuilder(bindingType);

var binding = bindingBuilder.CreateBinding();

var endpoint = CreateEndpoint(binding, new EndpointAddress(GetFormattedAddress(bindingType)), contractDescription);

serviceHost.AddServiceEndpoint(endpoint);

}

private static ServiceEndpoint CreateEndpoint(Binding binding, EndpointAddress address, ContractDescription cd)

{

return new ServiceEndpoint(cd, binding, address);

}

Create one binding builder for each endpoint type you need your service to support. In this sample, I have created the BasicHttpBinding and WSHttpBinding as MSMQ and NET.TCP is not supported in IIS Express or the Web Dev Server.

class BasicBindingBuilder : IBindingBuilder

{

public Binding CreateBinding()

{

return new BasicHttpBinding

{

Name = "basic",

AllowCookies = false,

HostNameComparisonMode = HostNameComparisonMode.StrongWildcard,

MaxBufferPoolSize = int.MaxValue,

MaxReceivedMessageSize = int.MaxValue,

MessageEncoding = WSMessageEncoding.Mtom,

TextEncoding = Encoding.UTF8,

ReaderQuotas = XmlDictionaryReaderQuotas.Max,

BypassProxyOnLocal = true,

UseDefaultWebProxy = false

};

}

public Binding CreateBinding()

{

return new WSHttpBinding(SecurityMode.None)

{

Name = "ws",

AllowCookies = false,

TransactionFlow = false,

HostNameComparisonMode = HostNameComparisonMode.StrongWildcard,

MaxBufferPoolSize = int.MaxValue,

MaxReceivedMessageSize = int.MaxValue,

MessageEncoding = WSMessageEncoding.Text,

TextEncoding = Encoding.UTF8,

ReaderQuotas = XmlDictionaryReaderQuotas.Max,

BypassProxyOnLocal = true,

UseDefaultWebProxy = false

};

}

The values to configure the bindings with can be read from a configuration store. I’ll post a simple version of a centralized configuration store later.

Bringing it all together

To enable the service to be configured by our new factory we need to add one simple statement to the svc markup (marked in red).

<%@ ServiceHost Language="C#" Debug="true" Service="Syrstad.Blog.WcfDemo.Service.DemoService" CodeBehind="DemoService.svc.cs" Factory="Syrstad.Blog.WcfDemo.WcfConfigurationModule.HostFactory" %>

When the development team is building both the service and the client(s) it is a good thing to extract the interface and the data classes in a separate assembly for easy distribution, through the build system, to the projects that depend on it.

Configuring the client

The client also needs to be configured in the same way. We want to ensure that resources used by WCF are properly cleaned, so we will create a container for the proxy that we make disposable.

For ease of use we will create a factory for client proxy containers, called ClientProxyFactory. This has one static method that returns an initialized instance of the container. We implement the container as a generic and uses the type parameter is the interface used in the service itself.

public static class ClientProxyFactory

{

public static ServiceClientContainer CreateProxy()

{

//Replace with your IoC of choice

return new ServiceClientContainer().Initialize();

}

The service container creates a new channel factory with the appropriate settings collected from the interface and the config store. This factory is used to create the actual proxy. The factory is kept as a instance field so it will be a part of the dispose.

For binding creation, we reuse the BindingFactory used by the service so that there is no possibility for configuration mismatch.

internal ServiceClientContainer()

{

ServiceName = typeof(T).Name;

BindingType = ConfigurationManager.AppSettings["useClientBinding"];

Url = AddressHelper.GetFormattedAddress(BindingType);

}

public ServiceClientContainer Initialize()

{

ClientFactory = CreateChannelFactory(ServiceName, Url);

return this;

}

internal ChannelFactory CreateChannelFactory(string servicename, string uri)

{

var builder = GetProxyBuilder();

var channelFactory = new ChannelFactory(builder.GetServiceBinding(servicename, uri, BindingType));

foreach (OperationDescription op in channelFactory.Endpoint.Contract.Operations)

{

var dataContractBehavior = op.Behaviors[typeof(DataContractSerializerOperationBehavior)] as DataContractSerializerOperationBehavior;

if (dataContractBehavior != null)

{

dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;

}

return channelFactory;

}

private static IProxyBindingBuilder GetProxyBuilder()

{

return new ProxyBindingBuilder();

}

Next we need a GetClient method that creates the proxy and returns it to the client code.

public T GetClient()

{

if (Client == null) Client = ClientFactory.CreateChannel(new EndpointAddress(Url));

return Client;

}

This approach makes it easy and clean to create and use runtime generated WCF proxies and ensure proper disposal of the underlying resources.

Download the demo solution and play with WCF. I apologize for the use of regions in some of the source files; they are added as an effort to make this post and the code easier to follow.

Please note that I have done some code cleaning (separated some code into new methods) after I wrote this post.

Download solution: http://jmp.sh/b/CLQ72y7IzGUgmWYULd0u

The demo solution

Project	Description
Syrstad.Blog.WcfDemo	Contains WCF Service interface and data transfer objects for the demo
Syrstad.Blog.WcfDemo.Client	The demo client
Syrstad.Blog.WcfDemo.Service	The demo service
Syrstad.Blog.WcfDemo.WcfConfigurationModule	The WCF configuration code. This will be updated in future posts to include centralized config store and more binding builders

ADFS, SAML and RelayState

2011-02-04T13:00:00.006+01:00

I have been working with ADFS for a customer for som time now, and as a part of their pilot we are going to enable trust with a SaaS application that suports SAML WebSSO Post profile. The customer requires deep linking to conten from their intranet. The SaaS solution handles this by reading the RelayState parameter in the SAML POST.

Microsoft did not implement support for this part of the POST profile....

See this post: http://social.msdn.microsoft.com/Forums/en/Geneva/thread/91812934-e620-44c7-b4ef-8383083dc3c4

In this forum thread Collins gives an outline of the solution, but no actual code examples. As we needed this feature I had to write this piece of code (not the prettiest code ever writen, but it works in my case).

So, to the solution:

(As I said, it is not going to be pretty)

code is shown in italic

Code to add a cookie:

in "IdpInitiatedSignOn.aspx.cs" add the following line in the using section:

using System.Web;

And at the beginning of the method "Page_Init" add the following lines at the beginngin of the method:

string value = Context.Request.QueryString["RelayState"];

if(String.IsNullOrEmpty(value))

value=" ";

HttpCookie = cookie= new HttpCookie("RelayState", value);

Context.Response.Cookies.Add(cookie);

(It might be a good idea to enable error messages in web.config (a small typo might cause crashes)

Create a class library project in Visual Studio 2008, with a strong name.

add a class called: "RelayStateModule"

public class RelayStateModule:System.Web.IHttpModule

{

#region IHttpModule Members

public void Dispose()

{

_Context = null;

}

private System.Web.HttpApplication _Context;

private RelayStateFilter MyFilter;

public void Init(System.Web.HttpApplication context)

{

_Context = context;

_Context.AuthorizeRequest += new EventHandler(_Context_AuthorizeRequest);

}

void _Context_AuthorizeRequest(object sender, EventArgs e)

{

if (_Context.Request.Cookies.AllKeys.Contains("RelayState"))

{

var value = _Context.Request.Cookies["RelayState"].Value;

MyFilter = new RelayStateFilter(_Context.Response.Filter, value);

_Context.Response.Filter = MyFilter;

}

#endregion

}

Add a class called: "RelayStateFilter"

public class RelayStateFilter : Stream

{

private Stream ParentFilter;

private StreamWriter streamWriter;

private string _RelayState;

public RelayStateFilter(Stream filter,string relayState)

{

_RelayState = relayState;

ParentFilter = filter;

streamWriter = new StreamWriter(ParentFilter);

}

public override void Write(byte[] buffer, int offset, int count)

{

MemoryStream ms = new MemoryStream(buffer, offset, count, false);

StreamReader sr = new StreamReader(ms, System.Text.Encoding.UTF8);

string s;

bool isSAMLResponse = false;

StringBuilder sb = new StringBuilder();

int i = 0;

int lineNumberToInsertRS = -1;

while ((s = sr.ReadLine()) != null)

{

i++;

if (s.Contains("SAMLResponse"))

{

isSAMLResponse = true;

}

if (isSAMLResponse && s.Contains("submit"))

{

lineNumberToInsertRS = i;

var rsIncluded = InsertRSIntoResponseString(s, _RelayState);

sb.AppendLine(rsIncluded);

streamWriter.WriteLine(rsIncluded);

}

else

{

sb.AppendLine(s);

streamWriter.WriteLine(s);

}

sb.AppendLine("number of lines="+i.ToString());

//For debugging purposes, remove from production code.

if (isSAMLResponse)

{

using (var fs = File.Open(@"c:\temp\lastToken.txt", FileMode.Create))

{

//fs.w

var sr2 = new StreamWriter(fs);

sr2.Write(sb.ToString());

sr2.Close();

}

streamWriter.Flush();

}

private string InsertRSIntoResponseString(string s, string _RelayState)

{

//Finding location of Submit action

var loc = s.IndexOf("<noscript>");

return s.Insert(loc,String.Format("<input type=\"hidden\" name=\"RelayState\" value=\>"{0}\" /", _RelayState)); //

}

#region Rest of Stream's function - our stream is write-only

public override int Read(byte[] buffer, int offset, int count)

{

throw new NotSupportedException();

}

public override bool CanRead

{ get { return false; } }

public override bool CanSeek

{ get { return false; } }

public override bool CanWrite

{ get { return true; } }

public override long Length

{ get { throw new NotSupportedException(); } }

public override long Position

{

get { throw new NotSupportedException(); }

set { throw new NotSupportedException(); }

}

public override void Flush()

{

ParentFilter.Flush();

}

public override long Seek(long offset, SeekOrigin origin)

{

throw new NotSupportedException();

}

public override void SetLength(long value)

{

throw new NotSupportedException();

}

#endregion

}

Compile and get the full name of your new assembly.

Create a new folder in the adfs\ls directory called "bin" and place your assembly there.

Then you need to register your assembly in web.config:

And at last you register the module in IIS Manager under the ls web site.

There you create a managed module called RelayStateFilter

And under type you have to refer your RelayStateModule

{your namespace}.RelayStateModule

hopefully you will have your RelayState in the SAML message to your RP.

The garbage collector and memory usage in .NET

2008-11-08T22:54:00.001+01:00

During the last weeks I have been diving into the darkest corners of .NET. Normally you don't pay that much attention to the garbage collector in .NET. When it works and you haven't done anything that messes this up it is just sweet. You do not have to release used objects the GC does this for you. But there are times when this is not the case. There are some obvious traps you can fall into and some a bit more obscure. I'll devide this into two parts, the obvious and the sneaky.

I'll start with a breef introduction to the Garbage Collector (GC).
The GC manages the allocation and release of memory for your application. It waches over your memory usage and when you are using too much memory it will release 'dead' objects from the managed heap. Objects are structured in 3 generations + the large objects heap.

Generations explained:

The collector only runs when a certain amount of memory has been used or there is enough pressure for memory on the system.
.Net uses generations to optimize the garbage collector. There are 3 primary generations, 0 through 2.
All new objects are stored in gen 0. if an object survives a collection of gen 0 objects it is moved to the next generation, which is gen 1 in this case. by moving older objects to the next generation, since these objects are likely to be long living objects, this reduces the number of objects the GC needs to check in each collection.
During collection the GC removes and compacts the memory heap for the given generation. This is done by using memcpy to copy them over to the free space to make them contiguous again.

The fact that .NET is a garbage collected runtime you cannot jus look at the memory usage in task manager to determine the actual memory usage.

You can force a collection programmatically, this is however not recommended since the GC is optimized. Calling this yourself might cause your application to spend more time in garbage collection than necessary. There are cases that this might be a good idea. But the general recommendation is 'don't'.

The obvious:

If a class implements the IDisposable you should call it. If you do not have control over your objects life cycle implement a destructor to release native resources. with native resoures we normally think of com objects and pInvoke. But there are classes in .NET that uses native resources, and you MUST release these.
An example of classes that uses native resources is the System.IO namespace. Most streams has native resources bound to it. This is why it is is important to call .Close() and .Dispose() on such objects. Batabase connections is also something you must close as fast as possible.

Methods that uses such resources should always have the finally operator at the end.

internal long GetDASyncStatusCode(long daId)
{
System.Data.OracleClient.OracleCommand cmd = new OracleCommand(string.Format("SELECT SYNCSTATUS FROM DA WHERE DAID={0}", daId.ToString()), this._mainConnection);
cmd.Connection.Open();
long code = 1;
System.Data.OracleClient.OracleDataReader dr = null;
try
{
dr= cmd.ExecuteReader();

if (dr.Read())
{
object o = dr.GetValue(0);
if ((o != null) && (o != DBNull.Value))
code = Convert.ToInt64(o);
else
code = 1;
}
//dr.Close();
}
catch (Exception ex)
{
Barwill.DAWeb.Utilities.ExceptionLogGateway.SaveException(ex);
}
finally
{
if (_mainConnection.State == System.Data.ConnectionState.Open)
{
if (dr != null)
if (!dr.IsClosed)
dr.Close();
_mainConnection.Close();
}
}
return code;
}

The sneaky

In order to keep performance up we often store data in Session or cache storage. if this is an inproc session state you are able to store the entire object also non serializable objects. If you hook up an event handler to a cached object in you ASP.NET pages or controls you might run into a potential memory leak. Event handlers store a reference to the subscribing object. This causes the GC to thing that your ASP.NET page is pinned and will not collect it. if your cached object lives for many hours and you have many users you will run into a OOM (Out Of Memory) exception this might be a bit anoying for the user as well as you, the developer. Below I have added a example og how to unhook your event handlers, a nice place to do this is in the OnUnload event of the page or control.

protected override void OnUnload(EventArgs e)
{
((JobDetail)Page).OnParentUpdated -= JobModuleControl_OnParentUpdated;
_CBSControl.OnControlUpdated -= ctrl_OnControlUpdated;
_CBSControl.OnStatusChanged -= ctrl_OnStatusChanged;

base.OnUnload(e);
}