MVP Systems - Support » Knowledgebase » Latest Articles

JAMS for OpenVMS V4.2Q

DanielS — Mon, 06 Sep 2010 21:07:33 GMT

The following issues are addressed in JAMS for OpenVMS Version 4.2Q

If a job running via the JAMS Agent for OpenVMS executing a SPAWN command, the job would never complete.

*Note that only the JAMS Agent changed in 4.2Q

Release Notes for JAMS v4.9.154

VanessaB — Mon, 06 Sep 2010 21:00:16 GMT

This release includes:

A correction to Canceling a Parameter addition to avoid a looping condition.
Added support for PowerShell jobs including Unicode characters in the script and as parameters.
Updated RebEx components to the latest version.
A correction to the JAMS database schema names to support SQL 2000.

Release Notes for JAMS v5.0.191

VanessaB — Mon, 06 Sep 2010 20:58:53 GMT

This release includes:

A correction to Canceling a Parameter addition to avoid a looping condition.
Added support for PowerShell jobs including Unicode characters in the script and as parameters.
Updated RebEx components to the latest version.
A correction to the JAMS database schema names to support SQL 2000.
Added support for output properties to the Submit workflow activity to pass final severity, status and status code.

Why Triggers Using File Events Do Not Automatically Reset

phils — Tue, 31 Aug 2010 17:12:20 GMT

In the definition of a JAMS trigger the "Status" tab has an option to reset the trigger after it fires:

This option does not apply to triggers that have any "File" events because the Trigger would continuously fire multiple times as the file would still be present. The simplest way to reset a trigger that relies on "File" events is to run a PowerShell Job afterwards that resets the trigger using the "Reset-JAMSTrigger" cmdlet. This could be done by creating a new Job with PowerShell as it's execution method. The source for this job would be:

Reset-JAMSTrigger -Name YourTriggerName

After running this job your trigger would then be active.

How to Use The JAMS File Transfer PowerShell Cmdlets

phils — Tue, 31 Aug 2010 16:24:53 GMT

In addition to using the "File Transfer" execution method, file transfers can also be performed using the JAMS PowerShell Snap-In. The Snap-In supports transfers in the following forms: FTP, FTPS, and SFTP. Before a connection can be made, you must first define the credentials for the user account that will be connecting to the file server.

[Getting Credentials from a JAMS User]

$userCredentials = Get-JAMSCredential -UserName JAMSUserName -Server JAMSServerName

Once the credentials have been established a connection can then be made.

[Establishing a Connection]

The following example demonstrates the format for establishing an FTP connection:

Connect-JFTP -Credential $userCredentials -Name YourFileServerName

The other two transfer methods follow the same format except that "Connect-JFTP" would be replaced with "Connect-JFTPS" or "Connect-JSFTP". Besides that difference, the following examples are the same for any of the three transfer methods.

Once a connection is made, you can then retrieve or send files to the server.

[Sending & Retrieving Files]

The format for sending a file is as follows:

Send-JFSItem -Name C:\MyFile.txt -Destination C:\ServerDirectory\MyFile.txt

The format for retrieving a file is very similar:

Receive-JFSItem -Name C:\ServerDirectory\MyFile.txt -Destination C:\MyFile.txt

To view files in a directory the cmdlet "Get-JFSChildItem" can be used:

Get-JFSChildItem -Path C:\Logs\

Another option is to get a single file using "Get-JFSItem":

Get-JFSItem -Path C:\Logs\Audit.log

The "Get-JFSChildItem" cmdlet is similar to the PowerShell "Get-ChildItem" cmdlet, they both return a collection of objects. The "Get-JFSChildItem" returns a collection of JAMSFileServerItems. Each JAMSFileServerItems describes an single file or directory that is on the file server. You can process these items using all the standard PowerShell commands, for example:

$fileList = Get-JFSChildItems *.txt
foreach($file in $fileList)
{
    if (($file.IsFile) -and ($file.Modified -gt $checkDate))
    {
        Receive-JFSItem $file
    }
}

[Directory Movement]

The "Get-JFSLocation" cmdlet enables you to determine the current path on the file server. An example of using this cmdlet might be to store the current directory in a PowerShell variable:

$CurrentDirectory = Get-JFSLocation

The "Set-JFSLocation" cmdlet allows you to change the directory on the file server and uses the format:

Set-JFSLocation -Location C:\NewDirectory

[Renaming & Removing Files]

Renaming and Removing files is also very simple. An example of renaming a file would be:

Rename-JFSItem -Name OriginalName.txt -NewName NewName.txt

While the format for removing a file is:

Remove-JFSItem -Path "C:\FTPNewName.txt" -Confirm:$false

In the example above, setting the "-Confirm" switch to false means that there should not be a verification prompt before deleting the file.

[Disconnecting]

Once the actions of the file transfer have completed the "Disconnect-JFS" cmdlet should be issued in order to disconnect from the file server.

Any of these cmdlets could be issued from a PowerShell console or from a Job within JAMS that uses PowerShell as it's execution method. Below is a simple example of how to use these cmdlets to perform a FTP transfer:

Creating a Sequential Workflow Outside of a Flowchart

phils — Fri, 20 Aug 2010 13:56:46 GMT

When creating a JAMS Workflow job a sequence of activities can be created using either the Flowchart or Sequence activity. The Sequence activity belongs to the "Control Flow" activity group and enables you to drop other activities onto it as seen in the example below:

A sequence can host any activity including Flowcharts and decision structures. The sequence activity is beneficial because it provides a more condensed view of a series of activities than a Flowchart.

Release Notes for JAMS v5.0.180

DanielS — Fri, 20 Aug 2010 11:13:13 GMT

JAMS V5.0 Release Notes

.NET Framework V4.0

JAMS V5.0 requires V4.0 of the .NET Framework. If it is not already installed, the JAMS setup program will download and install V4.0 of the .NET Framework.

The JAMS Agent works with V2.0 (or higher) of the .NET Framework.

The JAMS V4.9 Admin Client can connect to and administer a JAMS V5.0 server so you can continue to use the JAMS 4.9 Admin Client on machines that cannot be upgraded to V4.0 of the .NET Framework.

Report Definitions

There have been significant improvements to the JAMS Report Designer which requires that report definitions be updated. All of the JAMS predefined reports will be replaced during the upgrade. If you have customized any of the predefined reports without saving them to a new name, you should save your custom reports under a new name or to a file before upgrading to JAMS V5.0.

As a precaution, you should save any custom reports to a file before upgrading to JAMS V5.0. This will protect you in case you encounter an issue opening the report in the V5.0 designer.

After upgrading to V5.0, you must update any custom reports by opening them in the designer and clicking the "Save" button.

Backwards Compatibility

JAMS V5.0 is fully compatible with previous versions of JAMS. However you must make a small change to a configuration on V4.x JAMS servers before you can monitor jobs using the V5.0 JAMS Client. The configuration file that needs to be updated is in the C:\Program Files\MVPSI\JAMS\Scheduler directory and is named JAMSServer.exe.config. Open that file in any text editor, look for this line:

<bindingRedirect oldVersion="4.2.0.0-4.9999.9999.9999"

change the 4.9999.9999.9999 to 5.9999.9999.9999. Save the file then restart the JAMSServer service.

SQL Performance Metrics to Check

VanessaB — Fri, 20 Aug 2010 09:00:52 GMT

MVP recommends investigating the following performance metrics to examine SQL performance.

SQLServer : MemoryManager : Total Server Memory
SQLServer : Memory Manager : Target Server Memory

These two counters are the best way to know if SQL Server has enough RAM tooperate properly.

Total Server Memory indicates the current RAM currently in use by the SQLServer Service. This value includes the total number of buffers committed toSQL Server and the OS buffers of the type OS in use.

Target Server Memory indicates how much RAM the SQL Server Service wouldideally like to have.

Generally, if the Total Server Memory counter is less than the Target ServerMemory, then SQL Server has enough memory to run efficiently.

If, over time, the Total Server Memory value is equal to or higher than theTarget Server Memory, the SQL Server Service may be under serious memorypressure and an increase in RAM is needed.

By the way, don't just add physical RAM to the server.(You didn't think it wasgoing to be that easy, did you?)

You need to have the Server Administrator look at the properties of the SQLServer (using SQL Server Enterprise Manager in SQL Server 2000 or SQLManagement Studio in SQL Server 2005).

Check the service is configured to use the newly installed RAM once it isadded. If SQL Server is configured to use a fixed amount of memory, addingphysical RAM is useless - you need to the limit once the memory has beeninstalled.

SQLServer : Access Methods : Page Splits/Sec

Page splitting cause excessive I/O on your SQL Server machine. Page splittinggenerally starts when a page of SQL Server data becomes full and is then splitbetween the current and a newly allocated page.

Occasional page splitting is a normal condition in SQL Server, but when thisparticular counter is high, excessive disk I/O is generally the result - withsubsequent slow performance to the clients of the SQL Server.

If this counter exceeds 100 over 25% of the time you have a problem. Thesolution is to increase the FILL FACTOR value in SQL Server Properties -Database Settings.

SQLServer : SQL Statistics : Batch Requests/Sec
SQLServer : Databases: Transactions/Sec

Getting a feel for how busy SQL Server actually is can be complicated. A goodstarting point is Batch Requests/Sec.

A DBA may state that Transactions/Sec is a more accurate measurement, but thisis incorrect because Transactions/Sec only measures activity that is inside anactual transaction and not all activity. This can produce seriously skewedresults.

Batch Request/Sec measures all SQL Server activity.

In general, Batch Request/Sec over 1,500 shows a very busy SQL Serverenvironment.

But this is in general -- if the server is running on a modern SMP machinesitting on a gigabit network segment this figure can be as high as 3,000; atypical 100 megabit network card can handle about 4,000 batch requests persecond.

If the machine is a uni-processor, and over 1,500, tell your boss you need abigger machine...

SQLServer : Buffer Manager : Buffer Cache Hit Ratio

This counter is an indication of how often SQL Server is able to get data fromthe RAM buffer instead of the hard disk. A higher ratio is an indication ofbetter performance.

A good target for the Cache Hit Ratio is anything above 85 percent. Anythingless than 85% indicates the server needs more RAM.

Remember the counter is an accumulation from the time the SQL Server Service isstarted. The SQL Server Service should be restarted and watched for severalhours before an accurate picture of the Buffer Cache Hit Ratio can be gathered.

Memory : Pages Per Second

This value should always be less than 100 on a production SQL Server.

This particular counter is one of the most overlooked values in the entireWindows operating system. If the value for Pages Per Second is above 100 on aregular basis, the operating system itself may not have enough RAM.

Check the properties of the SQL Server and ensure SQL Server is not using 100percent of the RAM on the server. Ensure enough RAM is allocated to Windows forother tasks.

A quick and dirty way of measuring this is to simply use Task Manager to viewthe value for Available Physical Memory on the Performance tab.

Do not confuse this counter with Page Faults Per Second

A Page Fault means the required page is not currently paged in, but it may bein the discarded page list in memory. If the page is in the discarded pagebuffer, that is, it's in another buffer still in RAM, a physical page-in fromdisk is not needed; the Pages Per Second is not incremented.

Is Defragmentation Necessary?

If ODBC timeouts are an issue, fragmentation may be the cause.

You can buy a third-party defragger.

Because SQL Server data files and transaction logs tend to be very large,extensive fragmentation may be a real issue. I/O access can be slowedsignificantly.

Fragmentation is particularly evident when range scans and table scans takeplace, as these operations read a large amount of data. If the drive head hasto move all over the drive platter to locate the required data, time is wastedand timeouts can occur.

Watching for Files on OpenVMS

JohnV — Thu, 19 Aug 2010 14:35:59 GMT

Watching for files with JAMS for OpenVMS is a little different than watching for files with JAMS for Windows. The Windows NTFS file system has hooks that will send us events when a file is created or deleted and we don't have those hooks in the OpenVMS ODS2 file system.

There are two basic scenarios where we need to watch for a file:

When we know the aproximate time that a file will arrive and we have a job scheduled to process the file.
When we don't know when a file will arrive and we want to submit a job whenever the file does arrive.

The first scenario is easily handled with a precheck job. You can create a generic "file" precheck which job which obtains the file specification from the job that it is checking for. Here is the DCL source:

$!$!  FILE_PRECHECK - This is a generic job which is used as a precheck$!                  to look for a file.$!$!                  We get the filename that we're looking for from$!                  the job that we're checking for.  We look at the P1$!                  parameter from that job which should be a filename.$!$!  Get the filename from P1 of the job we're checking for$!$ fileName = f$getqui("DISPLAY_ENTRY", "PARAMETER_1", <<JAMS_PRECHECK_ENTRY>>)$!$Check_Loop:$    if (f$search(fileName) .nes. "")$    then$        exit 1$    endif$    wait 00:00:30$    goto Check_Loop$!

To use this, you simply set it as the precheck job in the primary job definition (the job that needs to wait for the file). You also have to add a P1 parameter to that job and set the value of the parameter to the file specification to look for. After that, when the primary job is scheduled to start, JAMS will submit the precheck job which looks for the file. When it seens the file it completes succesfully which is the signal to JAMS that the primary job can be released.

The second scenario is accomplished using JAMS Triggers and Variable events. First, you need a job that will watch for the file. You can tell JAMS to resubmit the job every few minutes or you could put a loop in the job. Here is an example that would be resubmitted every few minutes:

$!$! FILE_WATCHER - A job that watches for a file and sets a JAMS$!                Variable when the file arrives$!$ JAMS :== $MCR JAMS_EXE:JAMS_MASTER.EXE$!$ if (f$search("DISK:[INCOMING]*.DAT") .nes. "")$ then$     JAMS SET VARIABLE FILES_ARE_READY TRUE$ endif

