How Do I: Model Class Libraries using the Architecture Edition Power Tools?
Another video on MSDN about Team Architect from Richard Hundhausen... this time the video covers the Architecture Edition Power Toys.
three comments on the video:
- Hurray we get support for class libraries [00:00:34]. I'm not a big fan of having class libraries on the application diagram. when you make a serious project, you get a lot of shapes which don't add any value to the diagram [see image, also testprojects will show up in the diagram] and class libraries don't belong at application level [see Bill Gibson's post about this, TN_1105- Why Class Libraries are not shown on an Application Diagram]
- Synchronize back and forward with the solutions, just as every DSL should do... [00:01:04]. I disagree, not every DSL should do this, in most situations you really don't want this. When the differences in abstractions between the two languages is very low, it's an option in other situations I won't recommend synchronization.
- The rest of the demo: I really like... but, due to comment #1 I'm not using the powertoys.
Amazon Services, the Service Model
Trigger by Steve Clayton post about "Amazon - Where Do You Want To Go Tomorrow?"
A while ago I made a demo with Amazon Web Services, just to show what the limitations are when using models or how models can help to make better designs. Anyway I used the Web Service Software Factory Modeling Edition and Visual Studio Team Architect capabilities to generate the service models and service agents.
This is the application diagram where we have the existing Amazon services with two endpoints, the AWSECommerceService and the MechanicalTurk, and a Windows Client application which consumes them. For this demo I used the conform endpoint to WSDL functionality, but you can also use the Add Existing Service feature.
It looks pretty simple
The next thing I did during the demo is generating the service models and look... this is what you get, allot of shapes. A nice detail is the line between AWSECommerceService and the MechanicalTurk to the same messagecontract. the model generation functionality looks if there are contracts who are used by both services and connects them. [it's the HelpResponse message]
More detail
Anyway, I assume everybody agrees this is a useless model and the service agent model even looks more terrible. A real spaghetti model, where nobody can work with.
So, I totally agree with Juval Lowy's guidelines for services.
4. Avoid contracts with one member.
5. Strive to have three to five members per service contract.
6. Do not have more than twenty members per service contract. Twelve is probably the practical limit.
I say proven practice..!
5 minutes Visual Studio Team System Architecture survey.
VS Team Architect Blog: Architect Edition Survey
How Do I: Use the Retooled System Designer in Visual Studio Team System 2008 Architecture Edition?
A nice clean and short video about Top-Down design with Team Architect VS2008 from Richard Hundhausen.
Link to page here...
Download here...
How To Fire a Guidance Package Recipe from the Implement Application Feature of Team Architect.
Post #01 of a collection of posts with some more technical details about the creation of richer implementations with Visual Studio Team Architect.
The Start: Fire a Recipe, Wizard or something else when initiating the "Implement Application" feature from the Application Diagram.
There is only one place where you can change the behavior of this feature and that is in the properties window of the selected shape. You can change the the template it uses to implement the application. Select: "Custom Template..."
So, we have to focus on templates [vstemplate] if we want something else to happen.
Beside the fundamental elements "TemplateData" and "TemplateContent" where you can specify the files included in the template and categorizes the template, there is also an element "WizardExtension" which can be used to run custom code and more things like: "Display custom UI that collects user input to parameterize the template" and "Add parameter values to use in the template", actually you can perform virtually any action allowed by the Visual Studio automation object model on a project.
To use this element is easy, create a assembly which implements the IWizard interface, sign it and add it's details to the vstemplate WizardExtension element.
The IWizard interface gives us a number of methods which will fire during the execution of the template. For example:
public void RunFinished()
public void RunStarted
(
object automationObject,
System.Collections.Generic.Dictionary<string, string> replacementsDictionary,
WizardRunKind runKind,
object[] customParams
)
You can get additional information from the replacementsDictionary parameter and can add information to it.
So, with this information you can start with coding your additions to the template, add solution folders, add projects, add items, add code. The first solution I created, to accomplish a richer implementation then the "Empty Web Site" template offers, used a list of item templates in the "TemplateContent" element. But, after the solution went bigger and I wanted to do more this didn't gave me the flexibility I needed. So, the final solution ended with only the WizardExtension which executed all the necessary steps, from project creation to adding code with the CodeDOM and references. You only have to take the DTE Object and start coding...
// The application object can be cast to the root DTE object.
dte = (EnvDTE80.DTE2)(automationObject);
sol = (EnvDTE80.Solution2)dte.Solution;
To use the IWizard interface, DTE object and the CodeDOM is pretty hard, actually it really hurts and it's not suitable to make such a big customization to your templates, for small ones it's works fine but not for this size.
So, the release of the Guidance Automation Toolkit for Orcas made things much easier.
Guidance Packages also use the "WizardExtension" element behind templates to execute additional logic as you can see in this XML snippet.
<WizardExtension>
<Assembly>Microsoft.Practices.RecipeFramework.VisualStudio, Version=1.0.60429.0,
Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</Assembly>
<FullClassName>Microsoft.Practices.RecipeFramework.VisualStudio.Templates.UnfoldTemplate</FullClassName>
</WizardExtension>
When you dive into the "UnfoldTemplate" class you can see it also inherits the IWizard interface. So, things should work the same. Only with the GAX you get the ability to use T4 templates and all the other functionality like actions and recipes.
In the vstemplate there is the element "WizardData" which points to the recipe it executes during the unfoldtemplate action and with that you can use basic GAX functionality to create your projects.
<WizardData>
<Template xmlns="http://schemas.microsoft.com/pag/gax-template"
SchemaVersion="1.0"
Recipe="CreateSolution">
<References/>
</Template>
</WizardData>
So changing the Service Factory Modeling Edition or creating your own package starts with some customizations in this recipe, because we don't [I don't] want to see a wizard when initiating the implement application feature.
<Arguments>
<Argument Name="SolutionName">
<Converter Type="Microsoft.Practices.RecipeFramework.Library.Converters.RegexMatchStringConverter,
Microsoft.Practices.RecipeFramework.Library"
Expression="[a-zA-Z][a-zA-Z_0-9]*(\.[a-zA-Z][a-zA-Z_0-9]*)*"/>
<ValueProvider Type="Evaluator" Expression="$(safeprojectname)"/>
</Argument>
</Arguments>
<Actions>
<Action Name="CreateModelProject"
Type="Microsoft.Practices.ServiceFactory.CustomRecipes.CreateModelProject.CreateModelProjectAction,
Microsoft.Practices.ServiceFactory.GuidancePackage">
<Input Name="SolutionName" RecipeArgument="SolutionName"/>
</Action>
</Actions>
The argument captures the current selected [on the application diagram] projectname and the "CreateModelProject" action unfolds the model project template. Pointing to this changed / newly created vstemplate with in the Application Diagram will fire this recipe when using the Implement Application feature.
Next post: Collect data from the Application Diagram.
Reduce Project Risk: Get knowledge of the environment where the system operates.
One of the most “technical” challenging phase of a project is the transition of code from the development environment through the integration and test environments into production with Installer Packages.
Within most companies developers are responsible for the creation of Installer Packages. The MSI’s are created on development workstations, which have local admin rights and most often some exotic settings and applications. For sure, completely different than the production environment. With all the risks and extra work during deployment and testing.
In a more ideal situation, packages are automatically generated during the build process. A much better situation, but also harder to accomplish. The process is completely automated and can be reproduced. But still it doesn’t reflect the production environment, which still result in project risks.
When development doesn’t know and can’t test against real production environment settings we get some challenging risks.
For example how should we test non-functional requirements like: availability, scalability, capacity and performance? and how should development write installation instructions and operations guides (deployment, backup, recovery, weekly tasks) and probably there will be some problems with security and the configuration of security settings when deploying to production.
So, a better way should be when development knows the production environment details.
Operations can describe every detail about the environment, but, you also can use Team Architect’s Logical Datacenter Designer [LDD].
Logical Datacenter Designer is used to create models that describe the policies and logical structure of a datacenter, including servers, firewalls, communication paths, security constraints, and other configuration requirements that affect the deployment of application systems into a datacenter.
The Logical Datacenter Designer is a design tool..! so don't tease operations with Visual Studio, you will get the most strange reactions when you do that. You better could use the IIS Settings Import Wizard and ask for the credentials.
Anyway, finally you will end with a more "in control" deployment process.
Development knows the production environment, so they can design and build there applications with the real settings in mind. With this extra knowledge Design For Operations and Design For Deployment are much more realistic. Development can give operational management the right information how the solution need to be managed and monitored which will result in lower project risks..!
Some extra things we can do to automate this, "Enable ALM by Automation":
- Generate installer packages from the Logical Datacenter Designer, System Designer and Application Designer. We've got all the information we need! [see DSL 4 WiX]
- Generate MOM packages and manageability models [see Design for Operations on Codeplex and this post]
- Create WorkItems in TFS.
- Create Threat Models with the "Import Deployment Report" feature from the Microsoft Threat Analysis and Modeling Tool and create WorkItems from there.
- ...
some additional information:
- MSDN Virtual Lab: Architecting Connected Systems: Logical Data Center
- MSDN Virtual Lab: Architecting Connected Systems: System Designer
- Kevin Sangwell Blog: Bridging the Gap between Development and Production [very good information about this topic]
- Gearing Up for Modeling, Microsoft Style, April 01-2006
Rosario Team Architect Exposed, Getting Information Out Off the Designers.
I'm not fully up and running with the Rosario CTP, but found yesterday evening some time to dig into the internals of Team Architect. [Reflector rules]
Getting information out off the designers.
It is pretty hard to iterate through the various applications and endpoints within the VS2005 and VS2008 designers . You must load the .ad file with an XML reader and query it. Rosario makes this allot easier, it exposes methods to do this.
This is the Application Designer ToolAdapter Interface with the getApplications, getEndpoints, etc methods:
The new way to iterate the applications and endpoints. Much better than overly long XML queries:
Inside the "Rosario" Service Factory there are some helper classes to get the ISoaService
Update: removed the formatted code and added screenshots.