Implementing SOA Design Patterns with WCF

Service Oriented Architecture (SOA) is an architectural design pattern where it’s design is determined by few guiding principles mainly (a) Ser- vice compatibility is determined based on policy (b) Services share schema and contract, not class (c) Services are Autonomous and (d) Boundaries are Explicit. Implementation of these so-called SOA tenants requires a powerful framework which provides a unified programming model, reliable messaging, security, workflow service, interoperability and integration, syndication, meta-data exploration support, service versioning, REST-Ful endpoints and many other modern connected systems features. Both Service-Orientation and the Windows Communication Foundation (WCF) offer the promise of greater interoperability and ease of integration, but in order to realize benefits such as these we must evolve the way we architect solutions.

This session will be a hands-on introduction to SOA with Windows Communication Foundation. Speaker presents patterns using WCF that allows you to define descriptive, maintainable, yet extensible contracts and implementation of SOA tenants. Since SOA promotes loose coupling at the transport layer; you’ll learn how to create loosely coupled systems, the difference between web reference, service reference and channelfactory. The attendees will learn how to avoid anti-Patterns and leverage WCF to create extensible, versioned, responsive, interoperable, and easy-to- maintain services.

http://www.packtpub.com/microsoft-windows-server-appfabric-cookbook/book

The book is well organized and is written from a developer’s point of view with and end to end hands-on discussion on app-fabric. It’s goal is to help reader

• Gain a solid understanding of the capabilities provided by Windows Server AppFabric with a pragmatic, hands-on, results-oriented approach with this book and eBook
• Learn how to apply the WCF and WF skills you already have to make the most of what Windows Server AppFabric has to offer
• Includes step-by-step recipes for developing highly scalable composite services that utilize the capabilities provided by Windows Server AppFabric including caching, hosting, monitoring and persistence.

shameless plug, pre-order now

Are you

A) a Scientist/researcher/student/ looking for the right enterprise platform for your next big scientific project?

B) a developer/architect who wants to learn cloud computing with windows Azure and would like to go beyond the Hello World Apps?

C) an hobbyist interested in Stanford’s Folding@home distributed computing project and see it’s implementation

D) someone who would like to try out a free two week trial of windows Azure and see a cool distributed computing project unfold (literally )

E) a combination of above

If your answer is anything from A-E, this is a perfect opportunity for you. @home with Windows Azure is an online hands-on workshop! This is a guided tour of process of building and deploying a large scale Azure application. No more “hello world”! in this two hour long session, you will see how to build and deploy a real cloud app that leverages the Azure data center It’s a free online session where each attendee will receive a temporary, self-expiring, full-access account to work with Azure for a period of 2-weeks.

The webcast is 2 hours and offered at 4 different times during the month of June.

For details, check out the project website and the event registration page.

You’d need VS.NET 2008/2010 with the Windows Azure Tools for Microsoft Visual Studio 1.1 (February 2010)

Enjoy!

PS. A recording of the Tuesday, May 4th session can be viewed along with the webcasts on Creating your first Azure application and Running and deploying the @home with Windows Azure application however in order to get the free 2 week account, you’d need to signup and attend an event.

1. If your development machine is XP (or 2K3 server) and you need dev SSL cert installed on it, follow the instructions mentioned in the articles here. The SelfSSL makes it real easy to do self signed certificates, literally one statement.

Setting up SSL with a SelfSSL certificate on Windows Server 2003 (and XP)

Create a self-signed SSL certificate with IIS 6.0 Resource Kit SelfSSL

2. Create a WCF Service Project. Name the service and contracts appropriately. In my sample it is a simple contract like follows.

   [ServiceContract]
    public interface IWcfService
    {
        [OperationContract]
        string GetData(int value);
    }

Make sure you make the appropriate config changes matching with your service contract.

2. Add a custom validator class in your service. You can create a separate file for it. In this example I have added it to the main service file WcfService.svc.cs. You are going to need to add the reference (not just adding these lines at the top, go to add-reference and add the corresponding dll’s to the project)

