JobServer is highly scalable and extensible job scheduling and processing product.
It can be the foundation for building and consolidating your
company's business processes and internal/external job processing.
JobServer provides a feature rich and highly scalable environment for
scheduling and running everything from your most compute intensive
database ETL processing, to critical business number crunching, to web
services integration, to the mundane email notifications and system alerts. More about JobServer features.
A job can be as simple as an email notification, informing you of an
event at a set repeating calendar time, or as complex as a workflow, composed of a
dozen tasks each passing information to the other in a choreographed
and customizable fashion.
Consolidate all your cron jobs and batch programs into one central
repository. Develop new types of jobs using the SOAFaces API. This is a
Java API for building new software components that can be executed
and managed from within the JobServer environment. If you have
legacy programs written in C/C++, shell scripts or other languages
those can also be integrated.
Not all scheduling engines are created
equal. The needs of customers can impose varying demands
on a scheduling and job processing server. For example, needs
can vary in ways such as:
- Need to manage thousands of jobs with peak load requiring hundreds of
jobs be run concurrently.
- Have only a few dozen jobs to manage, but each job gets
scheduled hundreds of times during the day.
- Have jobs with sensitive response times, so a job needs to
get kicked off with a high degree of precision.
- Jobs that run for only seconds and some jobs that run for hours
- Have a large number of users that need to edit, create, track, and
administer jobs with fine grained privileges over the various tools and job groups.
- Have high-end hardware with lots of processing power that needs to be utilized.
- Complex scheduling rules.
- Need for a rich set of tools for managing jobs that also allows for a large number of
concurrent users with varying access rights and privileges.
JobServer is designed to do all these well. Whether you have ten jobs
or ten thousand jobs, whether you have two jobs running concurrently or
whether you have one thousand running concurrently, JobServer is up to
the task. Download JobServer now and get started.
JobServer offers a highly reliable, scalable, and manageable foundation from which
to base your company's job processing environment. Whether you have jobs that are
geared toward internal data warehousing, ERP processing, accounting, batch
processing, monitoring, or B2B transactions, JobServer might be what you are missing. These
jobs maybe internally IT facing and/or externally customer facing. JobServer
is a solid foundation to base your processing needs upon. Through JobServer's
scalability and powerful APIs, you will have the tools and the power you need.
For a detailed list of all the features available in JobServer go here.
JobServer comes with a rich set of GUI tools by which
to manage your jobs and environment. You can design, schedule, run, and track your jobs
with a high degree of precision and detail. Know how, what, and when a job ran. Know
who last modified a job's schedule, who last shutdown the server ...etc.
If a job throws errors or warnings get
notified by email or quickly search for such conditions across any set of
jobs (great reporting features available). When a job runs,
know exactly what was sent to the customer. Know what
inputs the job used when it ran and what outputs it generated. JobServer knows
everything about a job from the time it is created all the way through each and every run.
This is only a sample of what JobServer is capable of. The GUI tools available with
JobServer are network enabled requiring no software to be installed on the
client end. The tools can be accessed with standard web browsers and through
Web Services. With adequate hardware, the JobServer GUI tools
can support a large number of concurrent users.
Users can be granted restricted rights and privileges to certain tools. For example,
you can grant one user the right to view a job's schedule but not to edit it. Users
can also be granted rights to certain job's and job groups allowing for fine grained
The JobServer Scheduling Engine leaves no scheduling rule out
of your reach. Virtually, any repeating or one-off scheduling pattern
that you can imagine can be represented using the JobServer Scheduling
Engine. As an example, here is a sample of scheduling rules that are
- Every 15 minutes starting on 1/1/2011 09:00AM and only between 10:00AM and 7:30PM and ending on 3/3/2012 5:00PM
- Every other month starting on 1/1/2011 09:00AM and on the last, first and second Monday and last Friday of the Month
- Every other Week on Monday and Wednesday starting on 7/7/2011 except for Wednesday of 7/30/2011
- Many more...........
These examples only scratch the surface of the scheduling rules and options available. Other features include:
- Multiple one-off dates can be added or excluded to any schedule. For example, this is a
convenient way to include or exclude company holidays.
- Multiple intra-day time ranges can be excluded (e.g. exclude 1:00am to 4:00am)
- If schedule times are missed due to down time, past
scheduling times can be skipped ahead to the future or can be executed
one at a time until the schedule has moved to a date in the future.
- Jobs can be set to stop running after a certain number of
scheduled executions (e.g. stop after the job has run 55 times).
- Expire window requires a job run within a certain time
window from its scheduled time, otherwise, it will "expire"
(administrators can be alerted when this happens).
- Multiple levels of email alert can be setup when jobs fail.
This can be setup at the entire JobServer level, Partition level, Job
Group level, and/or individual job level.
- Many more......
Keep in mind also that a job can be manually launched by a user at any
time and as often as needed without being scheduled. So if a job needs to be rerun for any reason,
it can be rescheduled or manually run by the user as necessary.
The JobServer Scheduling Engine makes sure that jobs run when
they are supposed to. If a job can't run (e.g. system failures),
then the engine will keep trying to run the Job. If the Job
fails while running, the status of the job can easily be tracked to allow
the administrator to diagnose any problems. The engine is also highly
scalable and can manage the scheduling chores for thousands of jobs.
JobServer can scale with the hardware that is available to
it. It is designed to take advantage of multi-CPU and multi-core systems. The
JobServer uses an advanced look-ahead caching scheme to make sure that
no time is wasted when preparing to run a Job. It employs an advanced
multi-thread scanning design to efficiently detect what Jobs are ready
to run and quickly prepare them for running. The Scheduling
Engine and corresponding job processing unit can be segmented into any
number of Partitions. Partitions allow for higher degrees of
concurrency and are vital for installations that have a large number of
jobs and where scheduler promptness is critical. A Partition can also be
defined to limit the number of concurrently running Jobs to avoid
resource overload. Whether you are manging a handful of jobs or tens
of thousands of jobs, JobServer is up the task.
Some of the advanced features include:
Job Dependency Scheduling
Job dependency rules can be defined to control when jobs can run
relative to each other. For example, say you have job A that must run
and complete each day before a group of other jobs may be allowed to
start. In this case, the jobs in the group will not be scheduled so long
as job A has not completed and satisfied the dependency.
Job Time Versioning
Imagine you have a job that sends an email to a customer. Now next
month you know that you will need to change this email address. Job
Time Versioning allows you to change a job's properties and have them
take effect at a future time. You may set an arbitrary number of future
versions for a job.
Partitions and Groupings
Segment your JobServer environment into multiple computing Partitions
to manage and control CPU, database, and other resource utilization. Further
organize jobs into Groups and then restrict users rights to only the
Job Groups and Partitions you want them to have access to.
Detailed Job Run Accountability and Tracking
JobServer goes beyond just general reporting of when jobs run and how they
completed their processing.
Know exactly what inputs the job used when it was run and exactly what
outputs it generated as it ran. JobServer can
track the exact inputs/outputs used by a job for each and
every run. This give the user and administrator the ability to go back
into history, at the exact time the job was run, and know how it was
configured. This allows you to give customers and users detailed
proof of what was or wasn't done to the job.
The goal of the developer API is to allow companies to build
their own jobs in a modular and reusable fashion as they so desire.
Many of the features are optional, so you may choose the level
of functionality and reusability that you wish to employ.
To create a job that will
run in JobServer, all it takes is implementing one interface and
putting the developed Java software into an appropriate JAR file. The
job can be one line of code or thousands of lines of code. If you are
interested in more advanced reusability and extensibility features then
continue reading below. JobServer also comes prepackaged with built-in
components called SOAFaces that can, for example, execute unix bash, ksh, and perl
scripts and others that can send email alerts, FTP files,
make Web Services calls, or perform XML processing.
Support for Open Source
The SOAFaces API is an
innovative foundation that JobServer uses to define what a job does and
how it executes within a server. The API is developed on an open source
foundation allowing developers to get involved and drive innovation even
further, and without vendor lock in. There are also a sub project called BeanSoup that
builds on the SOAFaces. BeanSoup is a collection of reusable
SOAFaces components implemented and contributed by a community of developers. Even if you are not
using JobServer get involved!
Component Software Development is Here!
We have all heard about the promise of component
software. Buy/Build software and connect it together to compose more
complex functions. Well, JobServer is driving innovation by allowing developers
to build and compose component software called SOAFaces. Every job that
is scheduled and executed within the JobServer environment is composed
of one or more SOAFaces. A SOAFaces component (aka tasklet) can be as simple as a single line of code
or as complex as ten thousand or more. Developers have the option of
developing these tasklets in such as way that they can accept input and
send output to other tasklets. This is all done using a simple POJO (plain
old Java objects) API, so
that there is no vendor lock in or complex API for developers to learn.
All the heavy lifting is done by the JobServer Container. As an
example, all logging is done using the standard Java Logging API where
the JobServer Container manages the log output. GUI tools are provided
to search and view the logs. If a tasklet wishes to
expose its outputs to other tasklets, it can do so by defining a simple
JavaBean and it can optionally define what inputs can be passed to it
from other tasklets (using an output JavaBean). What's
more, is that users can also visually edit these input properties on
the JavaBean using JavaBean GUI Customizers. Most of the APIs and features
are optional so the developer can chose the level complexity they want.
For more details read here.
^ back to top ^