gridGISTICS Blog

Four IIS7 Modules you should be "Aware" of

Ryan Turner — Thu, 14 Aug 2008 12:32:22 -0400

IIS7 introduces a great number of features which are greatly appreciated. (Yes I know Apache already had them - but I'm not going there). My favorite thing about IIS7 is the module based architecture. Its extensibility is allowing the IIS team and the community to drum up some really cool modules.

AwareReverseProxyModule

This has enabled gridGISTICS to develop a "Reverse proxy" module which takes the incoming IIS request and hands it off DIRECTLY to an Aware service. Better yet - it intelligently find the appropriate service with all the load balancing and ninjaness you'd expect from Aware. You can even choose what services to expose to the web directly from the Aware Enterprise Manager. How could this get even better? You already have it if you are using the latest version of Aware - you just need to install the module.

URL Rewrite Module

Almost Mod Rewrite (mod_rewrite) for IIS. Enables flexibility of URLs and beats the snot out of the HTTP redirection module that ships with IIS7.

linky linky

Application Request Routing Module

(I totally stole this paragraph from the link below)

Microsoft Application Request Routing for IIS7 is a proxy based routing module that forwards HTTP requests to content servers based on HTTP headers and server variables, and load balance algorithms. Application Request Routing can be used to:

Increase application availability and scalability.
Better utilize content server resources.
Facilitate application deployment including pilot management and A/B testing.
Lower management costs and create opportunities for shared hosters.

linky linky

PowerShell Provider

I'd like to pretend that I am all savvy with PowerShell - but I just haven't personally tapped its power yet. However - my team members that are ninjas with it - tell me its the only way to go. The IIS team thinks so too and here is their module for managing IIS via powershell.

linky linky

Technorati Tags: iis7,modules,gridgistics

LINQPad - Go Get It!

Ryan Turner — Fri, 13 Jun 2008 01:44:23 -0400

Really wanted to shed some light on a tool we recently discovered. Its free, its well written and so far I have yet to break it. ( a skill I normally possess)

LINQPad

Here is why you should stop reading this and download it already.

Its Free
Query DB's using LINQ without SQL Management Studio on the box.
Doesn't require Visual Studio
2 MB Executable (no install required)
Can be used as a C#/VB.NET scratch pad.
Can be used as a mean calculator.
Quick test harness for a C#/VB snippets
It contains tons of free examples and even demo data to hone your LINQ skilz
O and yeah its Free

Found it really useful to do ad-hoc queries on Aware audits.

Technorati Tags: tool,linq,linqpad

Kudos to Robert who told me about this thing ;)

Microsoft Web Deployment Tool - Beta 1 Go Live

Ryan Turner — Tue, 10 Jun 2008 10:50:08 -0400

Web Deployment Tool

It slices, it dices, it synchs and snapshots - the IIS team has released a tool which eases the pain of site migration.

Benefits:

Simplify web farm deployments
Migrate sites or entire servers
Snapshot sites or entire servers for backups or versioning
Determine the differences between two sites or servers
Determine what components your site depends on

Features:

Synchronization of IIS 6.0/IIS 7.0:
The sync operation provides administrators with a way to quickly synchronize a site or server and deploy changes to existing sites and servers. A synchronization allows you to synchronize one source with one destination. For example, you can synchronize two directory paths or two web servers. The sync can be performed with local or remote objects.

Snapshot of IIS 6.0/IIS 7.0:
The snapshot, or archive, functionality allows administrators or developers to quickly take an archive of their web site or server for rollback, restore or backup purposes.

Migration from IIS 6.0:
The migrate operation provides administrators with a way to migrate sites or entire servers from IIS 6.0 to IIS 7.0, including their settings and content. A migration is essentially a way of synchronizing, filtered by migration rules. For example, when migrating from IIS 6.0 to IIS 7.0, MS Deploy will check the value of some properties and see if it is the IIS 6.0 default. If it is the default, such as the log files directory, it will instead use the value set on the IIS 7.0 server. This enables a server admin to maintain new settings on IIS 7.0 while moving sites or applications from IIS 6.0.

Analysis of IIS 6.0 Installed Features:
The analyze operation allows administrators to check what components are installed on the source server. In this way, they can determine if features are present that they will need in IIS 7.0 or that require more advanced setup than simply copying files. For example, ASP.NET requires more than a file copy and will need to be installed on the destination server.

Troubleshooting and Validation Features:
For validating an operation, the -whatif flag allows administrators to see what actions would happen when they perform an operation. This is especially useful for performing sync or migration, when they want to validate what changes will be made before performing them. For troubleshooting, the -verboseLevel flag allows administrators to get rich detail about what operations are being performed, and upon failure, the ability to diagnose the problem.

NEW FEATURES in this version!

PowerShell Support:
PowerShell cmdlets are included, allowing you to use the Microsoft Web Deployment Tool conveniently with PowerShell. For more information about how the PowerShell cmdlets work, see the Help file as well as the Microsoft Web Deployment Tool walkthroughs.

Enhanced Dependency Checking:
The dependencies that are checked for a web site or server can now be viewed on IIS 7.0 as well as IIS 6.0. They can be turned off on a granular level, such as disabling the drive space dependency check while still running the other dependency checks, or disabling the check for a single ISAPI script map. Additionally, when you view dependencies, you will be able to see the “trigger” for the dependency (what location(s) in configuration caused the Microsoft Web Deployment Tool to say that the module/component is a potential dependency).

Aware Server VS.NET Productivity Chart

Darrell Legault — Wed, 14 May 2008 12:45:00 -0400

I recently did a quite lengthy post on 67% increase in productivity.

http://blog.gridgistics.net/post/2008/05/Aware-Server-6725-More-Productive-than-VSNET.aspx

I just wanted to post a quick summary based on that post.

Aware Server	VS.NET 2008	Result
Built in F5 debugging of services and workflows.	Create your service, then configure your environment, and then create and code your testharness.	· Aware Server 54% faster to develop WCF services. · Aware Server – now prior WCF knowledge required. · Aware Server treats workflow development (WF) the same as service (WCF) development.
One click deployment – Any environment.	Deploy to your machine running IIS.	· Aware Server is “One Click” deployment of services. · Aware Server allows you to quickly test your services locally, and then deploy them to be shared with all developers.
Versioning services and running them side by side.	No built in versioning capabilities	· Aware Server will let you easily version and run those versions.
Provisioned endpoints.	Developer must create the endpoints.	· Aware abstracts protocol from the developer and puts it into the hands of operations.
Automatic service call load balancing	You need to setup and configure your own load balancing solution.	· Aware automatically scales your services by load balancing your service calls across all machines running your services.
Provisioning Conditions.	You need to setup your service on every machine you want it to run on.	· Setting up Aware Services to run on one server, or 1,000 servers. One policy will take care of all deployment and configuration for ALL of your servers.
Re-deployment will automatically run your new code.	Re-deployment is only local on your own machine.	· If an Aware Server policy is setup to run your service on 5 machines, when you redeploy that service Aware Server will automatically re-deploy the new code to all 5 machines.
Provisioning time schedules.	You would have to code/manage a schedule yourself.	· Aware Server automatically will run services when you want them to run, where you want them to run.
Zero configuration.	You need to know the URL of the machine of the services you wish to call	· Aware Server was designed from the ground up with Services Virtualization in mind to eliminate service location configuration.
IIS is not required, Although you can use IIS as well.	IIS is required to host your services.	· Aware Server offers you the flexibility of using whatever you hosting model you want.

Technorati Tags: Aware Server,gridGISTICS,VS.NET Productivity

Aware Server ASP.NET Deployment - 5 Reasons Why You Need It.

darrell legault — Wed, 14 May 2008 12:25:00 -0400

ASP.NET is the most widely used application development environment within VS.NET. As such, people waste much time designing and building ways to help them deploy their applications to their web farms (from staging, to QA, to production).

One of Aware Server's powerful features is the ability to package and deploy and configure ASP.NET applications across many machines and may environments.

Details on how can be found here Aware Server ASP.Net Web Deployment

The following are 5 simple reasons why Aware Server ASP.Net Deployment is 100 times easier and better than any other web deployment tool.

Command line vs UI point and click
1. Aware Server: Intuitive GUI allows for point, click, run your web.
2. MS Deploy: learning curve of what commands to do what, then write your script.
Setup of tools (remote service)
1. Aware Server: No tools, just publish, then deploy your ASP.NET application all of the machines at once.
2. MS Deploy: msi installation, remote service setup, scripting etc...
Versioning
1. Aware Server: Publish another version to your environment, then deploy it. Want to rollback? Just use the Aware wizard and republish your previous version.
2. MS Deploy: Another script, with hard coded configuration of source/remote machines. And hope that the old code was saved somewhere safe.
Environments
1. Aware Server: Just deploy your manifest to the environment, then publish. Then just as you would do with services or business processes, use the Aware Promotion wizard to promote your ASP.NET application to another environment.
2. MS Deploy: determine what machines are apart of an environment, write a script that will use those machines, as the environment changes, re-write your script.
Multi Machine Publishing
1. Aware Server: Just select the IIS machines you want to target and publish, no coding or scripting.
2. MS Deploy: You need to know each machine and then develop script to deploy to those machines.

Technorati Tags: Aware Server,gridGISTICS,ASP.NET Deployment,VS.NET productivity

Service Extensions

Dan Haligas — Wed, 14 May 2008 09:45:34 -0400

Service extensions inside Aware Server v3 can be used to build services that can have external algorithms or code attached to them by application administrators in a Lego type fashion. The blog refers to the Extensions sample that ships with the Aware SDK.

Imagine the following service contract:

   1:  [ServiceContract(Namespace = "urn:mynamespace", Name = "InsuranceClaimsService")]

   2:  public interface IInsuranceClaimsService

   3:  {

   4:      [OperationContract]

   5:      Double ComputeTotalClaim(String claimNumber, String state, Double carValue);

   6:  }

