This documentation supports the 11.2 version of BMC Discovery.

To view an earlier version of the product, select the version from the Product version menu.

Creating the prototype application map

While the application mapper searches in the datastore and investigates the results, he strives to build a picture of the application out of the IT components he finds. This picture is called the prototype application map, and is the goal of the Prototype stage in the Collaborative Application Mapping (CAM) process.

A successful prototype is crucial to CAM, and it fulfills two purposes:

  1. Provides a logical framework for the application mapper to capture what he finds about the application, and is a vital part of his toolset.
  2. Becomes something that can be shared with the application owner and to solicit feedback, thereby creating a very effective communication tool. See Sharing the prototype application map for more details.

Before you begin

Before you can build the prototype map, ensure that you have started searching and investigating the items in the datastore that should be added to the prototype, using the techniques described in Searching and investigating the datastore.

To create the application prototype

The prototype is built using the Manual grouping functionality in BMC Discovery. The application mapper creates a manual group for the application he is mapping. The group is the workspace for the application map.

The prototype is built in the group by creating subgroups to correspond to the application tiers, also known as functional components. A functional component is a part of an application that you want to map as a separate section. Generally, an application has one functional component for each tier (web, business logic, and database), but there are some more complicated applications that might need multiple functional components per tier. For example, if an application consists of a web layer, some message-driven Enterprise JavaBeans (EJBs) in one set of J2EE containers, a message broker, and a spring-based Plain Old Java Objects (POJO) service in a different set of J2EE containers, you would consider creating four functional components to represent the application.

As the mapper finds items in the datastore that he wants to add to the prototype, he adds them to the appropriate subgroup that corresponds to the functional component that he wants the item to be modeled in.

Notes are a key component in the CAM process, even at this early prototyping stage. Writing down observations and questions in this stage helps you maintain your understanding of the application as the prototype potentially becomes increasingly complicated. The questions are useful for soliciting feedback from the application owner when the time comes.

For more information, see Viewing created groups.

Example

In the following example, Mike continues where he left off in the previous stage, having gathered enough information from his searching the Discovery datastore for seed data given to him by George.

After locating hosts, software instances (SIs), and DBs, Mike gathers all this information into subgroups to group application components into more refined blocks that represent the tiers in the application (one for the web tier, and one for the DB tier).

  1. Create a workgroup for the application Friends, the application name that George provided as seed data.
    This screen illustrates how application mappers create a workgroup for the Friends application.













  2. Perform an index search of the BMC Discovery datastore for Friends.
    This screen illustrates the results of an index search for Friends.








    The results of the search indicate that two SIs and two software components were located. Mike clicks through to the SI details, and notices two Tomcat application servers, likely representing the Web component of the Friends application that George mentioned previously.
    This screen illustrates the SI details of the Friends application search.






    Drilling into each of the servers shows:
    • Software components, which are modules that run inside middleware (for example, J2EE EARs and WARs, .Net applications, IIS virtual directories, and so forth).
    • Client to server communications to a MySQL database
    • A dependency to that database (SQL Database Schema mellon for one server, one appended with _dev for the other)
       
  3. From the Actions menu, select Manual Groups > Friends.
     
  4. In the Subgroup field, type web and click Create.
    This screen illustrates how to add the software component to a subgroup of the Friends application.







  5. Perform an index search of the BMC Discovery datastore for Mellon (the name associated with the database).

     
  6. Click on the Database Detail link.
     
  7. From the Database Detail list, select all instances of the database and create a manual subgroup in the Friends group named db.
    This screen illustrates how to add the database instances to a subgroup of the Friends application.







  8. View the manual group to assess the details of the current prototype.
    This screen illustrates the created group with the defined subgroups representing the prototyped application.










  9. If necessary, add notes at the group, subgroup, or top level, or drag and drop items to rearrange them in the map to provide better context in the hierarchy.

Where to go from here

After you have created your prototype, you should have enough context in your applications to begin sharing information with the application owner in a PDF report. Creating a preview with context-driven notes enables the application mapper to communicate with the application owner efficiently on the map building process. Then mapper can apply the owner's feedback to refine the map before building it our further.

Was this page helpful? Yes No Submitting... Thank you

Comments