When this job sees a matching file it just sets a JAMS Variable named FILES_ARE_READY to true. Now, you can create Trigger Events or dependencies that are based on that variable. Here is a JAMS Trigger definition:

DEFINE TRIGGER PROCESS_FILES        DESCRIPTION "Process the files that FILE_WATCHER detects"        EVENT                VARIABLE FILES_ARE_READY TRUE        END_EVENT        ACTION                SUBMIT JOB PROCESS_FILE        END_ACTIONEND_TRIGGER

One detail of note, the trigger definition is not auto reset to prevent the PROCESS_FILE job from being submitted multiple times. After the PROCESS_FILE job has processed the files, it should do a JAMS RESET TRIGGER PROCESS_FILES to reset the trigger for the next file arrival.

Release Notes for JAMS v4.9.148

VanessaB — Mon, 02 Aug 2010 13:56:26 GMT

This release includes:

A correction if EnableSimpleSetups Configuration item was missing, automatic submits didn't work if a Setup definition was scheduled.
Added support for LockShortcutbar, a User.Config file setting to restrict changes to the Shortcut Bar
Added support allowing the limited list of Users even with no Inquire access.
A correction to zero agent license counts when restarting after a SQL failure.
An enhancement to tolerate database timeouts when deleting jobs. If there is a SQLException while deleting jobs, we trap it, log a message and retry after a 1 minute delay. Previously, the JAMS Scheduler service would fail and restart.

JAMS Command Line Environment

DanielS — Fri, 30 Jul 2010 15:17:40 GMT

In addition to the Client GUI, the Powershell SnapIn, and the .NET Controls, JAMS offers a command line interpreter for managing your scheduling environment.

When you install the JAMS Client, it installs JAMS.EXE, which is a command line tool. When started from the command line, you will get a JAMS> prompt. Type HELP, and you can discover all of the commands it supports. Type HELP COMMAND to get help on a particular command (For Example: HELP EXPORT JOB).

You first action establishes the connection to the JAMS ServerName.

SET SERVER JAMSServerName

Using SNMP Notifications With JAMS

phils — Fri, 30 Jul 2010 09:58:40 GMT

SNMP notifications can be used with JAMS to create alerts for the status of jobs and setups. An SNMP notification can be sent in the event that a job or setup completed successfully, failed, stalled, was short, or became runaway.

In order to use SNMP notifications with JAMS it is necessary to have an SNMP trap sender. An SNMP trap sender enables a JAMS notification job to send a notification across a network to the SNMP receiver.

A trap generator can be downloaded here:
http://www.ncomtech.com/trapgen.html

After installing this utility it is also necessary to download the JAMS MIB file. The MIB file allows a SNMP Trap receiver to understand the data context of the information being sent to it by the trap sender.

The JAMS MIB file can be downloaded here:
-You must be signed in to follow this link
http://www.jamssupport.com/Download50116.aspx

The next step is to open JAMS and create a new SNMP notification job. In this example we will create a new job definition and use PowerShell as the execution method. The following images will illustrate how to create the notification job:

You may have noticed that the job has three parameters defined at the top of the script. These parameters do not need to be defined in the parameter tab of the job definition, however they do need to be specified in the source tab as shown above. It is also important to notice that on lines 31-32 that I am navigating to the directory where I installed the trap sender. This file path will depend on the location where you installed the trap sender(TrapGen).

The first portion of the source is simply getting information about the job or setup that we want to create a notification for. The next image will show how to define the notifications that you want to send.

The source in the image above shows how to create a notification for a job that has failed, runaway, or was completed successfully. To get a better idea of what is going on in these notifications I will use the Failed notification as an example. Line 68 tells the trap generator where to send the notification on the network. This IP address should correspond to where you will have your SNMP trap receiver. Lines 68-77 reference objects from the JAMS MIB file and do not require any changes to get notifications working. Any of the lines that begin with "-v" can be re-ordered or removed to suit your notification requirements.

The last image shows the remaining source of the notification job and demonstrates how to create a few more notifications :

This job can now be specified as the notification job of any JAMS job or setup under the "Notify Names" tab of a job definition.

In order to receive notifications, you must specify the location of the JAMS MIB file in your SNMP Trap receiver. Your receiver should then be able to receive notifcations from JAMS.

Recommended Server Specifications

DanielS — Mon, 26 Jul 2010 09:00:17 GMT

Server Specifications for JAMS Scheduler:

Processor: 1GHz (x86 or x64)

Memory: 1GB

Disk Space: 1GB (in addition to the disk space required by the O/S)

These are the minimum system requirements andwill support running thousands of jobs per day. Heavy loads (i.e. 100,000jobs per day) will require more resources.

For database planning, our test lab runs approximately 1,000 jobs/day through one instance of JAMS. Retaining 30 days of data will create a database equal to 110Mb in size.

Running 100,000 per day:

Based upon customer implementations where more than 100,000 jobs run each day, the JAMS installation should consist of:

Two Windows Servers, each with Dual Quad 2.0 GHz CPUs and 32 GB of RAM (or more).

One of the above servers hosts the JAMS Scheduler while the second server is for SQL Server. Note that the SQL Server also has multiple high-speed SCSI drives.

Server Specifications for JAMS Agent:

Processor: 1GHz (x86 or x64)

Memory: 1GB

Disk Space: 5 MB

Server Specifications for JAMS Client:

Processor: 1GHz (x86 or x64)

Memory: 1GB

Disk Space: 50 MB

Release Notes for JAMS v5.0.180

VanessaB — Thu, 22 Jul 2010 13:32:12 GMT

This release includes:

A correction for Reports generation.
A correction for idle Windows Workflows that were falsely declared Runaway.

Release Notes for JAMS v4.9.143

VanessaB — Tue, 20 Jul 2010 09:51:12 GMT

This release includes:

Added support for converting and viewing SAP multistep and standard jobs on the "External" tab.
A correction to the Monitor view Submit ribbon bar button; if you select a job within a setup and then click "Submit", the setup was submitted instead of the job.

Running SQL DTS Packages in JAMS

phils — Fri, 16 Jul 2010 10:24:03 GMT

JAMS has the ability to run SQL DTS packages through the SSIS execution method. This execution method uses dtexec.exe.

More information on this utility can be found here:
http://msdn.microsoft.com/en-us/library/ms162810.aspx?PHPSESSID=o1fb21liejulfgrptbmi9dec92

JAMS includes a sample job, DBMaintPlan, as an example of a DTS package in JAMS.

To execute an SSIS package saved to SQL Server using Windows Authentication, use the following code:

/SQL pkgOne /ser productionServer

To execute an SSIS package saved to the File System folder in the SSIS Package Store, use the following code:

/dts "\File System\MyPackage"

To validate a package that uses Windows Authentication and is saved in SQL Server without executing the package, use the following code:

/sql pkgOne /ser productionServer /va

To execute an SSIS package that is saved in the file system, use the following code:

/f "c:\pkgOne.dtsx"

To execute an SSIS package that is saved in the file system, and specify logging options, use the following code:

/f "c:\pkgOne.dtsx" /l "DTS.LogProviderTextFile;c:\log.txt"

Stress Testing the JAMS Primary Engine

TonyC — Tue, 06 Jul 2010 09:11:34 GMT

Here are some tips to follow when stress testing the JAMS installation:

-          Do not run the JAMS GUI Monitor on the same machine as the JAMS Scheduler.
-          Do not run the jobs on the same machine as the JAMS Scheduler.
-          Run SQL on the same machine as the JAMS Scheduler.
-          Use a SQL Server Standard or Enterprise (NOT SQL Express).
-          Use queue job limits or resource requirements to prevent hardware overload.

Return the Forecasted Scheduling in PowerShell

DanielS — Tue, 22 Jun 2010 17:24:06 GMT

You can access the JAMS PowerShell provider to return a forecasted schedule in PowerShell.

$_srvobj = [mvpsi.jams.server]::getserver( “localhost” )
$_jobs = [MVPSI.JAMS.Schedule]::find( "*" , "*" , $( get-date "06-22-2010" ) , $( get-date "06-30-2010" ) , "CURRENT" , $_srvobj )
foreach ( $_scheduleEntry in $_jobs )
{
write-host ( $_scheduleEntry.EntryName + " " +$_scheduleEntry.HoldTime.ToString() )
}

Release Notes for JAMS v4.9.139

DanielS — Mon, 21 Jun 2010 10:40:20 GMT

This release includes:

A correction for the Remove-Item Powershell cmdlet for System definitions.
An enhancement for JAMSAgentX to better handle jobs ending with a line that did not include a CR/LF; the job would hang even though it was actually complete.
A correction for File Watching for events with wildcards and a minimum size or "Available" requirement; if one of the matched files is deleted before it satisfies the size or available requirement, the file watch may never be satisfied.
Added new PowerShell cmdlets for FTP, SFTP and FTPS file transfers.
An enhancement for the Remove-Item to function if a job or setup had an ambiguous name because the job.Delete() or setup.Delete() method used the ambiguous name instead of the fully qualified name.
An enhancement to allow adding an agent with the same name as a JAMS System.
Added AcceptAllCertificates option for FTPS.
Added Timeout option for file transfers.
An enhancement for Unix/Linux precheck jobs to allow exit codes with values of 101, 102, 103 or 104 and those values will be changed to the values for CancelJobSuccess, CancelJobInfo, CancelJobWarning or CancelJobError.

Deploying JAMS Agents

TonyC — Fri, 04 Jun 2010 14:43:52 GMT

The JAMS Primary Engine comes complete with the ability to remotely install a JAMS Agent on any Windows, Linux, Solaris, AIX, or HPUX operating system.

Just specify the target server and account to use, and JAMS will automatically deploy the Agent to the remote system. This is done by adding the DeployAgent job to the Schedule.

Resources In Use

TonyC — Fri, 04 Jun 2010 13:40:07 GMT

You can query the JAMS SQL database to determine what resources definitions are currently in use.

SELECT M.resource_name,
       M.qty_available,
       IsNull((select SUM(U.qty_in_use)
                                    from dbo.ResourceInUse as U
                                    where U.resource_id = M.resource_id), 0) as InUse
FROM dbo.ResourceM as M

Editing a Setup definition fails with primary key violation

JohnV — Thu, 03 Jun 2010 16:37:26 GMT

Editing a Setup definition may fail with an exception like:

Setup update failed

Job update failed

Violation of PRIMARY KEY constraint 'PK_SetupD'. Cannot insert duplicate key in object 'dbo.SetupD'.

The statement has been terminated.

If this happens every time you edit a particilar Setup, the Setup definition that is saved in the database is corrupt. To repair this corruption, follow these steps:

1. Right click on the problem Setup and pick "Copy To".
2. Enter a new name to copy the problem Setup to a new name.
3. Delete the problem Setup.
4. Rename the new copy of the Setup back to the original name.

Release Notes for JAMS v4.9.129

VanessaB — Tue, 18 May 2010 11:15:06 GMT

This release includes:

An enhancement for using a dotted decimal IP address as an Agent. We now call GetHostEntry which does a reverse lookup, takes the result and does a lookup. So, if an IP address reverses but the result of the reverse doesn't resolve to an IP address, the job can't start.
A correction when using JAMSAgentX, if a line in the log file was over 8192 bytes long, the job would hang.
An enhancement to detect when the network drops between the JAMSScheduler and a JAMSAgent and we reconnect when network service is restored. This also affects remote file watches.
An enhancement in a failover configuration, the backup server can now service clients for all functions (monitor, submit, maintenance etc).
An enhancement to improve recovery after a failure of the database server.
An enhancement to the Task Scheduler and SQL Agent tabs to combined them into the "External" tab.

JAMS AgentX vs. SSH Connections

DanielS — Wed, 05 May 2010 08:46:05 GMT

JAMS has the ability to execute UNIX scripts through the JAMS AgentX or agent-less through pure SSH connections. There four basic advantages to using the JAMS AgentX.

The job can contain a script rather than a series of commands. (i.e. , if statements, while loops, etc). The SSH execution method isn’t able to run a job as though it were a script; it runs it line by line as if one were typing it into the command line. JAMSAgentX runs jobs as a shell script; running it as a script makes it act the way most people expect it to. That’s the main purpose of JAMSAgentX.
File based Trigger mechanism require the JAMS AgentX.
Better exception capturing of the job processes are provided by the JAMS AgentX.
Reconnections. With SSH, if something fails which causes the JAMS server to disconnect, the job fails. With the AgentX, the job continues and we reconnect as if nothing ever happened.

Release Notes for JAMS v4.9.118

VanessaB — Tue, 20 Apr 2010 11:45:58 GMT

This release includes:

A correction to trim white space from User definition's Login Name.
Automatic addition of "Logon as batch job" permission when pushing the JAMS Agent.
Added support for the JAMS SAP Add-on
An enhancement to the Set-JAMSVariable cmdlet when the Variable has an ACL.
A correction to prevent the adding an ACL and then removing all the entries in the ACL to eilimanate a Null Reference exception.
An enhancement to Remote FileWatching to prevent cancellation when the Agent was stopped.
An enhancement to to the Monitor view to prevent a null reference exception on empty branches when scrolling.
An enhancement for when the JAMS Executor fails to reconnects to Agent jobs that were executing when the Executor failed. This has been enhanced for Failover and non-Failover environments.
An enhancement for Client GUI connection to the Failover Engine to support all operations on a Job or Setup definition.

Scripting Changes to Jobs

TonyC — Thu, 15 Apr 2010 09:20:23 GMT

One of the benefits that JAMS provides is the power to script the creation of new jobs, setups, systems, or any JAMS definitions.