Now lets define a service extension point for our service. Imagine we want to be able to plug different tax calculators into different instances of our service without having to recompile or touch our insurance claims service implementation. So lets define a TaxCalculator extension that our insurance engine will use to compute the tax associated to a car.

   1:  /// <summary>

   2:  /// This interface will be our extension point for allowing others to provide

   3:  /// TaxCalculatorExtension implementations

   4:  /// </summary>

   5:  [DataContract]

   6:  [Serializable]

   7:  public abstract class TaxCalculatorExtension : ServiceExtension

   8:  {

   9:      /// <summary>

  10:      ///

  11:      /// </summary>

  12:      /// <param name="manifestReference"></param>

  13:      /// <returns></returns>

  14:      public override sealed Boolean CanBeAssociatedTo(ManifestReference manifestReference)

  15:      {

  16:          //

  17:          // We can open the .aware file as xml in the ExtenableServices project to get the guid for that

  18:          // service.

  19:          //

  20:          // We only want to be associated to that type of service.  This limits what the management console

  21:          // shows to the user for associating extensions to your service.

  22:          //

  23:          return manifestReference.Id == new Guid("c7ff37eb-d286-475f-ad78-097e963a5d68") && manifestReference.Version == "1.0.0.0";

  24:      }

25:

  26:      /// <summary>

  27:      ///

  28:      /// </summary>

  29:      /// <param name="state"></param>

  30:      /// <param name="carValue"></param>

  31:      /// <returns></returns>

  32:      public virtual Double ComputeTax(String state, Double carValue)

  33:      {

  34:          return 0.0;

  35:      }

36:

  37:      /// <summary>

  38:      ///

  39:      /// </summary>

  40:      public override sealed Boolean AllowMultiple

  41:      {

  42:          get

  43:          {

  44:              //

  45:              // We only want one of these at most attached to our service

  46:              //

  47:              return false;

  48:          }

  49:      }

  50:  }

The CanBeAssociatedTo routine allows you to ensure that derived versions of this extension type are only applied to your service (guid and version make up a unique manifest inside Aware). The Aware Enterprise Manager will use this routine to limit the extensions that can be applied to a service.

The AllowMultiple allows you state that multiple of this extension type may be applied or just one. In our sample we want at most one tax calculator extension attached to our service.

The ComputeTax routine and any other virtual routines in this class define our extension points for tax calculators.

For good measure let's provide a default implementation of our tax extension.

   1:  /// <summary>

   2:  ///

   3:  /// </summary>

   4:  internal class DefaultTaxCalulator : TaxCalculatorExtension

   5:  {

   6:      /// <summary>

   7:      ///

   8:      /// </summary>

   9:      /// <param name="state"></param>

  10:      /// <param name="carValue"></param>

  11:      /// <returns></returns>

  12:      public override Double ComputeTax(String state, Double carValue)

  13:      {

  14:          return carValue * .07;

  15:      }

  16:  }

In our host file for our service we can override the AddHostExtensions event and attach our default extension if one has not been added to us already.

   1:  /// <summary>

   2:  ///

   3:  /// </summary>

   4:  /// <param name="sender"></param>

   5:  /// <param name="e"></param>

   6:  private void InsuranceClaimsServiceHost_AddHostExtensions(object sender, HostExtensionsEventArgs e)

   7:  {

   8:      //

   9:      // Check for an extension added from the outside otherwise add our default one

  10:      //

  11:      if (e.Extensions.Find<TaxCalculatorExtension>() == null)

  12:      {

  13:          e.Extensions.Add(new DefaultTaxCalulator());

14:

  15:          //

  16:          // Extensions are accessible in any operation using OperationContext.Current.Host.Extensions.Find<TaxCalculatorExtension>

  17:          //

  18:      }

  19:  }

Now take a look at the implementation of our IInsuranceClaimsService.

   1:  /// <summary>

   2:  ///

   3:  /// </summary>

   4:  /// <returns></returns>

   5:  ///

   6:  /// <summary>

   7:  ///

   8:  /// </summary>

   9:  Double IInsuranceClaimsService.ComputeTotalClaim(String claimNumber, String state, Double carValue)

  10:  {

  11:      //

  12:      // We know at least our DefaultTaxCalculator will be here

  13:      //

  14:      TaxCalculatorExtension taxCalculator = OperationContext.Current.Host.Extensions.Find<TaxCalculatorExtension>();

15:

  16:      //

  17:      // Use the tax calculator to finish the computation.  this could be our default one or

  18:      // one provided from the outside

  19:      //

  20:      return taxCalculator.ComputeTax(state, carValue) + 15000;

  21:  }

Notice how use the Extensions.Find method which is native to WCF on the current OperationContext. We grab our extension and call its compute tax routine.

Now lets implement an extension on the outside. To do this we create a new Service Extension project (project template that ships with Aware).

After adding a reference to our shared library (contains both the service contracts and service extension definitions) we implement a greedy tax calculator which returns 50% tax every time.

   1:  /// <summary>

   2:  ///

   3:  /// </summary>

   4:  /// </summary>

   5:  [DataContract]

   6:  [Serializable]

   7:  public sealed class GreedyTaxCalculator : TaxCalculatorExtension

   8:  {

   9:      /// <summary>

  10:      ///

  11:      /// </summary>

  12:      public GreedyTaxCalculator()

  13:      {

  14:      }

15:

  16:      /// <summary>

  17:      ///

  18:      /// </summary>

  19:      /// <returns></returns>

  20:      public override string ToString()

  21:      {

  22:          return Description;

  23:      }

24:

  25:      /// <summary>

  26:      ///

  27:      /// </summary>

  28:      /// <param name="state"></param>

  29:      /// <param name="carValue"></param>

  30:      /// <returns></returns>

  31:      public override Double ComputeTax(String state, Double carValue)

  32:      {

  33:          return carValue * .5;

  34:      }

35:

  36:      /// <summary>

  37:      ///

  38:      /// </summary>

  39:      [Browsable(false)]

  40:      public override String Category

  41:      {

  42:          get

  43:          {

  44:              return "Insurance Tax Calculators";

  45:          }

  46:      }

47:

  48:      /// <summary>

  49:      ///

  50:      /// </summary>

  51:      [Browsable(false)]

  52:      public override String Name

  53:      {

  54:          get

  55:          {

  56:              return "Greedy Tax Calculator";

  57:          }

  58:      }

59:

  60:      /// <summary>

  61:      ///

  62:      /// </summary>

  63:      [Browsable(false)]

  64:      public override String Description

  65:      {

  66:          get

  67:          {

  68:              //

  69:              // This will show in the notes column in the management console

  70:              //

  71:              return "Takes the car value and return 50% tax";

  72:          }

  73:      }

  74:  }

The overridden properties above are only used by the tools to provide verbose descriptions for this extension. After this we are done and ready to test. Publish both your service and your service extensions projects into Aware.

As shown above they are both deployed into Aware. Next we need to provision 2 instances of our Insurance Claims Service. One that uses the default tax calculator and one that uses the greedy one.

To do this go into the Aware Enterprise Manager and go to the Service Provisioning Policies tab. Click the 'Create New' button to create a new provisioning policy. Enter 'Insurance Claims' for the name of the policy and switch to the Included Service Manifests tab.

Add our service by clicking the 'Add Service Manifest' button and enter an additional attribute in the Additional Attributes section with a key of Tax and a value of Default. Then add our same service again.

For the second instance of our service add an additional attribute with a key of Tax and a value of Greedy. Before clicking save switch to the Extensions tab in the lower section of the screen. Click the Add Extension and select the Greedy Tax Calculator from the popup and click Apply.

Click Save and switch to the Service tab in the Enterprise Manager to see that we have 2 instances of our insurance service running and that each have an attribute attached to them with a key of Tax.

We can then use this attribute to route requests to different instances of our service. The client code is listed below.

   1:                  ServiceAttributes attributes = new ServiceAttributes();

   2:                  attributes["Tax"] = "Default";

3:

   4:                  using (InsuranceClaimsServiceClient client = new InsuranceClaimsServiceClient(attributes))

   5:                  {

   6:                      Double result = client.ComputeTotalClaim("122344x", "GA", 5600);

   7:                      Console.WriteLine("Claim result = {0}", result);

   8:                  }

9:

  10:                  ServiceAttributes attributes2 = new ServiceAttributes();

  11:                  attributes2["Tax"] = "Greedy";

12:

  13:                  using (InsuranceClaimsServiceClient client = new InsuranceClaimsServiceClient(attributes2))

  14:                  {

  15:                      Double result = client.ComputeTotalClaim("122344x", "GA", 5600);

  16:                      Console.WriteLine("Claim result = {0}", result);

  17:                  }

Above we call the insurance service twice. The first call is directed to the default tax calculator instance and the second is directed to the greedy instance. If you recall from our implementations above we add 15000 to whatever tax is computed. So for the first one our default tax will be 15000 + .07 * 5600 = 15392 and for the greedy one it will be 15000 + .5 * 5600 = 17800.

This really shows off how we can use the same binary bits (deployed service manifest) and change the behavior of the service through configuration and extensions. Tax algorithms can now be implemented independent of the insurance claims service and can be assembled at provisioning time depending on customer need, etc.

External Windows Workflow Correlated Communication Part 2

Dan Haligas — Tue, 13 May 2008 13:45:30 -0400

I am finally getting around to completing this two part series on what we have done for you as far as workflow communication goes inside Aware Server v3.0.

If you remember from Part 1 I simply demonstrated what it takes using plain vanilla Windows Workflow to have a workflow instance wait on an correlated event. To fire an event back into the right workflow instance you need the instance id to load it and fire the event. This poses a problem when an event may not come in for quite some time. Where do you store the instance id?

You can either store the instance id in one of your own application tables and look it up every time before firing events or you can use are somewhat simplified approach with Aware Server. I say simplified because we took it as far as we could. In our SDK there is an order processing sample so I will refer to that for the rest of this blog entry.

