MVP Systems - Support

Automating Outlook Tasks

TonyC — Tue, 09 Mar 2010 12:56:39 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.}
}

PowerShell Profile Settings

DanielS — Mon, 08 Mar 2010 14:56:05 GMT

You can define a PowerShell profile file to set common PowerShell settings, like automatically adding the JAMS PowerShell SnapIn, define 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

Release Notes for JAMS V4.9.93

DanielS — Thu, 04 Mar 2010 10:34:07 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

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.

Enabling logs for File Watch jobs

JohnV — Wed, 03 Mar 2010 19:20:26 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).

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")>>

Running SAS jobs

TonyC — Mon, 01 Mar 2010 09:40:15 GMT

JAMS can execute SAS programs with the Windows Command Procedure execution method.

Below is an example of a 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

Failover Scheduling Engine Installation

TonyC — Mon, 22 Feb 2010 16:06:06 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.97

VanessaB — Mon, 22 Feb 2010 08:46:46 GMT

This release includes:

Decreased 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.

Daylight Saving Time

TonyC — Thu, 18 Feb 2010 11:58:30 GMT

JAMS automatically handles Daylight Saving 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 schedule and knows how far it has advanced the schedule, only one instance of the 02:00 AM job would run.

Running Oracle Jobs

TonyC — Tue, 09 Feb 2010 15:27:59 GMT

JAMS runs Oracle batch jobs though 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

Deploying JAMS Agents

TonyC — Mon, 08 Feb 2010 11:14:34 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 schedule.

Killing a Runaway Job

DanielS — Mon, 08 Feb 2010 09:28:17 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

Release Notes for JAMS V4.9.91

VanessaB — Wed, 03 Feb 2010 21:03:39 GMT

This release includes:

A correction for Long running setups that did not do Runaway notification.
A correction for PowerShell jobs 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.86

VanessaB — Thu, 21 Jan 2010 11:46: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, your 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 that the job had 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.76

VanessaB — Tue, 12 Jan 2010 09:11:00 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 updates to current schedule of any newly added jobs
The ability to Trigger complex Setup definitions

This release also addresses the following issues:

Addressed a synchronization issue that could cause 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 from dependencies.
When the JAMSScheduler started, there was a failover delay even if failover wasn't configured.
Added support for MaxContentSize, MaxQueuedItems and MaxTotalSize config settings for JAMSShr.
The Monitor view didn't update unless a job moved or you changed the selection.

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.

ASP.NET Impersonation and JAMS Web Interface

VanessaB — Thu, 17 Dec 2009 11:28:06 GMT

In order for ASP.NET to properly authenticated 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>

Windows Vista and Windows 7 Security

TonyC — Thu, 17 Dec 2009 08:00:51 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.

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}"

Release Notes for JAMS V4.8.82

DanielS — Tue, 17 Nov 2009 12:00:04 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.

Displaying the OpenVMS queue entry number

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

Normally, JAMS displayes the JAMS entry number rather than the OpenVMS queue entry number but, you cna change that. To change the entery 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

JohnV — Fri, 13 Nov 2009 13:04:47 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

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.

Adding Syslog Capability

DanielS — Tue, 10 Nov 2009 19:27:19 GMT

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

Learn more about customizing execution methods 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.

JAMSDBA Utility

DanielS — Tue, 03 Nov 2009 13:50:09 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 for to get on-line 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

JAMS Command Line Environment

DanielS — Thu, 29 Oct 2009 11:36:12 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 that it supports. Type HELP COMMAND to get help on a particular command (For Example: HELP EXPORT JOB).

Client GUI Settings

DanielS — Fri, 23 Oct 2009 11:45:01 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.

Release Notes for JAMS V4.8.73

DanielS — Thu, 22 Oct 2009 08:12:56 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 improved database lock handling for improved concurrency.
An enhancement to improve retry handling when a connection is dropped between the JAMS Executor and JAMSAgentX.
An issue is resolved passing File transfer credentials to a JAMS Agent.