Because the JAMS Snap-in includes a PowerShell provider, you can use native Powershell commands like New-Item or Get-Item to create or change JAMS definitions.

For Example, to create a new Job:

$job = New-Item JD:\Systems\Samples\Jobs\MyJob
$job.Description = "This job was added programmatically"
$job.ScheduledDate = "Monday, Tuesday, Wednesday, Thursday"
$job.ScheduledTime = [MVPSI.JAMS.TimeOfDay] "23:40"
$job.AutoSubmit = $false
$job.Source = "Dir C:\"
$job.SubmitMethodName = "Command"
$requires = new-object MVPSI.JAMS.ResReq("Widgets", 12)
$job.Requirements.Add($requires)
$requires = new-object MVPSI.JAMS.ResReq("Gadgets", 5)
$job.Requirements.Add($requires)
$job.Update()

or to change an existing Job:

$job = Get-Item JD:\Systems\Samples\Jobs\MyJob
$job.Description = "This job was changed programmatically"
$job.ScheduledDate = "Monday, Tuesday, Wednesday, Thursday"
$job.ScheduledTime = [MVPSI.JAMS.TimeOfDay] "21:40"
$job.AutoSubmit = $false
$job.Source = "Dir C:\Temp"
$job.SubmitMethodName = "Command"
$requires = new-object MVPSI.JAMS.ResReq("Widgets", 7)
$job.Requirements.Add($requires)
$requires = new-object MVPSI.JAMS.ResReq("Gadgets", 2)
$job.Requirements.Add($requires)
$job.Update()

Visual Styles-related operation resulted in an error - Red X

TonyC — Wed, 07 Apr 2010 14:42:15 GMT

You may encounter RED X across the ribbon bar and receive the following message:

Visual Styles-related operation resulted in an error because visual styles are currently disabled in the client area.

To resolve this issue, perform the following steps:

1. Right-click on "My Computer", choose "Manage" in the pop-up menu.
2. In the Computer Management, choose "Services and Applications" -> "Services".
3. In the right panel, select "Themes" service,double-click it, on the pop-up dialog, click "Start" button.
4. Right-click on the Desktop, select "Properties" item to open the Display Properties Dialog, select a theme from the Themes list.

Multiple Schedules

SheilaE — Tue, 30 Mar 2010 12:30:46 GMT

Job and Setup Definitions in JAMS can have more than one Schedule assigned in a comma-separated list. This allows the creation of more complex Schedules.

Deleting Jobs from the Schedule

SheilaE — Fri, 26 Mar 2010 17:26:17 GMT

When Jobs are deleted from the Monitor view, these Job occurrences are marked for deletion by JAMS. However, it may appear that these Jobs are not deleted immediately. That is because the JAMS Scheduler service periodically checks for these deleted Jobs and removes them from the display. Doing this improves performance and reduces the possibility of lock contention.

Setting A JAMS Variable

SheilaE — Fri, 26 Mar 2010 17:24:23 GMT

There are many ways to set a JAMS Variable. If you are using the GUI interface, you can use the Definitions tab Variables shortcut.

If you are using PowerShell, you can set a JAMS Variables by doing:

Add-PSSnapin MVPSI.JAMS
Set-JAMSVariable MyVariableName "The New Value"

If you are not using PowerShell, you can use our legacy command line tool:

"C:\Program Files\MVPSI\JAMS\Client\JAMS.EXE" SET SERVER YourJAMSServer
"C:\Program Files\MVPSI\JAMS\Client\JAMS.EXE" SET VARIABLE MyVariableName "The New Value"

Release Notes for JAMS V4.8.50

SheilaE — Fri, 26 Mar 2010 17:22:59 GMT

This release includes:

•    A correction to the Failover Engine that prevents duplicate jobs.
•    An enhancement to include Failover Engine status information to the About->Server->Status page.
•    An enhancement to include support for -UserName and -AltUserName to the Submit-JAMSEntry Powershell cmdlet. –UsernName can be used to override the username that the Job will execute under. –AltUserName can be used to override a username that is Execution-Method specific. The FileTransfer Execution Method will use the –AltUserName instead of the UserSecurity specified in the Job.
•    A correction to File Transfer options where the options would be set to default values every time you edited a File Transfer.
•    In a PowerShell script, you no longer have to convert PSObjects into base objects before passing them as a parameter value in Submit-JAMSEntry.
•    All FileWatch jobs are now canceled when the JAMS Agent or JAMS Executor is shut down.
•    A correction to prevent service failure if a Trigger was deleted while we were watching for a file, and file arrives shortly after.

Permissions to Convert SQL Agent Jobs

SheilaE — Fri, 26 Mar 2010 17:20:34 GMT

In order to use the SQL Agent conversion tab of JAMS, you will need permissions to read the SQL Agent Jobs on the target SQL instance. In SQL Server 2000, it was difficult to allow users to see the SQL Server Agent Jobs on your database server without giving the user sysadmin permissions. SQL Server 2005 makes assigning this permission much easier through the use of new database roles in the msdb database.

The SQLAgentReaderRole is a database role located in the msdb database. It is one of three new roles in this database aimed at allowing the database administrator the ability to assign more granular permissions when it comes to the administration of SQL Agent Jobs. Assigning a user or group to be a member of this role allows the user to see any SQL Agent Job located on the server instance, even the Jobs that user does not own. The user can see the Job, along with any History saved to the Job. However, the group is not allowed to execute the Jobs. To add a user as a member of the SQLAgentReaderRole, you can execute the following command:

use msdb

EXECUTE sp_addrolemember

@rolename = 'SQLAgentReaderRole',

@membername = 'username'

It is also worth mentioning the other two SQL Agent roles available in SQL Server 2005. The SQLAgentUserRole allows users to create Jobs and to manage the Jobs that they create. The SQLAgentOperatorRole allows users all of the rights assigned to the SQLAgentReaderRole along with the permissions necessary to execute local Jobs that they do not own.

In the event that you are not comfortable with assigning SQLAgentReaderRole permissions or if you are still on SQL Server 2000, there is still hope. The custom system stored procedure below is a listing of the Jobs on the system, and some detail to go along with the Job. Once you’ve created the procedure, you can assign execute permissions to the users that need to see the Jobs on the system.

use master

go

CREATE PROCEDURE [dbo].[sp_ViewJobListing]

(

    @JobName VARCHAR(255)=NULL

)

AS

BEGIN

    IF OBJECT_ID('tempdb..#Results')>0

        DROP TABLE #Results

    CREATE TABLE #Results

    (

        job_id UNIQUEIDENTIFIER NOT NULL,

        last_run_date INT              NOT NULL,

        last_run_time INT              NOT NULL,

        next_run_date INT              NOT NULL,

        next_run_time INT              NOT NULL,

        next_run_schedule_id INT              NOT NULL,

        requested_to_run INT              NOT NULL,

        request_source INT              NOT NULL,

        request_source_id SYSNAME   COLLATE DATABASE_DEFAULT NULL,

        running INT              NOT NULL,

        current_step INT              NOT NULL,

        current_retry_attempt INT              NOT NULL,

        job_state INT              NOT NULL

    )

    DECLARE @JobID VARCHAR(100)

    SELECT TOP 1 @JobID = job_ID FROM msdb.dbo.sysjobs

    INSERT INTO #Results

    EXECUTE master.dbo.xp_sqlagent_enum_jobs 1, @JobID

    SELECT

        s.Name,

        CASE WHEN s.enabled = 0 THEN 'No' ELSE 'Yes' END AS Enabled,

        CASE WHEN next_run_date > 0 THEN 'Yes' ELSE 'No' END AS Scheduled,

        sc.name AS Category,

        current_step AS CurrentExecutionStep,

        last_run_date,

        next_run_date,

        CASE WHEN xp.running = 0 THEN 'Not Running' ELSE 'Executing...' END AS Status,

        ISNULL((

            SELECT CASE WHEN run_status = 1 THEN 'Succeeded' WHEN run_status = 3 THEN 'Cancelled' WHEN run_status = 0 THEN 'Failed' WHEN run_status IS NULL THEN 'Unknown' END AS LastRunStatus

            FROM

                msdb..sysjobhistory sho

            WHERE

                sho.job_id = xp.job_id AND

                sho.instance_id =

                (

                    SELECT MAX(instance_id)

                    FROM msdb..sysjobhistory sj (NOLOCK)

                    WHERE sj.job_id = sho.job_id

                )

        ) ,'Unknown') AS LastRunStatus

    FROM     #Results xp

        INNER JOIN msdb..sysjobs s on xp.job_id = s.job_id

        INNER JOIN msdb..syscategories sc on s.category_id = sc.category_id

    WHERE

        s.Name = ISNULL(@JobName, s.Name)

    ORDER BY s.Name

    IF @JobName IS NOT NULL

    BEGIN

        CREATE TABLE #JobHistory

        (

            StepID INT,

            StepName SYSNAME,

            Message NVARCHAR(1024),

            RunStatus INT,

            RunDate INT,

            RunTime INT,

            RunDuration INT,

            operator_emailed NVARCHAR(20),

            operator_netsent NVARCHAR(20),

            operator_paged NVARCHAR(20)

        )

        INSERT INTO #JobHistory

        SELECT

            sjh.step_id,

            sjh.step_name,

            sjh.message,

            sjh.run_status,

            sjh.run_date,

            sjh.run_time,

            sjh.run_duration,

            operator_emailed = so1.name,

            operator_netsent = so2.name,

            operator_paged = so3.name

        FROM

            msdb.dbo.sysjobhistory sjh

            JOIN msdb.dbo.sysjobs sjj ON sjh.job_id = sjj.job_id

            LEFT OUTER JOIN msdb.dbo.sysoperators so1 ON (sjh.operator_id_emailed = so1.id)

            LEFT OUTER JOIN msdb.dbo.sysoperators so2 ON (sjh.operator_id_netsent = so2.id)

            LEFT OUTER JOIN msdb.dbo.sysoperators so3 ON (sjh.operator_id_paged = so3.id),

            msdb.dbo.sysjobs                 sj

        WHERE

        sjj.Name = @JobName and

        (sj.job_id = sjh.job_id)

        SELECT

            StepID, StepName, Message, RunDate AS LastRunTime,

            CASE RunStatus

                WHEN 0 THEN 'Failed'

                WHEN 1 THEN 'Succeeded'

                WHEN 2 THEN 'Retry (step only)'

                WHEN 3 THEN 'Canceled'

                WHEN 4 THEN 'In-progress message'

                WHEN 5 THEN 'Unknown'

            END AS RunStatus

        FROM #JobHistory

        ORDER BY LastRunTime DESC, StepID ASC

    END

END

GO

EXECUTE sp_ms_marksystemobject 'sp_ViewJobListing'

Release Notes for JAMS V4.8.57

SheilaE — Fri, 26 Mar 2010 17:04:00 GMT

This release includes:

An enhancement to the JAMS Agent to improve restarting when jobs are executing
An enhancement to support JAMS AgentX Jobs restarting up to 5 times if a connection is dropped
Added support for SQL Authentication to the SQL Agent tab

This release addresses the following issues:

If you change a Trigger and then delete the Trigger before the JAMSScheduler has handled the change, the JAMS Scheduler will throw an unhandled exception and restart.

Resource counts were incorrect if a Job that required resources was killed while waiting for a resource.

The default SSH log level is now set to Off.

Cached objects are now cleared from the cache when we save an update to the server. This resolves issues where the cached object would not contain updates made by the server during a save (i.e., adding a default ACL).

Aborting a Job that was running on a different machine via the JAMS Agent could result in the Job terminating with a successful severity.

Force Job to Abort?

SheilaE — Fri, 26 Mar 2010 17:01:28 GMT

When aborting a job, you are given the option to "Force job to abort."

Whether or no you check "Force job to abort" depends on the Execution Method. In most cases, it doesn't make any difference.
For PowerShell or MS Workflow jobs, when unchecked we ask PowerShell to stop running the script. When checked, we kill the process.

Moving the JAMS SQL Database

SheilaE — Fri, 26 Mar 2010 16:59:29 GMT

The process for moving the SQL database used by JAMS does not require reinstalling JAMS.

To relocate the SQL database used by JAMS:
1. Perform a normal SQL database backup and restore to target SQL server.
2. Edit the connection string property of the Common.config file found in C:\Program Files\MVPSI\JAMS\Scheduler.
3. Restart the JAMS Scheduler service from the Windows control panel services applet.

The Common.config file contains the connection string used by JAMS services to connect to the SQL database. Below are two examples of connection string information, one for Windows Authentication models, one for SQL Authentication models.

For Windows Authentication:

<?xml version="1.0" encoding="utf-8" ?>
<appSettings>
<add key="ConnectionString" value="Server=SQLA\INST1; Failover Partner=SQLB\INST1; Database=JAMS; Application Name=JAMS; Connect Timeout=600; Integrated Security=SSPI"/>
</appSettings>

For SQL Account Authentication:

<?xml version="1.0" encoding="utf-8" ?>
<appSettings>
<add key="ConnectionString" value="Server=SQLA\INST1; Failover Partner=SQLB\INST1; Database=JAMS; Application Name=JAMS; Connect Timeout=600;Trusted_Connection=False;uid=YOURSQLACCOUNT;pwd=YOURPASSWORD" />
</appSettings>

Removing System Level Notification

SheilaE — Fri, 26 Mar 2010 16:57:38 GMT

Within a Job Definition, you can remove the Notify Names specified at the System Definition level by entering “-*,” at the beginning of the list. You can also remove individual names by entering –TonyC@mvpsi.com.

Killing a Runaway Job

SheilaE — Fri, 26 Mar 2010 16:47:27 GMT

