1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
# Copyright (C) 2013 Red Hat, Inc. All rights reserved.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#
# Authors: Roman Rakus <rrakus@redhat.com>
# Tomas Bzatek <tbzatek@redhat.com>
#
import pywbem
import os
import unittest
import Queue
import random
import BaseHTTPServer
import socket
import threading
"""
Base class for all tests
"""
class CIMListener(object):
""" CIM Listener
"""
class CIMHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_POST(self):
data = self.rfile.read(int(self.headers['Content-Length']))
tt = pywbem.parse_cim(pywbem.xml_to_tupletree(data))
# Get the instance from CIM-XML, copied from
# http://sf.net/apps/mediawiki/pywbem/?title=Indications_Tutorial
insts = [x[1] for x in tt[2][2][0][2][2]]
for inst in insts:
self.callback(inst)
self.send_response(200)
self.end_headers()
def log_message(self, format, *p):
# suppress log messages
pass
def __init__(self, callback, http_port=5988):
self.address = ('', http_port)
self.CIMHandler.callback = callback
self.thread = None
self.server = None
def start(self):
BaseHTTPServer.HTTPServer.allow_reuse_address = True
self.server = BaseHTTPServer.HTTPServer(self.address, self.CIMHandler)
self.thread = threading.Thread(target=self.server.serve_forever)
self.thread.start()
def stop(self):
if self.server is not None:
self.server.shutdown()
self.server.socket.close()
if self.thread is not None:
self.thread.join()
def running(self):
return self.thread is not None
class JournalBase(unittest.TestCase):
"""
Base class for all LMI Journal tests
"""
def setUp(self):
"""
Connnect to server
"""
self.url = os.environ.get("LMI_CIMOM_URL", "https://localhost:5989")
self.username = os.environ.get("LMI_CIMOM_USERNAME", "root")
self.password = os.environ.get("LMI_CIMOM_PASSWORD", "")
self.wbemconnection = pywbem.WBEMConnection(self.url,
(self.username, self.password))
# for indications
self.indication_port = random.randint(12000, 13000)
self.indication_queue = Queue.Queue()
self.listener = CIMListener(
callback=self._process_indication,
http_port=self.indication_port)
self.subscribed = {}
def tearDown(self):
self.listener.stop()
if self.subscribed:
for name in self.subscribed.keys():
self.unsubscribe(name)
def get_indication(self, timeout):
""" Wait for an indication for given nr. of seconds and return it."""
try:
indication = self.indication_queue.get(timeout=timeout)
except Queue.Empty:
raise AssertionError("Timeout when waiting for indicaiton")
self.indication_queue.task_done()
return indication
def subscribe(self, filter_name, query=None, querylang="DMTF:CQL"):
"""
Create indication subscription for given filter name.
"""
namespace = "root/interop"
hostname = socket.gethostname()
if query is not None:
# Create filter first
filterinst = pywbem.CIMInstance('CIM_IndicationFilter')
filterinst['CreationClassName'] = 'CIM_IndicationFilter'
filterinst['SystemCreationClassName'] = 'CIM_ComputerSystem'
filterinst['SystemName'] = hostname
filterinst['Name'] = filter_name
filterinst['Query'] = query
filterinst['QueryLanguage'] = querylang
filterinst['SourceNamespace'] = "root/cimv2"#namespace
cop = pywbem.CIMInstanceName('CIM_IndicationFilter')
cop.keybindings = { 'CreationClassName': 'CIM_IndicationFilter',
'SystemClassName': 'CIM_ComputerSystem',
'SystemName': hostname,
'Name': filter_name
}
cop.namespace=namespace
filterinst.path = cop
indfilter = self.wbemconnection.CreateInstance(filterinst)
else:
# the filter is already created, assemble its name
indfilter = pywbem.CIMInstanceName(
classname="CIM_IndicationFilter",
namespace=namespace,
keybindings={
'CreationClassName': 'CIM_IndicationFilter',
'SystemClassName': 'CIM_ComputerSystem',
'SystemName': hostname,
'Name': filter_name})
# create destination
destinst = pywbem.CIMInstance('CIM_ListenerDestinationCIMXML')
destinst['CreationClassName'] = 'CIM_ListenerDestinationCIMXML'
destinst['SystemCreationClassName'] = 'CIM_ComputerSystem'
destinst['SystemName'] = hostname
destinst['Name'] = filter_name
destinst['Destination'] = "http://localhost:%d" % (self.indication_port)
destinst['PersistenceType'] = pywbem.Uint16(3) # Transient
cop = pywbem.CIMInstanceName('CIM_ListenerDestinationCIMXML')
cop.keybindings = { 'CreationClassName':'CIM_ListenerDestinationCIMXML',
'SystemClassName':'CIM_ComputerSystem',
'SystemName':hostname,
'Name':filter_name }
cop.namespace = namespace
destinst.path = cop
destname = self.wbemconnection.CreateInstance(destinst)
# create the subscription
subinst = pywbem.CIMInstance('CIM_IndicationSubscription')
subinst['Filter'] = indfilter
subinst['Handler'] = destname
cop = pywbem.CIMInstanceName('CIM_IndicationSubscription')
cop.keybindings = { 'Filter': indfilter,
'Handler': destname }
cop.namespace = namespace
subinst.path = cop
subscription = self.wbemconnection.CreateInstance(subinst)
self.subscribed[filter_name] = [subscription, destname]
# start listening
if not self.listener.running():
self._start_listening()
return subscription
def unsubscribe(self, filter_name):
"""
Unsubscribe fron given filter.
"""
_list = self.subscribed.pop(filter_name)
for instance in _list:
self.wbemconnection.DeleteInstance(instance)
def _start_listening(self):
""" Start listening for incoming indications. """
self.listener.start()
def _process_indication(self, indication):
""" Callback to process one indication."""
self.indication_queue.put(indication)
|
