Updating

Signed-off-by: Andy Arnold <[email protected]>

docs/getting-started-guide-mtr/master.adoc

@@ -17,21 +17,21 @@ include::topics/making-open-source-more-inclusive.adoc[]
 == Introduction
 
 // About the {IntroToMTABookName}
-include::topics/about-the-intro-to-mta-guide.adoc[leveloffset=+2]
+include::topics/mtr-about-the-intro-to-mta-guide.adoc[leveloffset=+2]
 
 // About the Toolkit
 include::topics/mtr-what-is-the-toolkit.adoc[leveloffset=+1]
 
 // Windup Features
-include::topics/features.adoc[leveloffset=+2]
+include::topics/mtr-features.adoc[leveloffset=+2]
 
 // Windup Rules
-include::topics/about-rules.adoc[leveloffset=+2]
+include::topics/mtr-about-rules.adoc[leveloffset=+2]
 
 == Supported configurations
 
 // Supported Migration Paths
-include::topics/migration-paths.adoc[leveloffset=+2]
+include::topics/mtr-migration-paths.adoc[leveloffset=+2]
 
 // Prerequisites
 == Prerequisites
@@ -40,45 +40,45 @@ include::topics/snippet_jdk-hardware-mac-prerequisites.adoc[]
 // At a later date, we may wish to add the following section, once it is revised: For tips on how to optimize performance, see link:{ProductDocUserGuideURL}#optimize_performance[Optimizing {ProductShortName} performance] in {ProductShortName} _{UserCLIBookName}_.
 
 // About the Tools
-include::topics/about-tools.adoc[leveloffset=+1]
+include::topics/mtr-about-tools.adoc[leveloffset=+1]
 
 // About the {CLIName}
 include::topics/mtr-about-cli.adoc[leveloffset=+2]
 
 // About the {WebNameTitle}
-include::topics/about-the-web-console.adoc[leveloffset=+2]
+include::topics/mtr-about-the-web-console.adoc[leveloffset=+2]
 
 // About the {PluginNameTitle}
-include::topics/eclipse-about-plugin.adoc[leveloffset=+2]
+include::topics/mtr-eclipse-about-plugin.adoc[leveloffset=+2]
 
 // About the VS Code extension
-include::topics/about-vscode-extension.adoc[leveloffset=+2]
+include::topics/mtr-about-vscode-extension.adoc[leveloffset=+2]
 
 // About the {MavenNameTitle}
-include::topics/about-maven.adoc[leveloffset=+2]
+include::topics/mtr-about-maven.adoc[leveloffset=+2]
 
 == Planning your application migration
 
 // Goals of Assessing a Migration
-include::topics/migration-goals.adoc[leveloffset=+2]
+include::topics/mtr-migration-goals.adoc[leveloffset=+2]
 
 // Red Hat's Application Migration Approach
-include::topics/migration-approach.adoc[leveloffset=+2]
+include::topics/mtr-migration-approach.adoc[leveloffset=+2]
 
 // Best Practices
-include::topics/migration-best-practices.adoc[leveloffset=+3]
+include::topics/mtr-migration-best-practices.adoc[leveloffset=+3]
 
 // Migration Methodology
-include::topics/migration-methodology.adoc[leveloffset=+3]
+include::topics/mtr-migration-methodology.adoc[leveloffset=+3]
 
 // Discover Phase
-include::topics/method-discover.adoc[leveloffset=+4]
+include::topics/mtr-method-discover.adoc[leveloffset=+4]
 
 // Design Phase
-include::topics/method-design.adoc[leveloffset=+4]
+include::topics/mtr-method-design.adoc[leveloffset=+4]
 
 // Deploy Phase
-include::topics/method-deploy.adoc[leveloffset=+4]
+include::topics/mtr-method-deploy.adoc[leveloffset=+4]
 
 [appendix]
 == Reference material

docs/topics/mtr-about-maven.adoc

@@ -0,0 +1,9 @@
+// Module included in the following assemblies:
+//
+// * docs/maven-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="about-maven_{context}"]
+= About the {MavenNameTitle}
+
+The {MavenName} for the {ProductName} integrates into the Maven build process, allowing developers to continuously evaluate migration and modernization efforts with each iteration of source code. It provides numerous reports that highlight the analysis results, and is designed for developers who want updates with each build.

docs/topics/mtr-about-rules.adoc