JAMS makes it easy to kill a Runaway Job process through the use of a Notification Job.

Simply create a Job, called KillRunaway in this example, using the PowerShell Execution Method with the following Source:

param($JAMS_NOTIFY_JAMS_ENTRY, $JAMS_NOTIFY_REASON)
if ($JAMS_NOTIFY_REASON -eq 'RUNAWAY')
{
    write-host "Killing runaway entry $JAMS_NOTIFY_JAMS_ENTRY"
    Add-PSSnapin MVPSI.JAMS -erroraction SilentlyCOntinue
    Stop-JAMSEntry $JAMS_NOTIFY_JAMS_ENTRY -confirm:$false
}

More information on JAMS_NOTIFY_REASON:: The reason for the notifications. This parameter could be: COMPLETED, FAILED, SHORT, RUNAWAY, STALLED or MISSED_WINDOW.

http://www.mvpsi.com/doc/JAMSClient/NotificationParameters.html

Email notification in Powershell

SheilaE — Fri, 26 Mar 2010 16:46:22 GMT

You may want to create a Job that sends additional notification at a unique step in a Setup Definition.

The following PowerShell Job can do this for you:

# Create from/to addresses:
$from = New-Object System.Net.Mail.MailAddress <<Sender>>
$to = New-Object System.Net.Mail.MailAddress <<Email>>

# Set SMTP Server and create SMTP Client:
$server = <<YourSMTPServer>>
$client = new-object system.net.mail.smtpclient $server

# Create Message:
$message = new-object System.Net.Mail.MailMessage $from, $to
$message.Subject = "A message from JAMS"
$message.Body ="Using this feature, you can send an e-mail message very easily."

# Any attachments?:
#$attachment = new-object System.Net.Mail.Attachment "c:\temp\FileToSend.txt"
#$message.Attachments.Add($attachment)

# Send the message:
"Sending message to {0} by using {1} on port {2}." -f $to.ToString(), $client.Host, $client.Port
$client.Send($message)

Release Notes for JAMS V4.8.73

SheilaE — Fri, 26 Mar 2010 16:45:09 GMT

This release includes:

An enhancement to JAMSAgentX to prevent retry if the failure is due to login failure or fingerprint mismatch
An enhancement to DeployAgentX to improve detecting a failed deployment
An enhancement to prevent the addition of a Setup Job with no Job specified within (which results in a PK_DupKey error the next time the Setup is modified)
An enhancement to JAMSAgentX to improve database lock handling for improved concurrency
An enhancement to improve retry handling when a connection is dropped between the JAMS Executor and JAMS AgentX
An issue is resolved passing File transfer credentials to a JAMS Agent

Client GUI Settings

SheilaE — Fri, 26 Mar 2010 16:43:14 GMT

Client GUI Settings are preserved in .XML files found in:

%HOMEPATH%\Local Settings\Application Data\MVP Systems, Inc\JAMS\X.X.X.

You can replicate Settings from one Client to the next by copying these flat files.

Adding Syslog Capability

SheilaE — Fri, 26 Mar 2010 16:42:19 GMT

By editing JAMS Execution Methods, you can add Syslog functionality to your jobs.

Learn more about customizing Execution Methods click here:
Custom Execution Methods

First create the Custom Execution Method

Within the Source tab, we can reference the SSHWrapper Job module within the BaseMacro.xml file.

Then you can add Syslogging to all your UNIX jobs by adding the following to the BaseMacro.xml:

<Code>

<![CDATA[#!/bin/sh

logger "Job <<JAMS.Job.Name>> is starting. Description: <<JAMS.Job.Description>>"

<<JAMS.Source>>

logger "Job <<JAMS.Job.Name>> is done."

]]>

</Code>

</Macro>

In fact, any Job Class Property could be used to customize the information included in the Syslog message.

Release Notes for JAMS V4.8.82

SheilaE — Fri, 26 Mar 2010 16:40:03 GMT

This release includes:

An enhancement to improve JAMSAgentX Jobs to reconnect if the initial connection fails
A GUI enhancement to add Queue Entry number to list of Monitor fields
An issue is addressed in Setup logs to close if a Job is released in a completed setup

Windows Vista and Windows 7 Security

SheilaE — Fri, 26 Mar 2010 16:39:09 GMT

Windows Vista and Windows 7 have enhanced security to restrict the activities normally performed by an administrator account.

You must be an administrator account to access the Access Control and Configuration areas of the Management tab. If you're running Windows 7 or Vista, you must right-click on the JAMS icon in the Start Menu and pick "Run as Administrator" in order to have full administrative rights.

ASP.NET Impersonation and JAMS Web Interface

SheilaE — Fri, 26 Mar 2010 16:38:14 GMT

In order for ASP.NET to properly authenticate the account that has logged into the JAMS Web Interface, the folllowing steps should be taken:

1. Disable Anonymous Authentication for the Virtual Directory used by JAMS Web Interface.
2. Enable Windows Authentication for the Virtual Directory used by JAMS Web Interface.
3. Add the following to C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\CONFIG\Web.Config:


    <identity impersonate="true" />
    

Within the following area:

<system.net>
        <defaultProxy>
            <proxy usesystemdefault="true"/>
        </defaultProxy>
    </system.net>
    <system.web>

    <identity impersonate="true" />
    

        <authorization>
            <allow users="*"/>
        </authorization>

Release Notes for JAMS V4.9.76

SheilaE — Fri, 26 Mar 2010 16:37:07 GMT

This release includes:

Better organization of the GUI Ribbon Bar to reduce clicking
Push deployment of Windows-based Agents
Web Services for issuing scheduling commands from UNIX systems
Composite Views allowing multiple JAMS views from a single shortcut
A faster update to current Schedule of any newly added jobs
The ability to Trigger complex Setup Definitions
Added support for MaxContentSize, MaxQueuedItems, and MaxTotalSize config settings for JAMSShr

This release also addresses the following issues:

A synchronization issue caused the JAMSExecutor to fail with "Value cannot be null."
Dependencies on a Setup were propagated to all Jobs in the Setup.
If the minimum acceptable severity for a Setup Dependency was set to "Fatal," the Dependency was never satisfied.
When you released a halted Setup, the Monitor view still showed "Halted" even though the Setup continued to run.
If a Job in a Setup failed and you released the Job to run again, you had to also release the Job from Step wait and Dependencies.
When the JAMSScheduler started, there was a failover delay even if failover wasn't configured.
The Monitor view didn't update unless a Job moved or you changed the selection.

Release Notes for JAMS V4.9.86

SheilaE — Fri, 26 Mar 2010 15:56:59 GMT

This release includes:

Added support for Solaris i386 platform

and, addresses the following issues:

When a view was deleted, it didn't unregister the ServerChanged event handler, so when the server changed, you could see various null references exceptions.
Deploying the JAMS Windows Agent always passed an AgentBaseName of Windows; it now passes the value from the directory.
The first time that you used a History shortcut that had been converted from an earlier version of JAMS, the data in the list did not display even though the list was populated, and double-clicking a line in the list would bring up the detail.
Some view property windows did not show an icon.
View search criteria was not used the first time a view was created.
The SetupWebServicesx64.msi had the wrong default directory.
The ContextMenu in the Gantt view was not available.
Ribbon Bar buttons may not properly enable when you have multiple views.
If a FileWatch Job was running on a JAMS Agent and the Job failed, JAMS might not realize the Job failed and we would not respond to a file arrival.
Dates view didn't load the dates and types when the view was created.
If you did not have any access to the data in a view, you received an "Access Denied" error when opening the view, but if you switched to a different server where you did have access, the view still did not display anything.

Release Notes for JAMS V4.9.91

SheilaE — Fri, 26 Mar 2010 15:54:06 GMT

This release includes:

A correction for long-running setups that did not do Runaway notification
A correction for PowerShell Jobs that could have log files with many serialization exceptions
Added support for the Solaris SPARC32 platform
Improved Task Scheduler and SQL Agent tab shortcuts
A correction for Queue shortcut icon properties

Release Notes for JAMS V4.9.97

SheilaE — Fri, 26 Mar 2010 15:43:48 GMT

This release includes:

Decrease of the verbosity of JAMSServer logging when the JAMSScheduler is down
A correction for the JAMS Agent deployment to IA64
Support for always allowing a Trigger to be reset
Audit trail capturing of Trigger resets
Audit trail capturing of System changes when SQL server is case sensitive
Improved expired license warning
Improved audit trial capturing of User creation
Improvements to the SQL Server conversion tool to get the correct Execution Method
Improvements to the path for SQL execution methods (only on new installs)
An enhancement on the SQL Agent tab to eliminate the need to restart the Client to pick up the changes
A correction to the Submit shortcut to save the initial menu name
Added support for the EnableSimpleSetups configuration setting

Failover Scheduling Engine Installation

SheilaE — Fri, 26 Mar 2010 15:41:48 GMT

Here are the basic instructions for installing a JAMS Failover server:

Install the first Primary JAMS Scheduler.
If you want redundant databases, configure a SQL Server mirror of the JAMS Database.
Stop the JAMS Scheduler service on the Primary Engine.
Install the JAMS Scheduler on the second node; when prompted for the database server, specify the same SQL Server, Instance, and database name as the first server. You will receive a dialog that says “Database already exists.” Click “Use Database.”
Stop the JAMS Scheduler service on the second machine.
Create\Edit the Failover.config file in the X:\Program Files\MVPSI\JAMS\Scheduler directory.
Copy the Failover.config to both machines. Failover.config should be identical on both machines.
Start the JAMS Scheduler service on both machines.

Here is a sample Failover.config:

<FailoverConfig>
    <Primary>Server1</Primary>
    <Secondary>Server2</Secondary>
    <Port>4773</Port>
    <Interval>60</Interval>
</FailoverConfig>

Release Notes for JAMS V4.9.93

SheilaE — Fri, 26 Mar 2010 11:32:55 GMT

This release includes:

Dozens of useful sample jobs demonstrating the power of JAMS!
Throttling of Runaway and Stalled notifications to avoid SQL connection overload.
A correction to avoid a possible null reference exception when releasing a Setup.

PowerShell Profile Settings

SheilaE — Fri, 26 Mar 2010 11:32:03 GMT

You can define a PowerShell profile file to set common PowerShell settings, like automatically adding the JAMS PowerShell SnapIn, defining the JAMS PowerShell drive, or defining the default JAMS Server.

Create a text file in C:\Documents and Settings\Administrator\My Documents\WindowsPowerShell\ called Profile.ps1.

Then you can add settings like the following to your Powershell Profile:

$JAMSDefaultServer = "LocalHost"

Add-PSSnapin MVPSI.JAMS -ErrorAction SilentlyContinue

NEW-PSDrive JD JAMS Localhost

Automating Outlook Tasks

SheilaE — Fri, 26 Mar 2010 11:26:24 GMT

JAMS has the ability to automate Outlook tasks such as saving attachments or exporting email information.

While Outlook profile settings and Exchange security settings can complicate these tasks, Outlook provides COM objects for automation within Powershell.

The following examples parse the Test folder within the Outlook Inbox.

Example #1. Exporting the Sender email addresses from an Outlook folder:

$olFolderInbox = 6
$ol = new-object -comobject "Outlook.Application"
$mapi = $ol.getnamespace("mapi")
$inbox = $mapi.GetDefaultFolder($olFolderInbox)
$msgs = $inbox.Folders.Item("Test")
$msgs.items | Select-Object SenderName, SenderEmailAddress -unique | export-Csv c:\emails.csv -noTypeInformation

Example #2. Saving the email attachments from an Outlook folder:

$olFolderInbox = 6
$ol = new-object -comobject "Outlook.Application"
$mapi = $ol.getnamespace("mapi")
$inbox = $mapi.GetDefaultFolder($olFolderInbox)
$msgs = $inbox.Folders.Item("Test")

foreach ($group in $msgs.items |% {$_.attachments} | group filename)

{
    trap {
        Write-Host There was a problem saving $fName
        continue
        }
$fName = "C:\TEMP\$($group.Name)"
$group.Group[0].saveasfile($fName)
    if ($?) {Write-Host $fName was saved succesfuly.}
}

Release Notes for JAMS V4.9.109

SheilaE — Fri, 26 Mar 2010 11:23:03 GMT

This release includes:

A correction to prevent Job source code from being lost when clicking Next or Previous buttons.
An enhancement to the JAMSAgent to prevent failure if another process has a Job's command procedure open when the Job completes.
An enhancement to the JAMSExecutor to prevent failure if it tries to write to a Job log file after it has been closed or before it has been opened.
An enhancement to the JAMSScheduler to prevent failure if the SQL database becomes unreachable.

Running Oracle Jobs

SheilaE — Fri, 26 Mar 2010 11:21:49 GMT

JAMS runs Oracle batch Jobs through the use of SQLPlus. SQLPlus is the equivalent to SQLCMD.exe in Microsoft SQL Server. JAMS has the ability to handle native Oracle commands on both UNIX-based and Windows-based Oracle.

For UNIX-based Oracle installations, JAMS can execute native Oracle commands through the normal UNIX shell.
For Example:

$ . oraenv
ORACLE_SID = [orcl] ? orcl
$ sqlplus daniels/tiger

For Windows-based Oracle installation, JAMS can handle SQLPlus language by simply calling SQLPlus.exe within a normal Windows Command Procedure Execution Method.
For example:

Sqlplus.exe daniels/tiger@orcl

Running SAS Jobs

SheilaE — Fri, 26 Mar 2010 11:19:49 GMT

JAMS can execute SAS programs with the Windows Command Procedure Execution Method.

Below is an example of an SAS job-source information:

