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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
import json
import sys
from uuid import UUID
from subprocess import check_output, CalledProcessError
class Spdk_Rpc(object):
def __init__(self, rpc_py):
self.rpc_py = rpc_py
def __getattr__(self, name):
def call(*args):
cmd = "{} {} {}".format(sys.executable, self.rpc_py, name)
for arg in args:
cmd += " {}".format(arg)
try:
output = check_output(cmd, shell=True)
return output.decode('ascii').rstrip('\n'), 0
except CalledProcessError as e:
print("ERROR: RPC Command {cmd} "
"execution failed:". format(cmd=cmd))
print("Failed command output:")
print(e.output)
return e.output.decode('ascii'), e.returncode
return call
class Commands_Rpc(object):
def __init__(self, rpc_py):
self.rpc = Spdk_Rpc(rpc_py)
def check_get_bdevs_methods(self, uuid_bdev, bdev_size_mb, bdev_alias=""):
print("INFO: Check RPC COMMAND get_bdevs")
output = self.rpc.get_bdevs()[0]
json_value = json.loads(output)
for i in range(len(json_value)):
uuid_json = json_value[i]['name']
aliases = json_value[i]['aliases']
if uuid_bdev in [uuid_json]:
print("Info: UUID:{uuid} is found in RPC Command: "
"gets_bdevs response".format(uuid=uuid_bdev))
# Check if human-friendly alias is as expected
if bdev_alias and aliases:
if bdev_alias not in aliases:
print("ERROR: Expected bdev alias not found")
print("Expected: {name}".format(name=bdev_alias))
print("Actual: {aliases}".format(aliases=aliases))
return 1
# num_block and block_size have values in bytes
num_blocks = json_value[i]['num_blocks']
block_size = json_value[i]['block_size']
if num_blocks * block_size == bdev_size_mb * 1024 * 1024:
print("Info: Response get_bdevs command is "
"correct. Params: uuid_bdevs: {uuid}, bdev_size "
"{size}".format(uuid=uuid_bdev,
size=bdev_size_mb))
return 0
print("INFO: UUID:{uuid} or bdev_size:{bdev_size_mb} not found in "
"RPC COMMAND get_bdevs: "
"{json_value}".format(uuid=uuid_bdev, bdev_size_mb=bdev_size_mb,
json_value=json_value))
return 1
def check_get_lvol_stores(self, base_name, uuid, cluster_size=None, lvs_name=""):
print("INFO: RPC COMMAND get_lvol_stores")
json_value = self.get_lvol_stores()
if json_value:
for i in range(len(json_value)):
json_uuid = json_value[i]['uuid']
json_cluster = json_value[i]['cluster_size']
json_base_name = json_value[i]['base_bdev']
json_name = json_value[i]['name']
if base_name in json_base_name \
and uuid in json_uuid:
print("INFO: base_name:{base_name} is found in RPC "
"Command: get_lvol_stores "
"response".format(base_name=base_name))
print("INFO: UUID:{uuid} is found in RPC Command: "
"get_lvol_stores response".format(uuid=uuid))
if cluster_size:
if str(cluster_size) in str(json_cluster):
print("Info: Cluster size :{cluster_size} is found in RPC "
"Command: get_lvol_stores "
"response".format(cluster_size=cluster_size))
else:
print("ERROR: Wrong cluster size in lvol store")
print("Expected:".format(cluster_size))
print("Actual:".format(json_cluster))
return 1
# Also check name if param is provided:
if lvs_name:
if lvs_name not in json_name:
print("ERROR: Lvol store human-friendly name does not match")
print("Expected: {lvs_name}".format(lvs_name=lvs_name))
print("Actual: {name}".format(name=json_name))
return 1
return 0
print("FAILED: UUID: lvol store {uuid} on base_bdev: "
"{base_name} not found in get_lvol_stores()".format(uuid=uuid,
base_name=base_name))
return 1
else:
print("INFO: Lvol store not exist")
return 2
return 0
def construct_malloc_bdev(self, total_size, block_size):
print("INFO: RPC COMMAND construct_malloc_bdev")
output = self.rpc.construct_malloc_bdev(total_size, block_size)[0]
return output.rstrip('\n')
def construct_lvol_store(self, base_name, lvs_name, cluster_size=None):
print("INFO: RPC COMMAND construct_lvol_store")
if cluster_size:
output = self.rpc.construct_lvol_store(base_name,
lvs_name,
"-c {cluster_sz}".format(cluster_sz=cluster_size))[0]
else:
output = self.rpc.construct_lvol_store(base_name, lvs_name)[0]
return output.rstrip('\n')
def construct_lvol_bdev(self, uuid, lbd_name, size, thin=False):
print("INFO: RPC COMMAND construct_lvol_bdev")
try:
uuid_obj = UUID(uuid)
name_opt = "-u"
except ValueError:
name_opt = "-l"
thin_provisioned = ""
if thin:
thin_provisioned = "-t"
output = self.rpc.construct_lvol_bdev(name_opt, uuid, lbd_name, size, thin_provisioned)[0]
return output.rstrip('\n')
def destroy_lvol_store(self, uuid):
print("INFO: RPC COMMAND destroy_lvol_store")
try:
uuid_obj = UUID(uuid)
name_opt = "-u"
except ValueError:
name_opt = "-l"
output, rc = self.rpc.destroy_lvol_store(name_opt, uuid)
return rc
def delete_bdev(self, base_name):
print("INFO: RPC COMMAND delete_bdev")
output, rc = self.rpc.delete_bdev(base_name)
return rc
def delete_malloc_bdev(self, base_name):
print("INFO: RPC COMMAND delete_malloc_bdev")
output, rc = self.rpc.delete_malloc_bdev(base_name)
return rc
def destroy_lvol_bdev(self, bdev_name):
print("INFO: RPC COMMAND destroy_lvol_bdev")
output, rc = self.rpc.destroy_lvol_bdev(bdev_name)
return rc
def resize_lvol_bdev(self, uuid, new_size):
print("INFO: RPC COMMAND resize_lvol_bdev")
output, rc = self.rpc.resize_lvol_bdev(uuid, new_size)
return rc
def start_nbd_disk(self, bdev_name, nbd_name):
print("INFO: RPC COMMAND start_nbd_disk")
output, rc = self.rpc.start_nbd_disk(bdev_name, nbd_name)
return rc
def stop_nbd_disk(self, nbd_name):
print("INFO: RPC COMMAND stop_nbd_disk")
output, rc = self.rpc.stop_nbd_disk(nbd_name)
return rc
def get_lvol_stores(self, name=None):
print("INFO: RPC COMMAND get_lvol_stores")
if name:
output = json.loads(self.rpc.get_lvol_stores("-l", name)[0])
else:
output = json.loads(self.rpc.get_lvol_stores()[0])
return output
def get_lvol_bdevs(self):
print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
output = []
rpc_output = json.loads(self.rpc.get_bdevs()[0])
for bdev in rpc_output:
if bdev["product_name"] == "Logical Volume":
output.append(bdev)
return output
def get_lvol_bdev_with_name(self, name):
print("INFO: RPC COMMAND get_bdevs; lvol bdevs only")
rpc_output = json.loads(self.rpc.get_bdevs("-b", name)[0])
if len(rpc_output) > 0:
return rpc_output[0]
return None
def rename_lvol_store(self, old_name, new_name):
print("INFO: Renaming lvol store from {old} to {new}".format(old=old_name, new=new_name))
output, rc = self.rpc.rename_lvol_store(old_name, new_name)
return rc
def rename_lvol_bdev(self, old_name, new_name):
print("INFO: Renaming lvol bdev from {old} to {new}".format(old=old_name, new=new_name))
output, rc = self.rpc.rename_lvol_bdev(old_name, new_name)
return rc
def snapshot_lvol_bdev(self, bdev_name, snapshot_name):
print("INFO: RPC COMMAND snapshot_lvol_bdev")
output, rc = self.rpc.snapshot_lvol_bdev(bdev_name, snapshot_name)
return rc
def clone_lvol_bdev(self, snapshot_name, clone_name):
print("INFO: RPC COMMAND clone_lvol_bdev")
output, rc = self.rpc.clone_lvol_bdev(snapshot_name, clone_name)
return rc
def inflate_lvol_bdev(self, clone_name):
print("INFO: RPC COMMAND inflate_lvol_bdev")
output, rc = self.rpc.inflate_lvol_bdev(clone_name)
return rc
def decouple_parent_lvol_bdev(self, clone_name):
print("INFO: RPC COMMAND decouple_parent_lvol_bdev")
output, rc = self.rpc.decouple_parent_lvol_bdev(clone_name)
return rc
def construct_aio_bdev(self, aio_path, aio_name, aio_bs=""):
print("INFO: RPC COMMAND construct_aio_bdev")
output, rc = self.rpc.construct_aio_bdev(aio_path, aio_name, aio_bs)
return rc
def delete_aio_bdev(self, aio_name):
print("INFO: RPC COMMAND delete_aio_bdev")
output, rc = self.rpc.delete_aio_bdev(aio_name)
return rc
|