Email notification in Powershell

DanielS — Tue, 20 Oct 2009 16:44:18 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)

Multiple Schedules

DanielS — Thu, 15 Oct 2009 13:50:48 GMT

Job and Setup definitions in JAMS can more than one schedule assigned in a comma separated list. This allows for creating more complex schedules.

Recommended Server Specifications

DanielS — Wed, 14 Oct 2009 09:57:15 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. 10,000jobs per hour) will require more resources.

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

Removing System Level Notification

DanielS — Wed, 07 Oct 2009 16:25:55 GMT

Within 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.

Moving the JAMS SQL Database

DanielS — Wed, 07 Oct 2009 14:29:02 GMT

The process for moving the SQL database used by JAMS does not require re-installing 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. Re-start the JAMS Scheduler service from the Windows control panel services applet.

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

For Windows Authetication:

<?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>

Force Job to Abort?

DanielS — Tue, 06 Oct 2009 11:47:27 GMT

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

The difference between checking "Force job to abort" depends on the execution method. In most cases, it doesn't make any difference.
For PowerShell jobs or MS Workflow jobs, when unchecked we ask PowerShell to stop running the script. When checked, we kill the process.

Release Notes for JAMS V4.8.57

DanielS — Mon, 05 Oct 2009 09:57:29 GMT

This release includes:

An enhancement to the JAMSAgent to improve restarting when jobs are executing.
An enhancement to support JAMSAgentX 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.

Permissions to Convert SQL Agent Jobs

DanielS — Fri, 02 Oct 2009 14:38:06 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 in which 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'

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.50

DanielS — Mon, 28 Sep 2009 08:31:07 GMT

This release includes:

•    A correction to the Failover Engine which 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 shutdown.
•    A correction to prevent service failure if a Trigger was deleted while we were watching for a file, and file arrives shortly after.

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.

Setting A JAMS Variable

DanielS — Wed, 23 Sep 2009 11:37:24 GMT

There a 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"

Report Designer CHM

JohnV — Fri, 18 Sep 2009 10:18:26 GMT

Documentation on the JAMS Report Designer and other Winforms controls in Windows Compiled Help (CHM) format.

Download Report Designer Documentation

Report Designer PDF

JohnV — Fri, 18 Sep 2009 10:11:37 GMT

Documentation on the JAMS Report Designer and other Winforms controls in Portable Document Format (PDF).

Download Report Designer Documentation

Deleting Jobs from the Schedule

DanielS — Thu, 27 Aug 2009 12:13:53 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.

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

Editing a Setup definition fails with primary key violation

JohnV — Fri, 17 Apr 2009 12:10:30 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. The problem that causes this corruption was addressed in JAMS V4.4 but, you may still have corruption in the database. 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.

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.

How to Create a Custom Parsed Execution Method

ZachB — Fri, 16 Jan 2009 13:29:12 GMT

Creating a custom execution method can be very helpful in customizing how JAMS runs jobs. It is possible to utilize a technology which JAMS does not interface with out of the box, or modify an existing execution method to add, or customize functionality. In this guide, we will copy an existing execution method and modify how it runs jobs.

You can find a list of the JAMS execution methods by selecting the Management tab, and then clicking on the Execution Methods icon.

For this example, we will be copying the Parsed Windows Command procedure to a new execution method and adding some custom functionality.

First, we need to create a new execution method in JAMS. We can add a new execution method by clicking on the Add icon in the above dialog. This will start the JAMS Execution Method Definition Wizard. In the wizard, we must specify a unique name. Also, we can enter a description of the new method.

Next, we must specify an Execution Type. We will be selecting Batch.

The new execution method will now be added to the execution method list. We can now edit the new definition further. Open the definition and select the Source tab. In Job Module field, enter the name of the template library which will be used. We will be creating a new one later in this example called CustomParsed. Also, enter cmd as the Default File Extension.

