The goal of Archictecture Checker is to enable Enterprise Design and Architecture Checks. Enterprise Architects can capture and store Application Models and check overtime actual applications against these models. CAST enables real enterprise architecture checks as it offers checks of applications built using multiple languages and technologies. It fully leverages CAST's cross-language, cross-technology capabilities and CAST end-to-end application analysis.
Until recently, it was difficult to do architecture conformance checks just because architecture rules had to be very generic. Now with the Architecture Checker, Enterprise Architects can define architectures models that fit their specific application designs. Checking overtime actual applications against these architecture models is very important to avoid any Security and Robustness issues.
The goal of Archictecture Checker is also to help define quality rules at the application and design level without programming. Most engines that can help check design and architecture rules require users to master a programming language and a specific API. CAST Architecture Checker enables the definition of quality and architecture rules just by drag and drop.
The Architecture Checker GUI (CAST-ArchiChecker.exe) provides a means for you to:
- Create an Architecture Model that reflects a business application or set of applications via the use of Layers and Dependencies between those Layers
- Define the contents of Layers in terms of objects resulting from a CAST AIP analysis / snapshot
- You can check your model in "live" mode against the results of a snapshot that has already been generated.
Once the Architecture Model is defined, it can then be used in the CAST Management Studio. When your application or set of applications is then analyzed in the CAST Management Studio and a Snapshot is subsequently generated, the Architecture Model will be taken into account.
Results and information can then be consulted in the CAST Health Dashboard/CAST Engineering Dashboard as Quality Rules. Violations of the Architecture Model will be reported as violations to the Quality Rules.
Note about modules:
Please ensure that any objects you want to work with in the CAST Architecture Checker are part of a Module, i.e.:
- module created manually (a User Defined Module)
- A module created automatically (by the CAST Management Studio if no User Defined Modules exist when the snapshot is generated).
- Architecture Checker can report violations between two Layers even when objects inside the targeted Layer not only are external, but also belong to a module external to the Application being checked. The only constraint is that the objects inside the Layer from which the Dependency towards the targeted Layer is issued, must belong to a module internal to the Application. For example, it is possible to check for links which reach objects belonging to a .NET assembly outside of the Application boundary, provided these links start from objects in a module which is internal to the Application (even though these latter objects can be external).
Getting started with the CAST Architecture Checker
Creating a Model with the CAST Architecture Checker UI
First you need to create the architecture model to be checked according to your target application's design or according to the facts you want to check. The creation of an architecture model is done with the dedicated graphical user interface (CAST-ArchiChecker.exe).
An architecture model describes the layers of the application and defines the way the layers are filled with objects analyzed by CAST. Depending on your requirement, you can build two types of model:
- a model defining authorized dependencies between layers
- a model defining forbidden dependencies.
While defining the model, the user can check interactively the content of the layers and the compliance of an application by connecting to a CAST Analysis Service. Once saved, the model can be used within the CAST Management Studio to activate the automatic check for violation of the architecture and design. The CAST Architecture Checker helps you generate, without programming, the files that will be used in the CAST Management Studio to check the architecture of your application.
Click to enlarge:
Define the Weight and Criticality of the Architecture Model
Each Architecture Model that you assign to an Application will cause the creation of one corresponding Quality Rule (it will be be displayed with the name of the Architecture Model). You can define the Weight and Criticality of this Quality Rule (within the parent Technical Criterion) using File > Properties > Assessment Model tab in the CAST Architecture Checker:
Interactively check your model and the Application's compliance
The CAST Architecture Checker enables you to validate and tune models interactively during their creation and before using the model in production, thanks to an on-line mode that connects to the CAST Analysis Service and can:
- Check all layers
- Check content
- Check overlapping layers
- Check model
Activate the Automatic Architecture Check of your Application with CAST Management Studio
To force the CAST Architecture Checker to automatically check the defined model, you need to use the CAST Management Studio:
- In the Architecture Model view in the CAST Management Studio, add a model with an appropriate name and then select the .CASTArchitect file created with the CAST Architecture Checker as shown below:
To include the Architecture Model in the Application (i.e. to activate an architecture check during the Snapshot Generation process), you can either:
- drag and drop the model from the Architecture Model view on to the Application in the Application View
- or use the Architecture Models tab of the Application in question to activate the check of your model:
Viewing the results in the CAST Engineering Dashboard
Once the snapshot has been generated, you can visualize the results directly under the Technical Criterion called Architecture - Architecture Models Automated Checks in the CAST Engineering Dashboard. One Architecture Model generates one Quality Rule.