Matias Woloski’s Blog

Don Smith started a series of blogcasts where he is showing some of the Service Factory functionality. As usual this is very good stuff and very developer-friendly.

The first public drop of Service Factory is available on the workspace.

Download it and give feedback on the message boards! If you want to
keep updated with this project, here you have a list of Service Factory
bloggers:

• Don Smith
• Jason Hogg
• Tom Hollander
• Pablo Galiano
• Pablo Cibraro
• Christian Weyer
• Edward Bakker
• Beat Schwegler
• Matias Woloski

I will post more about this exciting project in the next weeks.

Don Smith announced today that Service BAT Service Factory is finally a public project. I’ve been part of this project since the beginning of the year and I can tell you that I’m pretty excited about it. Jason Hogg said that this were going to change the way we develop SO applications.

This is a great moment for people writing Service Oriented apps using Microsoft technologies!

First, if you are not aware of patterns & practices latest
activities, let me tell you that they’ve been creating BATs, Baseline
Architecture Toolkits, which are more than App Blocks. They cover the
whole thing! The first one was the SC-BAT (for Smart Client apps using CAB) which was more than successful. So here is the definition:

 What is a BAT? A BAT is a collection of various forms of guidance (written
guidance like patterns, reusable code like application blocks,
executable code like reference implementations, and guidance packages
embedded in Visual Studio) to help .NET developers and architects build
a certain kind of application.

What is the scope of Service BAT Service Factory? In short, from the proxy to the database.

Join this project if you want to

• Write Service Oriented apps using WCF or ASMX
• Leverage the best practices and the experience of a 50 recognized experts in the
  field (the advisor board) and a group of Redmond brainees
• Automate the menial tasks of creating a Service by leveraging the use of GAT
• If you were looking for the Grail on writing backends for Enterprise Applications
• Solve most of the cross-cutting concerns (Exception Shielding, Logging, Versioning, Security, Data Entitlement, and more)
• Align to WCF
• Have great tooling for WCF

See you there!

UPDATE: want to see some early screenshots? look at Edward Bakker post. Christian Weyer also blogged about it.

UPDATE 2: Service BAT was rebranded. Now it’s Web Service Software Factory.

Published by patterns & pracites: the long awaited question

My Blog has been moved… This is the new url: http://blogs.southworks.net/blogs/matiaswoloski

Southworks is pleased to announce the release of its EDRA Workshop material to the community!

This course has been delivered to over 65 companies in different industries like Banking, Finance, Insurance, Health and Automotive all around the world during the last year (including places like Argentina, Chile, Colombia, Costa Rica, Ecuador, Mexico, Sweden and Uruguay). Some of these workshops were co-hosted by Microsoft regional offices.

The material includes ALL THE HANDS ON LABS and the source code!

These are the labs you’ll find:

• MODA01 Installing EDRA
  
• MODA02 Creating a sample solution
  
• MODA03 Implementing Authenticate Use Case
  
• MODA04 Implementing Funds Transfer Use Case
  
• MODA05 Implementing Bill Payment Use Case
  
• MODA06 Implementing UIP in Funds Transfer Use Case
  
• MODA07 Implementing Account Summary Use Case
  
• MODA08 Instrumentation with EIF
  
• MODA09 Multilanguage implementation of Home Banking.pdf
  
• MODA10 Creating an EDRA Handler - IdentityImpersonate
  
• MODA11 Generating Unit Tests using NUnit 2.2

This is the same material used by the instructor lead course!

If you want to take a brief look at how they look, download the HOL PDFs from the EDRA workspace

Download the full version of the HOLs

The EDRA team has given me the status of Administrator of the Workspace

EDRA (Shadowfax) has a cool feature called ServiceGroup. This allows you to group services in a logical group and has a pipeline defined that uses the Service Group. An example of usage would be creating a service group for transactional service actions and another service group for non-transactional ones (example of Wake Jens from Volvo IT).

