Disaster Recovery Practice

A fourth area of UML use, which is sort of a combination of the previous
two, is disaster recovery practice. It’s a combination in the sense
that this would normally be done in a corporate environment, but the
UML virtual machines are used for training.

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.

THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.
THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.
THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.
THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.
THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

The idea is that you make a virtual copy of a service or set of services,
mess it up somehow, and figure out how to fix it. There will likely
be requirements beyond simply fixing what is broken. You may require
that the still-working parts of the service not be shut down or that the
recovery be done in the least amount of time or with the smallest number
of operations.
The benefits of this are similar to those mentioned earlier. Virtual
environments are far more convenient to set up, so these sorts of exercises
become far easier when virtual machines are available. In many
cases, they simply become possible since hardware can’t be dedicated to
disaster recovery practice. The system administration staff can practice
separately at their desks, and, given a well-chosen set of exercises,
they can be well prepared when disaster strikes.
THE FUTURE
This chapter provided a summary of the present state of UML and its
user community. This book will also describe what I have planned for
the future of UML and what those plans mean for its users.
Among the plans is a project to port UML into the host kernel so
that it runs inside the kernel rather than in a process. With some
restructuring of UML, breaking it up into independent subsystems
that directly use the resources provided by the host kernel, this in-kernel
UML can be used for a variety of resource limitation applications
such as resource control and jailing.
This will provide highly customizable jailing, where a jail is constructed
by combining the appropriate subsystems into a single package.
Processes in such a jail will be confined with respect to the
resources controlled by the jail, and otherwise unconfined. This structure
of layering subsystems on top of each other has some other advantages
as well. It allows them to be nested, so that a user confined
within a jail could construct a subjail and put processes inside it. It
also allows the nested subsystems to use different algorithms than the
host subsystems. So, a workload with unusual scheduling or memory
needs could be run inside a jail with algorithms suitable for it.
However, the project I’m most excited about is using UML as a
library, allowing other applications to link against it and thereby gain a
captive virtual machine. This would have a great number of uses:
☞ Managing an application or service from the inside, by logging in
to the embedded UML

Running scripts inside the embedded UML to control, monitor,
and extend the application
Using clustering technology to link multiple embedded UMLs into
a cluster and use scripts running on this cluster to integrate the
applications in ways that are currently not possible