clmgr command

Purpose

The clmgr command provides a consistent, reliable interface for performing PowerHA® SystemMirror® for Linux cluster operations by using a terminal or script.

Syntax

The command uses the following syntax:
clmgr {[-c|-d <DELIMITER>] [-S] | [-x]}  
[-v][-f][-T <#####>]
[-l {error|standard|low|med|high|max}][-a 
{<ATTR#1>,<ATTR#2>,...}] <ACTION> <CLASS> [<NAME>]
[-h | <ATTR#1>=<VALUE#1> <ATTR#2>=<VALUE#2> <ATTR#n>=<VALUE#n>]


clmgr {[-c|-d <DELIMITER>] [-S] | [-x]} 
[-v][-f] [-T <#####>]
[-l {error|standard|low|med|high|max}][-a {<ATTR#1>,<ATTR#2>,...}]
ACTION={add|modify|delete|query|online|offline|...}
CLASS={cluster|node|network|resource_group|...}

clmgr {-h|-?} [-v] [<ACTION>[ <CLASS>]]
clmgr [-v] help
The clmgr command uses the following basic format: 
clmgr <ACTION> <CLASS> [<NAME>] [<ATTRIBUTES...>]
You can use the built-in help option for the clmgr command from the command line interface. For example, when you run the clmgr command without specifying any flags or parameters, a list of the available ACTION flags are displayed. If you enter the clmgr ACTION command without specifying the CLASS object, a list of all the available CLASS objects for the specified ACTION flag is displayed. If you enter the clmgr ACTION CLASS command without specifying any NAME or ATTRIBUTES options, different output is displayed because few ACTION+CLASS combinations do not require any additional parameters. To display help information in this scenario, you must explicitly append the -h flag to the clmgr ACTION CLASS command. You cannot display help information from the command line for individual attributes of the clmgr commands.

Description

The clmgr command provides consistent syntax for easy use. In addition, the clmgr command provides consistent return codes for easier scripting. Several output formats are also provided for data queries to collect cluster information.

All clmgr command operations are logged in the clutils.log file, including the name of the command that was run, the commands start time and stop time, and the username that initiated the command.

Flags

ACTION
Describes the operation to be performed.
Note: The ACTION flag is not case-sensitive. All ACTION flags provide a shorter alias. For example, rm is an alias for delete action. Aliases are provided for convenience from the command line and must not be used in scripts.
The following four ACTION flags are available on almost all the supported CLASS objects:
  • add (Alias: a, cr*, make, mk, bu*, bld)
  • query (Alias: q*, ls, get, l, sh*)
  • modify (Alias: mod, ch, set)
  • delete (Alias: de*, rem*, rm , er*)
The following ACTION flags are typically supported only on a subset of the supported CLASS objects:
  • Cluster, node, resource group:
    • start (Alias: online, on*)
    • stop (Alias: offline, of*, dea*)
  • Resource group:
    • move (Alias: mov*, mv)
  • Log:
    • manage (Alias: ma, mg)
  • Cluster:
    • verify (Alias: ve)
  • Log:
    • view (Alias: vi)
  • Smart_Assist:
    • setup
    • update
  • Snapshot:
    • manage (Alias: ma, mg)
    • view (Alias: vi)
  • Application, service_ip, file_system, resource_group:
    • reset
CLASS
The type of object upon which the value that you specified for the ACTION flag is performed.
Note: The CLASS flag is not case-sensitive. All CLASS objects provide a shorter alias. For example, cl is an alias for Cluster. Aliases are provided for convenience from the command line and must not be used in scripts.
The complete list of supported CLASS objects follows:
  • cluster (Alias: cl*)
  • node (Alias: no*, nd)
  • interface (Alias: int*)
  • network (Alias: ne*, nw)
  • resource_group (resource_g*, rg)
  • service_ip (se*, si)
  • persistent_ip (Alias: pe*, pi)
  • application (Alias: ac, app*, as)
  • dependency (Alias: de*)
  • file_collection (Alias: file_c*, fc)
  • file_system (Alias: file_s*, fs)
  • snapshot (Alias: sn*, ss, ba*)
  • user (Alias: us*, ur)
  • group (Alias: gr*, gp)
  • equivalency (Alias: eq*)
  • nfs_client (Alias: nfs, nfsc, nfs_c*)
  • log (Alias: logs)
  • smart_assist (Alias: sm*, sa)
  • logical_volume(Alias: lv, logi*)
NAME
The specific object, of type CLASS, upon which the ACTION flag must be performed.
ATTR=VALUE
An optional flag that has attribute and value pairs that are specific to the ACTION+CLASS combination. Use these pairs to specify configuration settings or to adjust particular operations.
When this flag is used with the query ACTION flag, the ATTR=VALUE specifications can be used to perform attribute-based searching and filtering. In which case, you can use simple wildcard characters. The asterisk (*) wildcard character searches for any characters. For example, if I use a search term of "HO*" the search results that are returned are "HOT", "HOST", and "HOSTNAME". The question mark (?) wildcard character searches for a single character. For example, if I use a search term of "HA?" the search result returned are "HAT", "HAM".
Note: An ATTR attribute does not need to be fully typed. Only the number of leading characters that are required to uniquely identify the attribute from the set of available attributes for the specified operation must be specified.
-a
Displays only the specified attributes, and is valid only with the query, add, and modify ACTION flags. Attribute names are not case-sensitive, and can be used with the standard UNIX wildcard characters such as an asterisk (*) and question mark (?).
-c
Displays all data in colon-delimited format, and is valid only with the query, add, and modify ACTION flags.
-d
Valid only with the query, add, and modify ACTION flags, requests all data to be displayed in delimited format, by using the specified delimiter.
-f
Overrides any interactive prompts, forcing the current operation to be attempted (if forcing the operation is a possibility).
-h
Displays help information.
-l
Activates the following trace log values for serviceability:
Error
Updates the log file only if an error is detected.
Standard
Logs basic information for every clmgr operation.
Low
Performs basic entry and exit tracing for every function.
Med
Performs med tracing, adding function entry parameters, and function return values.
High
Performs high tracing, adding tracing to every line of execution, omitting routine, and utility functions.
Max
Performs maximum tracing, adding the routine function and utility function. Adds a time and date stamp to the function entry message and exit message.
Note: All trace data is written into the clutils.log file. This flag is used for troubleshooting problems.
-S
Displays data without column headers, and is valid only with the query ACTION flag and the -c flag.
-T
A transaction ID is applied to all logged output to help group one or more activities into a single section of output that can be extracted from the log file for analysis. This flag is used for troubleshooting problems.
-v
Displays maximum verbosity in the output.
Note: Displays all instances of the specified class, when this flag is used with the query ACTION flag and no specific object name. For example, if you run the clmgr -v query node command, all nodes and their attributes are displayed. This flag displays resulting attributes after the operation is complete (only if the operation was successful), when this flag is used with the add or modify ACTION.
-x
Displays all data in a simple XML format, and is valid only with the query, add, and modify ACTION flags.

Syntax for clmgr operations

The following sections show the example syntax for all the clmgr command operations:
Cluster

clmgr add cluster
         [ <cluster_label> ]
         [ NODES=<host>[,<host#2>,...] ]
add => create, make, mk
cluster => cl
 
         

clmgr modify cluster 
         [ SPLIT_POLICY={manual|none|tiebreaker} ]
         [ TIEBREAKER={disk|nfs} ]
         [ DISK_WWID=<#DISK_WWID> ]
         [ NFS_SERVER=<#NFS_SERVER> ]
         [ NFS_SERVER_MOUNT_POINT=<NFS_SERVER_MOUNT_POINT_PATH> ]
         [ NFS_LOCAL_MOUNT_POINT=<NFS_LOCAL_MOUNT_POINT_PATH> ]
         [ NFS_FILE_NAME=<#NFS_FILE_NAME> ]
 modify => change, set
 cluster => cl

             

clmgr offline cluster
         [ STOP_RSCT={no|yes} ]
offline => stop
cluster => cl

clmgr online cluster
         [ MANAGE={auto|manual} ]    
online => start
cluster => cl

clmgr query cluster [ ALL | {CORE,SPLIT} ]
query => get, list, ls, show
cluster => cl

clmgr delete cluster [ NODES={ALL|<node#1>,<node#n>,...} ]
delete => erase, remove, rm
cluster => cl

clmgr verify cluster
verify => validate
Node
start of change

clmgr add node <node>
		      [ START_ON_BOOT={TRUE|FALSE} ]
add => create, make, mk
node => no

clmgr query node {<node>|LOCAL}[,<node#2>,...]
clmgr -v query node
query => get, list, ls, show
node => no

clmgr delete node {<node>[,<node#2>,<node#n>,...] | ALL}
delete => erase, remove, rm
node => no

clmgr online node <node>[,<node#2>,<node#n>,...]
         [ MANAGE={auto|manual} ]
         [ WHEN={now|reboot|both} ]
 online => start
 node => no

clmgr offline node <node>[,<node#2>,<node#n>,...]
         [ MANAGE={offline|move}]
         [ STOP_RSCT={no|yes}]
         [ WHEN={now|reboot|both} ]
 offline => stop
 node => no
end of change
Network

clmgr add network <network>
          [TYPE={ether|disk}]
          [PVID={#PVID}]
          [NODES=<node_P1>[,<node_P2>,...]
add => create, make, mk
network => ne, nw

clmgr delete <network>[,<network#2>,<network#n>,...]
delete => erase, remove, rm
network => ne, nw

clmgr query network <network>[,<network#2>,<network#n>,...]

clmgr -v query network
query => get, list, ls, show
network => ne, nw

clmgr modify network <network>
         [ node=<nodeA1[,nodeA2,...]> ]
modify => change, set
network => ne, nw
Interface

clmgr add interface NETWORK= <network>
          NODE=<node>
          INTERFACE=<interface>
add => create, make, mk
interface => in, if        

clmgr delete interface NETWORK= <network>
  	NODE=<node>
         INTERFACE=<interface>
delete => erase, remove, rm
interface => in, if
Resource group

clmgr add resource_group <resource_group>[,<rg#2>,...]
         NODES=<node_P1>[,<node_P2>,...]
         [ STARTUP={OFAN|OAAN}]
         [ FALLOVER={FNPN|BO}]
         [ FALLBACK={NFB|FBHN}]
         [ SERVICE_LABEL=ser_ip#1[,ser_ip#2,... ]]
         [ APPLICATIONS=app#1[,app#2,...]]
         [ FILESYSTEM=fs#1[,fs#2,...]]
         [ PRIORITY=<0-200>]

 add => create, make, mk
 resource_group => rg

STARTUP:
    OFAN ---- Online on First Available Node
    OAAN ---- Online on All Available Nodes (concurrent)
        
FALLOVER:
    FNPN ---- Fallover to Next Priority Node (default value)
    BO ------ Bring Offline (On Error Node Only)

FALLBACK:
    NFB ----- Never Fallback (default value)
    FBHN --- Fallback to Home Node


 

clmgr modify resource_group <resource_group>
         [ NAME=<new_resource_group_label>]
         [ NODES=nodeA1[,nodeA2,...]]
         [ STARTUP={OFAN|OAAN}]
         [ FALLOVER={FNPN|BO}]
         [ FALLBACK={NFB|FBHN}]
         [ SERVICE_LABEL=service_ip#1[,service_ip#2,...]]
         [ APPLICATIONS=app#1[,app#2,...]]
         [ FILESYSTEM=fs#1[,fs#2,...]]
         [ PRIORITY= <0-200>]
modify => change, set
resource_group => rg



            
clmgr query resource_group <resource_group>[,<rg#2>,<rg#n>,...]

clmgr -v query resource_group
query => get, list, ls, show
resource_group => rg

clmgr delete resource_group {<resource_group>[,<rg#2>,<rg#n>,...] | ALL}
delete => erase, remove, rm
resource_group => rg

clmgr online resource_group { <resource_group>[,<rg#2>,<rg#n>,...] | ALL }
online => start
resource_group => rg

clmgr offline resource_group { <resource_group>[,<rg#2>,<rg#n>,...] | ALL }
offline => stop
resource_group => rg
Note: The ALL attribute attempts to bring all resource groups online or offline.
            
clmgr move resource_group <resource_group>[,<rg#2>,<rg#n>,...]
          NODE=<node>
move => mv
resource_group => rg

clmgr reset resource_group <resource_group>
          [NODE=<node_name>]
resource_group => rg
Persistent IP/Label
	
clmgr add persistent_ip <persistent_label>
          NETWORK=<network>
          NODE=<node>
          [ NETMASK=<###.###.###.###> ]
add => create, make, mk
persistent_ip => pi

clmgr delete persistent_ip {<persistent_label>[,<persistent_label#2>,<persistent_label#n>,...] | ALL}
delete => erase, remove, rm
persistent_ip => pi
 
clmgr modify persistent_ip <persistent_label>
         [ NAME=<new_persistent_label> ]
         [ NETWORK=<new_network> ]
         [ NETMASK=<###.###.###.###> ]
modify => change, set
persistent_ip => pi

clmgr query persistent_ip [<persistent_label>[,<persistent_label#2>,<persistent_label#n>,...] ]
clmgr -v query persistent_ip
query => get, list, ls, show
persistent_ip => pi
Note: The alias for the persistent_ip is pi.
Service IP/Label
            
clmgr add service_ip <service_ip_label>
         NETWORK=<network>
         [ NETMASK=<###.###.###.###>]
add => create, make, mk
service_ip => si

clmgr modify service_ip <service_label>
         [ NAME=<new_service_label> ]
         [ NETWORK=<new_network> ]
         [ NETMASK=<###.###.###.###> ]
modify => change, set
service_ip => si
												             
clmgr query service_ip <sLabel#1>[,<sLabel#2>,<sLabel#n>,...]
clmgr -v query service_ip
query => get, list, ls, show
service_ip => si

clmgr delete service_ip {<sLabe#l>[,<Label#2>,<Label#n>,...] | ALL}
delete => erase, remove, rm
service_ip => si

clmgr reset service_ip <service_ip>
         [NODE=<node_name>]
service_ip => si
Application

clmgr add application <application>
         TYPE=Process
         STARTSCRIPT="/path/to/start/script"
         STOPSCRIPT="/path/to/stop/script"
         PROCESS="/process/to/monitor"
         [OWNER="<owner_name>"]
         [RESOURCETYPE=“1,2” ]
         [STARTCOMMANDTIMEOUT=""]
         [STOPCOMMANDTIMEOUT=""]
         [CLEANUPMETHOD="</script/to/cleanup>" ]
         [PROTECTIONMODE="0,1" ]

 clmgr add application <application>
         TYPE=Custom
         STARTSCRIPT="/path/to/start/script"
         STOPSCRIPT="/path/to/stop/script"
         MONITORMETHOD="/program/to/monitor"
         [OWNER="<owner_name>" ]
         [RESOURCETYPE=“1,2” ]
         [STARTCOMMANDTIMEOUT=""]
         [STOPCOMMANDTIMEOUT=""]
         [MONITORCOMMANDTIMEOUT=""]
         [MONITORINTERVAL="1 .. 1024" ]
         [CLEANUPMETHOD="</script/to/cleanup>" ]
         [PROTECTIONMODE="0,1" ]
add => create, make, mk
application => app

clmgr modify application <application name>
         [ NAME=<new_label> ]
         [ TYPE={Process|Custom} ]
         [ STARTSCRIPT="/path/to/start/script" ]
         [ STOPSCRIPT="/path/to/stop/script" ]
         [ OWNER="<owner_name>" ]
         [ STARTCOMMANDTIMEOUT="" ]
         [ STOPCOMMANDTIMEOUT="" ]
         [ PROTECTIONMODE="0,1 ]
         PROCESS="process_name"
         [ CLEANUPMETHOD="</script/to/cleanup>" ]
         MONITORMETHOD="/program/to/monitor"
         [ MONITORINTERVAL="1 .. 1024" ]
         [ MONITORCOMMANDTIMEOUT="" ]
         [ CLEANUPMETHOD="</script/to/cleanup>" ]
modify => change, set
application => app

clmgr query application <application>[,<app#2>,<app#n>,...] 
clmgr -v query application
query => get, list, ls, show
application => app

clmgr delete application {<app>[,<app#2>,<app#n>,...] ALL}
delete => erase, remove, rm
application => app

clmgr reset application <application>
         [NODE=<node_name>]
Note: The app value is an abbreviation for application. Aliases for application are ac and app.
Dependency

clmgr add dependency <dependency_name>
          TYPE={[<DEPENDSON|DEPENDSONANY|STARTAFTER|STOPAFTER|COLLOCATED|ANTICOLLOCATED|FORCEDDOWNBY|ISSTARTABLE]}
          SOURCE="<rg#1>"
          TARGET="<rg#2>[,<rg#3>,...,<rg#n>]"
add => create, make, mk
dependency => de

clmgr delete dependency {<dependency>[,<dep#2>,<dep#n>,...] |
             ALL}
delete => erase, remove, rm
dependency => de

clmgr query dependency <depname>[,<dep#2>,<dep#n>,...]
clmgr -v query dependency
query => get, list, ls, show
dependency => de

clmgr modify dependency <dependency_name>
         [NAME="<new_label>" ]
         [TYPE={[<DEPENDSON|DEPENDSONANY|STARTAFTER|STOPAFTER|  
         COLLOCATED|ANTICOLLOCATED|FORCEDDOWNBY|ISSTARTABLE]}
         [TARGET="<rg#1>[,<rg#2>,...,<rg#n>]" ]
modify => change, set
dependency => de
File collection

clmgr add file_collection
         <file_collection>
         [ FILES="/path/to/file1,/path/to/file2,..." ]
         [ SYNC_WHEN_CHANGED={no|yes} ]
         [ DESCRIPTION="<file_collection_description>" ]
add => create, make, mk
file_collection => fi, fc

clmgr delete file_collection {<file_collection>[,<fc#2>,<fc#n>,...]
             | ALL }
 delete => erase, remove, rm
 file_collection => fi, fc

clmgr modify file_collection
          <file_collection>
          [ NAME="<new_file_collection_label>" ]
          [ ADD="/path/to/file1,/path/to/file2,..."]
          [ DELETE={"/path/to/file1,/path/to/file2,..."}]
          [ SYNC_WHEN_CHANGED={no|yes} ]
          [ DESCRIPTION="<file_collection_description>"]

modify => change, set
file_collection => fi, fc

clmgr query file_collection <file_collection>[,<fc#2>,<fc#n>,...]
clmgr -v query file_collection
query => get, list, ls, show
file_collection => fi, fc

clmgr sync file_collection <file_collection>

clmgr update file_collection [ SYNC_INTERVAL="10 .. 1440" ]
clmgr update file_collection
filecollection => fi, fc
Snapshot
	
clmgr add snapshots <snapshot>
          [ DESCRIPTION="<snapshot_description>" ]
add => create, make, mk
snapshot => sn, ss

clmgr delete snapshot {<snapshot>[,<snapshot#2>,<snapshot#n>,...] | ALL}
delete => erase, remove, rm
snapshot => sn, ss

clmgr manage snapshot restore <snapshot>
manage => mg
snapshot => sn, ss

clmgr modify snapshot <snapshot>
         [ NAME="<new_snapshot_label>" ]
         [ DESCRIPTION="<snapshot_description>" ]
modify => change, set
snapshot => sn, ss

clmgr query snapshot <snapshot>[,<snapshot#2>,...]
clmgr -v query snapshot
query => get, list, ls, show
snapshot => sn, ss

clmgr view snapshot <snapshot>
         [ TAIL=<number_of_trailing_lines> ]
         [ HEAD=<number_of_leading_lines> ]
view => cat
snapshot => sn, ss
Log
            
clmgr modify log {<log>}
         [ TRACE_LEVEL={default|medium|max} ]
modify => change, set

clmgr query log <log>[,<log#2>,<log#n>]
clmgr query -v log
query => get, list, ls, show

clmgr view log [ {<log>} ]
         [ TAIL=<number_of_trailing_lines> ]
         [ HEAD=<number_of_leading_lines> ]
view => cat

clmgr manage logs collect
         [ DIRECTORY="<directory_for_collection>" ] \
         [ NODES=<node>[,<node#2>,<node#n>,...] ]
manage => mg
User
	
clmgr add user <user_name>
         [ ID=<###|upto 4294967294> ]
         [ ADMINISTRATIVE={false|true} ]
         [ CHANGE_ON_NEXT_LOGIN={true|false} ]
         [ PRIMARY=<group> ]
         [ GROUPS=<group#1>[,<group#2>,...] ]
         [ ROLES=<role> ]
         [ Registry={local}]
         [ HOME=<full_directory_path> ]
         [ SHELL=<defined_in_/etc/shells> ]
         [ EXPIRATION=<days from epoch | YYYY-MM-DD> ]
         [ LOCKED={false|true} ]
         [ DAYS_TO_WARN={#|0} ]
         [ LOCKOUT_DELAY=<days_btwn_expiration_and_lockout> ]
         [ MAX_PASSWORD_AGE=<in days> ]
         [ MIN_PASSWORD_AGE=<in days> ]

clmgr add user <user_name>
         [ ID=<###|upto 4294967294> ]
         [ ADMINISTRATIVE={false|true} ]
         [ CHANGE_ON_NEXT_LOGIN={true|false} ]
         [ PRIMARY=<group> ]
         [ GROUPS=<group#1>[,<group#2>,...] ]
         [ ROLES=<role> ]
         [ Registry={ldap}]
	  [ DN=<Distinguished_name>]
         [ LDAP_PASSWORD={ldap_password} ]
         [ HOME=<full_directory_path> ]
         [ SHELL=<defined_in_/etc/shells> ]
         [ EXPIRATION=<days from epoch | YYYY-MM-DD> ]
         [ LOCKED={false|true} ]
         [ DAYS_TO_WARN={#|0} ]
         [ LOCKOUT_DELAY=<days_btwn_expiration_and_lockout> ]
         [ MAX_PASSWORD_AGE=<in days> ]
         [ MIN_PASSWORD_AGE=<in days> ]
add => create, make, mk
user => ur

clmgr delete user {<user_name>[,<user_name#2>,<user_name#n>,...]
         [ Registry={local}]}

clmgr delete user {<user_name>[,<user_name#2>,<user_name#n>,...] 
         [ Registry={ldap}] 
         [ DN=<Distinguished_name>] 
         [ LDAP_PASSWORD={ldap_password} ] }
delete => erase, remove, rm
user => ur

clmgr modify user <user_name>
         [ ID=<###|upto 4294967294> ]
         [ ADMINISTRATIVE={false|true} ]
         [ CHANGE_ON_NEXT_LOGIN={true|false} ]
         [ PRIMARY=<group> ]
         [ GROUPS=<group#1>[,<group#2>,...] ]
         [ ROLES=<role> ]
	  [ Registry={local}]
         [ HOME=<full_directory_path> ]
         [ SHELL=<defined_in_/etc/shells> ]
         [ EXPIRATION=<days from epoch | YYYY-MM-DD> ]
         [ LOCKED={false|true} ]
         [ DAYS_TO_WARN={#|0} ]
         [ LOCKOUT_DELAY=<days_btwn_expiration_and_lockout> ]
         [ MAX_PASSWORD_AGE=<in days> ]
         [ MIN_PASSWORD_AGE=<in days> ]

clmgr modify user <user_name>
         [ ID=<user id> ]
         [ ADMINISTRATIVE={false|true} ]
         [ CHANGE_ON_NEXT_LOGIN={true|false} ]
         [ PRIMARY=<group> ]
         [ GROUPS=<group#1>[,<group#2>,...] ]
         [ ROLES=<role> ]
         [ Registry={ldap}]
         [ DN=<Distinguished_name>]
         [ LDAP_PASSWORD={ldap_password} ]
         [ LDAP_USER_PASSWORD=<ldap_user_password> ]
         [ HOME=<full_directory_path> ]
         [ SHELL=<defined_in_/etc/shells> ]
         [ EXPIRATION=<days from epoch | YYYY-MM-DD> ]
         [ LOCKED={false|true} ]
         [ DAYS_TO_WARN={#|0} ]
         [ LOCKOUT_DELAY=<days_btwn_expiration_and_lockout> ]
         [ MAX_PASSWORD_AGE=<in days> ]
         [ MIN_PASSWORD_AGE=<in days> ] 
modify => change, set
user => ur

clmgr query user <user>[,<user#2>,...]
clmgr -v query user
query => get, list, ls, show
user => ur
Group

clmgr add group <group_name>
          [ ID=<###|upto 4294967294> ]
          [ USERS=<user#1>[,<user#2>,...] ]
          [ Registry={local}]
          [ ADMINISTRATIVE={false|true} ]

clmgr add group <group_name>
          [ ID=<group id> ]
          [ USERS=<user#1>[,<user#2>,...] ]
          [ Registry={ldap}]
          [ ADMINISTRATIVE={false|true} ]
          [ DN=<Distinguished Name>]
          [ LDAP_PASSWORD={ldap_password} ] 
add => create, make, mk
group => gp

clmgr delete group {<group_name>[,<group_name#2>,<group_name#n>,...]
          [ Registry={local}]}

clmgr delete group {<group_name>[,<group_name#2>,<group_name#n>,...]
          [ Registry={ldap}]
          [ DN=<Distinguished_name>]
          [ LDAP_PASSWORD={ldap_password} ]}
delete => erase, remove, rm
group => gp

clmgr modify group <group_name>
          [ ID=<###|upto 4294967294> ]
          [ USERS=<user#1>[,<user#2>,...] ]
          [ Registry={local}]
          [ ADMINISTRATIVE={false|true} ]

clmgr modify group <group_name>
          [ ID=<group id> ]
          [ USERS=<user#1>[,<user#2>,...] ]
          [ Registry={ldap}]
          [ DN=<Distinguished Name>]
          [ ADMINISTRATIVE={false|true} ]
          [ LDAP_PASSWORD={ldap_password} ]
modify => change, set
group => gp

clmgr query group <group>[,<group#2>,...]
clmgr -v query group
query => get, list, ls, show
group => gp
Equivalency
 	
clmgr query equivalency <equivalency_name>
query => get, list, ls, show
Logical_Volume

 clmgr query logical_volume <logical_volume>[,<logical_volume#2>,<logical_volume#n>,...]

 clmgr -v query logical_volume
 query => get, list, ls, show
 logical_volume => lv
NFS Client
	
clmgr add NFS_client
    	 <label>
    	 <REMOTE_DIR=Server:dir>
    	 <MOUNT_POINT= dir>
add => create, make, mk
	
clmgr delete NFS_client <label>
delete => erase, remove, rm

clmgr query nfs_client <nfs_client>[,<nc#2>,<nc#n>,...]
clmgr -v query nfs_client
query => get, list, ls, show
File_system

clmgr add file_system <file_system_name>
         TYPE={ext3|ext4}
         LOGICAL_VOLUME=lvname
         [ BLOCK_SIZE={1024|2048|4096} ]
         [ PERMISSIONS={ro|rw} ]
         [ OPTIONS={nosuid|nodev|all} ]

 clmgr add file_system <file_system_name>
         TYPE={xfs}
         LOGICAL_VOLUME=lvname
         [ BLOCK_SIZE={1024|2048|4096|8192|16384|32768|65536} ]
         [ PERMISSIONS={ro|rw} ]
         [ OPTIONS={nosuid|nodev|all} ]
add => create, make, mk
file_system => fs

clmgr query file_system <file_system>[,<fs#2>,<fs#n>,...]
clmgr -v query file_system
query => get, list, ls, show
file_system => fs

clmgr delete file_system {<file_system>[,<FS#2>,...] | ALL}
         [ REMOVE_MOUNT_POINT={false|true} ]
delete => erase, remove, rm
file_system => fs

clmgr reset file_system <file_system>
         [NODE=<node_name>]
file_system => fs
Smart Assist
start of change

clmgr add smart_assist APPLICATION={SAP_HANA}
         SID=<sid_value>
         INSTANCE=<HDB_instance_name>

clmgr add smart_assist APPLICATION={SAP_ABAP|SAP_JAVA}
         SID=<sid_value>
         INSTANCE=<SCS_instance_name>

clmgr add smart_assist APPLICATION={SAP_APPSERVER}
         SID=<sid_value>
         INSTALL_TYPE={ABAP|JAVA}
add => create, make, mk
smart_assist => sm, sa

clmgr delete smart_assist APPLICATION={SAP_HANA}
         SID=<sid_value>
         INSTANCE=<HDB_instance_name>
         [ DEL_POLICY={YES|NO} ]

clmgr delete smart_assist APPLICATION={SAP_ABAP|SAP_JAVA}
         SID=<sid_value>
         INSTANCE=<SCS_instance_name>
         [ DEL_POLICY={YES|NO} ]

clmgr delete smart_assist APPLICATION={SAP_APPSERVER}
         SID=<sid_value>
         INSTALL_TYPE={ABAP|JAVA}
         [ DEL_POLICY={YES|NO} ]
delete => erase, remove, rm
smart_assist => sm, sa

clmgr setup smart_assist APPLICATION={SAP_HANA}
         SID=<sid_value>
         INSTANCE=<HDB_instance_name>
         [ MODE={NEW|UPDATE} ]
         [ CONFIG={PERFORM_OPT|ACTIVE_ACTIVE|COST_OPT} ]

clmgr setup smart_assist APPLICATION={SAP_ABAP|SAP_JAVA}
         SID=<sid_value>
         INSTANCE=<SCS_instance_name>
         [ MODE={NEW|UPDATE} ]

clmgr setup smart_assist APPLICATION={SAP_APPSERVER}
         SID=<sid_value>
         INSTALL_TYPE={ABAP|JAVA}
         [ MODE={NEW|UPDATE} ]
smart_assist => sm, sa

clmgr update smart_assist APPLICATION={SAP_HANA}
         SID=<sid_value>
         INSTANCE=<HDB_instance_name>

clmgr update smart_assist APPLICATION={SAP_ABAP|SAP_JAVA}
         SID=<sid_value>
         INSTANCE=<SCS_instance_name>

clmgr update smart_assist APPLICATION={SAP_APPSERVER}
         SID=<sid_value>
         INSTALL_TYPE={ABAP|JAVA}
smart_assist => sm, sa

clmgr query smart_assist <policy>[,<policy#2>,<policy#n>]
clmgr query -v smart_assist
query => get, list, ls, show
smart_assist => sm, sa
end of change

Example: Case sensitivity

Details

The class attribute for the clmgr command is not case-sensitive. For example, in the following command, the NODES attribute can be NODES, nodes, or Nodes. This cluster is a cluster with two nodes. The cluster name is cluster1 and the nodes are named nodeA and nodeB.

Example
clmgr create cluster clMain NODES=nodeA,nodeB

Example: Creating a cluster

Details

This cluster is a cluster with two nodes. The cluster name is cluster1 and the nodes are named node1 and node2.

Example

clmgr create cluster cluster1 NODES=node1, node2

Example: Creating a resource group

Details

This resource group is a non-concurrent resource group that is created by using default policy and is named RG1. The resource group contains a service IP address that is named access1, and an application named app1.

Examples

clmgr add resource_group RG1 SERVICE_IP=access1
      APPLICATIONS=app1 FILESYSTEM=fs1

Example: Checking status

Details

To know the state of a specified object, so that appropriate actions can be taken, use the following clmgr query commands.

Examples
  • clmgr -a STATE query cluster

  • clmgr -a STATE query node nodeA
  • clmgr -a STATE query resource_group rg1
  • clmgr -a STATE query node nodeA

  • clmgr -a STATE query resource_group rg1
Notes:
  • For the CLASS object of a cluster, the STATE value that is returned is the worst possible status for all nodes in the cluster. For example, in four node cluster, if one node is experiencing an error, the STATE value for the cluster is ERROR.
  • The value that is returned after running the clmgr -a STATE query command is in the standard ATTR=VALUE format, for example STATE=OFFLINE. If you need only the value, you can combine other flags with the -a flag. If you specify the -cSa command, only the VALUE, such as OFFLINE, is returned. This option works for a single value at a time.
  • You can retrieve multiple attributes at one time with the -a flag, such as -a NAME, STATE. The -a flag is not case-sensitive. For example, the following is acceptable syntax for the clmgr command, clmgr -a Name, state. The -a flag supports wildcard characters, such as the asterisk (*) and question mark (?).

Example: Viewing all attributes and settings

Details

If the PowerHA SystemMirror for Linux software encounters a problem, it is necessary to view the contents of the cluster that includes settings. To view the cluster, you can use the clmgr query command with options to requesting specific formats, such as a colon-delimited format or an XML format. The following command examples use resource groups, but the same rules apply for all object classes.

Examples
  • clmgr query resource_group

  • clmgr query resource_group rg1,rg2

  • clmgr -c query resource_group rg1,rg2

  • clmgr -x query resource_group rg1,rg2

  • clmgr -v query resource_group

  • clmgr -cv query resource_group

  • clmgr -xv query resource_group
Notes:
  • When a target object is not specified with a query option, and the -v verbose flag is not used, a simple list of objects is displayed.
  • When one or more target objects are specified with a query option, all the known attributes or settings for those objects are displayed. This query option overrides the -v flag.
  • When the -v flag is used with the query option, all the known attributes or settings for all known objects of the specified class are displayed.
  • Detailed attributes or settings are displayed in the ATTR=VALUE format by default, one per line. If the -c flag is specified, all values are displayed on one line in a colon-delimited format. If -x flag is specified, all attributes and values are displayed in a simple XML format.

Example: Displaying objects based on some filter or criteria

Details

Searching the information is difficult when large number of objects are defined for a specified class, such as resource groups, or when large number of settings are defined within a specified class. Hence, the clmgr command provides the ability to specify filtering criteria by using the query action.

Examples

clmgr query resource_group CURRENT_NODE=`get_local_nodename`
Notes:
  • The example shows how to find an object that matches dynamic value. In this case, the command shows how to obtain the list of all resource groups that are currently running on the local node.
  • This filtering capability can be used in combination with the -a flag for powerful and flexible data retrieval.

Example: Simplifying the clmgr command

Details

The clmgr command does not use any case-sensitive flags or attributes for easier usage. All actions, classes, and attributes or options can be shortened to either an explicitly named alias (such as start instead of online, or rg instead of resource_group), or to the fewest number of letters that make them unique. The following pairs of commands are functionally identical.

Examples
  • 
clmgr query resource_group
clmgr q rg

  • clmgr online node nodeA
clmgr start node nodeA
Note: The shortening of actions and classes is intended when the clmgr command is used interactively within a terminal. Although these abbreviations can also be used in scripts, it is strongly suggested to use the full names of both actions and classes in scripts to make the scripts more readable and serviceable code.

Example: Help information for the clmgr command

Details

Online Help option is always available for the clmgr command. You can also use the built-in help that is provided by the clmgr command. You can use the help option if an object or value from a known set of objects or values is required. If an invalid object or value is specified, an error message and a list of objects or values that are valid for that operation is displayed. The help option can be used to determine which action, class, or object is needed. The clmgr command provides the following help options:

Examples
  • clmgr

  • clmgr add

  • clmgr add application

  • clmgr add application -h
Note: If you specify the -h flag after either an object class or a set of option pairs, a list of all valid options for this particular operation is displayed. The -h flag is the only flag in clmgr command that is not required to be positioned immediately after clmgr command.