Skip to main content

1E 23.7 (SaaS)

SLA management groups and rule expressions

SLA management groups and rule expressions.

These are the same as the rule-based and direct-based management groups seen in the Tachyon Portal UI. They are referred to as SLA because management groups depend upon the inventory features provided by SLA components of the Tachyon Platform.

For information on the PowerShell Toolkit cmdlets available for the management of SLA management groups, please refer to Instruction management cmdlets.

Note

Changes in Tachyon v8

Rule expressions have been significantly enhanced in Tachyon Platform v8 to support operator precedence, so that you can, effectively, group terms by using brackets to prioritize how they are evaluated. In previous releases this was not possible.

Management groups changed in Tachyon Platform v8.0. For more information on the changes, please refer to Management group changes in Tachyon v8.

About rule expressions

Within the Tachyon Settings UI, you will be able to define new management group rules graphically. However, when you are programmatically creating rules you will naturally want to express your rules as simple text expressions which you can pass to the appropriate cmdlets on the command line.

You build management group rule expressions in a very similar way to building Tachyon scope or filter expressions.

  • Scope expressions allow you to define a target set of devices for an instruction, which meet the criteria associated with the scope expression.

  • Filter expressions allow you to define how results from an instruction will be filtered, before being returned to the caller.

  • Management group rule expressions allow you to define a set of criteria which will control the devices that are associated with the specified management group.

Expressions use a set of attributes . For scope and filter expressions, these attributes are defined on the page Using scope and filter expressions with the Tachyon PowerShell Toolkit.

Rule expression attributes

A rule expression consists of a set of attributes which can be compared with values. To get a full set of attributes that are allowed, you can use the Get-TachyonSLAManagementGroupRuleAttribute cmdlet

233276749.png
Attributes and data sources

While you can always specify any attribute in a rule expression, be aware that some data sources do not populate these attributes. For example, Active Directory attributes, such as Organizational Unit, are only captured from data sources such as Microsoft SCCM, which collect them.

For more information on which attributes are available from the different data sources, please refer to Management groups rules.

Extending attributes using device tags

Tachyon supports a mechanism for assigning custom tags and values to a device population. Device tags have a name and one or more values. For a discussion of device tags in Tachyon, please refer to Using device tags with the Tachyon PowerShell Toolkit.

When a device tag is created in Tachyon, it automatically becomes available as a rule expression attribute. You can then refer to the device tag in a rule expression and compare it to a value or values to determine management group membership.

For example, suppose you create a device tag named DomainRole with an initial value DatabaseServer.

add-tachyondevicetag -name DomainRole -Value DatabaseServer

233276745.png

If you now use the Get-TachyonSLAManagementGroupRuleAttribute cmdlet to list all available attributes, you see a new attribute listed for the new coverage tag, called ReportDeviceTag.DomainRole. You can now refer to this tag in a rule expression.

233276746.png
Rule expression operators

Rule expressions support a set of operators which are defined in the table below. The UI operator column shows you the terminology that is used in the management group maintenance user interface, for these operators.

However, internally rules are encoded and stored using the operators defined below.

Operator

Supported datatpyes

Description

UI Operators

LIKE

String

Matches a string pattern using the normal syntax. For example, LIKE %abc% matches any string which contains 'abc'

Contains

Begins With

Ends With

(see note)

NOT LIKE

String

Matches any string pattern that does NOT match the LIKE pattern. For example, NOT LIKE %abc% will match any string that does not contain 'abc'

Not Contains

IN

Coverage/Device Tag

Matches a value list which is contained within brackets (parentheses). For example, IN (abc,def) matches any string which equals 'abc' or 'def'

Is One Of

NOT IN

Coverage/Device Tag

Matches any string which is outside the specified value list. For example, NOT IN (abc,def) matches any string which is not either 'abc' or 'def'

Is Not One Of

>

Number, Date

Matches any string or integer value which collates to be greater than the entity being tested

Greater than (number)

After (date)

<

Number, Date

Matches any string or integer value which collates to be less than the entity being tested

Less than (number)

Before (date)

>=

Number

Matches any string or integer value which collates to be greater than or equal to the entity being tested

Greater than or equal to

<=

Number

Matches any string or integer value which collates to be less than or equal to the entity being tested

Less than or equal to

==

String, Date, Number, Yes/No

Matches any string or integer value which collates to be equal to the entity being tested

Equal To

=

String, Date, Number, Yes/No

This is a convenience synonym for the == operator

Equal To

!=

String, Date, Number

Matches any string or integer value which collates to be not equal to the entity being tested

Not Equal To

IS NULL

String, Date, Number, Tag

Matches any entity that evaluates to NULL. Note that no comparison value is provided for this operator

Is Null

IS NOT NULL

String, Date, Number, Tag

Matches any entity that evaluates to NOT NULL. Note that no comparison value is provided for this operator

Is Not Null

Note

The UI operator Contains is equivalent to LIKE %string%

The UI operator Begins With is equivalent to LIKE string%

The UI operator Ends With is equivalent to LIKE %string

The UI operator Not Contains is equivalent to NOT LIKE %string%

Example rule expressions

Some simple examples are shown below. Note that expressions may use the AND and OR boolean operators to combine terms, and use brackets, or nested brackets, to determine operator precedence. You can combine multiple attributes in a rule expression, not just one, as in the simple examples

Note that you cannot compare one attribute with another. All comparisons are to constant values, not other attributes.

ReportDevice.Fqdn = abc

ReportDevice.Fqdn is not null

ReportDevice.Fqdn like %abc% or ReportDevice.Fqdn like %def%

ReportDevice.Fqdn like %abc% or (ReportDevice.Fqdn like %def% and ReportDevice.Fqdn not like %pqr%)

ReportDevice.Fqdn in (abc,def,ghi)
Retrieving the JSON model for direct use with the Management Group APIs

The Management Group APIs do not directly accept rule expressions in human-readable format. They accept the rule expression as a JSON model, which is a representation of the expression. To obtain a JSON model for a particular expression, you can use the Get-TachyonSLAManagementGroupRule cmdlet as shown below.

233276750.png
Notes on syntax differences between rule expressions and scope and filter expressions

The PowerShell toolkit expression parser is unified to accept either a rule expression, a scope expression or a filter expression, and to produce an internal JSON model for consumption by the appropriate APIs. There are some small syntax differences between the API sets which you should be aware of.

If you submit an expression containing one of these operators, the underlying API may reject it, depending on whether you are using the expression for scoping or filtering, or for defining a management group rule.

  • The scope and filter APIs do not accept IN, NOT IN, or NOT LIKE. You can express NOT LIKE %abc% as NOT(LIKE %abc%) however, for these APIs

  • The Management Group APIs do not accept the NOT operator as a standalone operator, so that you cannot negate a term using NOT()