using System.IdentityModel.Selectors;
using System.IdentityModel.Tokens;

and the custom validator code.

public class CustomValidator : UserNamePasswordValidator
    {
        public override void Validate(string userName, string password)
        {
            if (userName == "test" && password == "test")
                return;
            throw new SecurityTokenException(
                "Unknown Username or Password");
        }
    }

You probably want to make this user name and password moved to a more secure location or point to your database/authentication store for security and maintainability perspective.

3. Now the code part is done. Move to config file. Enable custom errors so you know details about the errors happening.

<customErrors mode=”Off” defaultRedirect=”GenericErrorPage.htm”>

4. Add a new bindings attribute in the config called SafeServiceConf which will specify the TransportWithMessageCredential type of security. You can add this right before </system.serviceModel>

<bindings>
<wsHttpBinding>
<binding name="SafeServiceConf" maxReceivedMessageSize="65536">
<readerQuotas maxStringContentLength="65536" maxArrayLength="65536"
maxBytesPerRead="65536" />
<security mode="TransportWithMessageCredential">
<message clientCredentialType="UserName" />
</security>
</binding>
</wsHttpBinding>
</bindings>
<bindings>       <wsHttpBinding>          <binding name="SafeServiceConf" maxReceivedMessageSize="65536">             <readerQuotas maxStringContentLength="65536" maxArrayLength="65536"                maxBytesPerRead="65536" />             <security mode="TransportWithMessageCredential">                <message clientCredentialType="UserName" />             </security>          </binding>       </wsHttpBinding>    </bindings>

5. Modify your end point address to refer to this binding configuration

			<endpoint address="" binding="wsHttpBinding" contract="MySamples.IWcfService" bindingConfiguration="SafeServiceConf">

also modify your metadata exchange endpoint to use mexHttpsBinding

				<endpoint address="mex" binding="mexHttpsBinding" contract="IMetadataExchange"/>

6. Modify your service behavior to look like this

				<behavior name="WcfService.Service1Behavior">
					<serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="true" />
          <serviceCredentials>
            <userNameAuthentication
                 userNamePasswordValidationMode="Custom"
                 customUserNamePasswordValidatorType="MySamples.CustomValidator,WcfService"
                                                                          />

          </serviceCredentials>
        </behavior>

It’s recommended that “Include exception in faults” should be disabled when moved to production.

7. Now you are almost ready to run the service however before you do this, make sure that you are running it in the IIS AND you have the SSL enabled on the server as specified in step 1 otherwise you’ll run into WCF error stating that there is no HTTPS endpoint available.

Setup Virtual Directory in IIS from Visual Studio

You should be able to run and see the service end point as follows.

Running WCF Service over SSL

Running WCF Service over SSL 2

8. Now that the service is done, let’s move towards building the client. Add the service reference to the service end point. You can do it either via entering the entire URL or using the discover feature.

Add WCF Reference

9. Name your reference “Client” or modify your code appropriately. Following is the code for client implementation.

       private static void Main(string[] args)
        {
           ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(
                delegate { return true; });

            var client = new WcfServiceClient();
            GetCredentials();
            client.ClientCredentials.UserName.UserName = username;
            client.ClientCredentials.UserName.Password = password;
            Console.Write(client.GetData(1));
            client.Close();
            Console.Read();
        }

The RemoteCertificateValidationCallback part is used to programatically avoid the following warning which would popup due to self signed cert usage.

Self signed Certificate Warning

10. Now run the program.

Running WCF client

You can see that for the right credentials, service will run just fine. Otherwise a security exception will be thrown.

Source code can be downloaded from here.WCFAuthSample

Feel free to drop me an email or comment here if you have any questions.

References and Further Readings:

How to: Authenticate with a User Name and Password

WCF Service over HTTPS with custom username and password validator in IIS

Chapter 5 – Authentication, Authorization and Identities in WCF