c:\YourSASPath\sas.exe

    -autoexec d:\sas\autoexec.sas
    -config d:\sas\config.sas
    -nologo
    -log d:\work\logs\pull_sample200102131244.log
    -sysin d:\YourDir\YourProgram.sas

JAMSDBA Utility

SheilaE — Thu, 25 Mar 2010 09:28:52 GMT

The JAMSDBA.exe utility is used to manage the JAMS Database and to perform other installation and management tasks. JAMSDBA is a command line utility and is located in the Scheduler installation directory (C:\Program Files\MVPSI\JAMS\Scheduler by default). When you start JAMSDBA, you are presented with a "JAMSDBA>" prompt. You can enter the command you want to execute or enter HELP to get online help.

You can also start JAMSDBA with a command appending the command you want to execute to the command to start JAMSDBA, for example:

JAMSDBA UPDATE/LOG

Daylight Savings Time

SheilaE — Tue, 23 Mar 2010 18:28:36 GMT

JAMS automatically handles Daylight Savings Time adjustments based on the operating systems time-zone settings.

What happens to a job scheduled for 02:00 AM every day?

In the United States, when the clock is moved forward in the spring, no instance of 02:00 AM occurs, JAMS would immediately detect that the job scheduled for 02:00 AM is late at 03:00 AM and attempt to run the job immediately.

In the fall, when two occurrences of 02:00 AM occur, JAMS would schedule the 02:00 AM instance and understand that it has already generated the schedule to a given time. JAMS maintains how far it has advanced the schedule with the ScheduleUntil value of the its configuration settings. Because JAMS generates schedules and knows how far it has advanced a schedule, only one instance of the 02:00 AM job would run.

Displaying the OpenVMS Queue Entry Number

SheilaE — Tue, 23 Mar 2010 18:22:11 GMT

Normally, JAMS displays the JAMS entry number rather than the OpenVMS queue entry number, but you can change that. To change the entry number displayed in the JAMS character-cell interface, define the logical name JAMS_DISPLAY_VMS_ENTRY to be the value 1. For example:

$ DEFINE JAMS_DISPLAY_VMS_ENTRY 1

Monitoring Large Numbers of Jobs on OpenVMS

SheilaE — Tue, 23 Mar 2010 18:10:01 GMT

If you have large numbers of executing Jobs (more than 25) and large numbers of Jobs in the Schedule (thousands), you may have to increase the size of an internal buffer used by the Job Monitor (Monitor Current Jobs). If this buffer overflows, the Job Monitor will clear the list of Jobs and rebuild it. If the buffer overflows before the list can be rebuilt, the Job Monitor winds up looping.

You can increase the size of this buffer by defining the logical name JAMS_LISTENER_MESSAGE_COUNT. This logical must be an integer between 6 and 16. The default is 6 which should be enough for most environments. The following table shows the size of the buffers created for each possible value of the logical name. Each entry is 16 bytes long.

    6 = 64 entries
    7 = 128 entries
    8 = 256 entries
    9 = 512 entries
    10 = 1024 entries
    11 = 2048 entries
    12 = 4096 entries
    13 = 8192 entries
    14 = 16384 entries
    15 = 32768 entries
    16 = 65536 entries

Enabling Logs for File Watch Jobs

SheilaE — Tue, 23 Mar 2010 17:06:00 GMT

When JAMS needs to watch for a file using an Agent, it creates a temporary, hidden job that it sends to the Agent. By default, the log file for these jobs is disabled. You may need to enable these log files to resolve issues with Agent file watches. To do that:

Make sure that your Common.config file specifies a valid TempDirectory. Here is an example:

<?xml version="1.0" encoding="utf-8" ?>
<appSettings>
    <add key="TempDirectory" value="C:\Temp\"/>
    <add key="ErrorEMail" value="Joe@mvpsi.com"/>
    <add key="ConnectionString" value="Server=...
</appSettings>

You need to make sure that the TempDirectory key is there and that it points to a valid directory.

Start the JAMSDebugger.exe application. This tools lets you make configuration changes to the JAMS Services without restarting the service. Pull down the "Options" menu and pick "Settings". Scroll down until you find Service Name JAMSExecutor and Name FileWatch. Change the Setting to Verbose. Click OK.

This change only lasts until the JAMSExecutor is restarted. If you want to make the change permmanent, edit the JAMSExecutor.exe.config file and add:

<add name="FileWatch" Value="Verbose" />

to the existing list in the <system.diagnostics><switches>.

The JAMS Executor will now create a log file in the temp directory for every Agent file watch job. The file name will be FileWatch_GUID.log (where GUID is a random Guid).

Release Notes for JAMS V4.8.87

DanielS — Thu, 04 Mar 2010 10:32:55 GMT

This release includes:

Addresses an issue where the completion of a simple setup did not satisfy setup dependencies, only job dependencies.
A simple setup did not show dependencies in the Monitor tab.
Evaluating special dates included the time in the evaluation which could prevent setup job schedules from working properly.
The Monitor view could fail or display just a red X.

Formatting Date Parameters

TonyC — Tue, 02 Mar 2010 09:27:43 GMT

When supplying a date parameter, you might need a specific format for the date. While the JAMS Job Parameter Date Data Type does provide a variety of sample output formats, you can also specify your own.

For example, if you would like to remove the year from the output format, specify the following in the source tab of the job:

<<baseDate("MMdd")>>

Deploying Windows Agent fails with "The RPC server is unavailable"

JohnV — Fri, 08 Jan 2010 18:10:12 GMT

When deploying the JAMS Agent to a Windows machine, the DeployAgent job may fail with the error:

The RPC server is unavailable. (Exception from HRESULT: 0x800706BA)

This is usually the result of the firewall blocking access to remote management. On the target machine, open a command prompt as an adminstrator and execute this command:

netsh firewall set service RemoteAdmin

Note that if you have a 3rd party firewall, the procedure to allow remote administration will be different.

ActiveState Perl execution method

JohnV — Thu, 10 Dec 2009 18:16:23 GMT

Creating an execution method for ActiveState Perl is easy, simply create an execution method with a Type of Batch and a Command of:

perl.exe "{0}"

Using multiple temp directories with OpenVMS

JohnV — Fri, 13 Nov 2009 13:00:12 GMT

JAMS uses a temporary directory for storing temporary command procedures for parsed and jacketed jobs. If a VMS directory file gets too large performance can degrade. If you expect to have more than 800 to 1,000 parsed or jacketed jobs scheduled simultaneously, you should use more than one temporary directory.

To use more than one temporary directory you must create directories in the current JAMS temporary directory. The directories must be named TEMPn where n is the number of the directory. The numbers must begin at 1 and there may not be any gaps. After creating the directories, you then define the logical name JAMS_TEMP_DIRECTORY_COUNT to be the number of temporary directories you created. This logical must be defined with /SYSTEM and /EXECUTIVE. The following example assumes that the JAMS temporary directory is JAMSDSK:[JAMS.TEMP].

    $ CREATE/DIR JAMSDSK:[JAMS.TEMP.TEMP1]
    $ CREATE/DIR JAMSDSK:[JAMS.TEMP.TEMP2]
    $ CREATE/DIR JAMSDSK:[JAMS.TEMP.TEMP3]
    $ DEFINE/SYSTEM/EXEC JAMS_TEMP_DIRECTORY_COUNT 3

JAMS Time Specifications

DanielS — Wed, 11 Nov 2009 16:34:29 GMT

All time specifications within JAMS are entered in the standard Windows format of d.hh.mm (days.hours:minutes).

For example 7.03:13:55 is seven days, three hours, thirteen minutes, and fifty-five seconds.

Jobs fail with "There are no child processes to wait for"

JohnV — Tue, 29 Sep 2009 17:34:39 GMT

When trying to execute a large number of jobs simultaneously, jobs may fail with the message:

There are no child processes to wait for

This happens when the job cannot allocate a Windows desktop. Each JAMS job has its own non-interactive desktop. The size of a desktop is defined in the "SharedSection" portion of the registry key:

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\SubSystems\Windows

This registry key value contains many entries, one of them is the SharedSection value. A typlical SharedSection would be "SharedSection=1024,3072,512". The third value is the size in kilobytes of a non-interactive desktop.

Desktops ar allocated from the Windows SessionView. The size of the SessionView is defined byt the registry key:

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management\SessionViewSize

A typical value of this entry is 30 hex (48 decimal). This value is in megabytes.

If you have a SessionViewSize of 48MB and a non-interactive desktop size of 512KB, in theory, you could run 96 simultaneous jobs. But, Windows and other applications also need desktops so the real number is less than that.

If you have jobs failing with "There are no child processes to wait for" you have three choices:

1. Increase the size of the SessionViewSize registry entry. This will require a reboot.
2. Decrease the size of the third value of SharedSection. This will require a reboot and may affect non-interactrive applications that need a 512KB desktop.
3. Limit the number of simultaneous jobs. This can be done with a job limit on batch queues or with resources.

More information about Windows desktops can be found at:

http://support.microsoft.com/kb/126962

http://blogs.msdn.com/ntdebugging/archive/2007/01/04/desktop-heap-overview.aspx

Note that this applies to WIndows 2000, Windows Server 2003 and Windows XP. Windows Vista, Windows Server 2008 and WIndows 7 can dynamically adjust the size of SessionViewSize.

Release Notes for JAMS V4.8.42

DanielS — Mon, 28 Sep 2009 08:30:33 GMT

This release includes:

A new Execution Method to support File Transfer (FTP, SFTP or FTP/SSL).

This includes:

FTP - Classic FTP Support, great for internal use
FTPS - FTP over TLS/SSL, secure and reliable
SFTP - SSH File Transfer
SCP - Secure CP, a de facto standard

JAMS now has "fill-in-the-blank" FTP capability, allowing you to more easily manage and secure file transfers.

File Modified Dependency

DanielS — Wed, 26 Aug 2009 17:58:34 GMT

In addition to normal file dependencies that check for the existence, non-existence, or availability of a file, JAMS also supports watching for a file to be modified.

The following Powershell script will watch for a file to be modified, and loop until the file has been modified.

$sinceTime = Get-Date
while($true)
{
    $fileInfo = Get-ChildItem FileToCheck.txt
    if ($fileInfo.LastWriteTime -gt $sinceTime)
    {
        break;
    }
    write-host "Sleeping"
    start-sleep 10
}
write-host "File has changed"

Release Notes for JAMS V4.7.121

DanielS — Tue, 25 Aug 2009 14:54:36 GMT

This release includes:

A correction to ensure installation steps proceed in sequential order.

Moving the JAMS AgentX

DanielS — Fri, 21 Aug 2009 08:39:30 GMT

By default, JAMS AgentX will install itself to the $JAMS_HOME directory.

Some customers may prefer a different location. A good way to move the JAMSAgentX data directory is to first create the directory and make sure that it has permissions set to allow access by the accounts that will be executing jobs. Then, open the SSHAgent execution method, under the “Execution” tab, change the “Command:” field from “JAMSAgentX” to:

env ‘JAMS_HOME=/usr/JAMS’ JAMSAgentX

This example is using the directory /usr/JAMS, you can use anything you want.

Process Dependencies

DanielS — Thu, 20 Aug 2009 16:24:19 GMT

When JAMS allows you to make your jobs dependent upon a number of factors. Such as, Is that mission critical process running?

You can easily create a PowerShell job to test a wide array of conditions, for example:

$ProcessName = "abcxyz"

Get-Process -name $ProcessName

If the process cannot be found, the job will fail:

NoProcessFoundForGivenName,Microsoft.PowerShell.Commands.GetProcessCommand
Cannot find a process with the name 'abcxyz'. Verify the process name and call the cmdlet again.

Release Notes for JAMS V4.7.120

DanielS — Wed, 19 Aug 2009 12:34:08 GMT

This release includes:

Changed default Setup completion time back to 60 seconds and added the KeepCompletedExecuting config parameter (hidden).
Resolved a potential race condition in PowerShell commands.
Prevents the JAMSAgent service from failing if a process cannot be created.
If multiple jobs were started simultaneously on a multiprocessor machine, there was a potential for an index out of range exception.
In some cases, a manually submitted job did not appear in the Monitor view until the job changed state.
If you ran a JAMS report under an account that did not have access to the JAMS Server, the report failed but, the error message in the .LOG file said that the Report did not exist. It now says "Access denied by JAMS Access control list".

Release Notes for JAMS V4.6.93

DanielS — Wed, 19 Aug 2009 12:23:53 GMT

This release includes:

Improved installer to reduce the need for downloading MS SQLExpress for prospects.
Support for SQL authentication
In order to provide even better customer support, we have added a brief registration page to the JAMS installer.This will help MVP Systems Software support to identify and troubleshoot potential issues for both customers and prospects.
SMTP Server can be set from the Configuration button
Changes to configuration settings no longer require a restart of a service
Support message after successful install

Powershell Error Handling

DanielS — Wed, 19 Aug 2009 12:22:01 GMT

JAMS monitors Powershell script execution for more than just an exit code. We trap exceptions thrown by Powershell and look for error objects in the Powershell error pipeline. This provides better error handling possibilities than a simple exit code. Within Powershell, your script can do:

Throw “Your error message here”

And the JAMS job will fail and show a final status of “Your error message here”.

We check the return code from the process but, a value of 0 means that our PowerShell host worked properly (even though the PowerShell script may have failed). A return code other than 0 would indicate a problem with our host.

By setting the job's notify options, you can receive notification of non-terminating errors within Powershell scripts that might have completed with an exit code 0.

Release Notes for JAMS V4.7.117

DanielS — Fri, 14 Aug 2009 11:31:08 GMT

This release includes:

