22.4. 使用 LMIShell

LMIShell 是交互式客户端和非交互式解释器，可用于访问 OpenPegasus CIMOM 提供的 CIM 对象。它基于 Python 解释器，但也实施额外的功能和类来与 CIM 对象交互。

22.4.1. 启动、使用和退出 LMIShell

与 Python 解释器类似，您可以使用 LMIShell 作为交互式客户端，或者用作 LMIShell 脚本的非交互式解释器。

以交互模式启动 LMIShell

要在互动模式下启动 LMIShell 解释程序，请运行不带额外参数的 lmishell 命令：

lmishell

默认情况下，当 LMIShell 尝试建立与 CIMOM 的连接时，它将根据证书颁发机构信任存储验证服务器端证书。要禁用此验证，请使用 --noverify 或 -n 命令行选项运行 lmishell 命令：

lmishell --noverify

使用 Tab 完成

在交互模式下运行时，LMIShell 解释器允许您按 Tab 键完成基本编程结构和 CIM 对象，包括命名空间、类、方法和对象属性。

浏览历史记录

默认情况下，LMIShell 在 ~/.lmishell_history 文件的交互式提示符处存储您键入的所有命令。这样，您可以浏览命令历史记录并重复使用以交互模式重新输入的行，而无需在提示符下再次键入这些行。要在命令历史记录中向后移动，请按向上箭头键或 Ctrlp 组合键。要在命令历史记录中向前移动，请按向下箭头键或 Ctrln 组合键。

LMIShell 还支持增量反向搜索。Ctrl+r。例如：