@@ -0,0 +1,26 @@
+// Module included in the following assemblies:
+//
+// * docs/rules-development-guide/master.adoc
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="about-rules_{context}"]
+= About {ProductShortName} rules
+
+The {ProductName} ({ProductShortName}) contains rule-based migration tools that analyze the APIs, technologies, and architectures used by the applications you plan to migrate. In fact, the {ProductShortName} analysis process is implemented using {ProductShortName} rules. {ProductShortName} uses rules internally to extract files from archives, decompile files, scan and classify file types, analyze XML and other file content, analyze the application code, and build the reports.
+
+{ProductShortName} builds a data model based on the rule execution results and stores component data and relationships in a graph database, which can then be queried and updated as needed by the migration rules and for reporting purposes.
+
+{ProductShortName} rules use the following rule pattern:
+
+----
+when(condition)
+  perform(action)
+otherwise(action)
+----
+
+{ProductShortName} provides a comprehensive set of standard migration rules out-of-the-box. Because applications may contain custom libraries or components, {ProductShortName} allows you to write your own rules to identify use of components or software that may not be covered by the existing ruleset.
+
+ifndef::rules-development-guide[]
+If you plan to write your own custom rules, see the {ProductDocRulesGuideURL}[_{RulesDevBookName}_] for detailed instructions.
+endif::rules-development-guide[]

docs/topics/mtr-about-the-intro-to-mta-guide.adoc

@@ -0,0 +1,9 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="about-the-intro-to-mta-guide_{context}"]
+= About the {IntroToMTABookName}
+
+This guide is for engineers, consultants, and others who want to use the {ProductName} ({ProductShortName}) to migrate Java applications or other components. It provides an overview of the {ProductName} and how to get started using the tools to plan and run your migration.

docs/topics/mtr-about-the-web-console.adoc

@@ -0,0 +1,10 @@
+// Module included in the following assemblies:
+//
+// * docs/web-console-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="about-the-web-console_{context}"]
+= About the {WebName}
+
+The {WebName} for the {ProductName} allows a team of users to assess and prioritize migration and modernization efforts for a large number of applications. It allows you to group applications into projects for analysis and provides numerous reports that highlight the results.
+

docs/topics/mtr-about-tools.adoc

@@ -0,0 +1,25 @@
+// Module included in the following assemblies:
+//
+// * docs/cli-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="about-tools_{context}"]
+= About the tools
+
+The {ProductName} ({ProductShortName}) provides several tools to assist you in the various stages of your migration and modernization efforts. Review the details of each tool to determine which one is right for your project.
+
+ifdef::mta[]
+* User interface
+endif::[]
+
+ifdef::mtr[]
+* Web console
+endif::[]
+
+* {ProductName} Operator
+* CLI
+* IDE addons for:
+** Eclipse
+** Visual Studio Code, Visual Studio Codespaces, and Eclipse Che
+** IntelliJ IDEA
+* {MavenName}

docs/topics/mtr-about-vscode-extension.adoc

@@ -0,0 +1,17 @@
+// Module included in the following assemblies:
+//
+// * docs/vs-code-extension-guide/master.adoc
+
+:_content-type: CONCEPT
+[id='about-vscode-extension_{context}']
+= About the {ProductShortName} extension for Visual Studio Code
+
+The {ProductName} ({ProductShortName}) extension for Visual Studio Code helps you migrate and modernize applications.
+
+The {ProductShortName} extension is also compatible with Visual Studio Codespaces, the Microsoft cloud-hosted development environment.
+
+The {ProductShortName} extension analyzes your projects using customizable rulesets, marks issues in the source code, provides guidance to fix the issues, and offers automatic code replacement, if possible.
+
+ifdef::getting-started-guide[]
+For more information about using the {ProductShortName} extension, see the {ProductShortName} link:{ProductDocVscGuideURL}[_Visual Studio Code Extension Guide_].
+endif::[]

docs/topics/mtr-eclipse-about-plugin.adoc

@@ -0,0 +1,20 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+// * docs/eclipse-code-ready-studio-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="eclipse-about-plugin_{context}"]
+= About the {PluginName} for Eclipse
+
+The {ProductName} ({ProductShortName}) plugin for Eclipse helps you migrate and modernize applications.
+
+The {PluginName} analyzes your projects using customizable rulesets, marks migration issues in the source code, provides guidance to fix the issues, and offers automatic code replacement, or Quick Fixes, if possible.
+
+ifdef::eclipse-code-ready-studio-guide[]
+For information about a similar extension for Visual Studio Code, see the link:{ProductDocVscGuideURL}[_Visual Studio Code Extension Guide_].
+endif::[]
+
+ifdef::getting-started-guide[]
+For more information on using the {PluginName}, see the {ProductShortName} link:{EclipseCrsGuideURL}[_{EclipseCrsGuideTitle}_].
+endif::[]

