Hive FAQ
What is a
Hive?
A Hive is a mission critical computing environment that
is...
- Self-Organizing
- Self-Healing
- Self-Maintaining
A Hive enables businesses and other organizations to
leverage the rising performance and falling prices of commodity
computers to construct mission critical computing solutions that are
simultaneously...
- Survivable
- Scalable
- Affordable
What are the
key features of a Hive?
A Hive has several key
features...
- Application Fabric
- Assimilation
- Collective Intelligence
- Platform Agile
- TimeSync
How does a Hive differ from existing solutions?
The advantage of a
Hive relative to existing solutions is that a Hive is
simultaneously...
- Survivability
- Scalability
- Affordability
In contrast, existing
solutions force you to make trade-offs.
Mainframes are capable but are extremely expensive to
acquire and maintain. Fault tolerant computers are available and
predictable but are inflexible, expensive, and hard to maintain.
Application servers are more scalable and easier to use but are
fragile, expensive, and inflexible. Solutions like Linux
clusters and distributed supercomputers offer tremendous scalability
but are not built for business.
As a result, when building mission critical applications,
too often businesses and other organizations must make tradeoffs and
settle for solutions that satisfy only a subset of their needs.
In contrast, a Hive
takes advantage of the falling costs, and rising capabilities, of
commodity computers to deliver all of these benefits at the same
time.
What are the
key elements of a Hive?
A Hive is made up of several
components...
Hive
Worker
Worker
Worker
Package
Application
Service
Service
Application
Service
Service
Service
Process Flows
Tasks
Each Hive is made up of one or more
Workers. Deployed on each Worker is a Package which contains all of
the code and other documents that describe different Applications.
An Application is a
logical entity, and the things that bring it to life are its
Operations. Operations are functions that can be performed. Each
Operation is made up of one or more Process Flows which control the
sequence in which Tasks are executed. Operations can be called by
Client Applications. The Interface of each Worker is identical and
is made up of the Operations it can perform.
Process Flows group
together Tasks, which are discrete blocks of code (similar to a
subroutine) which perform discrete Operations.
The advantage of ensuring that
every Worker is configured identically, and breaking an application
up into a series of Tasks wrapped by a Process flow, is that it
enables a Hive to be extremely Survivable. Every Request is sent to
two Workers in a Hive (B and C in the example below).
As a result, if Worker
B becomes incapacitated, the Hive can instruct Worker C to complete
the processing of the Request at the point in the Process Flow where
Worker B left off. This eliminates the need to restart the
processing of the Request from the beginning of the Process Flow.
Do different Workers
perform different Services?
No. Every Worker can
perform the same set of Services since the same Package is deployed
to every Worker in the Hive. There are two reasons why this is done.
First, it allows any Worker to handle any request from any Client
Application and pick up requests that may have died on another
Worker. This dramatically improves the reliability of the system.
Second, it makes it possible for a Hive to manage and maintain its
own configuration.
What are some examples of a Service?
In general, a Hive is best suited
to providing transaction-oriented Services.
A brokerage firm might
use a Hive to provide the following Services...
- GetRealtimeQuoteForStock
- GetDelayedQuoteForStock
- GetChartForStock
- GetNewsForStock
- GetProfileForStock
- CalculateCurrentPortfolioValue
A credit card company
might use a Hive to provide the following Services...
- PerformAuthorization
- PerformFraudCheck
- CaptureTransaction
- ReturnTransaction
- VoidTransaction
A bank may support an
ATM network with a Hive that provides the following Services...
-
GetCurrentBalanceForAccount
-
WithdrawMoneyFromAccount
-
DepositMoneyIntoAccount
-
TransferMoneyBetweenAccounts
A mortgage company
might use a Hive to provide the following Services...
-
GetScoreForApplication
-
CalculateMonthlyPayment
- CalculateEscrow
An ecommerce
application might use a Hive to provide the following Services...
-
GetCurrentPriceForProduct
-
GetCurrentInventoryLevelForProduct
A security application
might use a Hive to provide the following Services...
- AnalyzeFingerprint
- AnalyzeFace
- AuthenticateUser
What kinds of computers can
act as a Worker?
A Worker can be any of
a variety of machines, ranging from blades to PCs to high end UNIX
servers. These can be either newly-purchased or existing machines,
as long as they are used only in the Hive.
How many computers do you need to make up,
and can reside in, a Hive?
A Hive can be made up of from
between one and several thousand (or more) Workers.
If this is like a beehive, then where is
the queen bee?
At any moment, several
Workers in a Hive are acting as defacto queen bees, meaning that
they are monitoring and guiding the activities of the Hive. However,
should one of those Workers become incapacitated, the other Workers
will notice that fact and a new Worker will take over that role. As
a result, the only way to kill a Hive is to kill every Worker.
How does a Client
Application access an Service?
In order to access an
Service, the developer of a client application must import the
HiveCreator API into their application. From that point on, the
HiveCreator API allows the Client Application to communicate with
the Hive and request that it perform different Services. The
HiveCreator API is implemented as a Windows .DLL file, UNIX .SO
file, or Java .JAR file, and is deployed on the machine on which the
client application runs.
Can a Hive be accessed via an XML or
similarly-encoded message?
At the moment, all
communication with a Hive must flow through the HiveCreator API.
However, future versions of the product will include a HiveCreator
Proxy, which will provide SOAP and other interfaces. Developers will
then be able to call the HiveCreator Proxy, which will handle all
communications with the Hive.
Where does the database sit in a Hive?
Any databases and
other resources are located outside of a Hive and are accessed
through a connection pool. This ensures both that external resources
do not become overloaded and that there is no single point of
failure when it comes to communicating with them.
Where will a Hive fit into my
enterprise architecture?
A Hive will not
replace or interfere with your existing enterprise systems. Instead
a Hive will be used to perform a discrete set of high-value Services
that are used by one or more Client Applications. For example, this
may include processing certain types of transactions or requests.
However, over time the range of Services performed in a Hive will
likely expand and your Hive will come to perform functions that were
previously performed by other systems.
What is involved in porting an existing application to a Hive?
Enabling an existing
application to run as a set of Services is a straightforward,
three-step process...
- The developer
divides their application up into individual Tasks. Often this
means simply wrapping existing subroutines and configuring them to
communicate through the HiveCreator Simple Task Interface.
- The developer
creates a Process Flow, which is an XML document that describes
both the logical flow of the application and any recovery
parameters. Often, this Process Flow replaces the main() function
in a C or C++ application.
- The developer
deploys their Tasks and Process Flows.
Once the Tasks and
Process Flows that lie beneath a Service have been deployed, a Hive
takes over the process of ensuring that each Worker has the correct
version.
In what ways is a Hive self-healing?
Several
characteristics of a Hive allow it to be described as self-healing.
First, HiveCreator
uses a declarative programming model in which the developer simply
has to tell the Hive how his application should work; the developer
doesn’t have to worry about failure conditions. Instead, the Hive is
responsible for monitoring the execution of all code and recovering
it if a failure occurs. The goal is to allow the developer to focus
on the application and not worry about things like the complexities
of the physical environment.
Second, if an
individual Worker fails, the Hive will take over the responsibility
for recovering it (as long as it is not a hardware fault). That can
mean re-installing the operating system, HiveCreator core
executables, and application code. A Hive will also take over the
responsibility for bringing new workers on line and maintaining
their configuration once they have been assimilated.
|
