<< Click to Display Table of Contents >> RayPack > 7.3 u6 > User Guide > PackBot  Basic Concepts

Each PackBot session consists of tasks. A task can be understood as a request to convert one format into another using a virtual machine. RayPack supports the following input formats:

 

•Legacy setups (.exe)

•Windows Installer setups

•Custom setups and scripts (for example .cmd, .vbs, etc.)

 

The following output formats are available:

 

•Windows Installer formats

oWindows Installer database

oRCP project (PackRecorder project)

oRPP project (PackDesigner project)

•App-V formats

oApp-V 4.6

▪standard RayPack conversion

▪conversion via locally installed Microsoft App-V 4.6 Sequencer

oApp-V 5.x

▪standard RayPack conversion

▪conversion via locally installed Microsoft App-V 5.x Sequencer

•Thin-App format

•MSIX (Desktop Bridge) format

 

Each session may consists of one or more repackaging tasks, and has the following workflow:

 

1.The user defines the packages and the pool of virtual machines used to process them.

2.Packages are processed sequentially (if there is just one machine defined) or in parallel (if more than one machine is available).

3.The results are saved and users see the confirmation with logs, errors, and success messages.

 

For each task that converts to the Windows Installer format or Thin-App format or APPX / UWP format, PackBot snapshots the current state of the machine, performs the installation using the required package options and then makes the second snapshot. Snapshots are compared and the output is saved on a physical machine. For some formats (MSI, RPP, APPX / UWP) some additional post-processing may be executed on the physical machine.

 

Sequential Processing

Packages are processed sequentially if at least one of the following prerequisites applies:

 

•There is just one package in the queue.

•There is just one machine used by the defined packages.

•There is just one actual machine used by defined packages.

•The number of parallel operations has been limited to 1 by the user.

 

One of these assumptions introduces a concept of an actual virtual machine. This is understood as the following: any two machines are considered to be "unique" if:

 

1.They are pointing to different .vmx files (Workstation), or

2.if they have the same computer name (Hyper-V).

 

If two machines are defined from a single .vmx file but are using different snapshots, they are considered to be only one machine. In that case (should there be no more machines defined in the pool) the processing is sequential.

 

Parallel Processing

Packages are processed parallel if the following conditions are valid:

 

•The user has defined more than one task to process.

•The selected tasks use at least two different virtual machines (see the description of sequential processing for the definition of machine uniqueness).

•The user selected a parallelism level of 2 or higher.

 

If this is the case, packages are processed in parallel. Parallel processing makes it faster to repackage large numbers of products in a fully automated way.

 

Before starting with each package, PackBot finds the best candidate to provide the maximum efficiency. It allocates the virtual machines pool as effectively as possible, limiting idle times and race conditions between packages. This may lead to a non-linear processing (for example, PackBot may decide that it will be on average faster to start with first and third package in the list, leaving the second package for a later processing). The selection algorithm takes the following into account:

 

•Constraints on all open packages (it prefers packages having more constraints over packages having less constraints).

•The order in the list.

•The idle state of virtual machines.

•Some more factors are considered by the algorithm.

 

This process is fully automatic and requires no attention from the user.

 

Example 1

A user has a virtual machine representing his packaging environment. He clones this machine three times. He now has four machines all pointing to a different physical file. He defines a queue of 100 packages and assigns them to all four machines of the pool. He uses parallelism level 4, which means that four machines can be running at once. In this scenario, the repackaging of 100 applications will on average will be four times faster, because all four machines are running at the same time, processing four packages at once.

 

Example 2

A user has one virtual machine with the sequencer installed, and another one without sequencer. This two machines use different .vmx files. He now defines a queue of 100 packages. Out of these, 50 packages are to be virtualized and are assigned to the machine having the sequencer installed, and the other 50 are simply to be repackaged and are assigned to both machines. In this scenario, PackBot will run two packages at once, making sure that the App-V packages always run on the machine with the sequencer and that the other tasks run as much as possible on the machine without sequencer to not block the App-V related tasks. On average, the whole process takes two times less time as sequential processing.

 

Detailed information about process flow and runtime decisions are described in the chapter Parallel Processing.

 

Silent and Bulk Processing

A task defines a setup to be started and a corresponding command line to install the product. If the command line is fully silent (it ensures that no popups and prompts are shown, typically /S or /Q), then the package is installed, processed, and converted silently. If all tasks in the list are defined with a fully unattended command line, then the whole processing can be silent and run fully unattended without any user attention.

 

1.The machine is started and the user is signed in.

2.The first snapshot is captured.

3.The package is installed using the command line delivered by the user.

4.PackBot captures the second snapshot, compares it to the first one, and generates the output.

 

In order to process packages silently:

 

•Import all required setups to the list.

•Review the command lines used to install the products and ensure they run from the beginning to the end in an unattended mode.

•All virtual machines need to have auto-logon enabled (read more about it in Best Practises and Recommendations chapter).

 

 

Interactive Processing (Aka "Delayed Second Snapshot")

In order to perform bulk repackaging or a simple repackaging on a virtual machine which can capture custom user configurations, the user can decide to delay the second snapshot. By using this option, the processing of each task looks like the following:

 

1.The machine is started and the user is signed-in.

2.The first snapshot is captured.

3.The package is installed using the command line delivered by the user.

4.PackBot stops at this point and displays a window prompting the user to continue when he is finished with his configuration.
 

 

5.The user configures the product (starts the application, changes settings, etc.).

6.The user presses the Click to continue... button to continue.

7.The user can also reboot the machine by either pressing Reboot machine... or manually from Start menu. In any case, PackBot restarts after the reboot is complete and continues the processing. The user is able to reboot regardless of task settings once the Delayed second snapshot options is active

8.PackBot captures the second snapshot, compares it to the first one, and generates the output.