docs/topics/mtr-features.adoc

@@ -0,0 +1,27 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="features_{context}"]
+= {ProductShortName} Features
+
+The {ProductName} ({ProductShortName}) provides a number of capabilities to assist with planning and executing migration projects.
+
+Planning and work estimation::
+{ProductShortName} assists project managers by detailing the type of work and estimation of effort to complete the tasks. Level of effort is represented in {ProductShortName} reports as story points. Actual estimates will be based on the skills required and the classification of migration work needed.
+
+Identifying migration issues and providing solutions::
+{ProductShortName} identifies migration issues and highlights specific points in the code where an issue occurs. {ProductShortName} suggests code changes and provides additional resources to help engineers resolve the specific issue.
+
+Detailed reporting::
+{ProductShortName} produces numerous reports to give both high-level views of the migration effort and details of specific migration tasks. You can view migration issues across all applications, charts and summary information about issues in an application, a breakdown of issues by module in the application, reports of technologies used, and dependencies on other applications and services. You can also examine source files to see the line of code where an issue occurs. See the link:{ProductDocUserGuideURL}[_{UserCLIBookName}_] for more information on the available {ProductShortName} reports.
+
+Built-in rules and migration paths::
+{ProductShortName} comes with a core set of rules to provide migration assistance for several common migration paths. These rules identify the use of proprietary functionality from other application servers or deprecated subsystems from previous versions of JBoss EAP. {ProductShortName} also contains rules to identify common migration issues, such as hard-coded IP addresses and JNDI lookups.
+
+Rule extensibility and customization::
+{ProductShortName} provides the ability to create powerful and complex rules. You can expand upon the core set of rules provided by {ProductShortName} and create rules to identify additional issues that are important for your migration project. You can also override core rules and create custom rule categories. See the link:{ProductDocRulesGuideURL}[_{RulesDevBookName}_] for more information on customizing {ProductShortName} rules.
+
+Ability to analyze source code or application archives::
+{ProductShortName} can evaluate application archives or source code, and can evaluate multiple applications together. It can identify archives that are shared across multiple applications, which can help with more accurate effort estimation.

docs/topics/mtr-method-deploy.adoc

@@ -0,0 +1,16 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="method-deploy_{context}"]
+= Deploy phase
+
+.Red Hat migration methodology: Deploy phase
+image::RHAMT_AMM_Methodology_446947_0617_ECE_Deploy.png[Red Hat migration methodology: Deploy]
+
+The _Deploy_ phase is when you run the plan created in the Design phase. In this phase, you scale the overall transformation process to complete the plan and bring all applications to their new production environment.
+
+The plan is run in iterations to deliver value incrementally. With each iteration, you continuously validate against the plan and document findings to improve the next sprint.
+
+The use of the {ProductName} {PluginName} increases speed in each iteration. It can be used with Eclipse, and marks migration issues directly in the source code, provides inline hints, and offers code change suggestions. See the link:{EclipseCrsGuideURL}[_{EclipseCrsGuideTitle}_] for information on how to use the {PluginName}.

docs/topics/mtr-method-design.adoc

@@ -0,0 +1,32 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="method-design_{context}"]
+= Design phase
+
+.Red Hat migration methodology: Design phase
+image::RHAMT_AMM_Methodology_446947_0617_ECE_Design.png[Red Hat migration methodology: Design]
+
+The _Design_ phase is when you identify all risks, define a strategy and target architecture, prove the technology, and build the business case. This phase consists of the following steps:
+
+Assess::
++
+Examine the existing infrastructure, architecture, technologies, and applications. Identify dependencies, knowledge, processes, and lifecycles. Define the desired infrastructure, architecture, technologies, and applications. Determine the feasibility and potential risks. Draft a plan and provide rough estimates.
++
+Analyzing applications using the {ProductName} {WebName} or {CLIName} helps to determine dependencies, potential risks, and relative effort. See the link:{ProductDocWebConsoleGuideURL}[_{WebConsoleBookName}_] or link:{ProductDocUserGuideURL}[_{UserCLIBookName}_] for information on how to use these tools.
+
+Prove::
++
+Solve and document the identified technical risks, for example, high risk items and issues with unknown effort. Build and shape the new platform infrastructure. Refine the estimates based on the outcomes.
+
+Pilot::
++
+Choose a small set of representative applications to transform. Finalize the target platform infrastructure as necessary. Update the documentation as the process is fine-tuned. This pilot consists of one or several iterations of the migration execution, which is scaled during the Deploy phase.
++
+Use the {ProductName} {PluginName} to accelerate the code migration. See the link:{EclipseCrsGuideURL}[_{EclipseCrsGuideTitle}_] for information on how to use the {PluginName}.
+
+Plan::
++
+Based on the outcomes of the previous steps, sharpen the estimates and refine the project plan. Define the rollout strategy to be used in the Deploy phase to complete the migration. Prepare and schedule the relevant link:https://www.redhat.com/en/services/training[technical enablement courses].