How to: Use Transport Security and Message Credentials

SecurityMode Enumeration

WCF: Could not establish trust relationship for the SSL/TLS secure channel with authority

Deploying an Internet Information Services-Hosted WCF Service

How messages are encrypted when security mode is “Message”?

Simple WCF – X509 Certificate

Windows HTTP Services Certificate Configuration Tool (WinHttpCertCfg.exe)

Setting up SSL with a SelfSSL certificate on Windows Server 2003 (and XP)

Create a self-signed SSL certificate with IIS 6.0 Resource Kit SelfSSL

Jeff of course disagreed and pointed out the Christian’s Weyer’s
article on flattening. For my excellent
logging and tracing in WCF argument, he stated that “for asmx, you can add the [SoapLoggerExtensionAttribute]
to get some kind of logging of soap requests”. Therefore I am quoting his argument below; I am still somewhat unconvinced ‘in principle’ but pragmatically speaking, he drives a hard bargain!

“At the end of the
day, I think the WCF architecture is powerful but with power comes complexity,
complexity in configuration files and complexity in the wsdl it generates and
complexity in the pipeline architecture and how you can plug into it.

As for Rest, the WCF
team has developed the MVC Rest SDK.

I prefer convention
over configuration and simplicity of code instead of injection as a general
principle.

My preference would to
be to use WCF in situations where you have more control over the client
(internal uses mainly) and want to support different communication
channels.  At the end of the day when dealing with partners,
Interoperability is the biggest challenge and making things as simple to
consume as possible is desirable.”

Have you encountered an interop issue with your WCF service and
what has been your approach? Leave a comment or email me.

Happy Coding!

The Large Hadron Collider was created to help unlock the secrets of the universe. And also to create a working SOA implementation. (SOAFacts.com)

In a recent all-things-technology dinner conversation with a friend and developer extraordinaire Rashid, we talked about his recent purchase, Thomas Erl’s Service-oriented architecture: concepts, technology, and design. During this discussion he rightfully pointed out how virtually any and every distributed system is being dubbed “service oriented” raising a great point that since a lot has been said about “what SOA is?”, we should now talk about “what SOA is NOT” since this might be a able to clear things up as compared to, if it walks like SOA and talks like SOA… Hence I figured a typical non-SOA conversation may go as follows.

RealWorldPHB: “Do we have service oriented architecture? I have been hearing good things about it lately and the new partners really prefer it. Let’s go and buy one SOA or do they come in bulk?”

PerpetuallyPleasingIncompetentArchitect: “Of course we do have SOA sir, we are using web services for a long time, ahead of the curve!”

RWPHB: “Great; so we promote reuse, share contracts and schemas, do all those good things?”

PPIA: “No no, that’s too much work. Instead we share the dll’s and email it to our partners as soon as we sign the contract so they can build according to the specs. You gotta have specs for SOA”

RWPHB: “Even better; who cares about interop, right? If they have their SOA in order, they should be able to talk to us!”

PPIA: “Yessir!, you are right. We are loyal to our platform and we try to enforce uniformity, its better this way. Also our services share one database to ensure concurrency and integrity; someone called it violation of autonomous service principle and a bottleneck but we got rid of him!. We also bought that expensive SOA hardware solution and matching software suite to make sure our SOA works fine”.

RWPHB: “Glad you got rid of darn naysayer, these people upset me!. Anyways, so when we release the API update next month, how is going to work in SOA?”

PPIA: “Well, we want everyone to strictly follow our standards so we made sure our SOA does not allow any versioning. All 2000+ partners will be informed on deployment night to update their interfaces or they won’t be able to use our services. Now this is iron SOA as in iron fist!. I should patent this term.”

RWPHB: “Not sure what that means but it sounds good! I am going to tell board of directors we have SOA, woot!”

Now I should mention as a disclaimer that above mentioned conversation is a poor satirical attempt on my part on general state of SOA. Any similarity to actual persons or SOA’s, living or dead is purely coincidental. And that if you hear any such conversations in the corridors of power, hide! (No not really, educate please).

