tackle-dgi 0.0.4

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 pertating to object/dataflow depdendecies and thir 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. For more details, see here.

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. For more details, see docs/Schema.md.

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 transcational relationships as edges. For more details, see here.

Installation

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

pip install 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/tackle" \
    neo4j

export NEO4J_BOLT_URL="bolt://neo4j:tackle@localhost:7687"    

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

$ gdi --help

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

    Tackle Data Gravity Insights

Options:
    -a, --abstraction TEXT          The level of abstraction to use when
                                    building the graph. Valid options are:
                                    class, method, or full.  [default: class]
    -q, --quiet / -v, --verbose     Be more quiet/verbose  [default: verbose]
    -c, --clear / -dnc, --dont-clear
                                    Clear (or don't clear) graph before loading
                                    [default: clear]
    --help                          Show this message and exit.

Commands:
    c2g   This command loads Code dependencies into the graph
    s2g   This command parses SQL schema DLL into a graph
    tx2g  This command loads DiVA database transactions into a graph

Contributing

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

1. Set up your Developer Environment
2. Getting Started