This nice feature has an issue in EDRA 1.1 so I decided to go deep into it. I found that there was a problem in the Configuration Validation which didn’t take into account this service’s group. To make the long story short, as we have the source code of EDRA here are the methods I’ve changed (in bold) on the file ConfigValidator.cs to make the ServiceGroups work (download ConfigValidator.zip (61.44 KB)):

1. ValidateBusinessActionNames

private bool ValidateBusinessActionNames(StringBuilder report)
{
    string serviceActionName = null;
    string pipelineName = null;
    bool baServiceActionFound;
    bool result = true;

    IDictionaryEnumerator businessActionEnumerator = _businessActDefSettings.BusinessActions.GetEnumerator();
    while ( businessActionEnumerator.MoveNext() )
    {
        BusinessActionSettings baSettings = (BusinessActionSettings)businessActionEnumerator.Value;
            
        // Checking if the current business action specified in the configuration
        // is a compenstae business action or not. The checks for service interface
        // service implementation pipeline should be done only if the the business
        // action is not specified as compensate business action for any of the existing
        // business actions.
        if (IsCompensateBusinessAction(baSettings.Name))
        {
            continue;
        }

        IDictionaryEnumerator pipelineEnumerator = _pipelineDefSettings.ServiceInterfacePipelines.GetEnumerator();
        baServiceActionFound = false;
        while ( pipelineEnumerator.MoveNext() )
        {
            ServiceInterfacePipelineConfig pipelineCfg = (ServiceInterfacePipelineConfig)pipelineEnumerator.Value;
            serviceActionName = pipelineCfg.ServiceName;
            pipelineName = pipelineCfg.Name;

            bool isInServiceGroup = false;
            if ( pipelineCfg.ServiceGroup != null && pipelineCfg.ServiceGroup != String.Empty )
            {
                // get the service group for the current pipeline config and check that the service group contains the business action
                ServiceGroupConfig serviceGroup = (ServiceGroupConfig)PipelinesConfig.Config.ServiceGroups[ pipelineCfg.ServiceGroup ];
                isInServiceGroup = serviceGroup.Services.Contains( baSettings.Name.Trim() );
            }
            
            if( (String.Compare(baSettings.Name.Trim(), serviceActionName.Trim(), true) == 0 ) || ( serviceActionName == “*” ) || ( isInServiceGroup ) )
            {
                baServiceActionFound = true;
                break;
            }
        }
        if ( baServiceActionFound == false )
        {
            result &= false;
            report.Append(Resource.ResourceManager.FormatMessage(Resource.MessageKey.ServiceInterfacePipelineMissingForBAErrMsg, baSettings.Name));
            break;
        }


        pipelineEnumerator = _pipelineDefSettings.ServiceImplementationPipelines.GetEnumerator();
        baServiceActionFound = false;
        while ( pipelineEnumerator.MoveNext() )
        {
            ServiceImplementationPipelineConfig pipelineCfg = (ServiceImplementationPipelineConfig)pipelineEnumerator.Value;
            serviceActionName = pipelineCfg.ServiceName;
            pipelineName = pipelineCfg.Name;

            bool isInServiceGroup = false;
            if ( pipelineCfg.ServiceGroup != null && pipelineCfg.ServiceGroup != String.Empty )
            {
                ServiceGroupConfig serviceGroup = (ServiceGroupConfig)PipelinesConfig.Config.ServiceGroups[ pipelineCfg.ServiceGroup ];
                isInServiceGroup = serviceGroup.Services.Contains( baSettings.Name.Trim() );
            }

            if( (String.Compare(baSettings.Name.Trim(), serviceActionName.Trim(), true) == 0 ) || ( serviceActionName == “*” ) || ( isInServiceGroup ) )
            {
                baServiceActionFound = true;
            }
        }
        if ( baServiceActionFound == false )
        {
            result &= false;
            report.Append(Resource.ResourceManager.FormatMessage(Resource.MessageKey.ServiceImplPipelineMissingForBAErrMsg, baSettings.Name));
            break;
        }
    }
    return(result);
}