To make sure that you don’t have one of these conversations, let’s design with SOA tenants in mind. If this sounds too fancy, a simple breakdown of what is NOT SOA would be as follows.

• 
  
  Boundaries are Not explicit


• 
  
  Services are Not Autonomous


• 
  
  Services do Not share Schema and Contract, but Class


• 
  
  Compatibility is Not based upon Policy

There you go! This sums up all the things which would make your SOA design, a non-SOA design.

Ok, may be just adding a negation operator is not the best approach, let’s go with catch phrase methodology.

You might be a non-SOA if

• 
  
  Your services are too much dependent on each other.


• 
  
  Your service does not support versioning in contracts.


• 
  
  You have to pass around jars and dll’s to share contracts.


• 
  
  If your contracts and implementation are not properly isolated for consumers.


• 
  
  You have an enterprise SOA strategy even though your business stakeholders didn’t sit down with IT architects to examine business processes across the organization.


• 
  
  Your services use SOAP as a panacea when interop could have been better achieved with RESTful services.


• 
  
  Data is ignored and governance means a config file to turn off the service response to 500.


• 
  
  Your entire SOA strategy is implementing web services / BPM  / CEM / any other TLA including SOA (this will make it a circular definition).


• 
  
  A client is passing a database connection string to your service call…

Yeah, I agree the last one is probably just plain bad design.

and as if this has not been fun enough, let’s end with a knock-knock joke courtesy of SOAFacts.

Knock, knock
Who’s there?
SOA
SOA who?
You’re fired.

References

• What SOA is not
  
• Ten ways to tell it’s not SOA
  
• What you don’t want to know about SOA
  
• SOA Facts (Humor)

Programming Windows Communication Foundation (WCF)

CSE-40114  Credit: 3 units

Windows Communication Foundation (WCF) is a new object model for building distributed applications using .NET 3.0. WCF was designed to expose the current multitude of Windows remoting APIs (web servcies, MSMQ, Com+, peer-to-peer) using a single unified object model. In this course, attendees will examine the overall WCF object model, binding choices, host options and the use of declarative markup to specify the underlying infrastructure.

Section ID:      068791
Time/Dates:     Sa, 8:00 a.m. – 5:00 p.m. 1/24/2009 – 2/7/2009 (3 mtgs.)
Location:     Room 110, UCSD Extension Sorrento Mesa Center, 6925 Lusk Blvd, San Diego

Feel free to contact me if you have any questions or comments about the course. For enrollment, here is the link.

Following is the list of WCF out-of-the-box bindings, brief information about them (from MSDN) and the link which points to further details. I have ordered them according to the frequency of use in my opinion, YMMV.

BasicHTTPBinding
Represents a binding that a Windows Communication Foundation (WCF) service can use to configure and expose endpoints that are able to communicate with ASMX-based Web services and clients and other services that conform to the WS-I Basic Profile 1.1. The BasicHttpBinding uses HTTP as the transport for sending SOAP 1.1 messages. A service can use this binding to expose endpoints that conform to WS-I BP 1.1, such as those that ASMX clients consume. Similarly, a client can use the BasicHttpBinding to communicate with services exposing endpoints that conform to WS-I BP 1.1, such as ASMX Web services or services configured with the BasicHttpBinding. Security is turned off by default, but can be added setting the mode attribute of the <security> of <basicHttpBinding> child element to a value other than None. It uses a “Text” message encoding and UTF-8 text encoding by default.

webHTTPBinding
A binding used to configure endpoints for Windows Communication Foundation (WCF) Web services that are exposed through HTTP requests instead of SOAP messages.The WCF Web Programming Model allows developers to expose WCF Web services through HTTP requests that use “plain old XML” (POX) style messaging instead of SOAP-based messaging. For clients to communicate with a service using HTTP requests, an endpoint of the service must be configured with the WebHttpBinding that has the WebHttpBehavior attached to it. The WCF Web Programming Model also requires that the individual service operations are annotated with the WebGetAttribute or WebInvokeAttribute attributes. This defines a mapping from a URI and HTTP method to the service operation, as well as the format of the messages used to call the operation and return the results. Support in WCF for syndication and ASP.AJAX integration are both built on top of the WCF Web Programming Model.

