tackle-dgi 1.0.0

Konveyor Tackle Data Gravity Insights

Tackle Data Gravity Insights

Tackle Data Gravity Insights is a new way to gain insights into your monolithic application code so that you can better refactor it into domain driven microservices. It takes a wholistic approach to application modernization and refactoring by triangulating between code, and, data, and transactional boundaries.

Application modernization is a complex topic with refactoring being the most complicated undertaking. Current tools only look at the application source code or only at the runtime traces when refactoring. This, however, yields a myopic view that doesn't take into account data relationships and transactional scopes. This project hopes to join the three views of application, data, and transactions into a 3D view of the all of the application relationships so that you can easily discover application domains of interest and refactor them into microservices. Accordingly, DGI consists of three key components:

1. Call-/Control-/Data-dependency Analysis (code2graph): This is a source code analysis component that extracts various static code interaction features pertaining to object/dataflow dependencies and their respective lifecycle information. It presents this information in a graphical format with Classes as nodes and their dataflow, call-return, and heap-dependency interactions edges.

2. Schema: This component of DGI infers the schema of the underlying databases used in the application. It presents this information in a graphical format with database tables and columns as nodes and their relationships (e.g., foreign key, etc.) as edges.

3. Transactions to graph (tx2graph): This component of DGI leverages Tackle-DiVA to perform a data-centric application analysis. It imports a set of target application source files (*.java/xml) and provides following analysis result files. It presents this information in a graphical format with database tables and classes as nodes and their transactional relationships as edges.

Installation

Tackle Data Gravity Insights is written in Python and can be installed using the Python package manager pip.

pip install -U tackle-dgi

Usage

You will need an instance of Neo4j to store the graphs that dgi creates. You can start one up in a docker container and set an environment variable to let dgi know where to find it.

docker run -d --name neo4j \
    -p 7474:7474 \
    -p 7687:7687 \
    -e NEO4J_AUTH="neo4j:konveyor" \
    neo4j:4.4.17

Save the bolt url for further use:

export NEO4J_BOLT_URL="neo4j://neo4j:konveyor@localhost:7687"

You can now use the dgi command to load information about your application into the graph database.

 Usage: dgi [OPTIONS] COMMAND [ARGS]...

 Tackle Data Gravity Insights

╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --neo4j-bolt  -n  TEXT  Neo4j Bolt URL                                                                               │
│ --quiet       -q        Be more quiet                                                                                │
│ --validate    -v        Validate but don't populate graph                                                            │
│ --clear       -c        Clear graph before loading                                                                   │
│ --help                  Show this message and exit.                                                                  │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ c2g         Code2Graph add various program dependencies (i.e., call return, heap, and data) into the graph           │
│ partition   Partition is a command runs the CARGO algorithm to (re-)partition a monolith into microservices          │
│ s2g         Schema2Graph parses SQL schema (*.DDL file) into the graph                                               │
│ tx2g        Transaction2Graph add edges denoting CRUD operations to the graph.                                       │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Demo

This is a demonstration of the usage of DGI

1. Demonstration

Running DGI

To run this project please refer to the steps in the getting started guide

1. Getting Started

Contributing

To contribute to this project you will need to set up your development environment and set up some files. The steps are in the following file:

1. Set up your Developer Environment