A correction for AritmeticException in the JAMSExecutor if a Scheduler of a 32 bit version of Windows executes a job on a 64 bit version of Windows and the job uses more than 4GB of memory
A correction using a 4.7 Scheduler with a 4.6 Agent (or vice versa) to ensure the .LOG information is always returned properly.
A correction for “Releasing” a job in a completed setup to eliminate “duplicate key” error.
A correction to eliminate a race condition that could cause PowerShell jobs run via the JAMS Agent to finish with the wrong completion status.
An enhancement to include application configuration files for the ReportGenerator and ReportDesigner.
An enhancement to the ReportGenerator to now use the SMTPServer setting from the Configuration settings.

Release Notes for JAMS V4.7.112

DanielS — Tue, 11 Aug 2009 11:36:20 GMT

This release includes:

Web Controls- A predefined sample JAMS web site and all of JAMS ASP.NET Web Controls are now included in the standard installation.
Graphical Job Diagram - You can now diagram Jobs and Setups, for an easy, logical understanding of a workflow.
Enhanced Installation- The setup process now includes all of the necessary components for using JAMS through the GUI or any web browser.
Enhanced GUI Usability- System, Job and Setup definitions can be displayed in a “tree” view to make it easier to understand the relationship between them.
Enhanced Audit Trail- JAMS now includes an easily queried Audit Trail of all object changes.
Management Display of all remote JAMS Agents- You can now add JAMS Agent definitions to manage where your JAMS Agents are deployed.
Interactive Desktop Jobs- JAMS Execution methods now support an “Interactive” option which allows jobs to run on the interactive desktop session.
Enhanced Execution Control- This release adds support for pointing to a default macro XML file allowing users to better manage their customized execution methods.
Job Log Search - You can now easily search job log files directly within the GUI.
Active Directory Search - You can now search for Active Directory users and groups when adding a User or editing ACLs.

JAMS TCP/IP Ports

DanielS — Fri, 07 Aug 2009 14:52:44 GMT

JAMS uses the following TCP/IP ports:

77	JAMSAgent.exe	The JAMS Agent listens on port 77 for requests from other machines running JAMS. These are requests to execute a job.
773	JAMSServer.exe	The JAMS Server listens on port 773 for connection requests from JAMS Clients.
2773	JAMSScheduler.exe	The JAMS Scheduler listens on port 2773 for connections from theJAMS Server and JAMS Debugger. This is usually confined to the localmachine.
3773	JAMSExecutor.exe	The JAMS Executor will listen on port 3773 for connections from theJAMS Scheduler and JAMS Debugger. This is usually confined to thelocal machine.

JAMS Agent Cluster Installation

DanielS — Fri, 07 Aug 2009 11:19:48 GMT

JAMS supports Windows Clusters in Active/Passive mode for the JAMSScheduler and JAMSExecutor services. The JAMSAgent and JAMSServer services can be configured in Active/Passive or Active/Active modes.

The following is a guide to installing JAMS Agents into Microsoft Cluster environments for high availability.

Begin by first installing the JAMS Agent to each node within the MS Cluster.

Next, you can add the JAMS Agent as a Generic Service within the High Availability Wizard.

Select the JAMS Agent service to add.

You can supply the name users will access this resource by, in this case Cluster1JAMS.

JAMS does not require any specific storage volume to be available.

JAMS does not require any Registry settings to be replicated.

The Summary page, you can select to View Report button to show you the steps taken to create the generic service resource.

Your JAMS Agent service will now appear as an online resource within the MS Cluster Manager.

Running Jobs on the Desktop

DanielS — Thu, 06 Aug 2009 16:10:04 GMT

JAMS supports running jobs on the interactive desktop session. This is done by setting the 'Interactive' check box on the Source tab of the Execution Method.

How do I set the SMTP Server?

DanielS — Thu, 06 Aug 2009 16:02:35 GMT

In the JAMS Client, on the "Management" tab of the ribbon bar, click the "Configuration" button. This will display a list of configuration settings. Find the setting named "SMTPServer" and double-click it to open the properties dialog. Enter the name of your SMTP server under the "Value" tab.

You can also set the SMTP server in the .NET Framework Machine.config file. This will apply to all applications on that machine which use the .NET Framework SmtpClient class (unless overridden). The Machine.config file is located in the C:\Windows\Microsoft.Net\Framework\v2.0.50727\Config directory. There is also a Machine.config.comments file in that directory which contains some documentation.

An example of specifying the SMTP configuration is:

<system.net>
    <mailSettings>
      <smtp deliveryMethod="Network">
        <network defaultCredentials="false" port="25" host="your.host.name.com" />
      </smtp>
    </mailSettings>
</system.net>

Halting a Setup Definition

DanielS — Thu, 30 Jul 2009 15:44:50 GMT

You can add the logic to halt the Setup work flow progression by specifying any specific exit code value as the Informational value.

In the Job definition, use the“Source Options” tab, and enter an integer value in the “Informational:”field, 411 in the example above.

Then, in the Setup definition, on that job, set the “MinimumCompletion Severity” to Success. When the job should halt the setup, itexits with the value you entered into the Informational field, otherwise itexits with 0.

Now when exit code 411 is returned by the job, the Setup Definition will halt on the Informational status returned by the job. At any point a user may release the next step of the Setup definition to allow the work flow to progress.

Adding Verbose Logging

DanielS — Tue, 28 Jul 2009 11:40:36 GMT

JAMS has the ability to increase the log detail level for any job.

By adding a Parameter called JAMSTraceLevel with a value of Verbose, you can receive more information about job in the job log. This is very handy when testing new jobs.

Setting The PowerShell Execution Policy

DanielS — Tue, 28 Jul 2009 11:39:37 GMT

To change the PowerShell Execution Policy you can execute the following from within the PowerShell command window:

Set-ExecutionPolicy Unrestricted

Or you can change the Execution Policy via the registry by navigating to the following:

HKLM\Software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell

Then locate string value ExecutionPolicy and add the value from the list below:

Restricted
AllSigned
RemoteSigned
Unrestricted

For example if you want to set your PowerShell execution policy for RemoteSigned add the following:

HKLM\Software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell
"ExecutionPolicy"="RemoteSigned"

Here you will find a list of the available PowerShell execution policies with a brief description of each:

AllSigned
All scripts as well as configuration files must be signed by a trusted publisher. This includes script on the local as well as remote machines.

Default
Uses the default Restricted policy.

RemoteSigned
All scripts as well as configuration files downloaded via the Internet must be signed by a trusted publisher.

Restricted
As mentioned this is the PowerShell default and will not allow you to execute scripts or load configuration files.

Unrestricted
This allows you to execute all scripts as well as load configuration files however if you download a script from the internet you are prompted to approve it before it can execute.

Convert CRON jobs into JAMS!!!

DanielS — Tue, 28 Jul 2009 11:37:48 GMT

You've seen the Windows Task Scheduler and SQL Agent conversion tools within JAMS, but did you know JAMS can also convert your CRON jobs from UNIX installations? This gives you an easy method of migrating all your existing UNIX jobs from various UNIX flavors into JAMS for a single point of management.

All you need is your crontab configuration file, and Cron2JAMS.exe, the free Unix Cron job converter tool for JAMS available here:

http://www.jamssupport.com/Downloads.aspx

AuthorizationManager Check Failed

DanielS — Tue, 28 Jul 2009 10:19:18 GMT

When running Powershell scripts, you may encounter issues authorizing these scripts through Microsoft's Powershell Execution Policy.

The following information from a job log indicates a failure to authorized a signed script:

RuntimeException

AuthorizationManager check failed.

At C:\ProgramFiles\MVPSI\JAMS\Agent\Temp\JAMSTemp4629D89.ps1:1 char:50

+ \\BRADY\E$\Scripts\Powershell\startup.ps1 <<<< \\BRADY\E$\Scripts\Powershell

You could consider adjusting the Execution Policy, but if appropriate policy is already configured, it may indicate a problem loading the Microsoft profile for this user account. It is recommended to log onto the target system using the JAMS service account (or User account from failed job if unique user account is specified) to ensure the Microsoft profile has been properly loaded.

Automatically Submitting Jobs

DanielS — Mon, 27 Jul 2009 12:59:36 GMT

When a job or setup definition should be automatically submitted to the schedule by the JAMS service, you can place a check mark next to the Automatically Submit option of the Schedule Options tab.

If the box is unchecked, JAMS will no longer automatically submit this definition at the schedule time, but instances of the job that are already in the schedule are not affected.

If the Automatically submit box is unchecked, the job\setup definition will not be submitted based on its schedule time, but can be submitted by a Trigger or by manually submitting.

SSH Key Management

DanielS — Wed, 22 Jul 2009 12:02:54 GMT

JAMS supports generating and loading SSH public\private key pairs directly within the GUI. You can load any existing Private key by selecting the Load Key button. You will then be prompted for the Privacy Enhanced Mail Certificate (*.pem) file.

Typically, the SSH public key is loaded on the Server (JAMS Agent) and the private key is loaded to the Client (JAMS Scheduler).

Getting Started with the JAMS Agent for Linux & UNIX

JohnV — Wed, 15 Jul 2009 14:11:55 GMT

The JAMS Agent for Linux & UNIX (JAMSAgentX) is installed on your Windows Server along with the JAMSScheduler. Each supported platform has a directory in the C:\Program Files\MVPSI\JAMS\Scheduler\Agents\ directory.

To install JAMSAgentX, you simply copy the correct executable to your Linux or UNIX server. We suggest copying JAMSAgentX into /usr/local/bin, /usr/bin or /bin but, you can install it any place as log as the Execution Method supplies the correct command.

JAMSAgentX keeps an internal database. By default, JAMSAgentX stores these files in the directory “.jams” in your home directory. If you’d prefer these files to be kept elsewhere, first create a symbolic link named “.jams” in your home directory which points to an alternate location. For example, to force JAMSAgentX to use “/var/tmp/.jams” for storage:

# cd
# ln -s /var/tmp/.jams

Upon initial execution, JAMSAgentX will automatically create this directory if it does not yet exist, along with any configuration files JAMSAgentX requires to run. To test that it runs properly, type “JAMSAgentX --verbose” into a terminal. Type “quit” to exit.

You should verify that the SSHAgent Execution Method (or your custom Execution Method) has the correct command to activate JAMSAgentX. Click the "Execution Method" button on the "Management" ribbon tab and double-click the SSHAgent Execution method. The Command field is located on the "Execution" tab of the Execution Method.

If JAMSAgentX is located in a directory that is in the PATH, the command should be "JAMSAgentX". Otherwise, you have to supply the full path to where you installed JAMSAgentX.

Updating Your JAMS License Key

DanielS — Tue, 07 Jul 2009 14:42:32 GMT

Once you have received your JAMS license key, you can apply the key by saving the license file to C:\Program Files\MVPSI\JAMS\Scheduler directory. That's it. You don't need to restart any of JAMS services.

You can check the status of your license key from theJAMS Client by picking "About -> JAMS Server..." then, click the"Status" tab. If you stillhave a valid demo key in the Scheduler directory the status will show that keyas active but, the production key will be automatically loaded when the demokey expires.

Can a Trigger submit a job each time a file arrives?

JohnV — Mon, 06 Jul 2009 12:44:14 GMT

A common requirement is to create a trigger that fires when a file arrives and submits a job that processes the file and then resets the trigger. This is simple, straight forward and reliable when you have a single file arriving but, what about the case when you could have many files arriving at the same time? How can JAMS handle that case?

This example will show you how you can combine JAMS' triggers and PowerShell snap-in to create a simple, straight forward and reliable system for handling this case.

First, we'll create a job to handle the incoming files. This is the job that the trigger will fire and, it's the most interesting piece of this example. Here is the PowerShell source for the job:

##  Add the JAMS PowerShell snapin#Add-PSSnapin MVPSI.JAMS -ErrorAction SilentlyContinue##  Get all of the files that matches the trigger#$fileList = Get-ChildItem C:\Incoming\*.dat##  Submit a JAMS Job to process each of the files#foreach ($file in $fileList){    #    # get the filename from the file object    #    $filename = $file.FullName    #    #  Submit the ProcessFile job.  This job must have a parameter named "filename"    #  The "-UseVariables" parameter tells Submit-JAMSEntry to look for a PowerShell    #  Variable that matches each parameter in the job and use the variable value    #  as the value for the parameter    #    $lastSubmit = Submit-JAMSEntry ProcessFile -UseVariable    #    #  Write some information to the log file    #    write-host "Entry " $lastSubmit.JAMSEntry " submitted to process $filename"}##  We have submitted a job to process each file,#  now we will wait for the last job that we submitted to complete.#$waitEntry = Get-JAMSEntry $lastSubmit.JAMSEntryWait-JAMSEntry $waitEntry -verbose##  The last entry that we submitted has completed so all of the files#  have been processed.  We will reset the trigger now to prepare for#  the next file arrival.  Note that if a new file arrived while we#  were waiting, the trigger will fire as soon as it is reset.#Reset-JAMSTrigger WatchForIncomingFiles

Now we can create the trigger definition that will submit this job when one or more matching files arrives. The trigger will have a single file event that should use a wildcard in the file name so that it matches all possible incoming files, for example "C:\Incoming\*.dat". The trigger will also have a single action, submitting the job we just created.

Also, make sure that you uncheck "Reset when fired" under the "Status" tab of the trigger. In general, triggers that have file watch events need to be manually reset with the Reset-JAMSTrigger command.

The last step is to create the "ProcessFile" job that actually processes a file. The job must have a parameter named "filename" which will contain the name of the file that the job should process. The job also has to delete, move or rename the file so it doesn't fire the trigger again.