wsHttpBinding
Represents an interoperable binding that supports distributed transactions and secure, reliable sessions. The WSHttpBinding is similar to the BasicHttpBinding but provides more Web service features. It uses the HTTP transport and provides message security, as does BasicHttpBinding, but it also provides transactions, reliable messaging, and WS-Addressing, either enabled by default or available through a single control setting.

netTCPBinding
A secure, reliable binding suitable for cross-machine communication. The NetTcpBinding generates a run-time communication stack by default, which uses transport security, TCP for message delivery, and a binary message encoding. This binding is an appropriate Windows Communication Foundation (WCF) system-provided choice for communicating over an Intranet.

BasicHTTPContextBinding
Enables context for the BasicHttpBinding to be exchanged with HTTP cookies as the context exchange mechanism. The BasicHttpContextBinding adds a ContextBindingElement to the stack of BindingElement objects in the system-provided BasicHttpBinding. This enables SOAP headers to be used to exchange context.

NetMsmqBinding
Represents a queued binding that is suitable for cross-machine communication.
The NetMsmqBinding binding provides support for queuing by leveraging Microsoft Message Queuing (MSMQ) as a transport and enables support for loosely coupled applications, failure isolation, load leveling and disconnected operations.

wsDualHttpBinding
A secure and interoperable binding that is designed for use with duplex service contracts that allows both services and clients to send and receive messages.The WSDualHttpBinding provides the same support for Web Service protocols as the WSHttpBinding, but for use with duplex contracts. WSDualHttpBinding only supports SOAP security and requires reliable messaging. This binding requires that the client has a public URI that provides a callback endpoint for the service. This is provided by the ClientBaseAddress. A dual binding exposes the IP address of the client to the service. The client should use security to ensure that it only connects to services it trusts.

netPeerTCPBinding
Provides a secure binding for peer-to-peer network applications.The NetPeerTcpBinding binding provides support for the creation of peer networking applications that use a TCP-level peer-to-peer mesh infrastructure.

netNamedPipeBinding
Provides a secure and reliable binding that is optimized for on-machine communication.
The NetNamedPipeBinding generates a run-time communication stack by default, which uses transport security, named pipes for message delivery, and a binary message encoding. This binding is an appropriate Windows Communication Foundation (WCF) system-provided choice for on-machine communication. It also supports transactions.

MSMQIntegrationBinding
The MsmqIntegrationBinding class maps Microsoft Message Queuing (MSMQ) messages to Windows Communication Foundation (WCF) messages.

netTCPContextBinding
Provides a context-enabled binding for the NetTcpBinding. The NetTcpContextBinding adds a ContextBindingElement to the stack of BindingElement objects in the system-provided NetTcpBinding. This enables SOAP headers to be used to exchange context.

ws2007HttpBinding
Represents an interoperable binding that derives from WSHttpBinding and provides support for the updated versions of the Security, ReliableSession, and TransactionFlow binding elements. The WS2007HttpBinding class adds a system-provided binding similar to WSHttpBinding but uses the Organization for the Advancement of Structured Information Standards (OASIS) standard versions of the ReliableSession, Security, and TransactionFlow protocols. No changes to the object model or default settings are required when using this binding.

wsHttpContextBinding
The WSHttpContextBinding adds a ContextBindingElement to the stack of BindingElement objects in the system-provided WsHttpBinding. This enables SOAP headers to be used to exchange context when HTTP cookies are not enabled.

wsFederationHttpBinding
A secure and interoperable binding that supports federated security.

Thanks to Rashid Kamran for pointing me to it.