Files Reference

Resource_Data_Input File

Purpose

Input file for passing both resource class and resource attribute names and values to the resource monitoring and control (RMC) command-line interface (CLI). The data in this file is used for defining resources or for changing persistent attribute values of a resource or resource class.

Description

The Resource_Data_Input file is used in conjunction with the -f command-line flag to pass resource persistent attribute values to the RMC CLI in cases where using the command line directly would be too cumbersome or too prone to typographical errors. This file has no set location. It can be a temporary file or a permanent file, depending on requirements.

The mkrsrc and chrsrc commands read this file when they are issued with the -f flag. The lsrsrcdef and lsactdef commands generate a file with this format when issued with the -i flag.

PersistentResourceAttributes

Persistent attribute names and values for one or more resources for a specific resource class used to define a new resource or change attribute values for an existing resource. The persistent resource attributes are read in by the commands mkrsrc and chrsrc. These attributes are ignored if the input file is read by the chrsrc command that has been specified with the -c flag.

PersistentResourceClassAttributes

Persistent attribute names and values for a resource class used to change the attribute values of an existing resource class. The persistent resource class attributes are read in by the command chrsrc only when the -c flag is specified.

In general, the Resource_Data_Input file is a flat text file with the following format (bold words are literal). Text that precedes a single colon (:) is an arbitrary label and can be any alphanumeric text.

PersistentResourceAttributes::
# This is a comment
    label:
      AttrName1  = value 
      AttrName2  = value 
      AttrName3  = value 
    another label:
        Name        = name
        NodeNumber  = 1
		...
	::

PersistentResourceClassAttributes::
    label:
      SomeSettableAttrName 		= value
      SomeOtherSettableAttrName 	= value
    ::
...

See the Examples section for more details.

Some notes about formatting follow:

