RacksDB 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- RacksDB-0.2.0.dist-info/LICENSE +674 -0
- RacksDB-0.2.0.dist-info/METADATA +126 -0
- RacksDB-0.2.0.dist-info/RECORD +42 -0
- RacksDB-0.2.0.dist-info/WHEEL +5 -0
- RacksDB-0.2.0.dist-info/entry_points.txt +3 -0
- RacksDB-0.2.0.dist-info/top_level.txt +1 -0
- racksdb/__init__.py +74 -0
- racksdb/bases.py +117 -0
- racksdb/drawers/__init__.py +10 -0
- racksdb/drawers/base.py +42 -0
- racksdb/drawers/infrastructure.py +253 -0
- racksdb/drawers/room.py +160 -0
- racksdb/dtypes/__init__.py +0 -0
- racksdb/dtypes/angle.py +21 -0
- racksdb/dtypes/bytes.py +31 -0
- racksdb/dtypes/dimension.py +23 -0
- racksdb/dtypes/netif_type.py +17 -0
- racksdb/dtypes/rack_height.py +17 -0
- racksdb/dtypes/rack_width.py +26 -0
- racksdb/dtypes/storage_type.py +17 -0
- racksdb/errors.py +9 -0
- racksdb/exec.py +218 -0
- racksdb/generic/__init__.py +0 -0
- racksdb/generic/db.py +609 -0
- racksdb/generic/definedtype.py +24 -0
- racksdb/generic/dumpers/__init__.py +30 -0
- racksdb/generic/dumpers/_common.py +30 -0
- racksdb/generic/dumpers/console.py +31 -0
- racksdb/generic/dumpers/json.py +108 -0
- racksdb/generic/dumpers/yaml.py +138 -0
- racksdb/generic/errors.py +21 -0
- racksdb/generic/openapi.py +199 -0
- racksdb/generic/schema.py +367 -0
- racksdb/generic/views.py +139 -0
- racksdb/tests/__init__.py +0 -0
- racksdb/tests/test_schema.py +211 -0
- racksdb/tests/test_schema_defined_type_loader.py +23 -0
- racksdb/tests/tests_db_load.py +83 -0
- racksdb/version.py +11 -0
- racksdb/views.py +136 -0
- racksdb/web/__init__.py +0 -0
- racksdb/web/app.py +195 -0
racksdb/drawers/room.py
ADDED
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
import logging
|
|
8
|
+
import math
|
|
9
|
+
|
|
10
|
+
import cairo
|
|
11
|
+
|
|
12
|
+
from .base import Drawer, ImagePoint
|
|
13
|
+
from ..errors import RacksDBError
|
|
14
|
+
|
|
15
|
+
logger = logging.getLogger(__name__)
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class RoomDrawer(Drawer):
|
|
19
|
+
|
|
20
|
+
SCALE = 0.07 # 1mm to pixel
|
|
21
|
+
MARGIN_TOP = 30
|
|
22
|
+
MARGIN_LEFT = 30
|
|
23
|
+
RACK_DOOR_DEPTH = int(50 * SCALE)
|
|
24
|
+
|
|
25
|
+
def __init__(self, db, name, file, output_format):
|
|
26
|
+
super().__init__(db, file, output_format)
|
|
27
|
+
self.room = None
|
|
28
|
+
for datacenter in self.db.datacenters:
|
|
29
|
+
for room in datacenter.rooms:
|
|
30
|
+
if room.name == name:
|
|
31
|
+
self.room = room
|
|
32
|
+
if self.room is None:
|
|
33
|
+
raise RacksDBError(f"Unable to find room {name} in database")
|
|
34
|
+
|
|
35
|
+
def _racks_row_tl(self, row):
|
|
36
|
+
return ImagePoint(
|
|
37
|
+
self.MARGIN_LEFT + int(row.position.width * self.SCALE),
|
|
38
|
+
self.MARGIN_TOP + int(row.position.depth * self.SCALE),
|
|
39
|
+
)
|
|
40
|
+
|
|
41
|
+
def _rack_tl(self, rack):
|
|
42
|
+
# Start from top-left corner of the rack row, which is (0,0) after
|
|
43
|
+
# context matrix translation.
|
|
44
|
+
tl = ImagePoint(0, 0)
|
|
45
|
+
# Sum the width of all racks in row before the current rack
|
|
46
|
+
filled_slots = {}
|
|
47
|
+
for row_rack in rack.row.racks:
|
|
48
|
+
if row_rack.slot < rack.slot:
|
|
49
|
+
tl.x += int(row_rack.type.width * self.SCALE)
|
|
50
|
+
filled_slots[row_rack.slot] = row_rack
|
|
51
|
+
# filling empty slots with previous rack width
|
|
52
|
+
for slot in range(rack.slot):
|
|
53
|
+
if slot not in filled_slots:
|
|
54
|
+
logger.debug("Row %s slot %d is not filled", rack.row.name, slot)
|
|
55
|
+
last_rack_width = 0
|
|
56
|
+
reversed_slot = slot
|
|
57
|
+
for reversed_slot in range(slot, 0, -1):
|
|
58
|
+
if reversed_slot in filled_slots:
|
|
59
|
+
last_rack_width = filled_slots[reversed_slot].type.width
|
|
60
|
+
break
|
|
61
|
+
if not (last_rack_width):
|
|
62
|
+
last_rack_width = self.db.types.racks.first().width
|
|
63
|
+
tl.x += int(last_rack_width * self.SCALE)
|
|
64
|
+
return tl
|
|
65
|
+
|
|
66
|
+
def _draw_rack(self, rack):
|
|
67
|
+
tl = self._rack_tl(rack)
|
|
68
|
+
rack_width = int(rack.type.width * self.SCALE)
|
|
69
|
+
rack_height = int(rack.type.depth * self.SCALE)
|
|
70
|
+
# draw rack frame
|
|
71
|
+
self.ctx.set_source_rgb(0.4, 0.4, 0.4) # grey
|
|
72
|
+
self.ctx.set_line_width(1)
|
|
73
|
+
self.ctx.rectangle(
|
|
74
|
+
tl.x,
|
|
75
|
+
tl.y,
|
|
76
|
+
rack_width,
|
|
77
|
+
rack_height,
|
|
78
|
+
)
|
|
79
|
+
self.ctx.stroke()
|
|
80
|
+
|
|
81
|
+
# draw rack front door
|
|
82
|
+
if rack.row.reversed:
|
|
83
|
+
self.ctx.rectangle(
|
|
84
|
+
tl.x,
|
|
85
|
+
tl.y,
|
|
86
|
+
rack_width,
|
|
87
|
+
self.RACK_DOOR_DEPTH,
|
|
88
|
+
)
|
|
89
|
+
else:
|
|
90
|
+
self.ctx.rectangle(
|
|
91
|
+
tl.x,
|
|
92
|
+
tl.y + rack_height - self.RACK_DOOR_DEPTH,
|
|
93
|
+
rack_width,
|
|
94
|
+
self.RACK_DOOR_DEPTH,
|
|
95
|
+
)
|
|
96
|
+
self.ctx.fill()
|
|
97
|
+
|
|
98
|
+
# write rack name
|
|
99
|
+
self.ctx.set_source_rgb(0, 0, 0) # black
|
|
100
|
+
if rack_height > rack_width:
|
|
101
|
+
self.ctx.save()
|
|
102
|
+
# If the rack row rotation angle is between 0 and 180, flip the text
|
|
103
|
+
# to be right side up.
|
|
104
|
+
if rack.row.position.rotation > 0 and rack.row.position.rotation < 180:
|
|
105
|
+
self.ctx.move_to(tl.x + 15, tl.y - 2 + rack_height)
|
|
106
|
+
self.ctx.rotate(-math.pi / 2)
|
|
107
|
+
else:
|
|
108
|
+
self.ctx.move_to(tl.x + 2, tl.y + 2)
|
|
109
|
+
self.ctx.rotate(math.pi / 2)
|
|
110
|
+
else:
|
|
111
|
+
self.ctx.move_to(tl.x + 2, tl.y + 15)
|
|
112
|
+
self.ctx.show_text(rack.name)
|
|
113
|
+
if rack_height > rack_width:
|
|
114
|
+
self.ctx.restore()
|
|
115
|
+
|
|
116
|
+
def _draw_racks_row(self, row):
|
|
117
|
+
for rack in row.racks:
|
|
118
|
+
self._draw_rack(rack)
|
|
119
|
+
|
|
120
|
+
def draw(self):
|
|
121
|
+
room_width = int(self.room.dimensions.width * self.SCALE)
|
|
122
|
+
room_depth = int(self.room.dimensions.depth * self.SCALE)
|
|
123
|
+
|
|
124
|
+
width = room_width + 2 * self.MARGIN_LEFT
|
|
125
|
+
height = room_depth + 2 * self.MARGIN_TOP
|
|
126
|
+
self.init_ctx(width, height)
|
|
127
|
+
|
|
128
|
+
# draw room frame
|
|
129
|
+
self.ctx.set_source_rgb(0.2, 0.2, 0.2) # grey
|
|
130
|
+
self.ctx.set_line_width(1)
|
|
131
|
+
self.ctx.rectangle(
|
|
132
|
+
self.MARGIN_LEFT,
|
|
133
|
+
self.MARGIN_TOP,
|
|
134
|
+
room_width,
|
|
135
|
+
room_depth,
|
|
136
|
+
)
|
|
137
|
+
self.ctx.stroke()
|
|
138
|
+
|
|
139
|
+
# write room name
|
|
140
|
+
self.ctx.set_source_rgb(0, 0, 0) # black
|
|
141
|
+
self.ctx.select_font_face(
|
|
142
|
+
"Sans", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD
|
|
143
|
+
)
|
|
144
|
+
self.ctx.set_font_size(14)
|
|
145
|
+
self.ctx.move_to(self.MARGIN_LEFT + 2, self.MARGIN_TOP + 15)
|
|
146
|
+
self.ctx.show_text(
|
|
147
|
+
f"Datacenter {self.room.datacenter.name} room {self.room.name}"
|
|
148
|
+
)
|
|
149
|
+
|
|
150
|
+
for row in self.room.rows:
|
|
151
|
+
# Translate the context matrix to rack row top-left corner and
|
|
152
|
+
# rotate it as per row rotation angle.
|
|
153
|
+
self.ctx.save()
|
|
154
|
+
tl = self._racks_row_tl(row)
|
|
155
|
+
self.ctx.translate(tl.x, tl.y)
|
|
156
|
+
self.ctx.rotate(row.position.rotation * math.pi / 180)
|
|
157
|
+
self._draw_racks_row(row)
|
|
158
|
+
self.ctx.restore()
|
|
159
|
+
|
|
160
|
+
self.write()
|
|
File without changes
|
racksdb/dtypes/angle.py
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
from racksdb.generic.errors import DBFormatError
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class SchemaDefinedTypeAngle(SchemaDefinedType):
|
|
12
|
+
|
|
13
|
+
pattern = r"\d+"
|
|
14
|
+
native = int
|
|
15
|
+
|
|
16
|
+
def parse(self, value):
|
|
17
|
+
match = self._match(value)
|
|
18
|
+
degrees = int(match.group(0))
|
|
19
|
+
if degrees < 0 or degrees > 360:
|
|
20
|
+
raise DBFormatError(f"Invalid angle of {degrees} degrees")
|
|
21
|
+
return degrees
|
racksdb/dtypes/bytes.py
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeBytes(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"(\d+(.\d+)?)(TB|Tb|GB|Gb|MB|Mb)"
|
|
13
|
+
native = int
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
match = self._match(value)
|
|
17
|
+
quantity = float(match.group(1))
|
|
18
|
+
unit = match.group(3)
|
|
19
|
+
if unit == "Mb":
|
|
20
|
+
quantity *= (10 ** 6) / 8
|
|
21
|
+
elif unit == "MB":
|
|
22
|
+
quantity *= 1024 ** 2
|
|
23
|
+
elif unit == "Gb":
|
|
24
|
+
quantity *= (10 ** 9) / 8
|
|
25
|
+
elif unit == "GB":
|
|
26
|
+
quantity *= 1024 ** 3
|
|
27
|
+
elif unit == "Tb":
|
|
28
|
+
quantity *= (10 ** 12) / 8
|
|
29
|
+
elif unit == "TB":
|
|
30
|
+
quantity *= 1024 ** 4
|
|
31
|
+
return int(quantity)
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeDimension(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"(\d+(.\d+)?)(mm|cm|m)"
|
|
13
|
+
native = int
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
match = self._match(value)
|
|
17
|
+
size = float(match.group(1))
|
|
18
|
+
unit = match.group(3)
|
|
19
|
+
if unit == "cm":
|
|
20
|
+
size *= 10
|
|
21
|
+
elif unit == "m":
|
|
22
|
+
size *= 1000
|
|
23
|
+
return int(size)
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeNetifType(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"(ethernet|infiniband)"
|
|
13
|
+
native = str
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
self._match(value) # just check it matches
|
|
17
|
+
return value
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeRackHeight(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"(\d+)u"
|
|
13
|
+
native = int
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
match = self._match(value)
|
|
17
|
+
return int(match.group(1))
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeRackWidth(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"full|(\d+)(/\d+)?"
|
|
13
|
+
native = float
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
match = self._match(value)
|
|
17
|
+
if value == "full":
|
|
18
|
+
return 1.0
|
|
19
|
+
else:
|
|
20
|
+
dividend = int(match.group(1))
|
|
21
|
+
divisor = match.group(2)
|
|
22
|
+
if divisor is not None:
|
|
23
|
+
divisor = float(divisor[1:])
|
|
24
|
+
else:
|
|
25
|
+
divisor = 1.0
|
|
26
|
+
return dividend / divisor
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
from racksdb.generic.definedtype import SchemaDefinedType
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class SchemaDefinedTypeStorageType(SchemaDefinedType):
|
|
11
|
+
|
|
12
|
+
pattern = r"(ssd|disk|nvme)"
|
|
13
|
+
native = str
|
|
14
|
+
|
|
15
|
+
def parse(self, value):
|
|
16
|
+
self._match(value) # just check it matches
|
|
17
|
+
return value
|
racksdb/errors.py
ADDED
racksdb/exec.py
ADDED
|
@@ -0,0 +1,218 @@
|
|
|
1
|
+
# Copyright (c) 2022-2023 Rackslab
|
|
2
|
+
#
|
|
3
|
+
# This file is part of RacksDB.
|
|
4
|
+
#
|
|
5
|
+
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
6
|
+
|
|
7
|
+
import argparse
|
|
8
|
+
import sys
|
|
9
|
+
import logging
|
|
10
|
+
from itertools import chain
|
|
11
|
+
|
|
12
|
+
from pathlib import Path
|
|
13
|
+
|
|
14
|
+
from .version import get_version
|
|
15
|
+
from .generic.errors import DBFormatError, DBSchemaError
|
|
16
|
+
from .generic.dumpers import DBDumperFactory, SchemaDumperFactory
|
|
17
|
+
from . import RacksDB
|
|
18
|
+
from .drawers import InfrastructureDrawer, RoomDrawer
|
|
19
|
+
from .errors import RacksDBError
|
|
20
|
+
from .views import RacksDBViews
|
|
21
|
+
|
|
22
|
+
logger = logging.getLogger(__name__)
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
class RacksDBExec:
|
|
26
|
+
DEFAULT_FORMAT = "yaml"
|
|
27
|
+
|
|
28
|
+
@classmethod
|
|
29
|
+
def run(cls):
|
|
30
|
+
cls()
|
|
31
|
+
|
|
32
|
+
def __init__(self):
|
|
33
|
+
parser = argparse.ArgumentParser(description="Do something with RacksDB.")
|
|
34
|
+
parser.add_argument(
|
|
35
|
+
"-v",
|
|
36
|
+
"--version",
|
|
37
|
+
dest="version",
|
|
38
|
+
action="version",
|
|
39
|
+
version="RacksDB " + get_version(),
|
|
40
|
+
)
|
|
41
|
+
parser.add_argument(
|
|
42
|
+
"--debug",
|
|
43
|
+
dest="debug",
|
|
44
|
+
action="store_true",
|
|
45
|
+
help="Enable debug mode",
|
|
46
|
+
)
|
|
47
|
+
|
|
48
|
+
parser.add_argument(
|
|
49
|
+
"-s",
|
|
50
|
+
"--schema",
|
|
51
|
+
help="Schema to load (default: %(default)s)",
|
|
52
|
+
default=RacksDB.DEFAULT_SCHEMA,
|
|
53
|
+
type=Path,
|
|
54
|
+
)
|
|
55
|
+
parser.add_argument(
|
|
56
|
+
"-e",
|
|
57
|
+
"--ext",
|
|
58
|
+
help="Path to extensions of schema (default: %(default)s)",
|
|
59
|
+
default=RacksDB.DEFAULT_EXT,
|
|
60
|
+
type=Path,
|
|
61
|
+
)
|
|
62
|
+
parser.add_argument(
|
|
63
|
+
"-b",
|
|
64
|
+
"--db",
|
|
65
|
+
help="Database to load (default: %(default)s)",
|
|
66
|
+
default=RacksDB.DEFAULT_DB,
|
|
67
|
+
type=Path,
|
|
68
|
+
)
|
|
69
|
+
|
|
70
|
+
# Unfortunately, Python 3.6 does support add_subparsers() required
|
|
71
|
+
# attribute. The requirement is later handled with hasattr() check on
|
|
72
|
+
# args.func to provide the same functionnal level.
|
|
73
|
+
# This Python version conditionnal test can be removed when support of
|
|
74
|
+
# Python 3.6 is dropped in RacksDB.
|
|
75
|
+
if sys.version_info[1] >= 3 and sys.version_info[1] >= 7:
|
|
76
|
+
subparsers = parser.add_subparsers(
|
|
77
|
+
help="Action to perform with database",
|
|
78
|
+
dest="action",
|
|
79
|
+
required=True,
|
|
80
|
+
)
|
|
81
|
+
else:
|
|
82
|
+
subparsers = parser.add_subparsers(
|
|
83
|
+
help="Action to perform with database", dest="action"
|
|
84
|
+
)
|
|
85
|
+
|
|
86
|
+
# Parser for the schema command
|
|
87
|
+
parser_schema = subparsers.add_parser("schema", help="Dump loaded schema")
|
|
88
|
+
parser_schema.set_defaults(func=self._run_schema)
|
|
89
|
+
|
|
90
|
+
# Parser for the dump command
|
|
91
|
+
parser_dump = subparsers.add_parser("dump", help="Dump raw loaded DB")
|
|
92
|
+
parser_dump.set_defaults(func=self._run_dump)
|
|
93
|
+
|
|
94
|
+
self.views = RacksDBViews()
|
|
95
|
+
|
|
96
|
+
# Generate subcommands for all declared views (converted to actions) and
|
|
97
|
+
# all declared actions with their parameters.
|
|
98
|
+
for action in chain(self.views.views_actions(), self.views.actions()):
|
|
99
|
+
subparser = subparsers.add_parser(action.name, help=action.description)
|
|
100
|
+
for parameter in action.parameters:
|
|
101
|
+
if parameter.positional:
|
|
102
|
+
args = (parameter.name,)
|
|
103
|
+
else:
|
|
104
|
+
args = [f"--{parameter.name.replace('_','-')}"]
|
|
105
|
+
if parameter.short is not None:
|
|
106
|
+
args.insert(0, f"-{parameter.short}")
|
|
107
|
+
|
|
108
|
+
kwargs = {"help": parameter.description}
|
|
109
|
+
if parameter.nargs == 0:
|
|
110
|
+
kwargs["action"] = "store_true"
|
|
111
|
+
else:
|
|
112
|
+
kwargs["nargs"] = parameter.nargs
|
|
113
|
+
if parameter.choices is not None:
|
|
114
|
+
kwargs["choices"] = parameter.choices
|
|
115
|
+
if parameter.default is not None:
|
|
116
|
+
kwargs["default"] = parameter.default
|
|
117
|
+
kwargs["help"] += " (default: %(default)s)"
|
|
118
|
+
if parameter.required:
|
|
119
|
+
kwargs["required"] = True
|
|
120
|
+
subparser.add_argument(*args, **kwargs)
|
|
121
|
+
subparser.set_defaults(func=getattr(self, f"_run_{action.name}"))
|
|
122
|
+
|
|
123
|
+
self.args = parser.parse_args()
|
|
124
|
+
|
|
125
|
+
self._setup_logger()
|
|
126
|
+
|
|
127
|
+
try:
|
|
128
|
+
self.db = RacksDB.load(self.args.schema, self.args.ext, self.args.db)
|
|
129
|
+
except DBSchemaError as err:
|
|
130
|
+
logger.error("Error while loading schema: %s", err)
|
|
131
|
+
sys.exit(1)
|
|
132
|
+
except DBFormatError as err:
|
|
133
|
+
logger.error("Error while loading db: %s", err)
|
|
134
|
+
sys.exit(1)
|
|
135
|
+
|
|
136
|
+
if not hasattr(self.args, "func"):
|
|
137
|
+
parser.print_usage()
|
|
138
|
+
logger.error("The action argument must be given")
|
|
139
|
+
sys.exit(1)
|
|
140
|
+
try:
|
|
141
|
+
self.args.func()
|
|
142
|
+
except RacksDBError as err:
|
|
143
|
+
logger.critical(err)
|
|
144
|
+
sys.exit(1)
|
|
145
|
+
|
|
146
|
+
def _setup_logger(self):
|
|
147
|
+
if self.args.debug:
|
|
148
|
+
logging_level = logging.DEBUG
|
|
149
|
+
else:
|
|
150
|
+
logging_level = logging.INFO
|
|
151
|
+
|
|
152
|
+
root_logger = logging.getLogger()
|
|
153
|
+
root_logger.setLevel(logging_level)
|
|
154
|
+
handler = logging.StreamHandler()
|
|
155
|
+
handler.setLevel(logging_level)
|
|
156
|
+
formatter = logging.Formatter("[%(levelname)s] %(name)s: %(message)s")
|
|
157
|
+
handler.setFormatter(formatter)
|
|
158
|
+
root_logger.addHandler(handler)
|
|
159
|
+
|
|
160
|
+
def _run_schema(self):
|
|
161
|
+
print(SchemaDumperFactory.get("yaml")().dump(self.db._schema))
|
|
162
|
+
|
|
163
|
+
def _run_dump(self):
|
|
164
|
+
print(DBDumperFactory.get("yaml")().dump(self.db._loader.content))
|
|
165
|
+
|
|
166
|
+
def _run_racks(self):
|
|
167
|
+
self._dump_view()
|
|
168
|
+
|
|
169
|
+
def _run_datacenters(self):
|
|
170
|
+
self._dump_view()
|
|
171
|
+
|
|
172
|
+
def _run_nodes(self):
|
|
173
|
+
self._dump_view()
|
|
174
|
+
|
|
175
|
+
def _run_infrastructures(self):
|
|
176
|
+
self._dump_view()
|
|
177
|
+
|
|
178
|
+
def _dump_view(self):
|
|
179
|
+
data = getattr(self.db, self.args.action)
|
|
180
|
+
view = self.views[self.args.action]
|
|
181
|
+
# Filter data with optional filters specified in arguments
|
|
182
|
+
data = data.filter(
|
|
183
|
+
**{
|
|
184
|
+
_filter.name: getattr(self.args, _filter.name)
|
|
185
|
+
for _filter in view.filters
|
|
186
|
+
}
|
|
187
|
+
)
|
|
188
|
+
|
|
189
|
+
# Select only the item names
|
|
190
|
+
if self.args.list:
|
|
191
|
+
# When list option is select and no output format is specified, select the
|
|
192
|
+
# console dumper by default.
|
|
193
|
+
if self.args.format is None:
|
|
194
|
+
self.args.format = "console"
|
|
195
|
+
data = [item.name for item in data]
|
|
196
|
+
|
|
197
|
+
# If the output format is not defined at this stage, fallback to default.
|
|
198
|
+
if self.args.format is None:
|
|
199
|
+
self.args.format = self.DEFAULT_FORMAT
|
|
200
|
+
|
|
201
|
+
print(
|
|
202
|
+
DBDumperFactory.get(self.args.format)(
|
|
203
|
+
show_types=self.args.with_objects_types,
|
|
204
|
+
objects_map=view.objects_map,
|
|
205
|
+
fold=self.args.fold,
|
|
206
|
+
).dump(data)
|
|
207
|
+
)
|
|
208
|
+
|
|
209
|
+
def _run_draw(self):
|
|
210
|
+
file = f"{self.args.name}.{self.args.format}"
|
|
211
|
+
if self.args.entity == "infrastructure":
|
|
212
|
+
drawer = InfrastructureDrawer(
|
|
213
|
+
self.db, self.args.name, file, self.args.format
|
|
214
|
+
)
|
|
215
|
+
elif self.args.entity == "room":
|
|
216
|
+
drawer = RoomDrawer(self.db, self.args.name, file, self.args.format)
|
|
217
|
+
drawer.draw()
|
|
218
|
+
logger.info("Generated image file %s", file)
|
|
File without changes
|