2. ValidateImplPipelines

This week I did an architecture review together with German Marin, from Microsoft Consulting Services Chile for an MS partner, Novared, who is willing to implement a large application including Biztalk in the Middleware to conceive a unique customer database. Novared wanted to make the decision whether to use or not MBI 3 as the business framework in cooperation with Biztalk.

Happily, after one week implementing a proof of concept they decided that MBI will be the framework they will use from now on for their applications. Indeed, they realized that using it, will lead to:

• shorter development time;
  
• better support; 
  
• improvement on the development team workload distribution;
  
• enhaced quality on the solution;
  
• opportunity to create a base framework and have isolated development teams that implement the business actions
  
• and some other benefits.

The proof of concept included among other things:

• Single and Batch actions;
  
• Command Pattern & Service Oriented approach; 
  
• Request-Response sync communication with Biztalk 2004 orchestations;
  
• Business Event publishing using Output Providers;
  
• use of the MSMQ transport to inject data to Biztalk; 
  
• discussion of BAM (Business Activity Monitoring) in conjuction with MBI;
  
• Authorization Manager (AzMan) integration within MBI;
  
• Extensibility and Flexibility of the pipe & filters pattern;    

I’m leaving Chile with a lot of ideas spinning on my head. Specially regards EDRA / MBI 3 / Biztalk Server 2004 integration. I splashed the first ideas on under: EDRABiztalkIntegration

EDRA 1.1 is released. You can download it from http://www.southworks.net/edra/builds.aspx

From Hernan de Lahitte blog

This version has improvements in the following areas:

      â— Tooling & Wizards

      â— New & Enhanced Handlers

      â— Better Configuration Support

      â— Performance gains in specific areas

      â— Bug fixing (as usually happens with upgrades) 

The main new features that you will find are here:

● Wizards. The following wizards are included:

● Create New Solution. This wizard helps you create a new solution with the

EDAF code base.

● Add Business Action. This wizard helps you add a business action to a project

in your EDAF solution.

● Expose Service Action on a Transport. This wizard helps you expose the

business action on one of the available transports: InProc, Message Queuing,

Remoting, or Web service.

● In-Proc Service Interface. Allows the pipeline and handlers to be executed in the

same process as the host environment.

● TokenAuthentication handler. Used for custom authentication scenarios; allows

the first authentication to occur using a user name and password, and then the

handler issues a high-entropy token that can be used for authentication on

subsequent Web service requests.

● DuplicateMessage handler. In addition to existing functionality, added a

configurable reject mode to the handler to allow duplicate messages to be rejected.

● Additional runtime configuration validation. Moved logic from the external

configuration validation utility into the runtime so that as a configuration file is

modified, validation will automatically occur.

● Configure exception shielding. Added a configurable mode so that exception

shielding can be enabled or disabled. Exception shielding is a helpful feature for

production environments where an exception should not provide the client with

internal information (such as a connection string). During development and

testing however, it is useful to see the exceptions that are raised.

● Improve Performance. The following areas have been tuned to increase

performance:

● SyntacticValidation handler by caching the XSD and compiling it after loading.

● DCOM dispatching transport by creating a proxy pool.

● WebService interface transport by optimizing stream handling.

● Binary Application Template Solution. Can be used to demonstrate how the

EDAF could be deployed and used within a large organization after EDAF has

been customized to meet your requirements. The template references the binaries

instead of the EDRA source code projects. This makes the resulting Visual Studio

solution easier to develop with because the solution is easier to navigate and it

reduces compile time.

● Visual Basic .NET Application Template Solution. Can be used as a starting

point for creating applications in Visual Basic .NET. The template still references

the EDRA framework’s Visual C# .NET projects.

● Visual Basic .NET Code Snippets included in the documentation. You can use

these snippets with the Visual Basic .NET Application Template Solution and

while you step through the Tutorial and the Developer’s Guide.

● WSE Support. Explains different ways of configuring the service interface with

Web Services Enhancements 2.0 for Microsoft .NET (WSE).