Infrastructure Editor Reference

This document describes the AppLogic Infrastructure Editor. The Infrastructure Editor is a visual tool that makes it easy to create, assemble and troubleshoot disposable infrastructure for AppLogic applications. The user interface of the editor is highly interactive and is modeled after Visio: you assemble infrastructure by dragging components onto the canvas, wiring them together and configuring each component using a property sheet.

Quick Links to Other Editor Documentation

The following are shortcuts to topics relating to the AppLogic Infrastructure Editor:

• Application Configuration describes the Application Configurator tool
• Manage Application Volumes describes how to manage application volumes
• Instance Settings Property Sheet covers the Instance Settings property sheet
• Class Editor - Simple Appliances describes the Class Editor for simple Appliances
• Class Editor - Assemblies describes the Class Editor for Assemblies

Overview

This is the main screen of the Infrastructure editor. You use it to create and modify the disposable infrastructure for your applications. The same editor is used to edit the structure of the application and the structure of composite appliances (assemblies). In fact, the application itself is an assembly called main.

The editor main layout includes a palette with appliance catalogs on the left and a drawing canvas on the right.

You can reach the Infrastructure editor by first logging in and then selecting an application to edit.

Editing Applications

The application as a whole is an assembly -- a composite appliance with a well-defined boundary, built as a structure of connected appliance instances (subordinates). In addition to the application assembly main, which is created automatically by AppLogic, you can create additional assemblies that you can use to build up your application.

So, to restate, the infrastructure editor allows you to visually edit the interior structure of an assembly: to define the subordinate instances, their configurations and connections.

The editor provides a drawing canvas, where you build structures of connected appliances. The editor further provides a number of property sheets for configuring various aspects of the application and its appliances.

We have designed the editor to be intuitive and use the palette-and-canvas layout familiar from a number of drawing applications. Instead of reading the following sections that describe with text how to do visual operations, feel free to simply try the editor. Drag things left and right; double-click and right-click on various items and see what happens. If it wasn't easy to figure it out, please tell us.

Menu

The editor menu contains:

• File
  • save - save the current application
  • print - print the assembly currently on the canvas
  • close - close the editor

• Edit
  • cut - cut the selected appliance(s) into the clipboard
  • copy - copy the selected appliance(s) to the clipboard
  • paste - paste any appliance(s) from the clipboard to the canvas

• Options
  • application configuration - configure the application as a whole

• Help
  • Editor Help - opens this document
  • AppLogic Documentation - Opens AppLogic Documentation
  • About AppLogic - info about the maker of AppLogic

Tool Bar

The editor toolbar provides quick access to the following functions:

• Application operations
  • save the current application
  • print the current application

• Clipboard operations
  • cut - cut the selected appliance(s) into the clipboard
  • copy - copy the selected appliance(s) to the clipboard
  • paste - paste any appliance(s) from the clipboard to the canvas

• Edit mode
  • select - selection mode
  • connect - connection mode (default)
  • connect (balloon) - balloon connection mode
  • pan - pan the canvas (scroll)

• AppLogic operations
  • monitor - monitor application
  • shell - open command line shell

Next to the buttons, the editor shows the name of the application and the hierarchical path to the assembly being edited. The path also doubles as "breadcrumb" navigation: you can step up to parent assemblies, all the way up to main.

Catalogs

In AppLogic, each application has access to a two or more catalogs. At a minimum, the application has access to the global system catalog and to its local catalog.

The global system catalog contains appliance classes that are common for AppLogic and are accessible to all applications. Changing an appliance in the global catalog affects all applications.

The local catalog contains appliance classes specific to the application you are editing. Each application has its own local catalog. Changing an appliance in the local catalog affects only this application. Many applications don't actually have any appliances in the local catalog and use only appliances from the global catalog.

You can select which catalog to use by choosing it from the drop-down box above the palette.

The appliance classes in a catalog are grouped by category. You can visually collapse or expand a category by clicking on the category name. If the catalog has a lot of appliances, you may be able to scroll the catalog up and down as well.

The editor shows the catalog appliances with smaller shapes, using the same color and terminals as the appliance will have when dropped on the canvas. The class name of each appliance is shown under the shape.

You can create an instance of an appliance class by dragging its shape onto the canvas.

You can move a singleton appliance to the catalog -- and make it a catalog class -- by dragging the singleton into the catalog (make sure you have selected the correct catalog first). See Branching Classes for more information on singletons and on customizing classes.

You can access the following operations over appliance classes by opening the right-click menu on a class in the catalog:

• delete the class
• rename the class
• create an instance (similar to dragging the class shape onto the canvas)
• move the class to another catalog (or to the application as a singleton)
• view the class (in the Class Editor)

Canvas

The canvas is the drawing area, where you assemble your application by dragging elements from the catalog pallete and connecting them.

In addition to dragging instances around, selecting instances and re-routing connections, you can right-click on the canvas and access the following operations:

• paste from clipboard
• scroll the canvas (or exit scrolling mode)
• navigate up (only if inside an assembly interior)
• edit or view the boundary of the assembly (opens the Class Editor)
• manage application volumes
• configure the application as a whole (opens the Application Configuration)

Status Bar

The status bar shows your user name and the names of the currently selected appliances.

Also, it shows a progress indicator for some of the longer operations (such as loading or saving an application).

Subordinate Instances

You can create an instance of an appliance -- a subordinate within the assembly -- by simply dragging an appliance shape from a catalog palette onto the canvas. Once you create the instance, you can move its shape freely anywhere on the canvas.

The shape consists of the following visual elements:

• a main body (the rectangle in the middle)
• an instance name, shown in the center of the shape
• a class name, shown in the lower left side of the shape
• one or more terminals, shown as block arrows ( and ) on the left and/or right side of the shape

You can configure the instance settings of the new appliance by double-clicking on it: the editor opens the Instance Settings property sheet for the instance.

You can also perform the following operations on it by opening a right-click menu on the shape:

• configure Instance Settings: Attributes, Resources, User Volumes and Properties
• cut or copy the appliance to the clipboard (preserving all instance settings but not the connections)
• branch the appliance class to create a new class based on this instance (called a singleton class)
• move a singleton class into the catalog, so many instances of it can be created
• view or edit the appliance class (opens the Class Editor property sheet)
• view or edit the interior of an appliance, if it is itself an assembly (step into the assembly)

Connections

Once you have a few instances, you can also connect them. Appliances can be connected by connecting their terminals (the named "arrows" that stick out of the appliance shape). You connect two appliances by clicking on the terminals you want to connect: click the output first, then the input you want it connected to.

The mouse cursor will provide clues as to what connections are allowed. Many outputs can be connected to a single input. Each output, however, can be connected to exactly one input. It is even possible (but rarely useful) to connect the output of an appliance to an input of the same appliance.

For more information on what the connections mean at runtime and the benefits of using connections, please see the AppLogic Overview.

When multiple outputs are connected to a single input, the editor reduces visual clutter by joining the connections with as few lines as possible. Whenever a connection joins an existing connection, the editor places a small dot, indicating the joining of connections.

You can route the connections manually by dragging their corners up/down or left/right. Once you position the mouse cursor on a connection corner, it will give you visual clue as to what directions are allowed. You can also add a segment to the connection route, which will allow you to make a route that passes around another appliance.

You can perform the following operations over a connection by right-clicking on the connection and selecting from the menu:

• add a segment
• re-route the connection (automatic re-route, useful to simplify connections)
• delete the connection

Selection

You can select one or more appliances in order to perform operations on them.

Clicking on an appliance makes it the selected appliance. Clicking on an appliance while holding the Ctrl key adds the appliance to the currently selected appliance group. Drawing a rectangle on the canvas around several appliances selects all the appliances within that rectangle.

The editor shows the current selection with dashed line. Once you select a few appliances, you can do the following with them:

• move them as a group. The editor will keep the connection routing between the selected appliances and re-route the connections between the selected appliances and the appliances that remain on the canvas.
• delete them (press the Del key on the keyboard, or select Delete from the right-click menu on one of the selected appliances)
• cut or copy them as a group to the clipboard

Editing Assemblies

This section describes elements and editing capabilities that are available only when editing assemblies that are not the application top-level assembly (main).

The editing of an assembly is very much like editing and configuring application main. The following is a description of how to create and edit an assembly class.

• Drag the asembly template class from the "New Singletons" secion of the catalog pane onto the canvas.

• Right click on the new assembly appliance shape and chose "Edit Class". Configure the boundary of the assembly class as you would for a simple class. See Assembly class editor for details).

• To edit the interior of the assembly, Right click on the assembly appliance shape and chose "Edit Interior". You will be presented with a canvas that contains shapes for the assembly as defined by the class boundary.

• Create the infrastructure of the assembly by dragging classes from a catalog or creating new singleton classes as you would for editing the application main.
  Note, in order to move around the assembly terminals, you need to click within the gray area on the terminal shape to select it and then drag it to the desired position on the canvas.

• Configure the assembly subordinate instances are required. See class editor for details).

• When you are all done creating and configuring the assembly interior, click the "Save" button to save your changes.

• After testing the assembly, you can move it to a catalog by clicking on the assembly class shape and dragging it to the appropriate catalog as you would do for a simple class.

In AppLogic, assemblies can be used in any place you would use a simple appliance. This makes it possible to reuse infrastructure without increasing the the complexity of the application. For example, a specialist in database clustering can create a "stock" assembly for clustered database deployment like the one shown above and publish it in a catalog.

Application integrators can then use this assembly in multiple applications, whenever they need database scalability and/or high availability, and without having to know how exactly the cluster is set up and operates.

-- PeterNic - 22 May 2006