• The keywords PersistentResourceAttributes and PersistentResourceClassAttributes are followed by a double colon (::).
• The order of the keyword stanzas is not significant in the file. For example, PersistentResourceClassAttributes could precede PersistentResourceClass. It does not affect the portion of the data that is read in by the calling CLI.
• Individual stanza headings (beneath the keywords) are followed by a single colon (:), for example: c175n05 resource info:
• White space at the beginning of lines is not significant. Tabs or spaces are suggested for readability.
• Any line with a pound sign (#) as the first printable character is is a comment.
• Each entry on an individual line is separated by white space (spaces or tabs).
• Blank lines in the file are not significant and are suggested for readability.
• There is no limit to the number of resource attribute stanzas included in a particular PersistentResourceAttributes section.
• There is no limit to the number of resource class attribute stanzas included in a particular PersistentResourceClassAttributes section. Typically, there is only one instance of a resource class. In this case, only one stanza is expected.
• If only one resource attribute stanza is included in a particular PersistentResourceAttributes section, the label: line can be omitted.
• If only one resource class attribute stanza is included in a particular PersistentResourceClassAttributes section, the label: line can be omitted.
• Values that contain spaces must be enclosed in quotation marks.
• A double colon (::) indicates the end of a section. If a terminating double colon is not found, the next Reserved Keyword or end of file signals the end of a section.
• Double quotation marks included within a string that is surrounded by double quotation marks must be escaped. (\").
  Note:
  Double quotation marks can be nested within single quotation marks.
  These are examples:
  • "Name == \"testing\""
  • 'Name == "testing"'

    This syntax is preferred if your string is a selection string and you are going to cut and paste to the command line.

• Single quotation marks included within a string that is surrounded by single quotation marks must be escaped. (\').
  Note:
  Single quotation marks can be nested within double quotation marks.
  These are examples:
  • 'Isn\'t that true'
  • "Isn't that true"

    This syntax is preferred if you are going to cut and paste to the command line.

• The format you use to enter data in the Resource_Data_Input file may not be the same format used on the command line. The shell you choose to run the commands in has its own rules with regard to quotation marks. Refer to the documentation for your shell for these rules, which determine how to enter data on the command line.

Examples

1. This sample mkrsrc command:

   mkrsrc -f /tmp/my_resource_data_input_file IBM.Foo

   uses the sample input file /tmp/my_resource_data_input_file for the IBM.Foo resource class. The contents of the input file look like this:

   PersistentResourceAttributes::
   # Resource 1 - only set required attributes
   resource 1:
       Name="c175n04"
       NodeList = {1}
   # Resource 2 - setting both required and optional attributes
   # mkrsrc -e2 IBM.Foo displays required and optional
   # persistent attributes
   resource 2:
       Name="c175n05"
       NodeList = {1}
       Int32 = -99
       Uint32 = 99
       Int64 = -123456789123456789
       Uint64 = 123456789123456789
       Float32 = -9.89
       Float64 = 123456789.123456789
       String = "testing 123"
       Binary = 0xaabbccddeeff
       RH = "0x0000 0x0000 0x00000000 0x00000000 0x00000000 0x00000000"
       SD = [hello,1,{2,4,6,8}]
       Int32Array = {-4, -3, -2, -1, 0, 1, 2, 3, 4}
       Int64Array = {-4,-3,-2,-1,0,1,2,3,4}
       Uint32Array = {0,1,2,3,4,5,6}
       Uint64Array = {0,1,2,3,4,5,6}
       Float32Array = {-3.3, -2.2, -1.2, 0, 1, 2.2, 3.3}
       Float64Array = {-3.3, -2.2, -1.2, 0, 1, 2.2, 3.3}
       StringArray = {abc,"do re mi", 123}
       BinaryArray = {"0x01", "0x02", "0x0304"}
       RHArray     = {"0x0000 0x0000 0x00000000 0x00000000 0x00000000 0x00000000",
                      "0xaaaa 0xaaaa 0xbbbbbbbb 0xcccccccc 0xdddddddd 0xeeeeeeee"}
       SDArray     = {[hello,1,{0,1,2,3}],[hello2,2,{2,4,6,8}]}
       
   

2. This sample chrsrc command:

   chrsrc -f  /tmp/Foo/ch_resources -s 'Name == "c175n05"' IBM.Foo

   uses the sample input file /tmp/Foo/ch_resources to change the attribute values of existing IBM.Foo resources. The contents of the input file look like this:

   PersistentResourceAttributes::
   # Changing resources that match the selection string entered
   # when running chrsrc command.
   	resource 1:
           String            = "this is a string test" 
           Int32Array        = {10,-20,30,-40,50,-60} 
   

Location

/usr/sbin/rsct/bin/Resource_Data_Input

Contains the Resource_Data_Input file

Files

Related Information

The chrsrc, lsactdef, lsrsrcdef, and mkrsrc commands.

rmccli File

Purpose

Provides global information for the resource monitoring and control (RMC) command-line interface (CLI).

Description

This man page provides global information for the resource monitoring and control (RMC) command-line interface (CLI), including data types, terminology, and references to other related material.

Terminology

Common terminology used in the RMC CLI man pages:

attribute

Attributes are either persistent or dynamic. A resource class is defined by a set of persistent and dynamic attributes. A resource is also defined by a set of persistent and dynamic attributes. Persistent attributes define the configuration of the resource class and resource. Dynamic attributes define a state or a performance-related aspect of the resource class and resource. In the same resource class or resource, a given attribute name can be specified as either persistent or dynamic, but not both.

resource

An entity in the system that provides a set of services. Examples of hardware entities are processors, disk drives, memory, and adapters. Examples of software entities are database applications, processes, and file systems. Each resource in the system has one or more attributes that define the state of the resource.

resource class

A broad category of system resource, for example: node, file system, adapter. Each resource class has a container that holds the functions, information, dynamic attributes, and conditions that apply to that resource class. For example, the "/tmp space used" condition applies to a file system resource class.

resource manager

A process that maps resource and resource-class abstractions into calls and commands for one or more specific types of resources. A resource manager can be a standalone daemon, or it can be integrated into an application or a subsystem directly.

To see all of the resource classes defined in the system, run the lsrsrc command without any flags or parameters. To see all of the resources defined in the system for the IBM.FileSystem resource class, run the command: lsrsrc IBM.FileSystem.

selection string

Must be enclosed within either double or single quotation marks. If the selection string contains double quotation marks, enclose the entire selection string in single quotation marks, for example:

-s 'Name == "testing"'

-s 'Name ?= "test"'

Only persistent attributes can be listed in a selection string. For information on how to specify selection strings, see the RSCT Administration Guide.

Data display information

The flags that control the display function for the RMC CLI routines, in order of precedence, are:

1. -l for long display. This is the default display format.

   For example, the command:

   lsrsrc -s 'Name == "c175n05"' IBM.Foo Name NodeList SD Binary RH Int32Array

   produces output that looks like this:

   Persistent Attributes for Resource: IBM.Foo
   resource 1:
           Name       = "c175n05"
           NodeList   = {1}
           SD         = ["testing 1 2 3",1,{0,1,2}]
           Binary     = "0xaabbcc00 0xeeff"
           RH         = "0x0000 0x0000 0x00000000 0x00000000 0x00000000 0x00000000"
           Int32Array = {1,5,-10,1000000}

2. -t for tabular display.

   For example, the command:

   lsrsrc -s 'Name ?= "Page"' -t IBM.Condition Name EventExpression

   produces output that looks like this:

   Persistent Attributes for Resource: IBM.Condition
   
   Name                  EventExpression       
   "Page space out rate" "VMPgSpOutRate > 500" 
   "Page fault rate"     "VMPgFaultRate > 500" 
   "Page out rate"       "VMPgOutRate > 500"   
   "Page in rate"        "VMPgInRate > 500"    
   "Page space in rate"  "VMPgSpInRate > 500"  

3. -x for suppressing headers when printing.
4. -d for colon (:) delimited display.

   For example, the command:

   lsrsrc -xd -s 'Name == "c175n05"' IBM.Foo Name Int32 Uint32Array SD Binary 

   produces output similar to:

   c175n05:-100:{}:["hel  lo1",1,{0,1,2}]:"0xaabbcc00 0xeeff":

   Note the use of the -x flag along with the -d flag.

5. -D delimiter for string-delimited display.

   For example, the command:

   lsrsrc -xD:: -s 'Name == "c175n05"' IBM.Foo Name Int32 Uint32Array SD Binary 

   produces output similar to:

   c175n05::-100::{}::["hel  lo1",1,{0,1,2}]::"0xaabbcc00 0xeeff"::

   Note the use of the -x flag along with the -D Delimiter flag.

When output of any list command (lsrsrc, lsrsrcdef) is displayed in the tabular output format, the printing column width may be truncated. If more characters need to be displayed (as in the case of strings) use the -l flag to display the entire field.

Data input formatting

Binary data may be input in the following formats:

• "0x######## 0x######## 0x####..."
• "0x###################..."
• 0x################...

Be careful when you specify strings as input data:

• Strings that contain no white space or non-alphanumeric characters can be entered as input without enclosing quotation marks.
• Strings that contain white space or other alphanumeric characters must be enclosed in quotation marks.
• Strings that contain single quotation marks (') must be enclosed by double quotation marks ("), as shown in this example: "this is a string with 'single quotations marks'"

Selection strings must be enclosed in double quotation marks, unless the selection string itself contains double quotation marks, in which case the selection string must be enclosed in single quotation marks. For information on how to specify selection strings, see the RSCT Administration Guide.

• Sample selection string input: "NodeNumber == 1".
• Selection string input where double quotation marks are part of the selection string: 'Name == "c175n05"'.

Structured data (SD) types must be enclosed in square brackets: [hello,1,{2,4,6,8}]

When supplying structured data (SD) as command-line input to the RMC commands, enclose the SD in single quotation marks: SD='[hello,1,{2,4,6,8}]'

Arrays of any type must be enclosed in braces {}:

• Array of integers: {-4, -3, -2, -1, 0, 1, 2, 3, 4}
• Array of strings: {abc, "do re mi", 123}
• Array of structured data: {[hello,1,{0,1,2,3}],[hello2,2,{2,4,6,8}]}

Arrays of any type, with more than one element, must be enclosed in quotation marks. For example:

• mkrsrc IBM.Foo Name=testing NodeList={1} Uint32Array='{1,2,3}'
• mkrsrc IBM.Foo Name=testing NodeList='{1}' Uint32_array='{1,2,3}'

Arrays of strings and arrays of structured data must always be enclosed in quotation marks.

When supplying arrays of structured data or arrays containing strings enclosed in quotation marks as command-line input to the RMC commands, enclose the entire array in single quotation marks:

• Array of strings: mkrsrc IBM.Foo Name="c175n05" NodeList={1} StringArray='{"a string","a different string"}'
• Array of structured data: mkrsrc IBM.Foo Name="c175n05" NodeList={1} SDArray='{["string 1",1,{1,1}],["string 2",2,{1,2,3}]}'

For more examples, refer to the Resource_Data_Input file.

Data output formatting

String data is always displayed in either double or single quotation marks, as shown below:

• A description attribute that equals the string "This is a string that contains white space" is displayed using long format as:

  Description = "This is a string that contains white space"

• A description attribute value that equals an empty string "" is displayed in long format as:

  Description = "" 

• A description attribute value that equals a string that contains a new-line character at the end of the string is displayed in long format as:

  Description = "This string ends with a new - line character...
  "   

• A selection string containing double quotation marks is displayed in long format as:

  SelectionString = 'Name == "c175n05"'

• A name attribute value that equals the string "c175n05" is displayed in long format as:

  Name = "c175n05"

Binary data is displayed as follows:

"0x######## 0x######## 0x######## 0x###..."

Naming and numbering conventions

The following keywords are used throughout the RMC command man pages:

attr

The name of a resource class or resource attribute.

resource_class

The name of a resource class.

Command structure and use

The RMC commands may be grouped into categories representing the different operations that can be performed on resource classes and resources:

• Creating and removing: mkrsrc, rmrsrc
• Modifying: chrsrc, refrsrc
• Viewing definitions and data: lsrsrc, lsrsrcdef
• Viewing actions: lsactdef

The RMC commands can be run directly from the command line or called by user-written scripts. In addition, the RMC commands are used as the basis for higher-level commands, such as the event response resource manager (ERRM) command line interface.

Flags

-h

Writes the command's usage statement to standard output.

-T

Writes this command's trace messages to standard error. For your software-service organization's use only.

-V

Writes this command's verbose messages to standard output.

All RMC commands support a -V and -T flag. The -V flag is used to see additional information (verbose mode) regarding the command. Verbose messages are contained in message catalogs and are translated based on the locale in which you are running and other criteria.

Run a command with the -T flag only when your software service organization instructs you to turn tracing on. Trace messages are not translated. The -T flag shows the calls and returns to and from the underlying Perl to C Extensions.

Environment Variables

CT_CONTACT

When the CT_CONTACT environment variable is set to a host name or IP address, the command contacts the resource monitoring and control (RMC) daemon on the specified host. If the environment variable is not set, the command contacts the RMC daemon on the local system where the command is being run. The resource class or resources that are displayed or modified by the command are located on the system to which the connection is established.

CT_MANAGEMENT_SCOPE

Determines the management scope that is used for the session with the RMC daemon to monitor and control the resources and resource classes. The management scope determines the set of possible target nodes where the resources and resource classes can be monitored and controlled. The valid values are:

0

Specifies local scope.

1

Specifies local scope.

2

Specifies peer domain scope.

3

Specifies management domain scope.

If this environment variable is not set, local scope is used.

Examples

1. This sample mkrsrc command:

   mkrsrc -f /tmp/my_resource_data_input_file IBM.Foo

   uses the sample input file /tmp/my_resource_data_input_file for the IBM.Foo resource class. The contents of the input file look like this:

   PersistentResourceAttributes::
   # Resource 1 - only set required attributes
   resource 1:
       Name="c175n04"
       NodeList = {1}
   # Resource 2 - setting both required and optional attributes
   # mkrsrc -e2 IBM.Foo displays required and optional
   # persistent attributes
   resource 2:
       Name="c175n05"
       NodeList = {1}
       Int32 = -99
       Uint32 = 99
       Int64 = -123456789123456789
       Uint64 = 123456789123456789
       Float32 = -9.89
       Float64 = 123456789.123456789
       String = "testing 123"
       Binary = 0xaabbccddeeff
       RH = "0x0000 0x0000 0x00000000 0x00000000 0x00000000 0x00000000"
       SD = [hello,1,{2,4,6,8}]
       Int32Array = {-4, -3, -2, -1, 0, 1, 2, 3, 4}
       Int64Array = {-4,-3,-2,-1,0,1,2,3,4}
       Uint32Array = {0,1,2,3,4,5,6}
       Uint64Array = {0,1,2,3,4,5,6}
       Float32Array = {-3.3, -2.2, -1.2, 0, 1, 2.2, 3.3}
       Float64Array = {-3.3, -2.2, -1.2, 0, 1, 2.2, 3.3}
       StringArray = {abc,"do re mi", 123}
       BinaryArray = {"0x01", "0x02", "0x0304"}
       RHArray     = {"0x0000 0x0000 0x00000000 0x00000000 0x00000000 0x00000000",
                      "0xaaaa 0xaaaa 0xbbbbbbbb 0xcccccccc 0xdddddddd 0xeeeeeeee"}
       SDArray     = {[hello,1,{0,1,2,3}],[hello2,2,{2,4,6,8}]}
       
   

2. This sample chrsrc command:

   chrsrc -f  /tmp/Foo/ch_resources -s 'Name == "c175n05"' IBM.Foo

   uses the sample input file /tmp/Foo/ch_resources to change the attribute values of existing IBM.Foo resources. The contents of the input file look like this:

   PersistentResourceAttributes::
   # Changing resources that match the selection string entered
   # when running chrsrc command.
   	resource 1:
           String            = "this is a string test" 
           Int32Array        = {10,-20,30,-40,50,-60} 
   

Location

/usr/sbin/rsct/bin/rmccli

Contains the rmccli file

Related Information

Files: Resource_Data_Input

Books: see the RSCT Administration Guide for information about RMC operations