So what have we done for you to make this easier? For starters we provide our own implementation of the WorkflowSubscriptionService that ships with WF. The WF runtime detects if an instance of this service is added to the runtime and calls you to tell you about every Activity in an instance that requires correlation. This allows us to store this information in SQL Server so we can handle the lookups for you at a later time.

Next we assume that anything you are correlating on must be unique. For example if your system generates an OrderId and you tell the WF runtime that this is the attribute you want to correlate on using [CorrelationParameter("OrderId")] attribute then we take a hash of your order id and store it for later lookups.

So again lets assume we have the following workflow service interface. Except now notice we have added some new attributes.

   1:      /// <summary>

   2:      /// The [ExposedAutoCorrelationEvent] tells the client generation engine to

   3:      /// expose these events so the client can call the directly

   4:      ///

   5:      /// This service must be exposed to the Aware correlation engine via the

   6:      /// [ExposedWorkflowService(typeof(IOrderWorkflowService), "OrderEngine")] attribute located

   7:      /// in the OrderProcessingProcess.cs file attached to the OrderProcessingProcess.

   8:      /// </summary>

   9:      [ExternalDataExchange]

  10:      [CorrelationParameter("OrderId")]

  11:      public interface IOrderWorkflowService

  12:      {

  13:          /// <summary>

  14:          ///

  15:          /// </summary>

  16:          [CorrelationAlias("OrderId", "e.OrderId")]

  17:          [ExposedAutoCorrelationEvent]

  18:          event EventHandler<OrderWorkflowServiceEventArgs> OrderCanceled;

19:

  20:          /// <summary>

  21:          ///

  22:          /// </summary>

  23:          [CorrelationAlias("OrderId", "e.OrderId")]

  24:          [ExposedAutoCorrelationEvent]

  25:          event EventHandler<OrderWorkflowServiceEventArgs> OrderShipped;

26:

  27:          /// <summary>

  28:          ///

  29:          /// </summary>

  30:          [CorrelationAlias("OrderId", "e.OrderId")]

  31:          [ExposedAutoCorrelationEvent]

  32:          event EventHandler<OrderWorkflowServiceEventArgs> OrderProcessed;

33:

  34:          /// <summary>

  35:          /// This event will be fired from the Host.cs file in the ProcessStarted event.

  36:          /// This is necessary to initialize the Correlation engine for a particular workflow instance

  37:          /// inside WF.  Note this event is not exposed to the outside world as it will only be invoked

  38:          /// internally.

  39:          /// </summary>

  40:          [CorrelationAlias("OrderId", "e.OrderId")]

  41:          [CorrelationInitializer]

  42:          [ExposedAutoCorrelationEvent(ExposedExternally=false)]

  43:          event EventHandler<OrderWorkflowServiceEventArgs> OrderCreated;

  44:      }

Every event you want us to automatically expose to the outside world for you needs to be marked with the [ExposedAutoCorrelationEvent] attribute. The OrderCreated event (an internal event used to initialize the correlation) is marked as ExposedExternally=false.

Next we need to update our ExternalDataEventArgs class and add 2 attributes in the constructor.

   1:      /// <summary>

   2:      ///

   3:      /// </summary>

   4:      [Serializable]

   5:      public class OrderWorkflowServiceEventArgs : ExternalDataEventArgs

   6:      {

   7:          private Guid orderId;

8:

   9:          /// <summary>

  10:          ///

  11:          /// </summary>

  12:          public Guid OrderId

  13:          {

  14:              get { return orderId; }

  15:              set { orderId = value; }

  16:          }

17:

  18:          /// <summary>

  19:          /// The [AutoCorrelationInstanceId] tells the client generation engine which constructor parameter

  20:          /// should be mapped to the instance id to get workflow instance.

  21:          ///

  22:          /// The [AutoCorrelationParameter] tells the correlation engine which [CorrelationParameter] attribute to map

  23:          /// to on the IOrderWorkflowService.  You can have multiple correlation values.  The combination of them must be unique.

  24:          /// </summary>

  25:          /// <param name="instanceId"></param>

  26:          /// <param name="orderId"></param>

  27:          public OrderWorkflowServiceEventArgs([AutoCorrelationInstanceId] Guid instanceId, [AutoCorrelationParameter("OrderId")] Guid orderId)

  28:              : base (instanceId)

  29:          {

  30:              this.orderId = orderId;

  31:          }

  32:      }

Notice the [AutoCorrelationInstanceId] attribute. This is used to tell the Aware runtime which parameter is the unique WF instance id Guid. The other attribute [AutoCorrelationParameter("OrderId")] must be applied to each [CorrelationParameter("XXX")] you applied to your IOrderWorkflowService above. In this case we only have one correlation parameter so [AutoCorrelationParameter("OrderId")] is applied to the "orderId" parameter in the constructor. Again nothing new yet. Our engine will use all these attributes to automatically generate a typed proxy for any clients (ASP.NET, Winforms, etc.) that want to trigger events externally.

Lastly we need to implement our IOrderWorkflowService interface.

   1:      /// <summary>

   2:      /// You must derive from CorrelationWorkflowService

   3:      /// </summary>

   4:      public class OrderWorkflowService : CorrelationWorkflowService<IOrderWorkflowService>, IOrderWorkflowService

   5:      {

   6:          //

   7:          // All these events will be automatically wired up by Aware and fired when called.

   8:          //

   9:          #region IOrderWorkflowService Members

10:

  11:          public event EventHandler<OrderWorkflowServiceEventArgs> OrderCanceled;

12:

  13:          public event EventHandler<OrderWorkflowServiceEventArgs> OrderShipped;

14:

  15:          public event EventHandler<OrderWorkflowServiceEventArgs> OrderProcessed;

16:

  17:          public event EventHandler<OrderWorkflowServiceEventArgs> OrderCreated;

18:

  19:          #endregion

  20:      }

Notice we don't need to actually implement the events. By deriving from our CorrelationWorkflowService we will automatically implement those for you. When you build you will get CS0067 warnings, but your can wrap those with a #pragma to remove those.

In your Host.cs file of your Aware Business Process project make sure you add your OrderWorkflowService to the runtime.

   1:          /// <summary>

   2:          ///

   3:          /// </summary>

   4:          /// <param name="sender"></param>

   5:          /// <param name="e"></param>

   6:          void Host_InitializeWorkflowRuntime(object sender, InitializeWorkflowRuntimeEventArgs e)

   7:          {

   8:              //

   9:              // It is important that you add your services to the ExternalDataExchangeService and not the

  10:              // runtime directly.  The ExternalDataExchangeService handles interception of your events

  11:              // your service and ensures they get scheduled properly inside the WorkflowRuntime

  12:              //

  13:              ExternalDataExchangeService dataExchangeService = e.WorkflowRuntime.GetService<ExternalDataExchangeService>();

  14:              dataExchangeService.AddService(new OrderWorkflowService());

  15:          }

16:

  17:          /// <summary>

  18:          ///

  19:          /// </summary>

  20:          /// <param name="sender"></param>

  21:          /// <param name="e"></param>

  22:          void Host_ProcessStarted(object sender, ProcessEventArgs e)

  23:          {

  24:              //

  25:              // Grab the OrderDetails provided to the process

  26:              //

  27:              OrderDetails orderDetails = e.BusinessProcessContext.BusinessProcessRequest.Parameters["OrderDetails"] as OrderDetails;

28:

  29:              //

  30:              // This must be fired to initialize the correlation.  WF requires either a method

  31:              // or and event on the [ExternalDataExchange] based service to initialize the correlation via the [CorrelationInitialization] attribute

  32:              //

  33:              OrderWorkflowService orderService = GetWorkflowService<OrderWorkflowService>();

  34:              orderService.FireEvent("OrderCreated", new OrderWorkflowServiceEventArgs(e.BusinessProcessContext.BusinessProcessId, orderDetails.OrderId));

  35:          }

