Summary: This document provides technical information about the extension called Architecture Discovery (com.castsoftware.architecture).
Please see Architecture Discovery - 1.0 - Release Notes for more information.
What does the extension do?
The extension provides specific functionality for applications displayed in CAST Imaging:
AIP Core compatibility
AIP Core release
Download and installation instructions
The extension will be handled as follows by CAST Console:
- Onboarding with Fast Scan mode: always automatically downloaded and installed for each application provided that you change your extension strategy (see Administration Center - Extensions Strategy / Administration Center - Settings - Extensions Strategy) to include beta releases.
- Onboarding without Fast Scan mode: always automatically downloaded and installed for each application if:
- the Blue Print objective is enabled (see Application onboarding without Fast Scan - Standard onboarding - perform all actions - choose objectives)
- and you change your extension strategy (see Administration Center - Extensions Strategy / Administration Center - Settings - Extensions Strategy) to include beta releases.
You can manage it using the Application - Extensions interface:
What results can you expect?
Component and Connector view
This extension calculates the components for a Component and Connector view of an application. Those components will then be displayed in the Service scope in CAST Imaging. A Component and Connector view allows you to answer questions, such as:
What are the system's principal executing components, and how do they interact with each other?
How does data progress through a system as it is executed?
A Component is a part of the code that can be executed autonomously and is complete in that regard. Examples:
- an executable (xxx.exe)
- a web application on the "client side"
- a mobile application written in Java+Android or in Swift+Objective-C
- a database
- a classic JEE web server
- a micro service
For more information about component and connector views, see:
Component and Connector views function for all kinds of architecture types, including microservices architectures and older architecture styles.
We have analyzed the project PiggyMetrics, whose Component view is provided as part of the project documentation and we compare this with the Component view calculated by this extension:
|Component view given by documentation|
Click to enlarge
|Component view calculated automatically by CAST|
Click to enlarge
What is extracted?
Name of the components are extracted from the source code.
Each component has a list of Labels. Each of those labels provides some information about the component. Possible values of labels are:
|Labels||Details/Values of labels|
The component is considered as a non functional one
The component contains one lambda
The component uses AWS Cognito
|AWS Event Source XXX, with XXX one of 'S3', 'SNS', 'DynamoDB', 'SQS', 'Api', 'Cognito'|
The component has an event source (in triggering) of a given type
|AWS API Gateway|
The component uses AWS API Gateway
The component provides a discovery service
|The component is an Eureka client|
The component is a Consul client
The component is an Zookeeper client
The component is a configuration service
The component is an Admin service
API Gateway service
The component is an API Gateway service
Zipkin Tracing service
The component is a Zipkin Tracing service
The component is a Zipkin Tracing service
The component is a Turbine service
Oauth Authorization service
Oauth Resource service
Each component has a list of business words that describes the functionalities in it.
The same object, (for example: Java class), may belong to several components. This is the case for example of utility classes, shared libraries etc.
This information is extracted from the source code using :
- analysis of compilation projects (pom.xml, etc...) and folder structure
- techniques from Static Microservice Architecture Recovery Using Model-driven Engineering for labels and names
- business words are extracted from the source code file paths using a series of heuristics
Current known issues for Component and Connector view
Due to the complex nature of this computation there are potentially many unknown issues. However, current known limitations are as follows:
- Test projects will be taken into account leading to components, which is not really useful
- SQL code will be seen as part of its server code, when located inside the server, whereas it should be seen as a separate component
Project Structure view
- Available in ≥ 1.0.0-beta3.
- Requires CAST Imaging ≥ 2.17.
This extension extracts projects from an application, i.e. project files such as Visual Studio .csproj/.vsproj/.vcxproj project files, or Maven pom.xml files (for example). Projects that are identified by the extension are displayed in a dedicated Project Structure scope in CAST Imaging ≥ 2.17.
Project Structure scope with selection of projects:
Application scope + Aggregated by Project Structure:
Properties panel for a selected node (i.e. a project), showing the project type (Maven):
The Welcome page in CAST Imaging also includes a dedicated tile which will open the Project Structure scope - see User Guide - GUI - Welcome Page:
Projects taken into account and recognised by this extension are as follows:
Visual Studio projects
- *.vcxproj files
- *.vcproj files
- *.csproj files
- pom.xml files
- bower.json files
- .project files
- *.pbxproj files
- workspace.xml files
- setup.py files (Setup for Python)
- requirements.txt files (Requirements file)
Current known issues for Project Structure view
- When drilling down to Object level from a "project" node, all objects are currently displayed (classes/methods). A future release of this extension will change this behaviour to ensure only classes are displayed.
- Links correspond to call links between the objects grouped together in each "project" node
- No display of source code on objects