docs/topics/mtr-method-discover.adoc

@@ -0,0 +1,21 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="method-discover_{context}"]
+= Discover phase
+
+.Red Hat migration methodology: Discover phase
+image::RHAMT_AMM_Methodology_446947_0617_ECE_Discover.png[Red Hat Migration Methodology: Discover]
+
+The _Discover_ phase is when you gather all stakeholders and decision-makers together to understand the current state and business drivers, and to determine the migration or modernization needs.
+
+In this phase, you can do the following:
+
+* Explore technologies and discuss potential approaches.
+* Identify the existing pain points, concerns, requirements, and some potential challenges.
+* Define the high-level business priorities, and scope the assessment.
+* Determine in what ways you want to modernize your application development and delivery to allow you to innovate more rapidly.
+
+Typically, this can be covered in a day in a workshop with Red Hat experts.

docs/topics/mtr-migration-approach.adoc

@@ -0,0 +1,11 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="migration-approach_{context}"]
+= Red Hat's application migration approach
+
+Red Hat has defined a strategy to make large-scale application migrations to Red Hat JBoss Middleware quantifiable, less costly, less risky, and easier to complete.
+
+Migrating from proprietary or outdated middleware platforms to Red Hat JBoss Middleware gives you lightweight, modular, and cloud-ready middleware with a supporting application infrastructure to make teams more productive. JBoss Middleware and other Red Hat technologies also provide great opportunities to modernize your application development and delivery, allowing you to innovate more quickly.

docs/topics/mtr-migration-best-practices.adoc

@@ -0,0 +1,30 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="migration-best-practices_{context}"]
+= Best practices
+
+Red Hat recommends the following practices when planning and executing a migration or modernization:
+
+* Create a centralized collaboration platform for information sharing.
++
+Comprehensive and accessible documentation is important so that knowledge can be easily shared and to ensure that effort is not duplicated by solving the same issue twice. It is recommended to document the following items:
++
+** A step-by-step guide for migrating or modernizing an application from scratch.
+** A collection of solutions to known and encountered issues.
+** Information about the new platform.
+** A record of the changes made to specific pilot projects.
+
+* Reuse, automate, and standardize as much as possible.
++
+Consider reusing existing components instead of creating new ones. Automate processes related to the application lifecycle, such as builds, configuration, deployment, and tests. Standardize and document software packaging format, configuration management, libraries, and dependencies.
+
+* Use a proven and repeatable methodology.
++
+The recommendation is to follow a practical approach and make as few changes as possible to get a functionally identical application.
+
+* Involve Red Hat technical expertise early for the chosen Red Hat Middleware components.
++
+This is crucial to make your migrations and modernizations low risk, predictable, and efficient. Contact Red Hat Consulting for assistance.

docs/topics/mtr-migration-goals.adoc

@@ -0,0 +1,22 @@
+// Module included in the following assemblies:
+//
+// * docs/getting-started-guide/master.adoc
+
+:_content-type: CONCEPT
+[id="migration-goals_{context}"]
+= Goals of assessing a migration
+
+Many organizations are faced with the challenges of keeping their existing business operations running, while also trying to innovate. There are typically increased expectations to deliver new functionality faster and to reduce cost.
+
+When assessing a migration or modernization effort, it is important to address the challenges that are specific to your organization. Common challenges that organizations face are limited budgets, lack of in-house skills, perceived risks, no known predictable process, and accurate effort estimation in a timely manner.
+
+In general, the goals when assessing a large-scale middleware migration or modernization effort are the following:
+
+* Predicting the level of effort and cost
+* Scheduling application migrations and handling conflicts
+* Identifying all potential risks at a code, infrastructure, process, or knowledge level
+* Predicting the return on investment to make the business case
+* Identifying and mitigating risks to the business
+* Minimizing disruption to existing business operations
+
+Red Hat has developed a strategy to minimize risk and make application migration and modernizations more efficient.