|
Job & Task Automation.
Problem Monitoring, Alerting & Escalation.
1-800-538-3818
|
not logged in
|
|
|
|
JobQue/X Job and Task Automation
It's the right tool for your job, and all of your jobs.
JobQue/X is easy-to-use job automation software that schedules interdependent
tasks in your IT environment. Jobs run at the correct time and with the proper dependencies.
For UNIX, Linux, and Windows.
|
|
Roll your mouse over for a description
|
|
|
|
JobQue/X executes the right software task, at the right time.
With JobQue/X, you can automate a large number of processes and associated
interdependent jobs, in different applications and in multiple locations. JobQue/X
automates processing in any combination of AIX, HP-UX, Linux,
Solaris and Windows environments.
|
|
|
|
|
|
Although job scheduling can quickly
become a very sophisticated task, a job scheduler need not be an overcomplicated
software product. Nobix JobQue/X is easy-to-use, yet powerful, and starting
at under $500 for a Linux or Windows® server, JobQue/X
provides the same core functionality but is up to 60% less expensive than our competitors.
With JobQue/X you create schedules, which are collections of steps
or individual jobs, and calendars, which are the time references for running
the schedules. Simply associate a calendar with a schedule and you can be assured
that the steps in that schedule will run when you want them to. You can set dependencies
between any combination of schedules and jobs.
|
|
|
(Roll-over for larger view)
|
|
|
Event features allow you to test for events on your system. Events may be
used to start schedules, as well as satisfy dependencies between schedules and jobs.
Event scripts may be implemented for virtually any type of application, file or
system event. Additionally, each schedule and step that runs generates its own automatic
events, which may be used for error recovery, starting additional schedules, etc.
Queue features are handled through JobQue/X concurrency definitions, which
allow only the configured number of predetermined schedules/steps/executables to
run at the same time.
Multiple users may be configured to access only the parts of JobQue/X the
administrator allows. With the proper permissions, users may create, maintain and
monitor their own schedules and have access to reporting.
Server Group features allow a single JobQue/X master server to distribute
a common schedule to all of its members. There are features for file distribution
and execution on member systems.
JobQue/X server includes a web interface that may be used for monitoring
and control of one or more JobQue/X servers *. Also included with the server is
a command line interface which may be used from a terminal session or embedded in
scripts, applications, etc.
JobQue/X server creates its own job control for each job and saves each job's
stdout and stderr for a configurable period of time.
JobQue/X server is the software that schedules and runs your jobs. JobQue/X
server is licensed for each machine that runs jobs.
JobQue/X client software runs on your Windows PCs and includes three interfaces
- Administration, create and maintain your schedules
- Communication, monitor and control JobQue/X servers
- Reporting, for generating various schedule reports
You may run as many JobQue/X clients as you require, on any of your desktops. There
is no license fee for the interfaces.
|
|
|
|
Features
Benefits
Interface
Specifications
- Schedules can be started by calendars, events, other schedules, or any combination.
- Multiple machine scheduling between JobQue/X systems.
- Job, schedule, and event dependencies provide total control over job starting within
a networked environment.
- Unlimited number of calendars, schedules, steps and events.
- Automatically generated job control.
- Job stdout/stderr and JCL stored for a configurable period.
- Error message search capability for stdout/stderr.
- Server group features for distribution and execution of schedules and files.
- Easy-to-use and implement Windows client interfaces.
- Web interface for monitoring and control.*
- Command line interface may be embedded in scripts, etc.
- Parameter substitution.
- Job queueing for controlling concurrent processes.
- Changes to a schedules are automatically recognized.
- Real-time monitoring and maintenance of schedules provides total control over all
of your operations.
- Allows user-created schedules, jobs and their associated dependencies.
- Multiple user access means administration tasks may be delegated.
- Integrates with PageAlert for alerting and message escalation.
|
- Simple to use, yet powerful software easily implemented into your current environment.
- Reduces the need for manual intervention and offers total control over the timing
of jobs.
- Control over job execution within a networked environment.
- Eliminates scheduling limitations.
- Provides flexible startup options and resource allocation.
- Jobs run consistently and accurately.
- Reduces down time.
- Ensures accuracy and speeds the completion of production schedules.
- Quicker returns are achieved when you decide to license JobQue/X due to lower overall
licensing costs.
- JobQue/X can demonstrate a positive impact on your organization in a matter of days.
|
Windows Clients
JobQue/X includes three client interfaces for administraiton, control and reporting.
|
Scheduling Administration:
- Schedules
- Steps and jobs
- Schedule dependencies
- Calendars
- Job queues
- Exception messages
|
|
|
Monitoring:
- Monitor current activity
- View schedule history
- View job stdout/stderr
- Manual override for schedules/steps
- Start/Hold/Suspend/Delete
- Color coded schedule & step status
- Complete scheduler control
|
Reporting:
- Schedule Simulations
- Calendar crossreferences
- Schedule history
|
|
|
Command Line, on each server:
- Most of the client capabilties
- Useful from terminal sessions
- Allows control over scheduler functions
|
Web Interface:
- Same capabilities as Windows control interface
- Useful from anywhere
- Allows control over schedules & scheduler functions
|
|
|
|
Schedules
|
An unlimited number of schedules may be defined. Schedule definitions contain one
or more steps. Each step is responsible for starting a job, which is an instance
of a step.
|
|
Calendars
|
User-defined day, date, & julian defintions. Day offsets may be defined. Calendars
may be used to specify when to run, when to not run, and for schedule date validation.
|
|
Events
|
Events scripts are used to determine individual event status. Persistent and polled
scripting supported with exit code checking and validation time periods. Events
may be used to start schedules and may act as dependencies on schedules and jobs.
|
|
Dependencies
|
Schedule to schedule or event, schedule to step or event, step to schedule or event,
step to step or event. Cross-schedule and system dependencies allowed. Error and
non-error checking.
|
|
Schedule Start Options
|
Based on a calendar, event, explicit in a schedule, and manual.
|
|
Configurable schedule step properties
|
Run calendars, don‘t run calendars, step limits, executable pathname, start
directory, username (UNIX/Linux only), shell, stdin, priority, error message searching,
job dependencies, event dependencies.
|
|
Server Groups
|
No limit on number of defined server groups and associated member systems.
|
|
User Permissions
|
JobQue/X administrator permission assignments allow: Administrator, Job Submission,
Schedule Management, Operator, Reporting, and Read-Only delegation.
|
|
Naming Limitations
|
Schedule/Step/Calendar/Event names 31 characters. Step names optional. Error message
group names 255 characters. Base filename lengths 127 characters. Directory names
1023 characters. Hostnames and usernames 63 characters.
|
|
Operating systems(JobQue/X Server)
|
HP-UX, 11.0 and later
AIX, 5.1L and later
Solaris 7 and later
Redhat 7 and later, Fedora 7 and later
openSUSE Linux 10.2 and later
Windows 2000 and later
|
|
Hardware(JobQue/X Server)
|
HP, HP-PA & Integrity
IBM, pServer & p series
Sun, Sparc/sun4u/x86
x86,
|
|
Interfaces
|
Windows clients for Administration, Monitor & Communication, and Reporting
Web interface for Monitoring & Communication
Command line interface on each server for terminal sessions
|
|
Disk Space
|
Installation: 25MB approximate
Usage: 250MB typical, 10 days history
|
|
Security
|
Server->server and client->server connections encrypted. Administration, Monitor
& Reporting security is based on system administrator/superuser capabilites.
Non-admin capabilities allow user-submitted jobs and their control with permission.
|
|
Job error detection
|
Return code and error message group search of stdout/stderr
|
|
Notification
|
Error notification may utilize PageAlert or a user-supplied notification script.
|
|
Logging
|
Complete logging for connections and scheduler operation.
|
|
Reporting
|
Schedule simulation, dependencies, calendar definition, calendar crossreference,
post-production
|
|
Licensing
|
JobQue/X Server - UNIX systems: by machine and processor count
JobQue/X Server - Linux & Windows: by machine
JobQue/X Client - freely distributable
|
|
|
|
|
"We have implemented Nobix JobQue/X with our newly deployed
mission critical Insurance Policy Administration system, on both Solaris and Windows
platforms. The installation was straight-forward. Assistance from Nobix during our
implementation was excellent. We especially like the job grouping features and being
able to coordinate between servers. Our JobQue/X implementation is also integrated
with PageAlert and the integration is seamless." - Danny Lee, IT Systems Manager,
Farmers Insurance Hawaii
|
* JobQue/X web interface requires Apache web server running on a UNIX
or Linux platform.
|
A schedule is a collection of related steps. There is no limit
to the number of schedules that may be configured. A step is an individual task
or program that is to be run. When a schedule begins to execute, each step in the
schedule is run in the proper order, and each step becomes a unique job.
Steps in a schedule may also be used to initiate other schedules. Schedules and
steps automatically generate events, which may be used to satisfy dependencies and
start schedules.
Schedules may be started from the local machine, from a remote JobQue/X system,
or from the Windows and command line interfaces.
A job is an instance of a step that is running or has been run. Each
job corresponds to a task, program, or script that executes. The steps that become
jobs are started from their parent schedules.
Dependencies may be defined between any combination of schedules, jobs and events.
Each calendar that you define is a collection of days, dates and times.
There is no limit to the number of calendars. You define calendars with terms like
"every 3rd Friday", and JobQue/X turns that into a list of dates. You may add as
many defintions to a calendar as you require so that the calendar is tailored to
your purpose. You may assign a time to a calendar definition and then use it for
automatically starting a schedule.
Both Gregorian and fiscal calendars are supported. In addition, offsets may be employed
to keep a calendar definition from falling on the wrong day of the week.
You associate calendars to schedules and steps, thereby stating when the schedules
and steps should be run. You may also define calendars for days and times that schedules
and steps should not run, for example, on certain holidays, and then associate
those "don't run" calendars to schedules and steps.
Each calendar that you define may be associated with multiple schedules and steps.
Events occur in JobQue/X through the use of event scripts or programs
(defined events), and may also be automatically generated from schedules and jobs
that are run (automatic events).
Defined events run programs or scripts periodically or persistently. When an event
program terminates its exit code is compared to the configuration value, and if
it matches the event is marked as true.
Events from other JobQue/X systems may be used to satisfy event dependencies on
the local JobQue/X system.
Automatic events are generated everytime a schedule or job terminates, in either
a non-error or error state.
Events may be used to start schedules and satisfy dependencies on steps. Events
can test for things like files appearing in directories, or database access conditions,
or websites going down. We can help you customize events for your needs.
Exceptions in jobs are checked by examining the job's exit code, as well
as scanning the job's stdout and stderr files for error messaages that you may define.
You may define as many sets of error messages that you require.
The error message sets are given descriptive names, for example, "File Errors".
You may then associate one or more error message sets to a schedule's step, which
then causes the job to be examined for these messages. If a message is found in
the job's stdout or stderr it is treated as an exception.
Queues are collections of schedules, steps and other executables, that
are associated in a concurrency defintion. A limit is assigned to the defintion
and this limit is used to throttle the number of associated executables that may
simultaneously run. There is no limit to the number of concurrencies that may be
defined.
|
|
|