> (reverse-i-search)`connect': c = connect("server.example.com", "pegasus")

要清除命令历史记录，请使用 clear_history（） 函数，如下所示：

clear_history()

您可以通过更改 ~/.lmishellrc 配置文件中的 history_length 选项的值来配置命令历史记录中存储的行数。另外，您可以通过更改此配置文件中 history_file 选项的值来更改历史记录文件的位置。例如，要将历史记录文件的位置设置为 ~/.lmishell_history 并配置 LMIShell 以存储其中的最大 1000 行，请将以下行添加到 ~/.lmishellrc 文件中：

history_file = "~/.lmishell_history"
history_length = 1000

处理例外

默认情况下，LMIShell 解释器处理所有异常并使用返回值。要禁用此行为来处理代码中的所有异常，请使用 use_exceptions（） 函数，如下所示：

use_exceptions()

要重新启用自动异常处理，请使用：

use_exception(False)

您可以通过将 ~/.lmishellrc 配置文件中的 use_exceptions 选项的值改为 True 来永久禁用异常处理：

use_exceptions = True

配置临时缓存

使用默认配置时，LMIShell 连接对象使用临时缓存来存储 CIM 类名称和 CIM 类，以减少网络通信。要清除这个临时缓存，请使用 clear_cache（） 方法，如下所示：

object_name.clear_cache()

使用连接对象的名称替换 object_name。

要禁用特定连接对象的临时缓存，请使用 use_cache（） 方法，如下所示：

object_name.use_cache(False)

要再次启用它，请使用：

object_name.use_cache(True)

您可以通过将 ~/.lmishellrc 配置文件中的 use_cache 选项的值更改为 False 来永久禁用连接对象的临时缓存：

use_cache = False

退出 LMIShell

要终止 LMIShell 解释器并返回到 shell 提示符，请按 Ctrl+d 组合键或发布 quit（） 功能，如下所示：

> quit()
~]$

运行 LMIShell 脚本

要运行 LMIShell 脚本，请运行 lmishell 命令，如下所示：

lmishell file_name

将 file_name 替换为脚本的名称。要在执行后检查 LMIShell 脚本，还要指定 --interact 或 -i 命令行选项：

lmishell --interact file_name

LMIShell 脚本的首选文件扩展名为 .lmi。

22.4.2. 连接到 CIMOM

LMIShell 允许您连接到在同一系统上本地运行的 CIMOM，或者连接到可通过网络访问的远程计算机上。

连接到远程 CIMOM

要访问远程 CIMOM 提供的 CIM 对象，请使用 connect（） 功能创建一个连接对象，如下所示：

connect(host_name, user_name, password)

使用受管系统的主机名替换 host_name，user_name 替换为被允许连接到该系统上运行的 OpenPegasus CIMOM 的用户名称，密码为 用户的密码。如果省略密码，LMIShell 会提示用户输入密码。函数返回 LMIConnection 对象。

例 22.1. 连接到远程 CIMOM

以用户 peg asus 的身份连接到在 server.example.com 上运行的 OpenPegasus CIMOM，在交互式提示下输入以下内容：

> c = connect("server.example.com", "pegasus")
password:
>

连接到本地 CIMOM

LMIShell 允许您使用 Unix 套接字连接到本地 CIMOM。对于这种连接，您必须以 root 用户身份运行 LMIShell 解释器，并且 /var/run/tog-peg-pegasus/cimxml.socket 套接字必须存在。

要访问本地 CIMOM 提供的 CIM 对象，请使用 connect（） 功能创建一个连接对象，如下所示：

connect(host_name)

将 host_name 替换为 localhost、127. 0.0.1 或 ::1。函数返回 LMIConnection 对象或 None。

例 22.2. 连接到本地 CIMOM

以 root 用户身份 连接到 localhost 上运行的 OpenPegasus CIMOM，在互动提示下输入以下内容：

> c = connect("localhost")
>

验证到 CIMOM 的连接

connect（） 函数返回 LMIConnection 对象，如果无法建立连接，则返回 None。另外，当 connect（） 函数无法建立连接时，它会向标准错误输出输出错误消息。

要验证与 CIMOM 的连接是否已成功建立，请使用 isinstance（） 功能，如下所示：

isinstance(object_name, LMIConnection)

使用连接对象的名称替换 object_name。如果 object_name 是 LMIConnection 对象，则此函数返回 True，否则返回 False。

例 22.3. 验证到 CIMOM 的连接

要验证例 22.1 “连接到远程 CIMOM” 中创建的 c 变量是否包含 LMIConnection 对象，在互动提示符后输入以下内容：

> isinstance(c, LMIConnection)
True
>

另外，您可以验证 c 是否不是 None ：

> c is None
False
>

22.4.3. 使用命名空间

LMIShell 命名空间提供组织可用类的自然方法，并充当到其他命名空间和类的层次结构访问点。root 命名空间是连接对象的第一个入口点。

列出可用的命名空间

要列出所有可用的命名空间，请使用 print_namespaces（） 方法，如下所示：

object_name.print_namespaces()

将 object_name 替换为要检查的对象的名称。此方法将可用命名空间打印到标准输出。

要获取可用命名空间的列表，请访问对象属性 命名空间 ：

object_name.namespaces

这将返回字符串列表。

例 22.4. 列出可用的命名空间

要检查例 22.1 “连接到远程 CIMOM” 中创建的 c 连接对象的 根 命名空间对象并列出所有可用的命名空间，在互动提示符下输入以下内容：

> c.root.print_namespaces()
cimv2
interop
PG_InterOp
PG_Internal
>

要将这些命名空间的列表分配给名为 root_namespaces 的变量，请输入：

> root_namespaces = c.root.namespaces
>

访问命名空间对象

要访问特定的命名空间对象，请使用以下语法：

object_name.namespace_name

将 object_name 替换为要检查的对象的名称，并将 namespace_name 替换为要访问的命名空间的名称。这会返回 LMINamespace 对象。

例 22.5. 访问命名空间对象

要访问在例 22.1 “连接到远程 CIMOM” 中创建的 c connection 对象的 cimv2 命名空间并将其分配给变量 named ns，在互动提示中输入以下内容：

> ns = c.root.cimv2
>

22.4.4. 使用类

LMIShell 类表示 CIMOM 提供的类。您可以访问和列出其属性、方法、实例、实例名称和 ValueMap 属性，打印它们的文档字符串，然后创建新实例和实例名称。

列出可用的类

要列出特定命名空间中的所有可用类，请使用 print_classes（） 方法，如下所示：

namespace_object.print_classes()

将 namespace_object 替换为要检查的命名空间对象。此方法将可用的类打印到标准输出。

要获取可用类的列表，请使用 class（） 方法：

namespace_object.classes()

此方法返回字符串列表。

例 22.6. 列出可用的类

要检查例 22.5 “访问命名空间对象” 中创建 的命名空间 对象并列出所有可用的类，在互动提示下输入以下内容：

> ns.print_classes()
CIM_CollectionInSystem
CIM_ConcreteIdentity
CIM_ControlledBy
CIM_DeviceSAPImplementation
CIM_MemberOfStatusCollection
...
>

要将这些类的列表分配给名为 cimv2_classes 的变量，请输入：

> cimv2_classes = ns.classes()
>

访问类对象

要访问 CIMOM 提供的特定类对象，请使用以下语法：

namespace_object.class_name

将 namespace_object 替换为要检查的命名空间对象的名称，并将 class_name 替换为要访问的类的名称。

例 22.7. 访问类对象

要访问例 22.5 “访问命名空间对象” 中创建 的命名空间 对象 LMI_IPNetworkConnection 类并将其分配给名为 cls 的变量，请在交互式提示中输入以下内容：

> cls = ns.LMI_IPNetworkConnection
>

检查类对象

所有类对象存储其名称和所属命名空间的信息，以及详细的类文档。要获取特定类对象的名称，请使用以下语法：

class_object.classname

将 class_object 替换为要检查的类对象的名称。这会返回对象名称的字符串表示。

要获取有关类对象所属命名空间的信息，请使用：

class_object.namespace

这会返回命名空间的字符串表示。

要显示详细的类文档，请使用 doc（） 方法，如下所示：

class_object.doc()

例 22.8. 检查类对象

要检查例 22.7 “访问类对象” 中创建 的 cls 类对象并显示其名称和对应命名空间，请在交互式提示符后输入以下内容：

> cls.classname
'LMI_IPNetworkConnection'
> cls.namespace
'root/cimv2'
>

要访问类文档，请输入：

> cls.doc()
Class: LMI_IPNetworkConnection
  SuperClass: CIM_IPNetworkConnection
  [qualifier] string UMLPackagePath: 'CIM::Network::IP'

  [qualifier] string Version: '0.1.0'
...

列出可用的方法

要列出特定类对象的所有可用方法，请使用 print_methods（） 方法，如下所示：

class_object.print_methods()

将 class_object 替换为要检查的类对象的名称。此方法将可用方法打印到标准输出。

要获取可用方法的列表，请使用 method （） 方法：

class_object.methods()

此方法返回字符串列表。

例 22.9. 列出可用的方法

要检查例 22.7 “访问类对象” 中创建 的 cls 类对象并列出所有可用的方法，请在交互式提示符处输入以下内容：

> cls.print_methods()
RequestStateChange
>

要将这些方法的列表分配给名为 service_methods 的变量，请输入：

> service_methods = cls.methods()
>

列出可用属性

要列出特定类对象的所有可用属性，请使用 print_properties（） 方法，如下所示：

class_object.print_properties()

将 class_object 替换为要检查的类对象的名称。此方法打印标准输出的可用属性。

要获取可用属性的列表，请使用 properties（） 方法：

class_object.properties()

此方法返回字符串列表。

例 22.10. 列出可用属性

要检查例 22.7 “访问类对象” 中创建 的 cls 类对象并列出所有可用属性，请在交互式提示符处输入以下内容：

> cls.print_properties()
RequestedState
HealthState
StatusDescriptions
TransitioningToState
Generation
...
>

要将这些类的列表分配给名为 service_properties 的变量，请输入：

> service_properties = cls.properties()
>

列出和查看值映射属性

CIM 类可以在其受管对象格式(MOF)定义中包含 ValueMap 属性。ValueMap 属性包含恒定值，在调用方法或检查返回的值时很有用。

要列出特定类对象的所有可用 ValueMap 属性，请使用 print_valuemap_properties（） 方法，如下所示：

class_object.print_valuemap_properties()

将 class_object 替换为要检查的类对象的名称。此方法将可用的 ValueMap 属性输出到标准输出：

要获取可用 ValueMap 属性列表，请使用 valuemap_properties（） 方法：

class_object.valuemap_properties()

此方法返回字符串列表。

例 22.11. 列出 ValueMap 属性

要检查例 22.7 “访问类对象” 中创建 的 cls 类对象并列出所有可用的 ValueMap 属性，请在交互式提示符后输入以下内容：

> cls.print_valuemap_properties()
RequestedState
HealthState
TransitioningToState
DetailedStatus
OperationalStatus
...
>

要将这些 ValueMap 属性的列表分配给名为 service_valuemap_properties 的变量，请输入：

> service_valuemap_properties = cls.valuemap_properties()
>

要访问特定的 ValueMap 属性，请使用以下语法：

class_object.valuemap_propertyValues

将 valuemap_property 替换为要访问的 ValueMap 属性的名称。

要列出所有可用的常量值，请使用 print_values（） 方法，如下所示：

class_object.valuemap_propertyValues.print_values()

此方法将打印标准输出的命名常数值。您还可以使用 values( )方法获取可用常数值 的列表：

class_object.valuemap_propertyValues.values()

此方法返回字符串列表。

例 22.12. 访问 ValueMap 属性

例 22.11 “列出 ValueMap 属性” 提到名为 Requested State 的 ValueMap 属性。要检查此属性并列出可用的常数值，请在互动提示中输入以下内容：

> cls.RequestedStateValues.print_values()
Reset
NoChange
NotApplicable
Quiesce
Unknown
...
>

要将这些常量值的列表分配给名为 requests _state_values 的变量，请输入：

> requested_state_values = cls.RequestedStateValues.values()
>

要访问特定的常量值，请使用以下语法：

class_object.valuemap_propertyValues.constant_value_name

将 constant_value_name 替换为常量值的名称。或者，您可以使用 value（） 方法，如下所示：

class_object.valuemap_propertyValues.value("constant_value_name")

要确定特定常量值的名称，请使用 value_name（） 方法：

class_object.valuemap_propertyValues.value_name("constant_value")

此方法返回字符串。

例 22.13. 访问 Constant 值

例 22.12 “访问 ValueMap 属性” 显示 Requested State 属性提供了名为 Reset 的常量值。要访问名为常量值的这个值，在互动提示中输入以下内容：

> cls.RequestedStateValues.Reset
11
> cls.RequestedStateValues.value("Reset")
11
>

要确定这个恒定值的名称，请输入：

> cls.RequestedStateValues.value_name(11)
u'Reset'
>

获取 CIMClass 对象

许多类方法不需要访问 CIMClass 对象，这就是为什么 LMIShell 仅当调用方法真正需要时从 CIMOM 获取此对象。要手动获取 CIMClass 对象，请使用 fetch（） 方法，如下所示：

class_object.fetch()

将 class_object 替换为类对象的名称。请注意，需要访问 CIMClass 对象的方法会自动获取它。

22.4.5. 操作实例

LMIShell 实例表示 CIMOM 提供的实例。您可以获取和设置其属性、列表和调用方法，打印其文档字符串，获取关联或关联对象的列表，将修改的对象推送到 CIMOM，以及从 CIMOM 删除个别实例。

访问实例

要获取特定类对象的所有可用实例列表，请使用 instance （） 方法，如下所示：

class_object.instances()

将 class_object 替换为要检查的类对象的名称。此方法返回 LMIInstance 对象列表。

要访问类对象的第一个实例，请使用 first_instance（） 方法：

class_object.first_instance()

此方法返回 LMIInstance 对象。

除了列出所有实例或返回第一个实例外，instances （） 和 first_instance（） 都支持可选参数来允许您过滤结果：

class_object.instances(criteria)

class_object.first_instance(criteria)

使用由键值对组成的字典替换条件，其中键表示实例属性和值表示这些属性的必要值。

例 22.14. 访问实例

要查找在例 22.7 “访问类对象” 中创建的 cls 类对象的第一个实例，其 ElementName 属性等于 eth0，并将它分配给名为 device 的变量，在交互式提示下输入以下内容：

> device = cls.first_instance({"ElementName": "eth0"})
>

检查实例

所有实例对象存储其类名称和所属命名空间的信息，以及其属性和值的详细文档。此外，实例对象允许您检索唯一身份识别对象。

要获取特定实例对象的类名称，请使用以下语法：

instance_object.classname

将 instance_object 替换为要检查的实例对象的名称。这将返回类名称的字符串表示。

要获取有关实例对象所属命名空间的信息，请使用：

instance_object.namespace

这会返回命名空间的字符串表示。

要检索实例对象的唯一标识对象，请使用：

instance_object.path

这会返回 LMIInstanceName 对象。

最后，要显示详细的文档，请使用 doc（） 方法，如下所示：

instance_object.doc()

例 22.15. 检查实例

要检查例 22.14 “访问实例” 中创建 的设备 实例对象并显示其类名称和对应命名空间，请在互动提示符后输入以下内容：

> device.classname
u'LMI_IPNetworkConnection'
> device.namespace
'root/cimv2'
>

要访问实例对象文档，请输入：

> device.doc()
Instance of LMI_IPNetworkConnection
  [property] uint16 RequestedState = '12'

  [property] uint16 HealthState

  [property array] string [] StatusDescriptions
...

创建新实例

某些 CIM 提供程序允许您创建特定类对象的新实例。要创建类对象的新实例，请使用 create_instance（） 方法，如下所示：

class_object.create_instance(properties)

将 class_object 替换为类对象的名称和属性，该字典由键值对组成，其中键表示实例属性和值代表属性值。此方法返回 LMIInstance 对象。

例 22.16. 创建新实例

LMI_Group 类代表系统组，LMI_Account 类代表受管系统上的用户帐户。要使用例 22.5 “访问命名空间对象” 中创建 的命名空间 对象，为名为 peg asus 的系统组和名为 lmishell-user 的用户创建这两个类的实例，并将其分配给名为 group 和 user 的变量，在交互式提示中输入以下内容：

> group = ns.LMI_Group.first_instance({"Name" : "pegasus"})
> user = ns.LMI_Account.first_instance({"Name" : "lmishell-user"})
>

要为 lmishell-user 用户获取 LMI_Identity 类的实例，请输入：

> identity = user.first_associator(ResultClass="LMI_Identity")
>

LMI_MemberOfGroup 类代表系统组成员资格。要使用 LMI_MemberOfGroup 类将 lmishell-user 添加到 pegasus 组，请按照如下所示创建新实例：

> ns.LMI_MemberOfGroup.create_instance({
...   "Member" : identity.path,
...   "Collection" : group.path})
LMIInstance(classname="LMI_MemberOfGroup", ...)
>

删除单个实例

要从 CIMOM 删除特定实例，请使用 delete（） 方法，如下所示：

instance_object.delete()

将 instance_object 替换为要删除的实例对象的名称。此方法返回布尔值：请注意，删除实例后，其属性和方法将无法访问。

例 22.17. 删除单个实例

LMI_Account 类代表受管系统上的用户帐户。要使用例 22.5 “访问命名空间对象” 中创建 的命名空间 对象，请为名为 lmishell-user 的用户创建一个 LMI_Account 类实例，并将其分配给名为 user 的变量，在交互式提示下键入以下内容：

> user = ns.LMI_Account.first_instance({"Name" : "lmishell-user"})
>

要删除此实例并从系统中删除 lmishell-user，请输入：

> user.delete()
True
>

列出和访问可用属性

要列出特定实例对象的所有可用属性，请使用 print_properties（） 方法，如下所示：

instance_object.print_properties()

将 instance_object 替换为要检查的实例对象的名称。此方法打印标准输出的可用属性。

要获取可用属性的列表，请使用 properties（） 方法：

instance_object.properties()

此方法返回字符串列表。

例 22.18. 列出可用属性

要检查例 22.14 “访问实例” 中创建 的设备 实例对象并列出所有可用的属性，请在互动提示下输入以下内容：

> device.print_properties()
RequestedState
HealthState
StatusDescriptions
TransitioningToState
Generation
...
>

要将这些属性的列表分配给名为 device_properties 的变量，请输入：

> device_properties = device.properties()
>

要获取特定属性的当前值，请使用以下语法：

instance_object.property_name

将 property_name 替换为要访问的属性的名称。

要修改特定属性的值，请按如下所示为其分配一个值：

instance_object.property_name = value

使用属性的新值替换 value。请注意，要将更改传播到 CIMOM，还必须执行 push（） 方法：

instance_object.push()

此方法返回一个包含返回值、返回值参数和错误字符串的三项元组。

例 22.19. 访问单个属性

要检查例 22.14 “访问实例” 中创建 的设备 实例对象并显示名为 SystemName 的属性值，请在交互式提示符后输入以下内容：

> device.SystemName
u'server.example.com'
>

列出和使用可用的方法

要列出特定实例对象的所有可用方法，请使用 print_methods（） 方法，如下所示：

instance_object.print_methods()

将 instance_object 替换为要检查的实例对象的名称。此方法将可用方法打印到标准输出。

要获取可用方法的列表，请使用 method（）方法 ：

instance_object.methods()

此方法返回字符串列表。

例 22.20. 列出可用的方法

要检查例 22.14 “访问实例” 中创建 的设备 实例对象并列出所有可用的方法，请在交互式提示下输入以下内容：

> device.print_methods()
RequestStateChange
>

要将这些方法的列表分配给名为 network_device_methods 的变量，请输入：

> network_device_methods = device.methods()
>

要调用特定方法，请使用以下语法：

instance_object.method_name(
  parameter=value,
  ...)

将 instance_object 替换为要使用的实例对象名称，metric_name 替换为要调用的方法的名称，parameter 替换为要设置的参数的名称，value 替换为此参数的值。方法返回由返回值、返回值参数和错误字符串组成的三项元组。

重要

LMIInstance 对象 不会自动 刷新其内容（属性、方法、限定符等）。要做到这一点，请使用如下所示的 refresh（） 方法。

例 22.21. 使用方法

PG_ComputerSystem 类代表系统。要使用在例 22.5 “访问命名空间对象” 中创建了 then s namespace 对象并把它分配给名为 sys 的变量来创建此类实例，请在互动提示中输入以下内容：

> sys = ns.PG_ComputerSystem.first_instance()
>

LMI_AccountManagementService 类实施的方法允许您管理系统中的用户和组。要创建此类实例并将其分配给名为 acc 的变量，请输入：

> acc = ns.LMI_AccountManagementService.first_instance()
>

要在系统中创建名为 lmishell-user 的新用户，请使用 CreateAccount（） 方法，如下所示：

> acc.CreateAccount(Name="lmishell-user", System=sys)
LMIReturnValue(rval=0, rparams=NocaseDict({u'Account': LMIInstanceName(classname="LMI_Account"...), u'Identities': [LMIInstanceName(classname="LMI_Identity"...), LMIInstanceName(classname="LMI_Identity"...)]}), errorstr='')

LMIShell 支持同步方法调用：使用同步方法时，LMIShell 会等待对应的作业对象将其状态更改为"finished"，然后返回此作业的返回参数。如果给定方法返回以下类之一的对象，LMIShell 能够执行同步方法调用：

LMI_StorageJob
LMI_SoftwareInstallationJob
LMI_NetworkJob

LMIShell 首先尝试将信号用作等待方法。如果失败，则改为使用轮询方法。

要执行同步方法调用，请使用以下语法：

instance_object.Syncmethod_name(
  parameter=value,
  ...)

将 instance_object 替换为要使用的实例对象名称，metric_name 替换为要调用的方法的名称，parameter 替换为要设置的参数的名称，value 替换为此参数的值。所有同步方法的名称中包含 Sync 前缀，并返回由作业返回值、作业返回值参数和作业的错误字符串组成的三项元组。

您还可以强制 LMIShell 仅使用轮询方法。要做到这一点，请指定 PreferPolling 参数，如下所示：

instance_object.Syncmethod_name(
  PreferPolling=True
  parameter=value,
  ...)

列出和查看 ValueMap 参数

CIM 方法可以在其受管对象格式(MOF)定义中包含 ValueMap 参数。ValueMap 参数包含恒定值。

要列出特定方法的所有可用 ValueMap 参数，请使用 print_valuemap_parameters（） 方法，如下所示：

instance_object.method_name.print_valuemap_parameters()

将 instance_object 替换为实例对象的名称，将 method_name 替换为要检查的方法的名称。此方法将可用的 ValueMap 参数打印到标准输出。

要获取可用 ValueMap 参数列表，请使用 valuemap_parameters（） 方法：

instance_object.method_name.valuemap_parameters()

此方法返回字符串列表。

例 22.22. 列出 ValueMap 参数

要检查例 22.21 “使用方法” 中创建 的 acc 实例对象并列出 CreateAccount（） 方法的所有可用 ValueMap 参数，在交互式提示符处输入以下内容：

> acc.CreateAccount.print_valuemap_parameters()
CreateAccount
>

要将这些 ValueMap 参数的列表分配给名为 create_account_parameters 的变量，请输入：

> create_account_parameters = acc.CreateAccount.valuemap_parameters()
>

要访问特定的 ValueMap 参数，请使用以下语法：

instance_object.method_name.valuemap_parameterValues

将 valuemap_parameter 替换为要访问的 ValueMap 参数的名称。

要列出所有可用的常量值，请使用 print_values（） 方法，如下所示：

instance_object.method_name.valuemap_parameterValues.print_values()

此方法将打印标准输出的命名常数值。您还可以使用 values( )方法获取可用常数值 的列表：

instance_object.method_name.valuemap_parameterValues.values()

此方法返回字符串列表。

例 22.23. 访问 ValueMap 参数

例 22.22 “列出 ValueMap 参数” 提到名为 CreateAccount 的 ValueMap 参数。要检查这个参数并列出可用的常数值，在互动提示中输入以下内容：

> acc.CreateAccount.CreateAccountValues.print_values()
Operationunsupported
Failed
Unabletosetpasswordusercreated
Unabletocreatehomedirectoryusercreatedandpasswordset
Operationcompletedsuccessfully
>

要将这些常量值的列表分配给名为 create_account_values 的变量，请输入：

> create_account_values = acc.CreateAccount.CreateAccountValues.values()
>

要访问特定的常量值，请使用以下语法：

instance_object.method_name.valuemap_parameterValues.constant_value_name

将 constant_value_name 替换为常量值的名称。或者，您可以使用 value（） 方法，如下所示：

instance_object.method_name.valuemap_parameterValues.value("constant_value_name")

要确定特定常量值的名称，请使用 value_name（） 方法：

instance_object.method_name.valuemap_parameterValues.value_name("constant_value")

此方法返回字符串。

例 22.24. 访问 Constant 值

例 22.23 “访问 ValueMap 参数” 显示 CreateAccount ValueMap 参数提供了名为 Failed 的常量值。要访问名为常量值的这个值，在互动提示中输入以下内容：

> acc.CreateAccount.CreateAccountValues.Failed
2
> acc.CreateAccount.CreateAccountValues.value("Failed")
2
>

要确定这个恒定值的名称，请输入：

> acc.CreateAccount.CreateAccountValues.value_name(2)
u'Failed'
>

刷新实例对象

如果这样的对象在使用 LMIShell 时发生改变，则代表 CIMOM 端 CIM 对象的 LMIShell 使用的本地对象可能会过时。要更新特定实例对象的属性和方法，请使用 refresh（） 方法，如下所示：

instance_object.refresh()

将 instance_object 替换为要刷新的对象的名称。此方法返回一个包含返回值、返回值参数和错误字符串的三项元组。

例 22.25. 刷新实例对象

要更新在例 22.14 “访问实例” 中创建 的设备 实例对象的属性和方法，在互动提示中输入以下内容：

> device.refresh()
LMIReturnValue(rval=True, rparams=NocaseDict({}), errorstr='')
>

显示 MOF 表述

要显示实例对象的受管对象格式(MOF)，请使用 tomof（） 方法，如下所示：

instance_object.tomof()

将 instance_object 替换为要检查的实例对象的名称。此方法将对象的 MOF 表示形式打印到标准输出。

例 22.26. 显示 MOF 表述

要显示在例 22.14 “访问实例” 中创建 的设备 实例对象的 MOF 表述，在互动提示中输入以下内容：

> device.tomof()
instance of LMI_IPNetworkConnection {
    RequestedState = 12;
    HealthState = NULL;
    StatusDescriptions = NULL;
    TransitioningToState = 12;
...

22.4.6. 使用实例名称

LMIShell 实例名称是存放一组主键及其值的对象。这种类型的对象完全识别实例。

访问实例名称

CIMInstance 对象由 CIMInstanceName 对象标识。要获取所有可用实例名称对象的列表，请使用 instance_names（） 方法，如下所示：

class_object.instance_names()

将 class_object 替换为要检查的类对象的名称。此方法返回 LMIInstanceName 对象列表。

要访问类对象的第一个实例名称对象，请使用 first_instance_name（） 方法：

class_object.first_instance_name()

此方法返回 LMIInstanceName 对象。

除了列出所有实例名称对象或返回第一个对象外，instance _names（） 和 first_instance_name（） 支持可选参数以允许您过滤结果：

class_object.instance_names(criteria)

class_object.first_instance_name(criteria)

使用由键值对组成的字典替换条件，其中键表示键属性和值表示这些键属性的必要值。

例 22.27. 访问实例名称

要查找在例 22.7 “访问类对象” 中创建的 cls 类对象的第一个实例名称，其 Name 键属性等于 eth0，并将它分配给名为 device_name 的变量，在交互式提示下输入以下内容：

> device_name = cls.first_instance_name({"Name": "eth0"})
>

检查实例名称

所有实例名称对象存储其类名称和所属命名空间的信息。

要获取特定实例名称对象的类名称，请使用以下语法：

instance_name_object.classname

将 instance_name_object 替换为要检查的实例名称对象的名称。这将返回类名称的字符串表示。

要获取有关实例名称对象所属命名空间的信息，请使用：

instance_name_object.namespace

这会返回命名空间的字符串表示。

例 22.28. 检查实例名称

要检查例 22.27 “访问实例名称” 中创建的 device_name 实例名称对象并显示其类名称和对应命名空间，请在交互式提示符后输入以下内容：

> device_name.classname
u'LMI_IPNetworkConnection'
> device_name.namespace
'root/cimv2'
>

创建新实例名称

如果您知道远程对象的所有主键，则 LMIShell 允许您创建新的 wrapped CIMInstanceName 对象。然后，此实例名称对象可用于检索整个实例对象。

要为类对象创建新实例名称，请使用 new_instance_name（） 方法，如下所示：

class_object.new_instance_name(key_properties)

将 class_object 替换为类对象的名称，而 key_properties 替换为由键值对组成的字典，其中键代表键属性和值代表键属性值。此方法返回 LMIInstanceName 对象。

例 22.29. 创建新实例名称

LMI_Account 类代表受管系统上的用户帐户。要使用例 22.5 “访问命名空间对象” 中创建 的命名空间 对象，并创建代表受管系统中 lmishell-user 用户的 LMI_Account 类的新实例名称，请在交互式提示符后输入以下内容：

> instance_name = ns.LMI_Account.new_instance_name({
...   "CreationClassName" : "LMI_Account",
...   "Name" : "lmishell-user",
...   "SystemCreationClassName" : "PG_ComputerSystem",
...   "SystemName" : "server"})
>

列出和访问密钥属性

要列出特定实例名称对象的所有可用键属性，请使用 print_key_properties（） 方法，如下所示：

instance_name_object.print_key_properties()

将 instance_name_object 替换为要检查的实例名称对象的名称。此方法打印标准输出的可用密钥属性。

要获取可用密钥属性列表，请使用 key_properties（） 方法：

instance_name_object.key_properties()

此方法返回字符串列表。

例 22.30. 列出可用密钥属性

要检查例 22.27 “访问实例名称” 中创建的 device_name 实例名称对象并列出所有可用的密钥属性，请在互动提示符后输入以下内容：

> device_name.print_key_properties()
CreationClassName
SystemName
Name
SystemCreationClassName
>

要将这些密钥属性的列表分配给名为 device_name_properties 的变量，请输入：

> device_name_properties = device_name.key_properties()
>

要获取特定键属性的当前值，请使用以下语法：

instance_name_object.key_property_name

将 key_property_name 替换为要访问的键属性的名称。

例 22.31. 访问单个密钥属性

要检查例 22.27 “访问实例名称” 中创建的 device_name 实例名称对象并显示名为 SystemName 的键属性值，在交互式提示符处输入以下内容：

> device_name.SystemName
u'server.example.com'
>

将实例名称转换为实例

每个实例名称可以转换为实例。要做到这一点，请使用 to_instance（） 方法，如下所示：

instance_name_object.to_instance()

将 instance_name_object 替换为要转换的实例名称对象的名称。此方法返回 LMIInstance 对象。

例 22.32. 将实例名称转换为实例

要将例 22.27 “访问实例名称” 中创建的 device_name 实例名称对象转换为实例对象，并将其分配给名为 device 的变量，请在互动提示中输入以下内容：

> device = device_name.to_instance()
>

22.4.7. 使用关联的对象

通用信息模型定义受管对象之间的关联关系。

访问关联的实例

要获取与特定实例对象关联的所有对象的列表，请使用关联 器（） 方法，如下所示：

instance_object.associators(
  AssocClass=class_name,
  ResultClass=class_name,
  ResultRole=role,
  IncludeQualifiers=include_qualifiers,
  IncludeClassOrigin=include_class_origin,
  PropertyList=property_list)

要访问与特定实例对象关联的第一个对象，请使用 first_associator（） 方法：

instance_object.first_associator(
  AssocClass=class_name,
  ResultClass=class_name,
  ResultRole=role,
  IncludeQualifiers=include_qualifiers,
  IncludeClassOrigin=include_class_origin,
  PropertyList=property_list)

将 instance_object 替换为要检查的实例对象的名称。您可以通过指定以下参数来过滤结果：

AssocClass - 每个返回的对象必须通过本课程的实例或其子类与源对象关联。默认值为 None。
ResultClass - 返回的每个对象必须是此类的实例或其子类，或者必须是此类或其子类之一。默认值为 None。
角色 - 每个返回的对象必须通过关联（源对象在其中充当指定角色）与源对象关联。引用源对象的关联类中的属性名称必须与此参数的值匹配。默认值为 None。
ResultRole - 每个返回的对象必须通过关联与源对象关联，在其中返回的对象充当指定角色。引用返回对象的关联类中的属性名称必须与此参数的值匹配。默认值为 None。

剩余的参数指的是：

IncludeQualifiers - 表示每个对象的所有限定符（包括对象上和任何返回的属性上的限定符）是否都应包含在响应中，作为 QUALIFIER 元素包含在响应中。默认值为 False。
IncludeClassOrigin - 指明是否应将 CLASSORIGIN 属性显示在每个返回的对象中的所有相关元素的布尔值。默认值为 False。
AtityList - 此列表的成员定义了一个或多个属性名称。返回的对象不包括在此列表中缺失的任何属性的元素。如果 properties List 是空列表，则返回的对象中不包含任何属性。如果是 None，则不定义额外的过滤。默认值为 None。

例 22.33. 访问关联的实例

LMI_StorageExtent 类代表系统中可用的块设备。要使用例 22.5 “访问命名空间对象” 中创建 的命名空间 对象，请为名为 /dev/vda 的块设备创建一个 LMI_StorageExtent 类实例，并将其分配给名为 vda 的变量，在交互式提示下键入以下内容：

> vda = ns.LMI_StorageExtent.first_instance({
...   "DeviceID" : "/dev/vda"})
>

要获取此块设备上所有磁盘分区的列表并将其分配给名为 vda_partitions 的变量，请使用关联 器（） 方法，如下所示：

> vda_partitions = vda.associators(ResultClass="LMI_DiskPartition")
>

访问关联的实例名称

要获取特定实例对象的所有关联的实例名称列表，请使用 associator_names（） 方法，如下所示：

instance_object.associator_names(
  AssocClass=class_name,
  ResultClass=class_name,
  Role=role,
  ResultRole=role)

要访问特定实例对象的第一个关联的实例名称，请使用 first_associator_name（） 方法：

instance_object.first_associator_name(
  AssocClass=class_object,
  ResultClass=class_object,
  Role=role,
  ResultRole=role)

将 instance_object 替换为要检查的实例对象的名称。您可以通过指定以下参数来过滤结果：

AssocClass - 每个返回的名称都标识必须通过此类实例或其子类与源对象关联的对象。默认值为 None。
ResultClass - 每个返回的名称标识一个对象，该对象必须是本课程的实例或其子类，或者它必须是此类或其子类之一。默认值为 None。
角色 - 每个返回的名称都标识必须通过源对象扮演指定角色的关联与源对象关联的对象。引用源对象的关联类中的属性名称必须与此参数的值匹配。默认值为 None。
ResultRole - 每个返回的名称标识必须通过关联的关联与源对象关联的对象，在其中返回的指定对象 play 指定指定的角色。引用返回对象的关联类中的属性名称必须与此参数的值匹配。默认值为 None。

例 22.34. 访问关联的实例名称

要使用例 22.33 “访问关联的实例” 中创建的 vda 实例对象，请获取其关联的实例名称列表并将其分配给名为 vda_partitions 的变量，请输入：

> vda_partitions = vda.associator_names(ResultClass="LMI_DiskPartition")
>

22.4.8. 使用关联对象

通用信息模型定义受管对象之间的关联关系。关联对象定义另外两个对象之间的关系。

访问关联实例

要获得引用特定目标对象的关联对象列表，请使用 reference （） 方法，如下所示：

instance_object.references(
  ResultClass=class_name,
  Role=role,
  IncludeQualifiers=include_qualifiers,
  IncludeClassOrigin=include_class_origin,
  PropertyList=property_list)

要访问引用特定目标对象的第一个关联对象，请使用 first_reference（） 方法：

instance_object.first_reference(
...   ResultClass=class_name,
...   Role=role,
...   IncludeQualifiers=include_qualifiers,
...   IncludeClassOrigin=include_class_origin,
...   PropertyList=property_list)
>

将 instance_object 替换为要检查的实例对象的名称。您可以通过指定以下参数来过滤结果：

ResultClass - 返回的每个对象必须是此类的实例或其子类，或者必须是此类或其子类之一。默认值为 None。
角色 - 每个返回的对象必须通过具有与此参数值匹配的名称的属性引用目标对象。默认值为 None。

剩余的参数指的是：

IncludeQualifiers - 指明每个对象（包括对象上的限定符以及任何返回的属性上的限定符）的布尔值应包含在响应中，作为 QUALIFIER 元素包含在响应中。默认值为 False。
IncludeClassOrigin - 指明是否应将 CLASSORIGIN 属性显示在每个返回的对象中的所有相关元素的布尔值。默认值为 False。
AtityList - 此列表的成员定义了一个或多个属性名称。返回的对象不包括在此列表中缺失的任何属性的元素。如果 properties List 是空列表，则返回的对象中不包含任何属性。如果是 None，则不定义额外的过滤。默认值为 None。

例 22.35. 访问关联实例

LMI_LANEndpoint 类代表与特定网络接口设备关联的通信端点。要使用例 22.5 “访问命名空间对象” 中创建 的命名空间 对象，请为名为 eth0 的网络接口设备创建一个 LMI_LANEndpoint 类实例，并将其分配给名为 lan_endpoint 的变量，在交互式提示符后输入以下内容：

> lan_endpoint = ns.LMI_LANEndpoint.first_instance({
...   "Name" : "eth0"})
>

要访问引用 LMI_BindsToLANEndpoint 对象的第一个关联对象，并将其分配给名为 bind 的变量，请输入：

> bind = lan_endpoint.first_reference(
...   ResultClass="LMI_BindsToLANEndpoint")
>

现在，您可以使用 Dependent 属性访问代表对应网络接口设备的 IP 地址的依赖 LMI_IPProtocolEndpoint 类：

> ip = bind.Dependent.to_instance()
> print ip.IPv4Address
192.168.122.1
>

访问关联实例名称

要获取特定实例对象的关联实例名称列表，请使用 reference_names（） 方法，如下所示：

instance_object.reference_names(
  ResultClass=class_name,
  Role=role)

要访问特定实例对象的第一个关联实例名称，请使用 first_reference_name（） 方法：

instance_object.first_reference_name(
  ResultClass=class_name,
  Role=role)

将 instance_object 替换为要检查的实例对象的名称。您可以通过指定以下参数来过滤结果：

ResultClass - 返回的每个对象名称标识此类的实例或其子类，或标识此类或其子类之一。默认值为 None。
角色 - 每个返回的对象通过属性引用目标实例，该属性与此参数的值匹配。默认值为 None。

例 22.36. 访问关联实例名称

要使用例 22.35 “访问关联实例” 中创建的 lan_endpoint 实例对象，访问引用 LMI_BindsToLANEndpoint 对象的第一个关联实例名称，并将其分配给名为 bind 的变量，类型：

> bind = lan_endpoint.first_reference_name(
...   ResultClass="LMI_BindsToLANEndpoint")

现在，您可以使用 Dependent 属性访问代表对应网络接口设备的 IP 地址的依赖 LMI_IPProtocolEndpoint 类：

> ip = bind.Dependent.to_instance()
> print ip.IPv4Address
192.168.122.1
>

22.4.9. 使用 Indications

表示是对响应特定数据变化的特定事件作出响应。LMIShell 可以订阅一个信号来接收此类事件响应。

订阅印度语

要订阅指示信息，请使用 subscribe_indication（） 方法，如下所示：

connection_object.subscribe_indication(
  QueryLanguage="WQL",
  Query='SELECT * FROM CIM_InstModification',
  Name="cpu",
  CreationNamespace="root/interop",
  SubscriptionCreationClassName="CIM_IndicationSubscription",
  FilterCreationClassName="CIM_IndicationFilter",
  FilterSystemCreationClassName="CIM_ComputerSystem",
  FilterSourceNamespace="root/cimv2",
  HandlerCreationClassName="CIM_IndicationHandlerCIMXML",
  HandlerSystemCreationClassName="CIM_ComputerSystem",
  Destination="http://host_name:5988")

或者，您可以使用方法调用的较短版本，如下所示：

connection_object.subscribe_indication(
  Query='SELECT * FROM CIM_InstModification',
  Name="cpu",
  Destination="http://host_name:5988")

使用连接对象替换 connection_object，将 host_name 替换为您要向其发送声明的系统的主机名。

默认情况下，当解释器终止时，LMIShell 解释器创建的所有订阅都会被自动删除。要更改此行为，请将 persistent=True 关键字参数传递到 subscribe_indication（） 方法调用。这将阻止 LMIShell 删除订阅。

列出订阅的引用

要列出所有订阅的指示，请使用 print_subscribed_indications（） 方法，如下所示：

connection_object.print_subscribed_indications()

将 connection_object 替换为要检查的连接对象的名称。此方法打印订阅了标准输出的指示。

要获得订阅的注解列表，请使用 subscription _indications（） 方法：

connection_object.subscribed_indications()

此方法返回字符串列表。

例 22.38. 列出订阅的引用

要检查例 22.1 “连接到远程 CIMOM” 中创建的 c 连接对象并列出所有订阅的声明，请在互动提示下输入以下内容：

> c.print_subscribed_indications()
>

要将这些暗示的列表分配给名为投注的变量 ， 请输入：

> indications = c.subscribed_indications()
>

取消订阅 Indications

默认情况下，当解释器终止时，LMIShell 解释器创建的所有订阅都会被自动删除。要更快地删除单个订阅，请使用 unsubscribe_indication（） 方法，如下所示：

connection_object.unsubscribe_indication(indication_name)

使用连接对象的名称替换 connection_object ，将 indicating_name 替换为要删除的指示符的名称。

要删除所有订阅，请使用 unsubscribe_all_indications（） 方法：

connection_object.unsubscribe_all_indications()

例 22.39. 取消订阅 Indications

要使用在例 22.1 “连接到远程 CIMOM” 中创建的 c 连接对象并取消订阅在例 22.37 “订阅印度语” 中创建的指示，在互动提示符下输入以下内容：

> c.unsubscribe_indication('cpu')
LMIReturnValue(rval=True, rparams=NocaseDict({}), errorstr='')
>

实施 Indication Handler

subscribe_indication（） 方法允许您指定您要向其发送声明的系统的主机名。以下示例演示了如何实施指示处理器：

> def handler(ind, arg1, arg2, kwargs): ... exported_objects = ind.exported_objects() ... do_something_with(exported_objects) > listener = LmiIndicationListener("0.0.0.0", listening_port) > listener.add_handler("indication-name-XXXXXXXX", handler, arg1, arg2, kwargs)
> listener.start()
>

处理程序的第一个参数是 LmiIndication 对象，其中包含由指示器导出的方法和对象的列表。其他参数特定于用户：向侦听器添加处理程序时需要指定这些参数。

在上例中，add _handler（） 方法调用使用具有八个"X"字符的特殊字符串。这些字符替换为由侦听器生成的随机字符串，以避免可能的处理程序名称冲突。要使用随机字符串，请首先启动指示监听器，然后订阅指示，使得处理程序对象的 Destination 属性包含以下值： schema://host_name/random_string。

例 22.40. 实施 Indication Handler

以下脚本演示了如何编写监控位于 192.168.122.1 的受管系统的处理程序，并在创建新用户帐户时调用 indicates _callback（） 功能：

#!/usr/bin/lmishell

import sys
from time import sleep
from lmi.shell.LMIUtil import LMIPassByRef
from lmi.shell.LMIIndicationListener import LMIIndicationListener

# These are passed by reference to indication_callback
var1 = LMIPassByRef("some_value")
var2 = LMIPassByRef("some_other_value")

def indication_callback(ind, var1, var2):
  # Do something with ind, var1 and var2
  print ind.exported_objects()
  print var1.value
  print var2.value

c = connect("hostname", "username", "password")

listener = LMIIndicationListener("0.0.0.0", 65500)
unique_name = listener.add_handler(
  "demo-XXXXXXXX",   # Creates a unique name for me
  indication_callback, # Callback to be called
  var1,        # Variable passed by ref
  var2         # Variable passed by ref
)

listener.start()

print c.subscribe_indication(
  Name=unique_name,
  Query="SELECT * FROM LMI_AccountInstanceCreationIndication WHERE SOURCEINSTANCE ISA LMI_Account",
  Destination="192.168.122.1:65500"
)

try:
  while True:
    sleep(60)
except KeyboardInterrupt:
  sys.exit(0)

22.4.10. 用法示例

本节为随 OpenLMI 软件包分发的各种 CIM 提供程序提供了多个示例。本节中的所有示例都使用以下两个变量定义：

c = connect("host_name", "user_name", "password")
ns = c.root.cimv2

使用受管系统的主机名替换 host _name，user_name 替换为被允许连接到该系统上运行的 OpenPegasus CIMOM 的用户名称，密码为用户的密码。

使用 OpenLMI Service Provider

openlmi-service 软件包安装 CIM 提供程序以管理系统服务。以下示例演示了如何使用 CIM 提供程序列出可用的系统服务，以及如何启动、停止、启用和禁用这些服务。

例 22.41. 列出可用的服务

要列出受管机器上的所有可用服务以及有关服务是否已启动(TRUE)还是停止(FALSE)和状态字符串的信息，请使用以下代码片段：

for service in ns.LMI_Service.instances():
  print "%s:\t%s" % (service.Name, service.Status)

要只列出默认启用的服务，请使用这个代码片段：

cls = ns.LMI_Service
for service in cls.instances():
  if service.EnabledDefault == cls.EnabledDefaultValues.Enabled:
    print service.Name

请注意，已启用的服务 EnabledDefault 属性的值等于 2，对于 禁用的服务则等于 3。

要显示 cups 服务的信息，请使用：

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.doc()

例 22.42. 启动和停止服务

要启动和停止 cups 服务并查看其当前状态，请使用以下代码片段：

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.StartService()
print cups.Status
cups.StopService()
print cups.Status

例 22.43. 启用和禁用服务

要启用或禁用 cups 服务并显示其 EnabledDefault 属性，请使用以下代码片段：

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.TurnServiceOff()
print cups.EnabledDefault
cups.TurnServiceOn()
print cups.EnabledDefault

使用 OpenLMI 网络提供程序

openlmi-networking 软件包会安装用于网络的 CIM 提供程序。以下示例演示了如何使用此 CIM 提供程序列出与特定端口号关联的 IP 地址、创建新连接、配置静态 IP 地址以及激活连接。

例 22.44. 列出与给定端口号关联的 IP 地址

要列出与 eth0 网络接口关联的所有 IP 地址，请使用以下代码片段：

device = ns.LMI_IPNetworkConnection.first_instance({'ElementName': 'eth0'})
for endpoint in device.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_IPProtocolEndpoint"):
  if endpoint.ProtocolIFType == ns.LMI_IPProtocolEndpoint.ProtocolIFTypeValues.IPv4:
    print "IPv4: %s/%s" % (endpoint.IPv4Address, endpoint.SubnetMask)
  elif endpoint.ProtocolIFType == ns.LMI_IPProtocolEndpoint.ProtocolIFTypeValues.IPv6:
    print "IPv6: %s/%d" % (endpoint.IPv6Address, endpoint.IPv6SubnetPrefixLength)

此代码片段使用与给定的 LMI_IPProtocolEndction 类关联的 LMI_IPProtocolEndpoint 类。

要显示默认网关，请使用这个代码片段：

for rsap in device.associators(AssocClass="LMI_NetworkRemoteAccessAvailableToElement", ResultClass="LMI_NetworkRemoteServiceAccessPoint"):
  if rsap.AccessContext == ns.LMI_NetworkRemoteServiceAccessPoint.AccessContextValues.DefaultGateway:
    print "Default Gateway: %s" % rsap.AccessInfo

默认网关由 LMI_NetworkRemoteServiceAccessPoint 实例表示，AccessContext 属性等于 DefaultGateway。

要获取 DNS 服务器列表，需要按照如下所示遍历对象模型：

使用 LMI_Network SAPSAPDependency 获取与给定 LMI_IPNetworkConnection 关联的 LMI_ IPProtocolEndpoint 实例。
对 LMI_DNSProtocolEndpoint 实例使用相同的关联。

具有 AccessContext 属性的 LMI_NetworkRemoteServiceAccessPoint 实例等于通过 LMI_NetworkRemoteAccessAvailableToElement 关联的 DNS 服务器地址，在 AccessInfo 属性中具有 DNS 服务器地址。

可以通过更多路径进入 RemoteServiceAccessPath，并且可以重复条目。以下代码片段使用 set（） 功能从 DNS 服务器列表中删除重复条目：

dnsservers = set()
for ipendpoint in device.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_IPProtocolEndpoint"):
  for dnsedpoint in ipendpoint.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_DNSProtocolEndpoint"):
    for rsap in dnsedpoint.associators(AssocClass="LMI_NetworkRemoteAccessAvailableToElement", ResultClass="LMI_NetworkRemoteServiceAccessPoint"):
      if rsap.AccessContext == ns.LMI_NetworkRemoteServiceAccessPoint.AccessContextValues.DNSServer:
        dnsservers.add(rsap.AccessInfo)
print "DNS:", ", ".join(dnsservers)

例 22.45. 创建新连接和配置静态 IP 地址

要为网络接口 eth0 创建带有静态 IPv4 和无状态 IPv6 配置的新设置，请使用以下代码片段：

capability = ns.LMI_IPNetworkConnectionCapabilities.first_instance({ 'ElementName': 'eth0' })
result = capability.LMI_CreateIPSetting(Caption='eth0 Static',
    IPv4Type=capability.LMI_CreateIPSetting.IPv4TypeValues.Static,
    IPv6Type=capability.LMI_CreateIPSetting.IPv6TypeValues.Stateless)
setting = result.rparams["SettingData"].to_instance()
for settingData in setting.associators(AssocClass="LMI_OrderedIPAssignmentComponent"):
  if setting.ProtocolIFType == ns.LMI_IPAssignmentSettingData.ProtocolIFTypeValues.IPv4:
    # Set static IPv4 address
    settingData.IPAddresses = ["192.168.1.100"]
    settingData.SubnetMasks = ["255.255.0.0"]
    settingData.GatewayAddresses = ["192.168.1.1"]
    settingData.push()

此代码片段通过在 LMI_ IPNetworkConnectionCapabilities 实例上调用 LMI_CreateIPSetting（）方法来创建新设置，它通过 LMI_IPNetworkConnectionEnementCapabilities 与 LMI_IPNetwork ConnectionElementCapabilities 关联。它还使用 push（） 方法修改设置。

例 22.46. 激活连接

要将设置应用到网络接口，请调用 LMI_ IPConfigurationService 类的 ApplySettingToIP NetworkConnection（） 方法。这个方法是异步的，并返回一个作业。以下代码片段演示了如何同步调用此方法：

setting = ns.LMI_IPAssignmentSettingData.first_instance({ "Caption": "eth0 Static" })
port = ns.LMI_IPNetworkConnection.first_instance({ 'ElementName': 'ens8' })
service = ns.LMI_IPConfigurationService.first_instance()
service.SyncApplySettingToIPNetworkConnection(SettingData=setting, IPNetworkConnection=port, Mode=32768)

Mode 参数会影响设置的应用方式。此参数最常用的值如下：

1 - 立即应用设置，并将其自动激活。
2 - 使设置自动激活且现在不应用。
4 - 断开和禁用自动激活.
5 - 不更改设置状态，仅禁用自动激活。
32768 - 应用设置。
32769 - 断开连接.

使用 OpenLMI 存储提供程序

openlmi-storage 软件包安装 CIM 提供程序以进行存储管理。以下示例演示了如何使用此 CIM 提供程序创建卷组，创建逻辑卷，构建文件系统，挂载文件系统，以及列出系统已知的块设备。

除了 c 和 ns 变量外，这些示例还使用以下变量定义：

MEGABYTE = 1024*1024
storage_service = ns.LMI_StorageConfigurationService.first_instance()
filesystem_service = ns.LMI_FileSystemConfigurationService.first_instance()

例 22.47. 创建卷组

要创建位于 /dev/myGroup/ 中，且默认扩展大小为 4 MB 的新卷组，请使用以下代码片断：

# Find the devices to add to the volume group
# (filtering the CIM_StorageExtent.instances()
# call would be faster, but this is easier to read):
sda1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sda1"})
sdb1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sdb1"})
sdc1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sdc1"})

# Create a new volume group:
(ret, outparams, err) = storage_service.SyncCreateOrModifyVG(
    ElementName="myGroup",
    InExtents=[sda1, sdb1, sdc1])
vg = outparams['Pool'].to_instance()
print "VG", vg.PoolID, \
    "with extent size", vg.ExtentSize, \
    "and", vg.RemainingExtents, "free extents created."

例 22.48. 创建逻辑卷

要创建两个大小为 100 MB 的逻辑卷，请使用这个代码片段：

# Find the volume group:
vg = ns.LMI_VGStoragePool.first_instance({"Name": "/dev/mapper/myGroup"})

# Create the first logical volume:
(ret, outparams, err) = storage_service.SyncCreateOrModifyLV(
    ElementName="Vol1",
    InPool=vg,
    Size=100 * MEGABYTE)
lv = outparams['TheElement'].to_instance()
print "LV", lv.DeviceID, \
    "with", lv.BlockSize * lv.NumberOfBlocks,\
    "bytes created."

# Create the second logical volume:
(ret, outparams, err) = storage_service.SyncCreateOrModifyLV(
    ElementName="Vol2",
    InPool=vg,
    Size=100 * MEGABYTE)
lv = outparams['TheElement'].to_instance()
print "LV", lv.DeviceID, \
    "with", lv.BlockSize * lv.NumberOfBlocks, \
    "bytes created."

例 22.49. 创建文件系统

要从例 22.48 “创建逻辑卷” 在逻辑卷 lv 中创建 ext3 文件系统，请使用以下代码片段：

(ret, outparams, err) = filesystem_service.SyncLMI_CreateFileSystem(
    FileSystemType=filesystem_service.LMI_CreateFileSystem.FileSystemTypeValues.EXT3,
    InExtents=[lv])

例 22.50. 挂载文件系统

要挂载在例 22.49 “创建文件系统” 中创建的文件系统，请使用以下代码片段：

# Find the file system on the logical volume:
fs = lv.first_associator(ResultClass="LMI_LocalFileSystem")

mount_service = ns.LMI_MountConfigurationService.first_instance()
(rc, out, err) = mount_service.SyncCreateMount(
   FileSystemType='ext3',
   Mode=32768, # just mount
   FileSystem=fs,
   MountPoint='/mnt/test',
   FileSystemSpec=lv.Name)

例 22.51. 列出块设备

要列出所有系统已知的块设备，请使用以下代码片段：

devices = ns.CIM_StorageExtent.instances()
for device in devices:
  if lmi_isinstance(device, ns.CIM_Memory):
    # Memory and CPU caches are StorageExtents too, do not print them
    continue
  print device.classname,
  print device.DeviceID,
  print device.Name,
  print device.BlockSize*device.NumberOfBlocks

使用 OpenLMI 硬件提供程序

openlmi-hardware 软件包安装用于监控硬件的 CIM 提供程序。以下示例演示了如何使用 CIM 提供程序检索有关机器的 CPU、内存模块、PCI 设备、制造商和型号的信息。

例 22.52. 查看 CPU 信息

要显示基本 CPU 信息，如 CPU 名称、处理器内核数和硬件线程数量，请使用以下代码片断：

cpu = ns.LMI_Processor.first_instance()
cpu_cap = cpu.associators(ResultClass="LMI_ProcessorCapabilities")[0]
print cpu.Name
print cpu_cap.NumberOfProcessorCores
print cpu_cap.NumberOfHardwareThreads

例 22.53. 查看内存信息

要显示有关内存模块的基本信息，比如它们的各个大小，请使用以下代码片段：

mem = ns.LMI_Memory.first_instance()
for i in mem.associators(ResultClass="LMI_PhysicalMemory"):
  print i.Name

例 22.54. 查看机箱信息

要显示有关机器的基本信息，如制造商或其型号，请使用以下代码片段：

chassis = ns.LMI_Chassis.first_instance()
print chassis.Manufacturer
print chassis.Model

例 22.55. 列出 PCI 设备

要列出所有系统已知的 PCI 设备，请使用以下代码片段：

for pci in ns.LMI_PCIDevice.instances():
  print pci.Name

22.4. 使用 LMIShell

22.4.1. 启动、使用和退出 LMIShell

以交互模式启动 LMIShell

使用 Tab 完成

浏览历史记录

处理例外

配置临时缓存

退出 LMIShell

运行 LMIShell 脚本

22.4.2. 连接到 CIMOM

连接到远程 CIMOM

连接到本地 CIMOM

验证到 CIMOM 的连接

22.4.3. 使用命名空间

列出可用的命名空间

访问命名空间对象

22.4.4. 使用类

列出可用的类

访问类对象

检查类对象

列出可用的方法

列出可用属性

列出和查看值映射属性

获取 CIMClass 对象

22.4.5. 操作实例

访问实例

检查实例

创建新实例

删除单个实例

列出和访问可用属性

列出和使用可用的方法

列出和查看 ValueMap 参数

刷新实例对象

显示 MOF 表述

22.4.6. 使用实例名称

访问实例名称

检查实例名称

创建新实例名称

列出和访问密钥属性

将实例名称转换为实例

22.4.7. 使用关联的对象

访问关联的实例

访问关联的实例名称

22.4.8. 使用关联对象

访问关联实例

访问关联实例名称

22.4.9. 使用 Indications

订阅印度语

列出订阅的引用

取消订阅 Indications

实施 Indication Handler

22.4.10. 用法示例

使用 OpenLMI Service Provider

使用 OpenLMI 网络提供程序

使用 OpenLMI 存储提供程序

使用 OpenLMI 硬件提供程序

学习

尝试、购买和销售

社区

关于红帽文档

让开源更具包容性

關於紅帽

Red Hat legal and privacy links

Red Hat legal and privacy links