That's all there is to it! Now, you can sit back at watch JAMS work!

Add-PSSnapin takes a long time to execute

JohnV — Wed, 01 Jul 2009 11:29:21 GMT

The Add-PSSnapin command should execute in less than a second. But, if your machine has restricted access to the Internet, it could take 60 to 90 seconds to execute. This delay occurs when PowerShell is verifying the digital signatures on the snap-in that is being loaded. To verify the signatures, PowerShell needs to download the certificate revocation list and, if Internet access is restricted, it can take 60 to 90 seconds for this attempt to time out.

You can disable the check for the certificate revocation list by doing:

- Open "Internet Options" in the Control Panel or Internet Explorer
- Click the "Advanced" tab
- Scroll down to "Security"
- UNcheck "Check for publisher's certificate revocation"
- UNcheck "Check for server certificate revocation"
- Click OK

Using the SQL Server Agent Job Monitor

ZachB — Fri, 03 Apr 2009 10:53:30 GMT

SQL Agent Tab

The SQL Agent Tab can be used to view information about the SQL Server Agent Jobs located on the computer running the JAMS Client, as well as jobs located on other servers.

Displaying Jobs

To view the Jobs installed on the current machine, simply select the SQL Agent Ribbon Bar Tab. Then, click the SQL Agent Jobs shortcut in the Shortcut bar to the left. By default, this will display all the SQL Agent Jobs currently configured on the local machine. If no Jobs are displayed, there may not be any SQL Agent Jobs configured on the current machine.

To display the configured Jobs on a remote machine, right click on the shortcut bar, and choose the Add Shortcut option. Enter a new name for the shortcut.

Next, select the Query tab. In the Server Name field, enter the name of the SQL Server instance to connect to.

Press OK to add the new shortcut to the shortcut bar. When the newly added shortcut is selected, the Jobs on the remote machine will be displayed. If no tasks are displayed, ensure that there are SQL Agent Jobs present on the remote instance.

SQL Server Versions

There are two supported versions of SQL Server Agent, SQL Server 2005 and SQL Server 2008. The version is use is determined by the SQL Server version currently installed along with the JAMS Client. If the Client is running on a machine with SQL Server 2008 installed, then it will be able to access Job information from other instances running SQL Server 2008. It will also be able to access Jobs from instances running SQL Server 2005.

However, if the Client is running on a machine with SQL Server 2005 installed, then it will only be able to access Job information from other instances running SQL Server 2005. The libraries required to access Jobs on SQL Server 2005 instances are not present, and therefore, no Job information can be retrieved from these instances.

Converting Jobs

It is very easy to convert a SQL Server Agent Job to a JAMS Job. Simply select a Job from the Job list, right click, and choose the Convert option. You can also use the Convert to JAMS button in the Ribbon Bar.

Note: Agent Job conversion requires a connection to a JAMS Scheduler. The free version of the JAMS Client does not support converting SQL Agent Jobs to JAMS Jobs. A licensed JAMS Scheduler is required.

A Conversion Wizard will now begin, which walks though all the steps required to convert an Agent Job to a JAMS job. On each step of the wizard, fields will be pre-populated with information from the selected SQL Agent Job. You can then change the retrieved information before the new JAMS Job is created.

Since some SQL Agent Jobs will contain multiple Job Steps, these Agent Jobs will be converted to JAMS Setups, with two or more Jobs.

Note: Not all options for a SQL Agent Job are supported by JAMS. If an option is not supported, then you may receive an error when advancing to the next conversion step. This is done so that you can appropriately change the property of the Job.

It is also possible to convert multiple SQL Agent Jobs at the same time. Just select several Agent Jobs from the Jobs list and click the Convert to JAMS button. This will start the Wizard for converting multiple Jobs. The first few steps will prompt for information common to all of the Jobs selected for conversion. The Wizard will then attempt to convert all of the selected Jobs to JAMS Jobs.

If a SQL Agent Job property cannot be directly converted to a JAMS Job property, then a new Wizard screen will be displayed so that the property can be changed accordingly. A Job which cannot be converted automatically can be Canceled individually.

Other Actions

SQL Agent Jobs can also be started, stopped, and deleted from the SQL Agent instance. Simply select a Job from the Job list and click the appropriate button on the Ribbon Bar.

Using the Task Scheduler Monitor

ZachB — Fri, 03 Apr 2009 10:53:03 GMT

Task Scheduler Tab

The Task Scheduler Tab can be used to view information about the Windows Task Scheduler Tasks located on the computer running the JAMS Client, as well as jobs located on other computers.

Displaying Tasks

To view the Tasks installed on the current machine, simply select the Task Scheduler Ribbon Bar Tab. Then, click the SchedulerTasks shortcut in the Shortcut bar to the left. By default, this will display all the Scheduler Tasks currently configured on the local machine. If no tasks are displayed, there may not be any Scheduler Tasks configured on the current machine.

To display the configured Tasks on a remote machine, right click on the shortcut bar, and choose the Add Shortcut option. Enter a new name for the shortcut.

Next, select the Query tab. In the Server Name field, enter the UNC path to the remote computer. For example \\ServerName.

Press OK to add the new shortcut to the shortcut bar. When the newly added shortcut is selected, the Tasks on the remote machine will be displayed. If no tasks are displayed, ensure that there are Task Scheduler Tasks present on the remote machine. Also, insure that your current user account has access to the Tasks on the remote machine.

Task Folders

If you are using Windows Vista or Server 2008, Task Scheduler supports the use of folders to organize Tasks. If the Folder field is left blank in the shortcut Query settings, then all the Tasks from all folders will be displayed. If you would like to limit the results, simply enter the path to the desired folder. Entering a single backslash "\" will display all of the Tasks in the root folder. In the below example, all Tasks within the \Microsoft\Windows\Defrag\ folder will be displayed.

Note: After changing the Query properties for a shortcut, you will need to select the Shortcut in the Shortcut Bar and press the Refresh button in order for the Query changes to take effect.

Scheduler Versions

There are two supported versions of Windows Scheduler. The version is use is determined by the Operating system on which the JAMS Client is installed. If the Client is running on Windows Vista or Server 2008, then it will be able to access Task information from other machines running Vista or Server 2008. It will also be able to access Tasks from machines running Windows XP or Server 2003.

However, if the Client is running on Windows XP or Server 2003, it will only be able to access Task information from other machines running XP or Server 2003. The libraries required to access Tasks on Vista and Server 2008 machines are not present, and therefore, no Task information can be retrieved from these servers.

Converting Tasks

It is very easy to convert a Task Scheduler Task to a JAMS Job. Simply select a Task from the Task list, right click, and choose the Convert option. You can also use the Convert to JAMS button in the Ribbon Bar.

Note: Task conversion requires a connection to a JAMS Scheduler. The free version of the JAMS Client does not support converting Tasks to JAMS Jobs. A licensed JAMS Scheduler is required.

A Conversion Wizard will now begin, which walks though all the steps required to convert a Task to a JAMS job. On each step of the wizard, fields will be pre-populated with information from the selected Task Scheduler Task. You can then change the retrieved information before the new JAMS Job is created.

Note: Not all options for a Task are supported by JAMS. If an option is not supported, then you may receive an error when advancing to the next conversion step. This is done so that you can appropriately change the property of the Job.

It is also possible to convert multiple Tasks at the same time. Just select several Tasks from the Task list and click the Convert to JAMS button. This will start the Wizard for converting multiple Tasks. The first few steps will prompt for information common to all of the Tasks selected for conversion. The Wizard will then attempt to convert all of the selected Tasks to JAMS Jobs.

If a Task property cannot be directly converted to a JAMS Job property, then a new Wizard screen will be displayed so that the property can be changed accordingly. A Task which cannot be converted automatically can be Canceled individually.

Other Actions

Tasks can also be started, stopped, and deleted from Task Scheduler. Simply select a Task from the Task list and click the appropriate button on the Ribbon Bar.

Using the Free JAMS Monitor

ZachB — Fri, 03 Apr 2009 10:34:10 GMT

The JAMS Client provides the ability to monitor and manage Windows Task Scheduler Tasks and SQL Server Agent Jobs. Both of these features can be used for free, with very little setup required. In order to use these features, you will need to install the free JAMS Client. The other components of JAMS are not required.

After installing JAMS Client, please refer to the following articles, which demonstrate how to configure and use the client to manage Windows Scheduler Tasks and SQL Server Agent Jobs.

Please note: In order to use the other features of the JAMS Client, a connection to a JAMS Scheduler is required. Only the Task Scheduler and SQL Agent tabs will work properly without a connection to a JAMS Scheduler. Also, some features, such as converting Tasks and SQL Jobs, will be unavailable without a JAMS Scheduler connection.

The JAMS Scheduler component does require a license. Please request additional information from our sales department.

Extending the SQLCMD execution method to work with any server

JohnV — Tue, 17 Mar 2009 17:20:45 GMT

The SQLCMD Execution Method executes SQL commands against the default SQL Server instance on the machine where the job is running. This article describes how you can create a new Execution Method which gets the SQL Server machine and instance from one of the job's parameters.

Note: The SQLCMDServer execution method is included in JAMS V4.6.28 or higher

We'll start by copying the SQLCMD Execution Method to a new Execution Method using the JAMS PowerShell snap-in and the following command (make sure you replace "YourServer" with the name of your JAMS Server):

PS C:\> copy JAMS::YourServer\Methods\SQLCMD JAMS::YourServer\Methods\SQLCMDServer

Now, open the SQLCMDServer Execution Method in the JAMS GUI, click the "Execution" tab and remove the "-S (local)" from the Command string. Save those changes and the SQLCMDServer execution method is ready to go.

With the SQLCMDServer execution method, you have to connect to a SQL Server instance in your job's source. You do that with the ":connect" command (don't forget the leading colon). You can use a specific Server name and instance or get them from a JAMS Parameter or Variable. Here are some examples:

:connect MySqlServer
:connect MySqlServer\SQLExpress
:connect <<SqlInstance>>
:connect MySqlServer -U Joe -P <<PasswordForJoe>>

How to Customize the Source Editor

JohnV — Thu, 19 Feb 2009 12:47:42 GMT

When using the JAMS Source Editor, it is possible to load a user created configuration file which allows you to create your own language syntax coloration rules. This can be especially useful if you’ve added a custom execution method, and would also like to support fully colorized syntax in the Source Editor. Instructions for defining a custom execution method can be found here: http://www.jamssupport.com/KnowledgebaseArticle50017.aspx

Custom colorization rules can be applied by using an XML document which specifies which words or characters belong to which color group. A sample XML document can be found below.

<?xml version="1.0" encoding="utf-8" ?>
<ArrayOfConfigLanguage>
<ConfigLanguage name="TestLang">
    <formats>
      <format name="Text" Font="Courier New, 10pt" FontColor="Black" />
      <format name="SelectedText" Font="Courier New, 10pt" BackColor="Highlight" FontColor="HighlightText" />
      <format name="Whitespace" Font="Courier New, 10pt" FontColor="Black" />
      <format name="KeyWord" Font="Courier New, 10pt" FontColor="Blue" />
    </formats>
    <extensions>
      <extension>foo</extension>
    </extensions>
    <lexems>
      <lexem BeginBlock="Test" Type="KeyWord" />
    </lexems>
    <splits>
      <split>+=</split>
    </splits>
</ConfigLanguage>
</ArrayOfConfigLanguage>

In this simple example configuration, notice the format name “KeyWord” has been specified, and the FontColor property has been set to Blue. Whenever a lexem is defined with the Type “KeyWord”, it will appear in the editor as Blue.
Save the above file in a location which can be accessed by your JAMS client. Now, edit the User.config file in the JAMSClient installation directory and add or edit a like like:

<add key="SourceEditConfig" value="C:\Path\To\Your\File.xml" />

To test the new configuration file, navigate to the Definitions tab, choose the Jobs shortcut, and Add a new job. Proceed to the Source editor screen. To test the new configuration settings, choose the Open File option and load a .foo file.

Notice the word “Test” appears in blue. Using this process, you can define additional lexems in the configuration file, as well as additional languages. Also, it is possible to override existing language definitions using this process. Just change the “name” property of the ConfigLanguage tag, and update the extension tag as well.
Some additional resources to help you in defining new language configurations can be found below:
http://help.syncfusion.com/ug_71/edit/default.html
http://help.syncfusion.com/ug_71/edit/HowDoICreateMyOwnLanguageConfigurationFile.html

Accessing JAMS from the Web

ZachB — Thu, 29 Jan 2009 13:05:38 GMT

JAMS is very extensible and can be customized and integrated into your own applications. This is also true of connecting to JAMS over the web. This guide will demonstrate how to connect to a JAMS server and submit jobs via a web page.

For this example, we will be creating a new ASP.NET Web Application. Name it JAMSWebParameters.

After creating a new project, open the web designer for Default.aspx. Add a couple of text boxes to the page and a button. These will be used to accept input from the user for job parameters, and start the new job instance.

Double click the button to move to the codebehind of the web page and add a new button click event. We will need to write some code which interacts with the JAMS system. Before we do so, we need to add a reference to JAMSShr.dll. Right click on the References folder in the Solution Explorer window, choose Add Reference, and then select the browse tab. The dll can be found at Program Files\MVPSI\JAMS\Client\JAMSShr.dll