Next go to your workflow and view code. At the top of your class add the following attribute.

   1:      [ExposedWorkflowService(typeof(IOrderWorkflowService), "OrderEngine")]

   2:      [BusinessProcessScheduledInitializer(typeof(ScheduledInitializer))]

   3:      [BusinessProcessHost(typeof(Host))]

   4:      public sealed partial class OrderProcessingProcess : StateMachineWorkflowActivity

   5:      {

   6:          private OrderDetails orderDetails;

The [ExposedWorkflowService(typeof(IOrderWorkflowService), "OrderEngine")] attribute tells our proxy engine to generate a typed class for you that exposes all the [ExposedAutoCorrelationEvent] on the IOrderWorkflowService externally and call it "OrderEngine".

If you add an Aware Reference from your client.

You will end up with a generated client that looks like the following. The guts of each fired routine is omitted for brevity. Notice the name of the typed class "OrderEngine" and the static routines on the OrderProcessingProcessClient.

   1:      public class OrderEngine : Gridgistics.Aware.BusinessProcesses.Clients.GeneratedBusinessProcessExposedServiceClient

   2:      {

3:

   4:          public OrderEngine(Gridgistics.Aware.Workflow.CorrelationValues correlationValues, Gridgistics.Aware.Workflow.CorrelationHostReference correlationHostReference) :

   5:                  base(correlationValues, correlationHostReference)

   6:          {

   7:          }

8:

   9:          public void FireOrderCanceled()

  10:          {

  11:          ...

  12:          }

13:

  14:          public void FireOrderShipped()

  15:          {

  16:          ...

  17:          }

18:

  19:          public void FireOrderProcessed()

  20:          {

  21:          ...

  22:          }

  23:      }

And

   1:      public class OrderProcessingProcessClient : Gridgistics.Aware.BusinessProcesses.Clients.GeneratedBusinessProcessClientBase

   2:      {

3:

   4:          public static OrderEngine GetOrderEngine(System.Guid orderId)

   5:          {

   6:              return OrderProcessingProcessClient.GetOrderEngine(orderId, new Gridgistics.Aware.Services.ServiceAttributes());

   7:          }

8:

   9:          public static OrderEngine GetOrderEngine(System.Guid orderId, Gridgistics.Aware.Services.ServiceAttributes searchAttributes)

  10:          {

  11:          ...

  12:          }

  13:      }

To use this generated client you will use the following code.

   1:                      using (OrderEngine orderEngine = OrderProcessingProcessClient.GetOrderEngine(detail.OrderId))

   2:                      {

   3:                          orderEngine.FireOrderProcessed();

   4:                      }

No matter what server your WF instance is running on and no matter which version it is the events will be routed back to the right instance using the right assembly versions, etc. by simply providing us with your correlated value (order id in this case).

So as you can see we have done our best to take some of the sting out of using correlated workflow services inside WF and easily exposing these events externally to any .NET client.

Aware Server ASP.Net Web Deployment

Darrell Legault — Tue, 13 May 2008 12:17:00 -0400

With Aware Server, deploying ASP.NET web sites is as easy as 123. Essentially you publish your web application into the Aware Environment, then use Aware to publish your ASP.NET web application out to the Farm (1 machine or 1000 machines). In the first diagram you see the flow, from VS.NET, to Aware Server, to the farm. I will walk you through exactly how it works, no coding, no scripting, no hassles.

Let us start by creating a new Aware Web Application Project (Note: existing ASP.NET applications can easily be converted to become "Aware" ASP.NET applications as well).

Open the App_Deployment Folder, and then double click the "WebApplicationDeployment_Debug.aware" file. Just like services and business processes, the ASP.NET applications use the same process to build, package, deploy, and provision process. Now build your web site, then click the "Publish Now" button.

For our sample here, we will deploy into our current local environment. Click "Deploy".

We can verify that it was deployed by looking in the Aware Enterprise Manager Deployment tab.

Now to publish our Web Application, we can go to the Management Extensions tab in the Aware Enterprise Manager and run the ASP.NET Application Provisioning extension (double click the icon).

The ASP.NET Application Provisioning extension runs, and displays all of the Web Applications that exit in the environment, and that have been published. Ours has not been published yet, so go ahead and click on the "Publish Web Application" link on the left to start the wizard.

Once the wizard starts you will see the Checklist page. Read and then click next.

Now you will see a list of all the IIS servers you can publish too (with their versions). Select from the list and then click next.

Select the appropriate site, and give an appropriate virtual directory (optional). Then select your security settings and click next.

At this point you can set any of the web sites application variables, or configuration strings. Make your changes then click next.

You will see the last confirmation screen of where it will be published too, click "publish" to commence.

Once the publishing has finished, you should see success messages. Click close to complete the wizard.

The ASP.NET Application Provisioning extension will update, and you will now see your application published to the servers you selected in your environment.

Now here is the real beauty of the Aware Server ASP.NET publishing. Lets say you make a change to your web site. Just republish from VS.NET (like you did above), and your changes are now ready to be published to all of the IIS machines.

To republish to all of the IIS machines, now just click the "republish web application" and you will quickly walk through the wizard to confirm you previous selections.

Now let's one up that. Let's say you want to version your site. Just make the changes in the "Version Information" in the VS.NET deployment settings tab, and then build and "publish now".

When you return to the ASP.NET Application Provisioning tool, you will now see both of your versions out there. Publish version 1.1 with the wizard, if things do not work out, then just publish version 1.0. Its that easy.

To keep on tab on all things that occur, just refer to the "Publish History" tab and you will see when sites were deployed and to where.

Aware Server ASP.NET Deployment - no code, no scripts, no hassles.

Technorati Tags: Aware Server,ASP.NET Deployment,gridGISTICS

Aware Server: Be 67% More Productive with VS.NET

Darrell Legault — Mon, 05 May 2008 16:19:00 -0400

I ran across an interesting blog about “Creating, Configuring, and Consuming a WCF Service in IIS”. 60 steps later and you had something to play with…. http://blogs.msdn.com/zainnab/archive/2008/04/30/creating-configuring-and-consuming-a-wcf-service-in-iis-7.aspx

As much as we love .NET development, we can hardly call this productive. What I am going to show you is how Aware Server can take your developers to the next level, and increase their productivity by 67%. Not only do you get an huge boost in development productivity, you also save an enormous amount of time and gain tremendous number of features for Operations (deployment, provisioning, and monitoring of your services).

It’s a no brainier, be more productive, deploy and provision your services to any number of machines. Aware Server gives you everything, and picks up where VS.NET drops off. So let’s get started. Also this entry is quite long because I included every screenshot as I did things.

Create and Debug an Aware Service (4 steps – 5^th step is if you do not trust me)

1. Run VS.NET as Admin.

2. Start a new project – As you can see, we are going to use an Aware Template. One of the many templates is the “Aware Distributed Service”. This is what we will use today for our comparison.

3. Enter your Aware Service information.

4. Debug your new service. Hit F5 – Now the Aware Service Invoker starts up (no more test harness app's needed) and allows you to test your service immediately. Go ahead and click the “SomeOperation” function on the left tree, then click the “Invoke” button. You will see the Results, Request, and Response messages. By default the Aware Distributed Service template creates the “SomeOperation” method for you so that is what you will test. Now all you need to do is code your own operations.

5. Just for kicks, I’ll add in a step to let you verify your service was up and running fine. Just open up the Aware Enterprise Manager and while you are debugging you will see that your service is running. By default on net.TCP.

Deploy an Aware Service (3 steps – 4^th step is if you do not trust me)

1. Now since we do not need a testharness any more we actually eliminate about 11 steps. That said, we will walk through the overall process that leads you to create a client application. This will let you see how easy it is to consume and use Aware Services from ANYWHERE.

Before we call this service, we will deploy and provision the service. Aware Server is based on Environments. You deploy to environments, and then provision your services to run within those environments. Now you may say that this is actually more work than using the VS.NET “WCF Service” template which automatically deployed and provisioned it to your local IIS. What we are actually doing is eliminating about 20 of the other steps that happen later on to configure and use different endpoints, and in our case, we automagically do this for any machine that our service is provisioned for.

So let’s get started, and deploy this service. In the Solution Explorer, open the Deployments directory, and double click the ServiceDeployment_Debug.aware file.

2. This will open the Aware Deployment File Viewer for you which you should then see the following viewer (Deployment Settings). Now to deploy your service, click the “publish now” button. Notice that there is an “Auto Publish” option here if you wish to automatically publish this service on each build.

3. After you click the “Publish Now” button you will see the “Deploy to Environment”. By default your current environment is selected, but you may choose any environment that you have security access too. For or example just click deploy and your service will be deployed to your default environment.

4. Lets validate that it was deployed. Return to the Aware Enterprise Manager and then navigate to the “Deployment” tab at the very top. You will see all of the services deployed in your environment, one of which is the service you just deployed (Easy Aware Services).

Provision an Aware Service (3 steps – 4^th for info, 5^th step is if you do not trust me)

1. Now that we deployed our service, let’s provision it to run in our environment. Return to the Aware Enterprise Manager again, and now click on the “Service Provisioning Polices” tab at the top. You will see all of the policies in your environment.

2. Let’s go ahead and create one for our new service, so click the “Create New” in the tool bar. You will see the Service Provisioning Policy Editor pop up. Give your policy a name, application name, and description, and then click on the “Included Service Manifests” tab.

3. Once you are on the “Included Service Manifests” tab, click the “Add Service Manifest button and you will get a list of all services deployed in that environment. Select your “Easy Aware Service” and click “OK”. At this point you could click “Save” on the policy and be done (defaults will be used).

4. At this point we could click the “Save” and our services would start running, but we will review some additional options you have for our policy. Now remember how we talked about the default protocol used is net.TCP, you can easily change that here, or just add as many wish to use (from TCP to REST). No code changes, no configuration night mare. Click Cancel here and we will continue with the default setup.

Not let’s set the “Conditions / Exclusions” that will be used to determine what machines the service will run on. By default conditions are set to Any/Any. Click the “Add Condition” button and you will see you can specify any type of condition (from machine names, to only machines running with 2 processors, or machines that only have 4gig of Ram). For this example well just use the defaults.

Another option that you have is to set time windows of when your service should run. This allows you the flexibility that if you have some services that are heavily used in the early mornings you can schedule them to run on more machines to handle the heavy peak loads, but then during the day stop those services so that they do not interfere with daily operations.

Click “Save” and you should see your newly created policy enabled and running. Note that by mousing over the policy it will tell you the details.

5. We created the policy; now let’s verify that our policy is doing what we asked it to do. Return to the Aware Enterprise Manager and select the “Services” tab again. Just as we saw before during F5 development, we see our service running, but now it is running due to the policy being applied.

Call an Aware Service (4 steps – 5^th step is if you do not trust me)

1. Now that we have developed, deployed, and provisioned our service to run. Let’s put together a little client application to call our service. Create a new project. Just like before you get the project selection window. This time we will use the “Aware Console Application”, give it a name of “MyFirstAwareClient” and then click OK.

2. Now proceed to add Aware Server References by right clicking on the project and “Manage Aware Server References…”

3. You will see the “Aware Service and Business Process References” pop up screen. All you need to do is select your service, then click “Add”. Now click “Apply” and you are ready to call your service. No URL is needed.

4. Aware Server automatically adds all of the proper references (downloading shared contracts) and generates the client proxy to make your calls. What it boils down to is TWO lines of code; create the client, make the call.

   1:  using(EasyAwareServicesClient client = new EasyAwareServicesClient()

   2:  {

   3:      Console.WriteLine("What is 2 + 3? {0}", client.AddNumbers(2,3));

   4:  }

5. Hit F5 and you should see.

Zero configuration, no URL’s to know. So how does Aware know where my service is? That is the magic and simplicity of Aware Server and its Service Virtualization capability based on the Service Location Protocol. Our goal was to make using services as easy and simple as possible.

Summary of Aware Server development vs. VS.NET 2008

Aware Server

VS.NET 2008

Result

Built in F5 debugging of services and workflow's.

Create your service, then configure your environment, and then create and code your testharness.

· Aware Server 54% faster to develop WCF services.

· Aware Server – now prior WCF knowledge required.

· Aware Server treats workflow development (WF) the same as service (WCF) development.

One click deployment – Any environment.

Deploy to your machine running IIS.

· Aware Server is “One Click” deployment of services.

· Aware Server allows you to quickly test your services locally, and then deploy them to be shared with all developers.

Versioning services and running them side by side.

No built in versioning capabilities

· Aware Server will let you easily version and run those versions.

Provisioned endpoints.

Developer must create the endpoints.

· Aware abstracts protocol from the developer and puts it into the hands of operations.

Automatic service call load balancing

You need to setup and configure your own load balancing solution.

· Aware automatically scales your services by load balancing your service calls across all machines running your services.

Provisioning Conditions.

You need to setup your service on every machine you want it to run on.

· Setting up Aware Services to run on one server, or 1,000 servers. One policy will take care of all deployment and configuration for ALL of your servers.

Re-deployment will automatically run your new code.

Re-deployment is only local on your own machine.

· If an Aware Server policy is setup to run your service on 5 machines, when you redeploy that service Aware Server will automatically re-deploy the new code to all 5 machines.

Provisioning time schedules.

You would have to code/manage a schedule yourself.

· Aware Server automatically will run services when you want them to run, where you want them to run.

Zero configuration.

You need to know the URL of the machine of the services you wish to call

· Aware Server was designed from the ground up with Services Virtualization in mind to eliminate service location configuration.

IIS is not required, Although you can use IIS as well.

IIS is required to host your services.

· Aware Server offers you the flexibility of using whatever you hosting model you want.

To find out more please visit www.gridgistics.net and go to the learn section.

Technorati Tags: Aware Server,VS.NET,SOA,Service Virtualization,.NET Development Productivity

Designing and Deploying Services

Darrell Legault — Fri, 02 May 2008 12:32:00 -0400

As a company we spend much of our time building marketing materials, messaging materials, demo's, presentations etc.... Anyone who is apart of a small organization can appreciate the amount of time and effort that goes into every little aspect of building your story. Much time is spent researching, reading, understanding the markets, future directions. The rare time you stumble upon a piece of gold, but gold you can share.

"We have long believed that 80% of operations issues originate in design and development..." Developers may not believe it, but here is 20 years of experience that explains why.

Below you will find the most comprehensive explanation of what it takes to design and deploy services.

http://research.microsoft.com/~JamesRH/TalksAndPapers/JamesRH_Lisa.pdf

Some key observations

designing for automation and provisioning
dependency management
release cycle and testing
hardware selection and standardization
operations and capacity planning
auditing
monitoring and alerting
graceful degradation and admission control
customer and press communications plan
customer self provisioning and self help

Conclusion --> "Reducing operations costs and improving service reliability for a high scale Internet service starts with writing the service to be operations-friendly."

That sentence probably best describes what we try to achieve with Aware Server.... what's good for the developer, is good for operations.

Check it out at http://www.gridgistics.net/main_learn.aspx

Technorati Tags: gridGISTICS,Aware Server,designing and deploying services

Microsoft and Intel Drop $20 Million on Parallel Computing

Ryan Turner — Fri, 28 Mar 2008 17:29:00 -0400

Microsoft and Intel Launch Parallel Computing Research Centers to Accelerate Benefits to Consumers, Businesses

To give you the skinny. Microsoft and Intel are partnering to develop edu programs and further research in an effort to make parallel computing easier and bring it to the mere mortal developer. I definitely get warm and fuzzy's from the affirmation that the problem exists, its real and the big guys see it too.

My favorite quote from the article is:

“We now face the exciting challenge of making parallelism so easy to use that parallel programming becomes synonymous with programming”
- Marc Snir (University of Illinois at Urbana-Champaign professor of Computer Science)

MS press release

Of course this seems strangely family to the Google and IBM announcement back in October.

IBM press release

My favorite quote from this one was:

"The goal of this initiative is to improve computer science students’ knowledge of highly parallel computing practices to better address the emerging paradigm of large-scale distributed computing. IBM and Google are teaming up to provide hardware, software and services to augment university curricula and expand research horizons. "

Internet Explorer Trick for Mere Mortals

Ryan Turner — Fri, 28 Mar 2008 12:55:16 -0400

Ok. So while the other guys are ripping out long entries on how the latest technologies can impact your enterprise, I come up with something rather inconsequential to your company's success.

However - I still had a person pep rally in my cube when I discovered this scientific breakthrough that is bound to rawk our industry to the core.

(hang on your armrests and BEHOLD the automatic launch of multiple default tabs in Internet Explorer)

Yeah ok... I know it actually SAYS what it does in the description - and its not the discovery of sustained cold fusion which will freely power our planet. But I'm easily impressed, and wanted to share some love.

Life on the Bungie Farm: Fun Things to do with 180 Servers and 350 Processors

Ryan Turner — Fri, 22 Feb 2008 14:09:24 -0400

Yesterday Luis Villegas and Sean Shypula gave an exciting talk at the Game Developer Conference (in Sanfran)

I'll tell ya what... I'm personally stoked to hear anything about Bungie development in general. First and foremost I'm a huge Bungie fan from a company and game perspective.

<flashback>I had a copy of Marathon release day on my overclocked Powermac Quadra </flashback>

Secondly they are moving a lot of their stuff to .NET/C# - which just makes me smile ;)

Its awesome to see this company grow and prosper and continue to put out quality games at such an amazing scale. I'd have to chalk it up to the smart people they have working there. However - what really hit home with me is the similarities between such dissimilar industries.

For example.. whether your grid solves daily Monte Carlo simulations for million dollar decisions in the energy sector - or whether your grid pre-compiles lighting in Halo 3 maps - the problems faced are the exact SAME.

Some of the daily issues Sean and Luis face:

Application Abstraction (vitalization) from the grid - allowing machines to be utilizes like a commodity.
Dynamic Provisioning of services and environments. (lighting / rendering / payroll / mathematically determine whether Superman or Batman would win in a fist fight if Superman wasn't allowed to fly)
Distributed Workflows and sub workflows
Workflow auditing
Debugging Grid Environment.
Auditing Jobs
Simplified Deployment
Admin tools for configuration, deployment, provisioning
Managing multiple environments (development, testing, production, etc)
Real-time monitoring
Performance tuning.

Do these issues sound familiar? Sure! Only most of us are writing enterprise level services for work and play games for fun - rather than work to make the games.

once more... every MS shop who faces these obstacles owes it to their team and their company - to checkout Aware Server and schedule a demo.

I don't know about you... but I'd get a kick out of knowing Master Chief uses Aware Server to keep his perfectly rendered helmet nice and shiny ;)

>rt

Technorati Tags: news,workflow,.net,grid

.NET Framework Library Source Code now available

Ryan Turner — Wed, 20 Feb 2008 18:36:00 -0400

Scott Gu (love his blog btw) announced the official release of the .NET Framework source library.

Though this is only about a month old - I had thought this would have picked up more buzz. The consensus may be that either only uber geeks or hackers really want / care about the source. We can already use Reflector to peeky peeky. Debugging the actual framework? You mean you think you are smarter than the great and powerful MS. Possibly, but not necessarily. Regardless its a good learning tool and allows us to gain supported insight into the framework itself.

I'm not saying you should be having a personal pep rally in your cube or get a Visual Studio tattoo on your forearm - I'm just saying it takes some serious cojones for them to release it and you have to get warm and fuzzies from any MS-love we get.

Lets give my man Ozzy some props.

Technorati Tags: .net framework,news

Environmental Singleton

Dan Haligas — Fri, 15 Feb 2008 15:11:01 -0400

In Aware Server v3.0 there may be times when you want to ensure that one and only one of a particular service is running in an environment (Dev, QA, etc.).

We needed this functionality for the core layers so we decided to expose it to anyone developing WCF services on top of Aware.

To make your service an Environmental singleton, simply add the following attribute to the top of your service implementation of IMyServiceContract.

[EnvironmentBehavior(EnvironmentInstancing.Singleton, typeof(IMyServiceContract))]

If another instance tries to come online a warning will be put in the Event Log of the offending server and the service will not be allowed to start. These warnings can be picked up by our monitoring engine which I will cover in a later topic.

Visual Studio 2008 Support

Dan Haligas — Mon, 11 Feb 2008 20:17:56 -0400

With Aware v3.0 we support both VS.net 2005 and 2008. All of our project templates are written for 2005, but work just fine in 2008.

There may be some times when VS.NET 2008 barks and asks you to overwrite this or that during a project creation. Accept overwrite when asked (if asked) and all will be well. This usually occurs when using our project templates for creating Web Application Projects which will be covered in another post.

Being that we are a small ISV we are not sure how long we will continue to support the 2005 stuff as 2008 has virtually made it irrelevant. Anyone that is still on 2003 will jump right to 2008. Anyone on 2005 can move to 2008 with no more than a day’s effort.

Reduce development time by 40%....no that is not a typo!

Michael Smith — Mon, 11 Feb 2008 00:01:00 -0400

Claiming that Aware Server can reduce code generation and overall development time by 40% often provokes looks of disbelief. But this claim is for real and in today's world where building scalable and agile applications is a must, spending less time on code and more time on the business logic of your applications would give you a serious competitive advantage, not to mention coming in on time and under budget, and maybe even going home early once in awhile!

So let me give you a quick overview of how we do this. Let's start with the typical development process, what you are probably doing today and compare developing in an Aware Server Environment.


Today's Development Process	Development in an Aware Server Environment
Contract definition Data Contracts Implementation and then...... Host it Expose it Secure it Share it (so others can call the service) Deploy it/provision it Apply versioning Provide for logging and auditing Monitor performance	Contract definition Data Contracts Implementation And then..... DONE

The table is pretty self explanatory, but let me break it down a little further. Aware Server gives you a complete o ut of the box solution for development, deployment, packaging, provisioning, monitoring and maintaining your services. It also enables you to instantly create grid/high performance computing environments, and enables human interaction workflows and business process management.

So with one platform, you are able to reduce your code by 40% and maximize your existing hardware. Take a look at our videos to see exactly how easy we have made it to take your programming to the next level. http://www.gridgistics.net/main_learn.aspx

Windows Server 2003 Administration Tools Pack - Remote DesktopS

Ryan Turner — Sat, 09 Feb 2008 21:16:23 -0400

I have another tool of the trade for you.

Technorati Tags: remote desktop,windows management

Unfortunately I cannot take credit for finding it - as Robert showed me about it. Fortunately he hasn't blogged about it yet - so I'll hopefully steal his thunder :P

Any time you need to remote desktop into multiple machines at the same time - the current Remote Desktop tool is pretty annoying. Even when you specify a windowed mode, you are still alt-tabbing like some sort of demon-possessed.

Windows Server 2003 Administration Tools Pack gives us Remote Desktops - and yes its plural.

Here is the skinny - its just an MMC snap in for remote desktops. However - it makes managing our large environments much easier, by letting you connect to simultaneously to as many machines as you want and quickly switch back and forth.

So whether you are installing software, handling updates, tracking issues, peeking the event log or fighting the latest fire - this will make it a bit easier.

O Snap. I almost forgot the best part (aside from being free) - the thing installs on Vista 32/64 just fine - thus allowing you to get this functionality on any machine you are on.

Download Here

Resources for Windows High Performance Computing

Ryan Turner — Thu, 07 Feb 2008 22:00:35 -0400

I just wanted to spread some link juice back to Eric Nelson - who took the time to put together a great blog post on Windows High Performance Computing. If you haven't stumbled upon his blog or aren't savvy on HPC. Check it out.

Topics generally include: .NET 3.0 / Vista, AIC, Visual Studio 2008, SQL Server 2008, etc..

Eric Nelson

Take Control of Window Services

Ryan Turner — Thu, 07 Feb 2008 21:53:41 -0400

Came across a freebie tool that is really proving invaluable to me and I wanted to share the love. Whether you write Windows services or just have a vague idea of what they are you need to read further.

Its called Service Studio and manages Windows Services (Services MMC replacement) from an incredibly powerful interface. Here is a list of a few of the highlights:

Multi-select services and adjust their properties all at once.
Create Service Profiles and Switch between with a single click.
Remotely Manage another machines Services (yep you heard me)
Review Service Dependencies
View Current Service Memory footprint in a graphical form.

This profile thing is a real life saver. In my case - I am continually changing from my developer profile (containing Aware / SQL / VM Services) and to my designer profile (just network / security services left on). On laptops this works great as well - as you may have a development profile and a Starbucks profile - or an audio recording profile and a gamers profile. (whatever floats your boat).

Check it out... its free and has Ryan's personal seal of approval.

Service Studio

Our Current Options

Ok.. smarty pants. Your first inclination is to say.. "Ryan haven't you heard of the Services MMC Snap-In?". O contraire.. I have and have spent many dozen clicks to yield changing the startup type of 3 services.

( for those who aren't familiar in XP we had )

(hold your applause... I know its some good look'n stuff)

But wait in Vista we have a new and not improved version.

New great look! No new love.

The Ninja Weapon

(drum roll please...)

Ok look at this thing.. If it did nothing more than let me multi-select and change properties I would consider it a must have. But hang on to your horses!

How about a visual representation of the service footprint?

Ok.. I'm done sharing for the day.

Technorati Tags: windows services,tools,3rd Party

Aware Server - Core Configurations

darrell legault — Fri, 25 Jan 2008 00:22:27 -0400

If you want to have different core configurations, meaning, a different repository for each core configuration, you can accomplish this with the creation of another StoreRepository file.

The StoreRepository.xml file can be found in the following directory

C:\Program Files\Common Files\Gridgistics\Aware\Runtime

By default, the StoreRepository.xml file will be used for every environment, but you you want a different repository for a different environment, just copy the StoreRepository.xml file and then rename it to StoreRepository.{environment name}.xml. Make your changes within the new file, and you now have your new repository configuration.

Now when you switch your core server to the "environment name" it will use the configuration found in the StoreRepository.{environment name}.xml

If now custom StoreRepository file is found, the default file is used.

Technorati Tags: gridGISTICS,Aware Server,Configuration

Aware Server - Create Environments

darrell legault — Thu, 24 Jan 2008 13:30:00 -0400

So you have Aware Server installed, and now you want to create your own little kingdom. A place where you can hoard all the machines you can find. Its easy.

First, you will need to run the Aware Runtime Management Tool. It can be found in the

C:\Program Files\Common Files\Gridgistics\Aware\Runtime\AwareLocalRuntimeTools.exe

Run the exe and you should see the following screen.

The Aware Local Runtime Tools, as it suggests, consists of many different tools to help diagnose and certify the runtime environments. For today's exercise, we will concentrate on create a new environment. Once you click on the "environments" icon on the left, the right will display a list of all of the environments that already exist. To create a new one simply click the "new" link below the list of environments.

The above screen will be displayed where you can change any one of its listed properties.

Name -- the name of your new environment

Direct Uri -- the location of the service registry

Locator Address -- multicast address used for locating services

locator port -- port used for locating services

Notification Address -- multicast address used for notifications

Notification Port -- port used for notifications

Force direct connect -- instead of using discovery, force the use of the specific URI

Ignore Isolation Mode -- when checked, allows the environment to interact with other machines. If left unchecked, messages from other machines will be ignored, hence your environment will be isolated from everyone else.

In our case, I will just enter a new name and change my ports to 3020 and 3021 respectively, then click ok. The new environment is now created. Before we go through the steps to switch to that environment, you need to make sure you create the groups for it (so that you can manage it) and make sure you add the account for which the Aware Services run as is added to those new groups. If your new environment name is "Stage" then you will need to create 3 new groups:

Aware Stage Management
Aware Stage Deployment
Aware Stage Diagnostics

Now that the groups exist, and we added the account to those groups, we can switch our local machine to use that environment. To do so:

start the Aware Server Enterprise Manager
go to the "Servers" tab at the top.
Click the "Manage All Servers" in the top tool bar

You should now see the following screen.

If other machines on your network are running Aware (server or just service hosts) they should appear on the left hand side. To switch environments, just select the machine, and then select a environment from the "other environments" drop down list. In that list you should see our newly created environment.

For my exercise, I'm going to select my new environment "Rhys" and then the "Server Role" of "Core", then click the "switch to" button. Environment Changed. Notice my environment name is now "Rhys".

Now this is where it get's fun. We can now take over, meaning, I can move machines into MY environment so I can control them. Simply click on another machine, then just as we did earlier, select the environment, and then role, and then click "switch to". Take one machine.

Or two.

Or Three.

Now, close the Manage Machine Environments screen, and then click on the "Manage Another Environment" in the tool bar. Select your new environment that you just switched too, then select the "Services" tab. You should see all of the machines you just moved to your environment ready to be used.

Enjoy your newly found power.

Technorati Tags: gridGISTICS,Aware Server,Installation,SOA,Environments

Aware Server Installation

Darrell Legault — Thu, 24 Jan 2008 12:30:00 -0400

Just how quick and easy is it to have your own grid of Aware Service Hosts at your disposal? Lets walk through the process and see.

Step 1 - Aware Server Installation

Locate your installation directory, and run the AwareSetup.exe

Accept the license agreement, and you will advance to the option screen.

Choose your option

Today we will walk through the Aware Core Server install. The core server, as it implies, is the main server for an environment. To the right on the screen you will notice the components that get installed during the process, and as you select different options, that list changes. So select the Aware Core Server option and click next.

Service Setup

Either use an existing account that you know will have proper access, or create a new account. All of the installed services will us this account to run. The key to the services account setting is that each machine should use the same account. Once you enter your account information, click next.

Repository Setup

The repository is where Aware Server stores all of its configuration, manifests (services, business processes, asp.net web sites), provision policies, audit logs, etc... You simply need to point to an existing instance of Microsoft SQL Server 2005 with valid credentials to create a new database. Enter the information, and click validate. If all looks well, click next.

Shared Directory

For business process state (workflow state) a shared directory is used. Ensure that the credentials you used (service setup) has access to the directory you use and then click next.

Aware Environment

The installation creates a "default" environment for you, or you can easily import an existing environment. For our example we will just use the default environment, so just click next.

Complete Installation

The last step in the wizard is a confirmation screen listing the steps that will executed to complete your installation. Click "start" to complete your installation. As the installation completes each step, you will see that step change to a green check mark.

Within a few moments, all actions should have green check marks. Click "close". We are now ready to start the Aware Server Enterprise Manager.

Step 2 - Start the Aware Serve Enterprise Manager

Click "start" on your taskbar, and then click on the "Gridgistics Aware" folder. You will find the Aware Enterprise Manager shortcut.

When you start the Aware Enterprise Manager you may notice the following screen.

Aware Server security is relies on the groups derived from the environment name, hence in our case we did not already have the above groups. We will need to add these groups, and then add the account we used during the installation to the newly created groups. Regardless of not having the groups, you should still see the newly installed environment. We will just need to create the groups and add our account to that group before we continue (so we have security setup to manage our environment).

And now you have it, Aware Server installed and ready to go.

Technorati Tags: gridGISTICS,Aware Server,Installation

Aware Server 3.0 Released

Michael Smith — Thu, 24 Jan 2008 12:11:00 -0400

Technorati Tags: Aware Server,Gridgistics

We have been recieving serveral questions about Aware Server 3.0 and some of the new features, so I thought I would repost the press release here as well. Let me know if anyone has any more questions about what is new in Aware Server 3.0.

gridGISTICS Aware Server™ reduces development time by 40%

Atlanta GA (September 18, 2007)— gridGISTICS announced the release of Aware Server 3.0, the latest version of their revolutionary service virtualization and grid computing platform providing an all-encompassing solution to SOA, distributed/grid computing, human workflow and business process management for the .NET environment.For years businesses and their IT departments have shied away from these technologies because of their complexity and the associated development costs, even though they could have significant business impact. “Our goal was to make things easy, whether that was SOA, distributed computing or workflow, so businesses could really dream about the “what if” and know the cost and complexity of the technology would not get in the way.” says Michael Smith, VP of Sales and Marketing “We wanted businesses to be able to ask questions like: “What if everything we write is immediately grid enabled, scalable, and reliable?” With the power and ease of Aware Server, they can now focus on their business logic and not how they are going to architect and execute their solutions. The ease of use is one aspect that makes Aware Server 3.0 so impressive over earlier versions. “We have been focused on the typical .NET developer from the beginning. With Aware 3.0, just about anyone can install, watch a couple of the instructional videos and be creating, deploying, and provisioning services as well as distributed/grid environments and workflows.” “Our biggest challenge is people dismissing us as hype, but we really make it that easy. “ says Dan Haligas, Director of Product DevelopmentAware Server is built on .NET 3.0 and is completely integrated with Windows Workflow Foundation (WF) and Windows Communication Foundation (WCF). “We realized that these technologies were the key in solving a lot of the issues with the complexity that is introduced while trying to leverage the business benefits of SOA and grid/distributed technologies. Because we have addressed these issues from the perspective of the developer, we ended up with a product that really allows developers to use the .NET technology out of the box, accelerating productivity while not getting in the way” says Darrell Legault, COO.Aware Server is the ideal product for anything that requires scalability and reliability. It also can easily reduce the amount of code for a project by 40% and will reduce the cost of monitoring and maintenance over the application lifecycle as well.New features include:· Visual Studio 2005 and 2008 integration.· Expansion of F5 debugging for services and business processes eliminates the need to build test clients.· One click deployment of services.· More Aware Server is a truly revolutionary solution for IT because when you move your applications from environment to environment (development, integration, staging, QA, production), nothing changes. All service locations are abstracted (virtualized with no hard coded or configured Uri's) and configuration (database connection strings, etc.) can be changed by application administrators without intervention from a developer. We also realized that ASP.NET is the platform of choice when doing a .NET-based UI, so we provided complete support for deploying your ASP.NET-based solutions to as many Web servers as you have in your farm with the click of a button. Aware Server also provides a lifecycle solution for the IT department providing for development, deployment, monitoring and maintenance of your solutions all within the Aware Environment. With businesses increasingly focused on the agility of their IT departments and trying to find solutions to quickly respond to the pressure of delivering new business functionality, Aware Server represents a cost effective solution with an almost immediate ROI. gridGISTICS offers a best of breed and cost effective solution that can be quickly deployed to leverage new .Net technologies and relieve the burden of IT infrastructure, delivering the flexibility to rapidly respond to changing business demands.

Service Oriented Platform (SOP) - Aware Server

darrell legault — Tue, 22 Jan 2008 13:36:00 -0400

Another way of describing Aware Server - Service Oriented Platform (SOP).

Lets set the stage of where this originates from. Many IT organizations leverage SOA with the understanding that the spirit of SOA is to provide the basis of all future needs of the enterprise. Requirements gathered, technical specifications created, services and processes designed, a beginnings of a solution is born (not to over simplify things but for brevity of the idea).

Time to execute. Where do we start? Planning the development, what is needed first, where are they tested, where do I put configuration? What about logistics of the development environment, staging, QA, production? What about integration testing, deployment of services (installation), how do I redeploy a change, or create another version, or know what has already been implemented? How do I promote from development to staging to QA to production?

How do I make SOA a reality? You need a platform on which you can execute SOA. Many try to build one, but they quickly find out that is where they lose their ROI that they originally thought SOA would yield them.

This is where Aware Server comes in. Aware Server is SOP.

The platform that brings development, configuration, deployment, provisioning, promotion, monitoring, management, and much much more to SOA.

See just how... its easy! Aware Server Video's

Technorati Tags: SOA,Service Oriented Architecture,Aware Server,gridGISTICS,Service Oriented Platform,SOP

Aware Server and BizTalk Services

darrell legault — Tue, 15 Jan 2008 09:51:00 -0400

I put together a video on how we have quickly and easily integrated BizTalk Services / ISB (Internet Service Bus) into our product Aware Server. With a few clicks, we can quickly and easily expose any Aware Services on the ISB. No knowledge of how to expose a service on the ISB is necessary, and any existing Aware Service is instantly available via the ISB.

The video can be found at the link below.

http://www.gridgistics.net/userfiles/downloads/videos/aware_and_biztalk_services.wmv

Technorati Tags: SOA,Aware Server,BizTalk Services,ISB

Gartner's top 10 strategic technologies for 2008

Ryan Turner — Wed, 28 Nov 2007 08:16:26 -0400

Found an interesting article toting the top 10 strategic technologies of '08. At a minimum it was really reassuring that gridGISITCS in on the right path. The Aware Server product, encompasses 4 out of 10 of these. If you don't mind I'd love to comment on it.

http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleId=9041738

Green IT

Given that even the most intensive data centers, have less than a 5% average CPU utilization - its actually quite disturbing seeing a shiny new cabinet of servers knowing each server runs a lonely service totally unAWARE of the other machines. Each service just anxiously waiting for its turn to run - all the meanwhile its machine is consuming power 24/7 and the host is consuming power to keep the environment temperatures regulated. I could be just a lil biased, however - I think if your enterprise services knew they could be "Aware" - they might just go on strike until their developers promise to put them on Aware Server ;)

Business process management

Here is one technology strategy that is used loosely - mostly because the word "management" is relative. Some professionals think that being able to start and stop a business process and report on the process's outcome is management. Well it is... but it can be so much more. How about visual display of running workflow's, the time taken at each step, the properties and parameters of each one as well as a complete log and audit trail.... o and did I forget to mention? Its built right in! Write the service and "whoop there it is!"- management and monitoring immediately available.

Virtualization

When virtualization is mentioned most people directly think of server virtualization aka hardware virtualization - in order to get more utilization out of a machine, reduce licensing costs and hopefully give higher reliability and availability (I could go on...) I agree whole heartedly, but think our sector needs to extend their understanding of virtualization to service virtualization and application virtualization as well. Spawning up new VM's, rather than new machines - does yield warm and fuzzies, but in many situations the extra overhead of the VM's isn't needed. Service virtualization truly allows commodity computing and the ability to dynamically provision services to hardware resources based upon load or policy. Service virtualization allows SOA to be done right!

Computing fabric

I was excited to hear about this! Distributed computing / grid computing / computing fabric - had previously been something solely for computer science uber ninjas and universities with million dollar grants trying to solve world changing problems. Aware Server was written by those uber ninjas with the goal of making grid computing easy. That's exactly what they did, and they didn't stop there...

The Web platform

Patrick Thibodeau says "This is the model for services in the future." and I couldn't agree more. Given this priority in gridGISTICS we are incredibly pleased to announce that Web Project deployment is fully supported in Aware Server 3.0. What this means is that you can either go home early on deployment Friday's or you'll have to tell your boss deploying to the web site to the farm no longer takes 6 hours and is now reduced to a key stroke - we won't tell them if you don't :)

External Windows Workflow Correlated Communication

Dan Haligas — Mon, 26 Nov 2007 22:07:22 -0400

This is 1 of a 2 part posting on external windows workflow correlated communication. The first post will focus on windows workflow today without the use of Aware Server. After reading this post you should be able to plug in a communication service that supports correlation into your windows workflow instances.

The second post will build off the sample built here and demonstrate what Aware Server does to help make this easier in a server environment.

Workflow External Communication Service

The Windows Workflow runtime defines a way for the hosting application to communicate back and forth with a running workflow instance via an ExternalDataExchange service. To perform this you start by creating a normal .NET interface.

interface IOrderWorkflowService

{

event EventHandler<OrderEventArgs> OrderCreated;

event EventHandler<OrderEventArgs> OrderShipped;

}

Next you adorn your interface with ExternalDataExchange attribute located in the System.Workflow.Activities namespace.

[ExternalDataExchange]

interface IOrderWorkflowService

Any events your fire from you workflow service must have EventArgs that derive from ExternalDataEventArgs and must be Serializable.

/// <summary>

///

/// </summary>

[Serializable]

class OrderEventArgs : ExternalDataEventArgs

{

private Guid orderId;

public Guid OrderId

{

get { return orderId; }

set { orderId = value; }

}

/// <summary>

///

/// </summary>

/// <param name="instanceId"></param>

/// <param name="orderId"></param>

public OrderEventArgs(Guid instanceId, Guid orderId)

: base(instanceId)

{

this.orderId = orderId;

}

Correlation is built in the Windows Workflow engine via several attributes. The workflow runtime uses these correlation attributes to ensure an event is fired on the right activity inside a running worklow instance.

[CorrelationParameter("OrderId")]

[ExternalDataExchange]

interface IOrderWorkflowService

{

[CorrelationInitializer]

[CorrelationAlias("OrderId", "e.OrderId")]

event EventHandler<OrderEventArgs> OrderCreated;

[CorrelationAlias("OrderId", "e.OrderId")]

event EventHandler<OrderEventArgs> OrderShipped;

}

The CorrelationParameter attribute defines what the correlation parameter should be named and will be used in with all the other correlation attributes. In this case we named our parameter “OrderId”. You can have N number of these attributes. The combination of the parameters must form a unique key.

The CorrelationAlias attribute defines a mapping between the parameter “OrderId” to the path inside the OrderEventArgs which is “e.OrderId”. Why “e.” you ask? Well if you right click on the EventHandler class and select “Go to Definition” you will see that the delegate’s signature is as follows:

public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);

Notice the second parameter named “e”. Hence once our OrderEventArgs is replaced in the delegate “e.OrderId” would get us to the OrderId property on the OrderEventArgs.

...EventHandler<OrderEventArgs>(object sender, OrderEventArgs e);

The last attribute of concern is the CorrelationInitializer. This attribute is very important and must be on at least one event or on method in your interface. When either an event or method is called with this attribute applied the workflow runtime will establish the correlation for that particular workflow instance and bind it to the “OrderId” thus marrying the OrderId to the workflow instance. In our example above we opted to fire the created event once an order workflow instance is started to initiate the correlation.

Next you must provide an implementation of this interface in a local class.

class OrderWorkflowService : IOrderWorkflowService

{

public event EventHandler<OrderEventArgs> OrderCreated;

public event EventHandler<OrderEventArgs> OrderShipped;

public void RaiseOrderCreated(Guid instanceId, Guid orderId)

{

RaiseEvent(this.OrderCreated, instanceId, orderId);

}

public void RaiseOrderShipped(Guid instanceId, Guid orderId)

{

RaiseEvent(this.OrderShipped, instanceId, orderId);

}

private void RaiseEvent(EventHandler<OrderEventArgs> eventHandler, Guid instanceId, Guid orderId)

{

if (eventHandler != null)

{

eventHandler(null, new OrderEventArgs(instanceId, orderId));

}

After the implementation is complete the Workflow Runtime needs to know about this service specifically the ExternalDataExchangeService because it will wire up all the events on the implementation class to ensure that when someone fires the normal CLR event that it gets put in the workflow instance’s scheduler queue and processed. This code goes in the program.cs file if you are using a console workflow application.

ExternalDataExchangeService service = new ExternalDataExchangeService();

workflowRuntime.AddService(service);

service.AddService(new OrderWorkflowService());

Sample Workflow

To use the service in the workflow drag on a HandleExternalEventActivity and configure it to point at our IOrderWorkflowService and the OrderCreated event.

Notice the CorrelationToken property above. This is the key to using correlation in our workflow. Type in any string you want like “OrderToken” for example and then select the scope to apply this token to. We want this token to be available to any activity in the workflow so we select Workflow1.

Lastly drag another HandleExternalEventActivity onto the workflow and configure to point at the OrderShipped event.

Select our OrderToken as the value for CorrelationToken thus coupling the Created and Shipped events together.

Test Program

Back over in the program.cs file of your console workflow test application add the following code after the workflow instance has been started. This code will fire the initial OrderCreated event thus initializing the correlation for that particular workflow instance.

WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ExternalWorkflowCommunications.Workflow1));

instance.Start();

OrderWorkflowService orderService = workflowRuntime.GetService<OrderWorkflowService>();

orderService.RaiseOrderCreated(instance.InstanceId, orderId);

Back over in the program.cs file add a handler to the WorkflowRuntime.WorkflowIdled event and execute the following code forcing the OrderShipped event to be fired.

workflowRuntime.WorkflowIdled += delegate(object sender, WorkflowEventArgs e)

{

OrderWorkflowService orderService2 =

workflowRuntime.GetService<OrderWorkflowService>();

orderService2.RaiseOrderShipped(e.WorkflowInstance.InstanceId, orderId);

};

Run the console application and notice our events were fired via the following code.

private void HandleCreated_Invoked(object sender, ExternalDataEventArgs e)

{

Console.WriteLine("Order Created");

}

private void HandleShipped_Invoked(object sender, ExternalDataEventArgs e)

{

Console.WriteLine("Order Shipped");

}

Notice that we need the instance id to fire any of these events to ensure that they get to the appropriate instance. In a stateless server environment we will need to have the instance id in memory as we do in this sample. From most clients we would have the order id, but not the instance id. The next post will demonstrate how Aware Server handles this external workflow communication and how it tracks all the correlation automatically for you. This coupled with Aware Server’s side-by-side versioning allows you to have 2 different versions of business process running and Aware will ensure that external events are not only fired to the right workflow instance, but to the right version as well.

Below is the full listing of program.cs.

Guid orderId = Guid.NewGuid();

using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())

{

ExternalDataExchangeService service = new ExternalDataExchangeService();

workflowRuntime.AddService(service);

service.AddService(new OrderWorkflowService());

workflowRuntime.StartRuntime();

AutoResetEvent waitHandle = new AutoResetEvent(false);

workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) {waitHandle.Set();};

workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)

{

Console.WriteLine(e.Exception.Message);

waitHandle.Set();

};

workflowRuntime.WorkflowIdled += delegate(object sender, WorkflowEventArgs e)

{

OrderWorkflowService orderService2 = workflowRuntime.GetService<OrderWorkflowService>();

orderService2.RaiseOrderShipped(e.WorkflowInstance.InstanceId, orderId);

};

WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(ExternalWorkflowCommunications.Workflow1));

instance.Start();

OrderWorkflowService orderService = workflowRuntime.GetService<OrderWorkflowService>();

orderService.RaiseOrderCreated(instance.InstanceId, orderId);

waitHandle.WaitOne();

Human Interaction and Windows Workflow

Dan Haligas — Mon, 26 Nov 2007 21:58:02 -0400

Out of the box Windows Workflow provides the core engine necessary to build episodic processing. What I mean by episodic is that the code in a particular business process does not execute all the way through. Only portions (Activities) execute in episodes as events, etc. occur. This allows workflows or business processes to start something and finish it maybe a week later.

In Aware Server you have the ability to build business processes that may require human interaction before continuing. Take the sample below which is of a payroll business process where the paychecks are distributed across the network for processing using the DistributedWorkflowReplicatorActivity and then a human interaction is created (highlighted activity on the left) asking for the user who initiated the payroll job to please approve or reject the values computed during processing. The workflow at this point completes its current episode and goes to sleep (dehydrates to persistence store).

Another thing Aware allows you to do is attach another workflow instance to your parent process to monitor each and every human interaction you create. In the sample above the workflow to the right is monitoring the interaction created by the parent process. The monitoring instance in this example will wait for 1 minute and then cancel the interaction which the parent process is monitoring as well unless the user tells us that he/she has started working on our interaction (In Progress). If the interaction is canceled the parent process will determine that the payroll is already too stale and will cancel the entire run.

What’s really powerful is that both workflow instances (parent and monitoring flow) are watching for correlated events on the same interaction. In a later blog post I will cover how to make this possible and how we have simplified external workflow communication (ExternalDataExchangeServices).

How we define Business Processes

Dan Haligas — Mon, 26 Nov 2007 21:53:45 -0400

Business processes in terms of Aware Server refer to a collection of Windows Workflow Instances as well as audits, human interaction and grid/distributed computing.

With Aware Server you can build a business process that includes all your business logic, plus human interaction and grid computing. Every business process has one parent Windows Workflow instance at the root and that root workflow can have human interaction monitoring flows and distributed processing flows (GridWorkflow) all associated to it.

The screenshots below are of the Aware Business Process Monitor which shows you how Aware captures all the workflow instances as well as audits, human interactions and grid computing statistics inside of one view. All this information is stored in SQL Server 2005 allowing you to review business processes at a later date.

Parent (Root) Workflow

Human Interactions

Associated Workflows (Human Interaction Monitoring Flows and Distributed Grid Flows)

Technorati Tags: business processes , grid computing , Aware Server , Aware Business Process Monitoring , Human Interaction

gridGISTICS Blog

Four IIS7 Modules you should be "Aware" of

AwareReverseProxyModule

URL Rewrite Module

Application Request Routing Module

LINQPad - Go Get It!

Microsoft Web Deployment Tool - Beta 1 Go Live

Benefits:

Features:

Aware Server VS.NET Productivity Chart

Aware Server ASP.NET Deployment - 5 Reasons Why You Need It.

Service Extensions

External Windows Workflow Correlated Communication Part 2

Aware Server ASP.Net Web Deployment

Aware Server: Be 67% More Productive with VS.NET

Create and Debug an Aware Service (4 steps – 5th step is if you do not trust me)

Deploy an Aware Service (3 steps – 4th step is if you do not trust me)

Provision an Aware Service (3 steps – 4th for info, 5th step is if you do not trust me)

Call an Aware Service (4 steps – 5th step is if you do not trust me)

Summary of Aware Server development vs. VS.NET 2008

Designing and Deploying Services

Microsoft and Intel Drop $20 Million on Parallel Computing

Internet Explorer Trick for Mere Mortals

Life on the Bungie Farm: Fun Things to do with 180 Servers and 350 Processors

.NET Framework Library Source Code now available

Environmental Singleton

Visual Studio 2008 Support

Reduce development time by 40%....no that is not a typo!

Windows Server 2003 Administration Tools Pack - Remote DesktopS

Resources for Windows High Performance Computing

Take Control of Window Services

Our Current Options

The Ninja Weapon

Aware Server - Core Configurations

Aware Server - Create Environments

Aware Server Installation

Step 1 - Aware Server Installation

Choose your option

Service Setup

Repository Setup

Shared Directory

Aware Environment

Complete Installation

Step 2 - Start the Aware Serve Enterprise Manager

Aware Server 3.0 Released

Service Oriented Platform (SOP) - Aware Server

Aware Server and BizTalk Services

Gartner's top 10 strategic technologies for 2008

Green IT

Business process management

Virtualization

Computing fabric

The Web platform

External Windows Workflow Correlated Communication

Workflow External Communication Service

Sample Workflow

Test Program

Human Interaction and Windows Workflow

How we define Business Processes

Create and Debug an Aware Service (4 steps – 5^th step is if you do not trust me)

Deploy an Aware Service (3 steps – 4^th step is if you do not trust me)

Provision an Aware Service (3 steps – 4^th for info, 5^th step is if you do not trust me)

Call an Aware Service (4 steps – 5^th step is if you do not trust me)