JobServer Standard 3.2.8
JobServer Standard 3.2.8 Ranking & Summary
JobServer Standard 3.2.8 description
JobServer Standard 3.2.8 provides users with the entry level version that comes with a built-in and lightweight database, which helps make it convenient to setup and get started out of the box.
It supports most of the major functionality found in the high-end versions and is most applicable to environments with under a few hundred jobs, moderate load, and a few concurrent users.
Developers wanting to develop new SOAFaces components in their development environment, or just use it to schedule jobs for their own personal use can also get started using this version. Request a download now and you will be able to download a fully functional trial version.
- The main JobServer scheduling and processing engine runs in a dedicated Java VM(s). The supporting GUI application are J2EE based and integrate closely with the main JobServer engine. JobServer architecture diagrams:
- JobServer Simple Configuration
- JobServer Advanced Configuration
- JobServer Processing/Scheduling Architecture
- JobServer Workflow/Tasklet Processing Architecture
- Database Transaction Reliability
- All critical operations, managed by JobServer, from the scheduling to the job processing are managed and organized in a relational database. All major functions are backed by database transaction level reliability to insure integrity and stability.
- Web-based Interface
- All JobServer tools/applications are web based and also utilize the GWT (Google Web Toolkit) AJAX framework for SDK plugin extensibility and customization.
- Security and Authentication
- JobServer supports SSL/TLS for web based authentication. All user passwords and configuration passwords are encrypted.
- LDAP and Active Directory
- JobServer has support for LDAP version 3 allowing integration with LDAP and Active Directory servers for centralized authentication management.
- Advanced Scheduling Rules
- 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 supported:
- Every 15 minutes starting on 1/1/2003 09:00AM and only between 10:00AM and 7:30PM and ending on 3/3/2004 5:00PM
- Every other month starting on 1/1/2003 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/2003 except for Wednesday of 7/30/2003
- Many more...........
- Relative & Absolute Time Scheduling
- With this scheduling rule, a job can be run using "absolute scheduling" or "relative scheduling". Absolute scheduling means the job will run relative to the original start time, so if the job has a start time of 10:00 AM and the interval is one hour then the job will run at the top of every hour. With this same example, if relative scheduling is used, the job will still run every hour but it may or may not run at the top of every hour as it will run one hour from the last time it ran last.
- Skip Ahead Scheduling Rule
- This features defines what a job does if it falls behind in its schedule. Often times this feature does not come into play. But for example, if a job is set to run at 6:00PM on a given day but JobServer is down for 2 days due to say a hardware problem. When JobServer is started, the job will get kicked off, since its next run date has long past. Now this is when the Skip-Ahead feature comes into play. If this option is set, then after the initial run, the job will "skip" ahead to the next valid run date that is in the future. If it is not set, then next scheduled date will be used even if it is not in the future. The job will keep running until it encounters a next run date that is in the future again.
- Schedule Jobs One-At-A-Time
- This scheduling feature permits only one instance of a job to be running at any one time. This is useful in scenarios where you want to prevent more than one instance of a job from being scheduled at any one time. For example, you may have a job that runs every two minutes and in some rare cases, when the job might take 3 minutes to complete its processing you do not want the same job to run again. This feature prevents any other instance of the job from running until the current instance has completed. This feature can also be used in scenarios where you want a job to be running for extended periods of time and you only want to have one instance of the job to ever be running at any moment. So as an example, you might setup a job to run every 2 seconds and this job might be polling indefinitely (until killed) looking for certain events like a file being dropped in an FTP directory. In this scenario the job runs forever looking for such events. If it ever dies, due to a failure for example, the scheduler will start another instance.
- Controlled System Shutdown and Startup
- JobServer has a variety of controls available to administrators for managing and operating the JobServer scheduler and job processing environment. Users can startup JobServer in several modes, such as "Gradual Startup". This startup mode, for example, allows you to startup the JobServer engine but suspending all job processing and job scheduling. You can then go into the JobServer system controls and turn on job scheduling and/or processing for the entire system or for one Partition at a time - it is all under your control. There are similar controls for shutting down the system. You can shutdown the system "immediately" (jobs that are running will be killed) or "gracefully" (all currently running jobs will run to completion then JobServer will shut itself down once all jobs are done and during this time no new jobs will be allowed to be run or be scheduled). There are other features similar to these as well that administrators will find useful.
- Administer System Wide Scheduling and Queuing
- Administrators can control the scheduling, queuing and job processing of the JobServer environment at a system wide level or at a Partition by Partition level. This allows users to shutdown, suspend and throttle different groups of jobs in a variety of ways.
- Event Triggers & File Transfer
- Jobs can be triggered when certain events happen like a file put into a directory or a database record entered in a table. This feature allows you to create "monitoring jobs" that when they detect an event (like a file being placed in a directory) can then invoke other jobs to run, and also pass parameters to those jobs, based on the event that triggered them. Transferring files using FTP, SFTP and FTPS are provided using the Java APIs and through the open source SDK.
- Built-in Support for Batch/Shell Scripting
- JobServer comes with built-in support for executing Unix/Linux shell scripts and MS Windows batch scripts. This is provided by a Tasklet that comes pre-packaged with JobServer. The Tasklet allows job designers to configure arbitrary scripts to be run by JobServer. This scripting Tasklet uses JobServer's open source plugin SDK for building custom Tasklets and Jobs. Source code is provided for developers to customize if they choose. The scripting Tasklet provides many powerful features like the ability to store and save the script and output of the script for each job run and comes with a GUI interface.
- Variable Time Property (for ETL Jobs)
- This feature does not directly impact the scheduling rules of a job, but is instead passed to a job when it is run. The start and end offsets defines the amount of days that will be added/subtracted to the next run time and last run time, respectively. When a job is run, it has access to an effective date range (start time and end time values). The last run date is the end date and the next run date is the start date. Normally, this feature is used to make business decisions and for ETL types of jobs that need to know when they ran last because the next ETL run depends on the date/time the job ran last. For example, if you have a job that runs every day and it pulls data from a database, the start date and end date can be used to access data from the database over that given date range. This can be a very useful feature for ETL type processing applications. You also have the option of selecting a custom start and end dates for each run time.
- Point and Click Workflow Builder
- Jobs within JobServer are composed of multiple Tasklets (and an optional customizable GUI interface called a Weblet). A job can be composed of one or more Taskets that run as part of a workflow chain. Tasklets are modular pieces of code that execute and log their output to JobServer. When you assign a Tasklet to a job you choose the implementation of the Tasklet. You can use some of the built-in Tasklets or have a Java Developer write a custom one and add it dynamically to the JobServer environment. Tasklets withing a job, can also share and pass data to each other when they run in a workflow chain. This allows for very advanced capabilities. The property passing between Tasklets can be done all through a point and click GUI interface.
- Job Dependency Scheduling
- Dependency rules are a very powerful feature that can allow one Job to affect the scheduling rules of other Jobs. The best way to describe it, is to use an example. Say you have Jobs C and B that run every day at 8:00am, but they must not run until Job A runs before them. And Job A normally runs at 2:00am. If for some reason Job A fails to run at its expected time, Jobs C and B must not run till Job A completes. This is just one example of how to use Dependency Rules.
- Job Property Time Versioning
- Versioning a Tasklet, allows you to specify changes to a Tasklet's input properties that will take effect at predefined dates/times in the future. A Job that is executed by JobServer, will run with a version of Tasklet properties that is effective at the time the Job/Tasklet is run. The input properties of the Tasklet can change with time if you choose to define future changes to the properties of the Tasklet. This is a very powerful feature as it allows you to make changes to a Tasklet's input properties ahead of time, and they only become "effective" at a set time in the future. For example, at the start of the new year have the job (that runs weekly for example) start sending its summary report to "email@example.com" instead of "firstname.lastname@example.org", which it is currently set to do.
- Importing/Exporting Jobs
- Export a job's state to an XML file format and import back into another JobServer environment. This feature can be useful when needing to move a job from say a staging environment to a production system. You can export/import one or many jobs at a time. All the state of a job from scheduling to Tasklet properties are persisted in an XML file format and can be later imported back into another JobServer system.
- Job Grouping Job Groups are a way to logically organize jobs together. You can restrict user access to groups of jobs and assign certain properties and behavior to groups of jobs (like error alerting for example).
- Throttling Job Processing
- JobServers allows you to organize jobs into "Partitions". Each Partition can have attributes like how many jobs can run concurrently within it. There are other attributes you can assign, but one of the main purposes of a Partition is to allow user to throttle job processing and job scheduling for a category of jobs.
- Advanced Threading Design
- JobServer uses an advanced threading design through out the system from scheduling job runs to job the processing itself. JobServer is capable of taking advantage of high-end hardware with many CPUs and cores. For example, you can configure JobServer (via the GUI tools) to create multiple job scheduling threads so as to improve scheduler response times (for cases where you have hundreds or thousands of jobs running simultaneously) by assigning more scan threads to the JobServer schedulers. JobServer makes many of these features available in the GUI for the administrator to configure if they need advanced tuning options.
- Kill Running Jobs
- JobServer allows users to kill running jobs. Jobs that run in their own dedicated JVM and in the main shared JVM pool can be killed.
- Delete and Edit Queued Jobs Jobs get put in a Queue when the maximum concurrent job threshold has been reached for a Partition. JobServer offers end users tools for deleting and changing the order and priority of jobs in the Queue.
- Isolated JVM Per Job
- When a job enters running state, it can be run in a dedicated thread within a shared JVM or the user has the choice to have the job run in its own dedicated JVM. Running jobs in dedicated JVM's can be useful in cases where process isolation is important and to reduce chances that a rogue or misbehaving job can bring down a partition or node.
- Queue Management
- Monitor and track jobs as they enter the Queue and the Job Processor. Jobs can be organized to use dedicated Queues and have different priorties.
- Open Source Java SDK and API
- The goal of the JobServer open source SDK, SOAFaces, is to allow developers 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.JobServer also comes prepackaged with built-in components called Tasklets/Weblets 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.
- Server requirements:
- Java 1.5.x or higher
- Microsoft Windows (2000/XP) or Unix/Linux computers that are compatible with Java
- Minimum of 256M memory.
- Minimum of 100M free disk space.
- The Professional version requires a relational database. MySQL, Oracle, and PostgreSQL are supported. Standard version comes with its own built-in database so it requires no additional software.
- Client requirements:
- Client is browser based and will run on IE 6 or higher, Firefox 2.x and Google Chome. Other browsers are usable but have not been extensively tested.
JobServer Standard 3.2.8 Screenshot
JobServer Standard 3.2.8 Keywords
Bookmark JobServer Standard 3.2.8
JobServer Standard 3.2.8 Copyright
Want to place your software product here?
Please contact us for consideration.