Now, select the Execution tab. In the Command field, enter “cmd.exe /c "{0}"”.

There are other properties which may be needed for other execution methods. A full list of the available execution method properties, and descriptions of the properties can be found here: http://www.mvpsi.com/doc/JAMSClient/MethodsProperties.html

Now that we have created a new entry in JAMS for our custom execution method, we need to create a new Job Module in the BaseMacros.xml file. This file provides JAMS with a template for parsing a Job’s command procedure. To add a new entry to the file, open the BaseMacros.xml file which is located in C:\Program Files\MVPSI\JAMS\Scheduler\BaseMacros.xml

Since we are adding functionality to an existing execution method, we can copy the existing macro for Parsed jobs. This is the first Macro entry in the file.

<Macro name="Parsed">
    <Code>
         <![CDATA[REM JAMS Parsed Macro <%Symbol(JAMS.Parameters)%>
         <<JAMS.Source>>
         exit %errorlevel% ]]>
    </Code>
</Macro>

Copy and paste this code back into the BaseMacros.xml file, inside of the <ArrayOfMacro> tags. We will now change the macro to provide our custom functionality. First, we need to change the name of the macro to match the execution method’s Job Module property. In this example, it is “CustomParsed”. Next, we can begin changing the macro. When a job executes, the code contained within the “<Code><![CDATA[“ tags will be evaluated by JAMS, and then sent to where the execution method properties specify.

JAMS can retrieve data from the job currently executing. This data is then used to execute the job. Data is contained within the <<>> tags. JAMS can also evaluate and insert other macros, which are contained in the <%%> tags.

In this example code, the JAMS.Parameters collection, and the JAMS.Source property are being referenced. The objects you can retrieve data from are as follows:

System	The Job or Setup’s JAMS System
Setup	Only accessible when running a Setup
Job	Only accessible when running a Job
SetupJob	Only accessible when running a Setup
Current	The CurJob object
Node	A NodeInfo object
Source	The Source property provided by the Job
NotifyEMail	The final list of email addresses to be notified. This is a combination of e-mail addresses from the DefaultNotifyEmail config setting, System, Setup, and Job notify lists.

You can reference any of the above objects starting by starting with “JAMS.”. So, if we want to retrieve a description of the System this job is running under, we would use <<JAMS.System.Description>> in our macro. It is possible to access any public property from any of the above objects. If one of the above objects are not specified, the Current object is inserted. So, in the macro source, <<JAMS.JobName >> and <<JAMS.Current. JobName >> would evaluate to the same value. The properties of the above objects can be found in our documentation, here: http://www.mvpsi.com/doc/ProgrammerReference/Default.html

Parameters and variable values can also be accessed. If you do not start out the reference with “JAMS.”, the value of a Parameter or JAMS variable will be used instead, if one is found. So, if your job specifies a parameter named “FileLocation”, you can access the value from the macro by using “<<FileLocation>>”.

It is also possible to add formatting to a value. For example, we could use <<JAMS.Current.StartTime(”d”)>> to format the StartTime of the Current job in a Short Date pattern. Any format supported by the .NET String.Format method can be used. A listing of these formats can be found here: http://msdn.microsoft.com/en-us/library/fbxft59x.aspx

Macro tags will insert another macro from within the BaseMacros.xml file. They can be used with any object which supports the IEnumerable interface. In this example, the Symbol macro is used.

<%Symbol(JAMS.Parameters)%>

It will be inserted once for each of the JAMS.Parameters which are retrieved from the job at execution time. The Symbol macro is as follows:

Once inside of a sub macro, you can access the properties of the current object within the enumeration by specifying the property name within angle brackets. So, for each parameter in the JAMS.Current.Parameters collection, the Symbol macro is inserted. Then, the values of the NAME and VALUE properties are retrieved and inserted into the SET line.

When the default Parsed macro is executed, it looks similar to this:

C:\Windows\system32>REM JAMS Parsed Macro

C:\Windows\system32>SET Param1=Value1

C:\Windows\system32>SET Param2=Value1

C:\Windows\system32>REM Source of Job inserted here

C:\Windows\system32>exit 0

Now that we have an understanding of how the parsing works, we can modify the default to add some custom functionality. We will be adding a couple of lines to the beginning of the job execution to better log what job is being executed. Make the highlighted changes to the CustomParsed macro we pasted into the BaseMacros.xml file.

<Macro name="CustomParsed">
    <Code>
         <![CDATA[REM JAMS Custom Parsed Macro
         REM Job Name: <<JAMS.Current.JobName>>
         REM Job Description: <<JAMS.Job.Description>>
         REM Running under System: <<JAMS.System.SystemName>>
         <%Symbol(JAMS.Parameters)%>
         <<JAMS.Source>>
         exit %errorlevel% ]]>
    </Code>
</Macro>

Now, save the BaseMacros.xml file. In order for the new macro to be used, the JAMSScheduler service must be restarted. This must be done every time a change is made to the BaseMacros.xml file, or the changes will not take effect when job runs. This can be done in Windows PowerShell using the command Restart-Service JAMSScheduler.

Once the service has restarted, we can create a new job to test the execution method we just made, or change the execution method of an existing job. This property can be found in the Source Options tab of a job definition.

Note: If you do not see the CustomParsed Execution method in the dialog, you may need to hit the Refresh button in order for the newly created method to appear.

Now, submit the job and view the resulting log file when the job completes. You can now see that the additional information we inserted in the BaseMacros.xml file has been parsed, and the additional logging comments have been displayed successfully.

Description of the JobState Enum type

ZachB — Wed, 14 Jan 2009 15:35:47 GMT

The life cycle of a JAMS Job istracked by the JobState property. The following list describes whathappens as a job moves through each of the states.

Scheduled

The job has just been added tothe schedule and the JAMSSchedule service has not looked at it. The jobwill be in this state for only a short period of time. When theJAMSSceduler service looks at the job, it will advance the JobState to Held.

Held

If the job has been “Held untilreleased”, it will stay in the Held state until it is manually released. If the job has not been held, it will advance to either Timed or StepWaitstate. If the job is a subjob of a Setup, it advances to StepWaitotherwise, it advances to timed.

Timed

The job is waiting for itsscheduled time to arrive and/or waiting for its Schedule Window to open. When the scheduled time arrives, the job’s dependencies are evaluated and theJobState is advanced to DependencyWait

StepWait

The job is waiting for its Setupto advance to the job’s step. When the Setup does, the job’s JobState isadvanced to DependencyWait.

DependencyWait

The job is waiting for all ofits dependencies to be satisfied. When they are satisfied, the JobStateis advanced to PrecheckWait.

PrecheckWait

The job’s Precheck job issubmitted (if there is one). When the job completes successfully, theJobState is advanced to ResourceWait. If the precheck job is notsuccessful, it is resubmitted after a delay. If the job does not have aprecheck job, the JobState advances to ResourceWait.

ResourceWait

The job is waiting for resourcesor a queue job limit slot. When resources and queue slot are available,the JobState is advanced to Pending.

Pending

The job is ready to run. Send the information the to the JAMS Executor service and advance the JobStateto Starting

Starting

Waiting for the completion ofthe JAMSExecutor remote procedure call. When it completes, the JobStateis advanced to Executing

Executing

The job is executing.

Idle

The job is still logically“executing” but, it is idle while waiting for an event. There is nolonger a process or executable associated with the job, the job’s processnotified us before exiting that is was not done, it was just going idle while waitingfor an event. This state is only used by Workflow Foundation jobs.

Completed

The job is done. Allprocesses associated with the job have completed. We leave the job in theCompleted state for 60 seconds before either deleting all traces of the job oradvancing the job state to CompletedKept

CompletedKept

The job is done but is beingretained in the schedule for awhile. The amount of time to keep the jobin the schedule could be specified in the job’s retain options, the job’ssystem’s retain options or the KeepCompleted Configuration setting.

Rescheduling

The Rescheduling JobState is nolonger used.

Missing

While a job is executing theJAMSScheduler service will periodically ask the JAMSExecutor service to thestatus of the job. If the JAMSExecuter doesn’t have the job, theJAMSScheduler changes the JobState to missing. A job in the MissingJobState will eventually be handled as a failed job and the job state willchange to Completed.

SQL Server Express install fails

JohnV — Tue, 30 Sep 2008 11:40:16 GMT

The JAMS Scheduler for Windows requires Microsoft's SQL Server. The JAMS Setup kits will install SQL Server Express Edition if SQL Server is not already installed. There is a known problem with Microsoft's SQL Server setup which causes the installation to fail if the SQL Server Native Client is already installed. To work around this problem you have to uninstall the SQL Server Native Client and then rerun the JAMS Setup.

This issue is documented is section 2.1 of this knowledgebase article:

http://support.microsoft.com/kb/910229/en-us

How do I get the Windows client working with an OpenVMS server?

JohnV — Wed, 17 Sep 2008 17:21:04 GMT

The JAMS Windows based client tools can connect to either a Windows or OpenVMS based JAMS Server. To connect to an OpenVMS Server, you must install and configure the JAMS OpenVMS Connector. This guide will help you install, configure and troubleshoot the JAMS OpenVMS Connector.

JAMS Services fail to start

JohnV — Fri, 05 Sep 2008 14:09:14 GMT

There is a potential problem with the Microsoft .NET Framework that can prevent the JAMS Services from starting. The .NET Framework verifies an executable images digital signature when a service starts. During this verification the Framework downloads a certificate revokation list from:

http://crl.microsoft.com/pki/crl/products/CSPCA.crl

If internet access is slow or access to this URL is blocked, the service may fail to start because the Service Control Manager times out waiting for the image to start.

Here is a link to a Microsoft Knowledgebase article that talks about the problem:

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

This Knowledgebase article describes how to increase the service timeout value which could be a way to work around this issue:

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

Options for specifying the JAMS Server in PowerShell

JohnV — Tue, 26 Aug 2008 12:49:59 GMT

If you're using the JAMS Snapin for PowerShell you've already found that every cmdlet has a "-Server" parameter that you can use to specify which JAMS Server should be used. However, you probably don't want to use it! The -Server parameter is fine when you want to explicitly specify the JAMS Server but it's easier to use one of the defaults.

Here's how a JAMS cmdlet determines which JAMS Server it should use:

Was -Server specified on the command line?
Is the $JAMSDefaultServer PowerShell variable defined?
Is our current default location a JAMS Provider drive?
Are we being executed as batch job by a JAMS Server?
Pick the first first JAMS Provider drive.
Throw an exception.

Setting $JAMSDefaultServer is what we usually use when working interactively. You might want to set that in your PowerShell profile but, be careful or you'll break option 4. Option 4, checking to see if the cmdlet is being executed as a JAMS job, may be the most interesting option. The idea is to make it easy to use JAMS cmdlets in your jobs without requiring any changes when the job moves from a test server to a production server.

So, how can you set $JAMSDefaultServer in your profile without breaking the default host option? Simple, just check for the $Host.PrivateData. When JAMS executes a job, it creates a HostName property in $Host.PrivateData so you can do this in your profile:

if ($Host.PrivateData.HostName -eq $null)
{
$JAMSDefaultServer = "MyJAMSServer"
}

Are there any issues with OpenVMS V8.3?

JohnV — Mon, 25 Aug 2008 21:16:04 GMT

There are a couple of issues with VMS V8.3 but, they’re minor and it’s likely that you won’t run into them. The fixes for these issues are in JAMS V4.2K (and later).

If it’s not convenient to upgrade JAMS, you can avoid the issues by doing two things, first:

Make sure that your SYSUAF file does not have global buffers enabled. You can check this by doing:

$ SET DEFAULT SYS$SYSTEM
$ DIR/FULL SYSUAF

Look at “File attributes:”, the last item is the number of global buffers. If that is greater than 0, set it to zero with:

$ SET FILE/NOGLOBAL SYSUAF

The second this is:

Check the value of your CTLPAGES setting by doing:

$ WRITE SYS$OUTPUT F$GETSYI(“CTLPAGES”)

Define the JAMS_SPARE_CTLPAGES logical name to be 40% of the value of CTLPAGES so, if CTLPAGES was 1056, you would do:

$ DEFINE/SYSTEM/EXEC JAMS_SPARE_CTLPAGES 422

Let us know if you have any questions or problems.

Getting started with PowerShell

BobS — Mon, 25 Aug 2008 17:33:18 GMT

PowerShell is Microsoft's new scripting and command line environment. It's a teriffic tool that will change the way that you manage your Windows machines. This article will help you get started using the JAMS PowerShell snap-in.

Before you can use the JAMS PowerShell snap-in, you have to have PowerShell. If you don't already have PowerShell, you can download it from:

http://www.Microsoft.com/PowerShell

This is also a good place to learn about PowerShell.

Once you have PowerShell installed, you have to make sure that you have to JAMS PowerShell snap-in installed. If you installed the JAMS Client before PowerShell you must reinstall the JAMS Client to get the PowerShell snap-in.

Before you can use a PowerShell snap-in, you have to add it to your PowerShell environment. You do that with the Add-PSSnapin cmdlet. Add the JAMS Snap-in like this:

PS C:\> Add-PSSnapin MVPSI.JAMS

To get a list of the commands in the JAMS Snapin, enter:

PS C:> Get-Command -PSSnapIn MVPSI.JAMS

To get help on any of those commands (or any other PowerShell command), try:

PS C:\> Get-Help the-command-you-want-help-with

How do I shrink the history file?

JohnV — Mon, 25 Aug 2008 10:40:48 GMT

Purging JAMS history should be completely automated. When JAMS is initially installed, a job named JAMS_PURGE is created which is scheduled to run every Sunday. This job purges the JAMS History and then does a CONVERT/RECLAIM on the HIST.DAT file to reclaim space from the deleted records.

You should verify that the JAMS_PURGE job is successfully running.

If JAMS_PURGE is running, it could be that you're keeping more history than you want. You can adjust the default values for the parameters to JAMS_PURGE to change the amount of history you keep.

It could also be that the HIST.DAT file grew so large because of an unusual event and the file is mostly free space. The JAMS_PURGE job won't shrink the physical size of the file. To shrink the file while preserving the history, do this:

$ MCR JAMS_EXE:JAMS_MASTER STOP SCHEDULE/NORESTART
$ SET DEFAULT JAMS_DATA:
$ ANALYZE/RMS/FDL/OUTPUT=HISTOPT.FDL HIST.DAT
$ EDIT/FDL/NOINTERACTIVE/ANALYSIS=HISTOPT.FDL HISTOPT.FDL
$ CONVERT/FDL=HISTOPT.FDL/STATS/NOSORT HIST.DAT HIST.DAT
$ PURGE HIST.DAT
$ MCR JAMS_EXE:JAMS_MASTER START SCHEDULE

Note that this make take a LONG time.

If you don't really care about the history and you just want to quickly shrink the file, do this:

$ MCR JAMS_EXE:JAMS_MASTER STOP SCHEDULE/NORESTART
$ SET DEFAULT JAMS_DATA:
$ DELETE HIST.DAT;*
$ CREATE/FDL=HIST.FDL HIST.DAT
$ MCR JAMS_EXE:JAMS_MASTER START SCHEDULE

This is quick but, IT WILL DELETE ALL OF YOUR HISTORY.