Now that we have a reference added to the JAMS dll, we can start writing code which accesses the JAMS scheduler. The code to submit a job and set parameter values can be found below:

        protected void Button1_Click(object sender, EventArgs e)
        {
            //Accesses the JAMS server running on the local machine
            MVPSI.JAMS.Server server = MVPSI.JAMS.Server.GetServer("localhost");

            //Load the job we will be submitting
            Submit.Info si;
            Submit.Load(out si, "ReportProjectedSchedule", server, Submit.Type.Job);

            //Set the parameters which the job needs
            //Some of these will be obtained from the textboxes on the webpage
            si.Parameters["Server"].ParamValue = server.Name;
            si.Parameters["StartDate"].ParamValue = DateTime.Today;
            si.Parameters["EndDate"].ParamValue = DateTime.Today.AddDays(1);

si.Reports["ProjectedSchedule"].PrintQueue = TextBox1.Text;
si.Reports["ProjectedSchedule"].PrintForm = TextBox2.Text;

            //Submit the job
            si.Submit();

        }

Build and run the application. When the web page is displayed, you can enter the required information in the textboxes and click the submit button. This will submit a new job instance in the scheduler on the local machine.

This simple concept can be taken much further to fully leverage the programability of the JAMS system. All of the functionality of the client GUI is available to the developer. Using the API, a developer can display information about any JAMS object, such as Jobs, Setups, Systems, Variables, and Triggers. It is also possible to edit the definitions of any of these objects, if necessary. Below are a couple of code snippets which demonstrate how to retrieve a listing of Jobs from a JAMS server, and how to change values in a Job definition.

Retrieve a list of Jobs

        protected void Page_Load(object sender, EventArgs e)
        {
            Server server = new MVPSI.JAMS.Server("localhost");
            //The find method requires query information to find the jobs you are looking for
            JobList joblist = JobList.Find("*","*", server);
            //The list can now be bound to a web control datasource
            DataList1.DataSource = joblist;
            DataList1.DataBind();

        }

Change the definition of a Job

         protected void Page_Load(object sender, EventArgs e)
        {
            Server server = new MVPSI.JAMS.Server("localhost");
            //The find method requires query information to find the jobs you are looking for
            JobList joblist = JobList.Find("*","*", server);
            //The list can now be bound to a web control datasource
            DataList1.DataSource = joblist;
            DataList1.DataBind();

        }

        protected void Button1_Click1(object sender, EventArgs e)
        {
            //Connect to a server
            Server server = new MVPSI.JAMS.Server("localhost");
            //Get the job named DefragDisk
            Job job = new Job();
            Job.Load(out job, 9, server);

            //Start an Edit and set the new name
            job.BeginEdit();
            job.JobName = TextBox1.Text;

            //Submit the update to the server
            job.Update(server);
        }

The sample application described in this article can be downloaded from the attachments section of the page.

How to Integrate JAMS with a .NET Application

ZachB — Mon, 26 Jan 2009 11:40:36 GMT

JAMS can easily be extended to integrate with new or existing .NET applications. In this demonstration, we will be creating a new .NET class library which receives input from a JAMS job, and writes the output to a text file.

First, create a new Class Library solution in VS2008. It will be named JAMSIntegratedDLL.

Once the Solution is created, we will need to add a reference to the JAMSShr.dll. Right Click on the References folder in the Solution Explorer window, choose Add Reference…, click the Browse tab, and then navigate to \Program Files\MVPSI\JAMS\Agent\JAMSHostBase.dll.

Now that the reference has been added, we need to implement the MVPSI.JAMS.Host.IJAMSHost interface. Code which implements the interface can be found below. In this example, most of the method implementations will only be stubs and are not shown.

The Solution used in this example is also attached at the bottom of the page.

C#:

using System;

usingSystem.Collections.Generic;

usingSystem.IO;

usingSystem.Text;

usingMVPSI.JAMS.Host;

namespaceJAMSIntegratedDll

{

public class JAMSExecute: IJAMSHost

{

private FileStreamfs;

private FinalResultsresults;

#region IJAMSHost Members

public voidInitialize(IServiceProvider serviceProvider,Dictionary<string,object> attributes,

Dictionary<string,object> parameters)

{

results = new FinalResults();

//Initialize the text file.

try

{

fs = new FileStream(parameters["FileName"].ToString(), FileMode.Create);

}

catch (Exceptionex)

{

//An error occured during Initialize method

WriteErrorInfo(ex, "Initialize");

}

public FinalResultsExecute(IServiceProvider serviceProvider, Dictionary<string,object> attributes,

Dictionary<string,object> parameters)

{

//If there were no errors during Initialize

if (results.FinalSeverity != 3)

{

//Execute the job.

try

{

var encoding = newASCIIEncoding();

byte[] bytes = encoding.GetBytes(parameters["Message"].ToString());

fs.Write(bytes, 0, bytes.Length);

//No errors occured

results.FinalSeverity = 0;

results.FinalStatus = "The operation completedsuccessfully";

results.FinalStatusCode = 0;

}

catch (Exceptionex)

{

//An error occured during execution

WriteErrorInfo(ex, "Execute");

}

return results;

}

public void Cleanup(IServiceProvider serviceProvider, Dictionary<string,object> attributes,

Dictionary<string,object> parameters)

{

//Dispose of the FileStream

if (fs != null)

{

fs.Dispose();

}

#endregion

private voidWriteErrorInfo(Exception ex, string methodName)

{

//Any messages written to the Console will appear inthe JAMS Job log

Console.WriteLine(ex.ToString());

results.FinalSeverity = 3;

results.FinalStatus = "Execption occuredduring " + methodName;

results.FinalStatusCode = 1;

}

VB.NET:

Imports System.IO

ImportsMVPSI.JAMS.Host

ImportsSystem.Text

Public Class JAMSExecute

ImplementsIJAMSHost

Privatefs As FileStream

Privateresults As FinalResults

Public Sub Initialize (ByValserviceProvider As IServiceProvider, ByVal attributes AsDictionary(Of String,Object), _

ByVal parameters AsDictionary(Of String,Object)) ImplementsIJAMSHost.Initialize

results = New FinalResults()

'Initialize the text file.

Try

fs = New FileStream (parameters ("FileName").ToString(), FileMode.Create)

Catch ex As Exception

'An error occured during Initialize method

WriteErrorInfo (ex, "Initialize")

End Try

End Sub

Public Function Execute (ByValserviceProvider As IServiceProvider, ByVal attributes AsDictionary(Of String,Object), _

ByVal parameters AsDictionary(Of String,Object)) AsFinalResults _

Implements IJAMSHost.Execute

'If there were no errors during Initialize

If results.FinalSeverity <> 3 Then

'Execute the job.

Try

Dim convertEncoding AsASCIIEncoding = New ASCIIEncoding()

Dim bytes As Byte() = convertEncoding.GetBytes (parameters ("Message").ToString())

fs.Write (bytes, 0, bytes.Length)

'No errors occured

results.FinalSeverity = 0

results.FinalStatus = "The operation completedsuccessfully"

results.FinalStatusCode = 0

Catch ex AsException

'An error occured during execution

WriteErrorInfo (ex, "Execute")

End Try

End If

Return results

End Function

Public Sub Cleanup (ByValserviceProvider As IServiceProvider, ByVal attributes AsDictionary(Of String,Object), _

ByVal parameters AsDictionary(Of String,Object)) ImplementsIJAMSHost.Cleanup

'Dispose of the FileStream

If fs IsNot Nothing Then

fs.Dispose()

End If

End Sub

Private Sub WriteErrorInfo (ByValex As Exception, ByValmethodName As String)

'Any messages written to the Console will appear in theJAMS Job log

Console.WriteLine(ex.ToString())

results.FinalSeverity = 3

results.FinalStatus = "Execption occuredduring " + methodName

results.FinalStatusCode = 1

End Sub

End Class

After building the dll successfully, we need to move it to a location where the JAMS Scheduler is able to find it. Copy the JAMSIntegrated dll to the Program Files\MVPSI\JAMS\Scheduler directory. Alternatively, you can install the dll in the Global Assembly Cache. Instructions on how to do so can be found here: http://support.microsoft.com/kb/315682

Now we can create an execution method which uses the new dll. Open an instance of the JAMS Client and navigate to the Management tab. Then select Execution Methods. You will see a dialog containing all of the execution methods currently installed. We will be adding a new execution method, so click on the Add icon at the top of the dialog. This will launch the Add an Execution Method wizard. Fill in a name and description for the new method and hit Next.

Now, we need to select the Execution Type. This should be set to Routine.

After finishing the Wizard, double click on the new Execution Method in the listing to open its’ properties. Select the Execution tab. We now need to specify the Assembly and Class which we will be executing. These values will correspond to the dll we created earlier. The Assembly field should contain the name of the dll, and the Class field should contain the fully qualified name of the class which should be executed.

Now that we have an execution method defined, we can create a new job which uses the method. Change to the Definitions tab and click the Add button to start the Add a Job Definition wizard. Fill in the necessary properties for your job, making sure to select the newly created execution method. Once the new job has been created, open the definition and select the Parameters tab. We need to add the parameters which will be used in the execution of our assembly. Enter properties similar to the following to test the new execution method. Make sure the FileName path is valid.

Parameter Name	Default Value	Data Type	Prompt	Is Required?
FileName	C:\Temp\TestFile.txt	Text	File to write to	Yes
Message	This is a test message	Text	Message to write	No

Save the job definition. Then execute the newly created Job. The job should execute successfully. Open the text file which was written to the hard drive and ensure that the parameter message has been written properly.

This was a very simple example of creating a .NET dll for use with a JAMS Job. It should be very easy to use this same approach and add automated functionality to your own .NET applications.

The Solution used in this example is attached to this article.

How to Automatically Generate Reports

ZachB — Tue, 20 Jan 2009 16:43:17 GMT

This guide will show you how to automate the generation of reports using JAMS. JAMS makes it easy to add reporting to existing job definitions, or create new jobs which are used just to generate reports. We will be exploring both of these options in this guide.

Let’s take a look at the report definitions which are provided by default. You can view these reports in your JAMS Client by selecting the Reporting tab. To view the reports installed with JAMS, click the Open icon. You will now be presented with report categories, and the name of reports within each category. Also, note that you can open a standalone report file by clicking the File… button.

Select one of the default reports and click OK. The report parameters screen will now open. Here, you can specify different options for the report you have opened. Clicking the submit button will query the JAMS system and produce a report with the specified parameters. After running the report, note that you can export the document to several file formats using the Export To menu in the top right corner of the screen.

Using the reporting tab is an easy way to manually run reports against the JAMS system. It is also possible to run the same reports automatically, which will be demonstrated later in this guide.

If you would like to make changes to one of the default report layouts, or create your own report layout from scratch, you can do so in the Report Designer. To access the Report Designer, select the Definitions tab, and click the Report Designer icon. This will open a new window with the JAMS Report Designer. With this designer, it is possible to open an existing report definition, or create a new report. After creating a new report, you can save the report definition to the JAMS system, or to a file on the hard drive. Either way, the report can be loaded later on to view manually, or automatically, as part of a job.

When creating a new report, you will be asked to select the data source for the new report. These data sources are used to query different aspects of the JAMS system. Each data source comes with pre-defined parameters whose values can be changed in order to produce a different report output.

Now that we have an idea of what reports are available, and how to create new ones, we can go about integrating these reports with Jobs. There are several Jobs installed by default which produce reports. In this guide, we will be looking more closely at the ReportCurrentSchedule Job. Select the Definitions tab, and then the Jobs icon to display the job definitions on your system. Then double click the ReportCurrentSchedule job to open its properties. Select the Source Options tab. The Execution Method is set to Reports. This is a built-in execution method which generates report documents attached to a job. If you would like to extend other Execution Methods to provide this functionality, or create a new Execution Method which uses reports, you can find a useful guide here: http://www.jamssupport.com/KnowledgebaseArticle50017.aspx

Now, select the Reports tab in the Job definition. Here, you will see all the reports this job will produce, as well as a description. Select the CurrentSchedule report and click the Properties… button.

From this screen, we can change the default properties for this report. The Logical Name field is the location of the report definition which will be loaded at runtime and generated. Specify the location in the JAMS database by using the “Category\Report Name” format, or use a full filename to load a report definition stored on a hard drive.

The File Name field is the location a report output file will be saved to, once the report has been generated. Only specify the directory a report should be saved to. A filename and extension will be added automatically.

The Print Queue field can contain a list of email addresses to send the generated report file to. The different addresses should be separated by semi-colons or commas. If both the File Name and Print Queue fields are specified, then the report will be both saved and emailed to any listed recipients.

The Print Form field specifies which format to export the report to. The supported formats are: PDF, HTML, MHT, CSV, RTF, Text, or Xls. “Print” can also be specified, which will send the output of the document to the default printer.

Return to the Job Definitions screen and right click on the ReportCurrentSchedule job. Then select Submit. This will display the submit dialog for the selected job. This dialog contains several parameters which are the various options the report will use to query the JAMS database. Select the Reports tab to view the override options for the report settings. Here, the Print Queue and Print Form field values can be changed from the default values specified in the job definition. When the job is submitted, these final values will be used to determine how the job is exported and who the document is sent to.

The default report jobs included with the install of the JAMS client can be submitted manually, but they can also be scheduled to run at various times. It may be beneficial to know which jobs ran over the course of the previous day, or what the upcoming job schedule looks like. It is also easy to specify a report job as a Notification Job, or a Recovery Job.

Another way of integrating reporting with automated jobs is using the JAMSReportGenerator.exe. It is possible to specify the same report properties mentioned earlier, such as email list or export format in the Parameters of a parsed job which does not use the Reports execution method. Once these parameters are supplied, the report can be generated with a call to the JAMSReportGenerator.exe. This example uses the Parsed Windows Command procedure Execution Method.

Integrating reporting into JAMS provides an easy way to retrieve information and monitor how your JAMS system is performing on a routine basis. The methods which were used to generate reports in this guide can also be extended and customized to work exactly how they need to in many different situations.