22 | 
91 |
92 |
--------------------------------------------------------------------------------
/frontend/src/views/InfrastructureDetailsView.vue:
--------------------------------------------------------------------------------
1 |
6 |
7 |
58 |
59 |
60 |
27 | Datacenters
35 |
36 |
67 |
68 |
28 |
30 |
37 | {{
42 | props.datacenterName
43 | }}
45 |
46 |
47 |
38 |
40 |
48 | {{
53 | props.datacenterName
54 | }}
56 | {{
62 | props.datacenterRoom
63 | }}
65 |
66 |
49 |
51 |
57 |
59 |
60 |
69 | Infrastructures
77 |
78 |
90 |
70 |
72 |
79 | {{
85 | props.infrastructureName
86 | }}
88 |
89 |
80 |
82 |
62 | ![]()
69 |
70 |
71 |
97 |
98 |
99 |
104 |
105 |
--------------------------------------------------------------------------------
/racksdb/tests/drawers/test_axonometric_infrastructure.py:
--------------------------------------------------------------------------------
1 | # Copyright (c) 2025 Rackslab
2 | #
3 | # This file is part of RacksDB.
4 | #
5 | # SPDX-License-Identifier: MIT
6 |
7 | import unittest
8 | import tempfile
9 | from pathlib import Path
10 |
11 | from racksdb import RacksDB
12 | from racksdb.drawers.axonometric_infrastructure import AxonometricInfrastructureDrawer
13 | from racksdb.drawers.parameters import DrawingParameters
14 | from racksdb.generic.db import DBDictsLoader
15 | from racksdb.errors import RacksDBDrawingError
16 |
17 | from ..lib.common import drawing_schema_path, schema_path, db_path
18 |
19 |
20 | class TestAxonometricInfrastructureDrawer(unittest.TestCase):
21 | def setUp(self):
22 | try:
23 | self.drawings_schema_path = drawing_schema_path()
24 | self.schema_path = schema_path()
25 | self.db_path = db_path()
26 | except FileNotFoundError as err:
27 | self.skipTest(err)
28 | self.parameters = DrawingParameters.load(
29 | DBDictsLoader({}), self.drawings_schema_path
30 | )
31 | self.db = RacksDB.load(schema=self.schema_path, db=self.db_path)
32 |
33 | def test_draw_png(self):
34 | with tempfile.TemporaryDirectory() as tmpdir:
35 | filename = Path(tmpdir) / "output.png"
36 | drawer = AxonometricInfrastructureDrawer(
37 | self.db, "mercury", filename, "png", self.parameters, None, "yaml"
38 | )
39 | drawer.draw()
40 | self.assertTrue(filename.exists())
41 |
42 | def test_draw_svg(self):
43 | with tempfile.TemporaryDirectory() as tmpdir:
44 | filename = Path(tmpdir) / "output.svg"
45 | drawer = AxonometricInfrastructureDrawer(
46 | self.db, "mercury", filename, "svg", self.parameters, None, "yaml"
47 | )
48 | drawer.draw()
49 | self.assertTrue(filename.exists())
50 |
51 | def test_draw_pdf(self):
52 | with tempfile.TemporaryDirectory() as tmpdir:
53 | filename = Path(tmpdir) / "output.pdf"
54 | drawer = AxonometricInfrastructureDrawer(
55 | self.db, "mercury", filename, "pdf", self.parameters, None, "yaml"
56 | )
57 | drawer.draw()
58 | self.assertTrue(filename.exists())
59 |
60 | def test_draw_not_existing_infrastructure(self):
61 | with tempfile.TemporaryDirectory() as tmpdir:
62 | filename = Path(tmpdir) / "output.png"
63 | with self.assertRaisesRegex(
64 | RacksDBDrawingError, "^Unable to find infrastructure fail in database$"
65 | ):
66 | AxonometricInfrastructureDrawer(
67 | self.db, "fail", filename, "png", self.parameters, None, "yaml"
68 | )
69 | self.assertFalse(filename.exists())
70 |
71 | def test_draw_no_rack_error(self):
72 | self.parameters.infrastructure.equipment_tags = "fail"
73 | with tempfile.TemporaryDirectory() as tmpdir:
74 | filename = Path(tmpdir) / "output.png"
75 | drawer = AxonometricInfrastructureDrawer(
76 | self.db, "mercury", filename, "png", self.parameters, None, "yaml"
77 | )
78 | with self.assertRaisesRegex(
79 | RacksDBDrawingError,
80 | "^Unable to find racks to draw with filters provided in drawing "
81 | "parameters$",
82 | ):
83 | drawer.draw()
84 | self.assertFalse(filename.exists())
85 |
--------------------------------------------------------------------------------
/docs/modules/usage/pages/integrations.adoc:
--------------------------------------------------------------------------------
1 | = Integrations
2 |
3 | == Clustershell
4 |
5 | https://clustershell.readthedocs.io/en/latest/index.html[ClusterShell] is a
6 | scalable cluster administration Python framework, designed to execute commands
7 | on many cluster nodes in parallel. ClusterShell supports the possibility to
8 | define groups of nodes. These groups can be extracted from external sources.
9 |
10 | This section illustrates how to make ClusterShell extracts groups from RacksDB
11 | and tags associated to nodes with a simple example. In this example, let's
12 | consider a cluster infrastructure named _atlas_.
13 |
14 | Create file [.path]#`/etc/clustershell/groups.conf.d/racksdb.conf`# with this content:
15 |
16 | [source,ini]
17 | ----
18 | [racksdb]
19 | map: racksdb nodes --infrastructure atlas --tags $GROUP --list
20 | all: racksdb nodes --infrastructure atlas --list
21 | list: racksdb tags --infrastructure atlas --on-nodes
22 | reverse: racksdb tags --node $NODE
23 | ----
24 |
25 | With this simple configuration, ClusterShell can extract groups and nodes from
26 | RacksDB. For example, with `nodeset` command:
27 |
28 | * Get the list of groups:
29 | +
30 | --
31 | [source,console]
32 | ----
33 | $ nodeset -s racksdb -l
34 | @racksdb:admin
35 | @racksdb:compute
36 | @racksdb:login
37 | ----
38 | --
39 |
40 | * Get all nodes in _compute_ group (ie. associated to _compute_ tag in
41 | database):
42 | +
43 | --
44 | [source,console]
45 | ----
46 | $ nodeset -f @racksdb:compute
47 | atcn[1-2]
48 | ----
49 | --
50 |
51 | * Get all nodes in this cluster:
52 | +
53 | --
54 | [source,console]
55 | ----
56 | $ nodeset -f -s racksdb -a
57 | atadmin,atcn[1-2],atlogin
58 | ----
59 | --
60 |
61 | ClusterShell can execute commands on nodes from these groups with `clush`:
62 |
63 | [source,console]
64 | ----
65 | # clush -bw @racksdb:compute uname
66 | ---------------
67 | atcn[1-2] (2)
68 | ---------------
69 | Linux
70 | ----
71 |
72 | This way, ClusterShell groups are always synchronized with tags and content of
73 | RacksDB database. when RacksDB database is updated, changes are automatically
74 | reflected in ClusterShell.
75 |
76 | .More than one infrastructure?
77 | ****
78 | If you need to extract groups from multiple infrastructures in RacksDB, a simple
79 | approach if to use ClusterShell
80 | https://clustershell.readthedocs.io/en/latest/config.html#multiple-sources-section[multiple sources sections]
81 | feature and `$GROUP` variable. For example, in
82 | [.path]#`/etc/clustershell/groups.conf.d/racksdb.conf`#:
83 |
84 | [source,ini]
85 | ----
86 | [trinity,atlas]
87 | map: racksdb nodes --infrastructure $SOURCE --tags $GROUP --list
88 | all: racksdb nodes --infrastructure $SOURCE --list
89 | list: racksdb tags --infrastructure $SOURCE --on-nodes
90 | reverse: racksdb tags --node $NODE
91 | ----
92 |
93 | This way, RacksDB commands are executed for multiple infrastructures:
94 |
95 | [source,console]
96 | ----
97 | $ nodeset -f @trinity:compute
98 | tricn[1-4]
99 | $ nodeset -f @atlas:compute
100 | atcn[1-2]
101 | ----
102 |
103 | Another yet more generic approach to split the group source with shell:
104 |
105 | [source,ini]
106 | ----
107 | [racksdb]
108 | map: GRP=$GROUP; racksdb nodes --infrastructure ${GRP%:*} --tags ${GRP#*:} --list
109 | all: racksdb nodes --list
110 | reverse: racksdb tags --node $NODE
111 | ----
112 |
113 | This way, infrastructures names are not mentioned in ClusterShell configuration
114 | file and all infrastructures defined in RacksDB can be requested:
115 |
116 | [source,console]
117 | ----
118 | $ nodeset -f @racksdb:trinity:compute
119 | tricn[1-4]
120 | $ nodeset -f @racksdb:atlas:compute
121 | atcn[1-2]
122 | ----
123 | ****
124 |
--------------------------------------------------------------------------------
/docs/modules/usage/pages/drawparams.adoc:
--------------------------------------------------------------------------------
1 | = Drawing Parameters
2 |
3 | RacksDB offers the possibity to generate graphical representations of datacenter
4 | room and infrastructures with their racks and equipments in various images
5 | formats. The images are generated with various default drawing parameters that
6 | user are able to customize for their requirements.
7 |
8 | The xref:#usage[first section] of this page describes how to specify drawing
9 | parameters with both RacksDB xref:racksdb.adoc[CLI] and
10 | xref:rest.adoc[REST API]. The xref:#reference[second section] is the reference
11 | documentation of all available drawing parameters with their format and default
12 | values.
13 |
14 | [#usage]
15 | == Usage
16 |
17 | === CLI
18 |
19 | The `draw` subcommand of xref:racksdb.adoc[`racksdb` CLI] accepts drawing
20 | parameters with `--parameters` option. The value of this option must specify a
21 | path to a YAML file that contains the drawing parameters.
22 |
23 | .Show example `custom.yml` drawing parameters YAML file
24 | [%collapsible]
25 | ====
26 | [source,yaml]
27 | ----
28 | include::example$custom.yml[]
29 | ----
30 | ====
31 |
32 | For example, to generate graphical representation of _tiger_ infrastructure with
33 | custom drawing parameters in `custom.yml` file, run this command:
34 |
35 | [source,console]
36 | ----
37 | $ racksdb draw infrastructure --name=tiger --parameters=custom.yml
38 | ----
39 |
40 | Alternatively, the option accepts the special value `-`. In this case, the
41 | drawing parameters are read on command standard input (_stdin_). For example:
42 |
43 | [source,console]
44 | ----
45 | $ racksdb draw room --name=noisy --parameters=- < custom.yaml
46 | ----
47 |
48 | === REST API
49 |
50 | It is also possible to provide custom drawing parameters to RacksDB
51 | xref:rest.adoc[REST API]. The REST API accepts drawing parameters in both JSON
52 | and YAML formats. The parameters must be sent in requests body content with
53 | content type header set according to the format.
54 |
55 | For example, to generate graphical representation of _mercury_ infrastructure
56 | with inline drawing parameters in JSON format, the following `curl` command can
57 | be used:
58 |
59 | [source,console,subs=attributes]
60 | ----
61 | $ curl -X POST -H 'Content-Type: application/json' \
62 | --data '{"margin":{ "top": 200 }}' \
63 | http://localhost:5000/{api-version}/draw/infrastructure/mercury.png \
64 | --output mercury.png
65 | ----
66 |
67 | Alternatively, the drawing parameters can be extracted a JSON file. For example
68 | with file `custom.json`:
69 |
70 | [source,console,subs=attributes]
71 | ----
72 | $ curl -X POST -H 'Content-Type: application/json' \
73 | --data @custom.json
74 | http://localhost:5000/{api-version}/draw/infrastructure/mercury.png \
75 | --output mercury.png
76 | ----
77 |
78 | .Show example `custom.json` drawing parameters YAML file
79 | [%collapsible]
80 | ====
81 | [source,json]
82 | ----
83 | include::example$custom.json[]
84 | ----
85 | ====
86 |
87 | To send drawing parameters in YAML format, the content type HTTP header must be
88 | changed:
89 |
90 | [source,console,subs=attributes]
91 | ----
92 | $ curl -X POST -H 'Content-Type: application/x-yaml' \
93 | --data-binary @custom.yml \
94 | http://localhost:5000/{api-version}/draw/infrastructure/mercury.png \
95 | --output mercury.png
96 | ----
97 |
98 | CAUTION: To send YAML content with `curl` client, the `--data-binary` option
99 | must be used in favor of `-d, --data` to preserve line breaks.
100 |
101 | [#reference]
102 | == Reference
103 |
104 | include::db:partial$symbols.adoc[leveloffset=+1]
105 |
106 | include::partial$drawing-objects.adoc[leveloffset=+1]
107 |
108 | include::partial$drawing-deftypes.adoc[leveloffset=+1]
109 |
--------------------------------------------------------------------------------
/racksdb/generic/dumpers/json.py:
--------------------------------------------------------------------------------
1 | # Copyright (c) 2023 Rackslab
2 | #
3 | # This file is part of RacksDB.
4 | #
5 | # SPDX-License-Identifier: MIT
6 |
7 | from typing import Any
8 | import json
9 | import logging
10 |
11 | from ._common import MapperDumper
12 | from ...generic.db import DBObject, DBObjectRange, DBObjectRangeId, DBDict, DBList
13 |
14 | logger = logging.getLogger(__name__)
15 |
16 |
17 | class GenericJSONEncoder(json.JSONEncoder, MapperDumper):
18 | def __init__(self, objects_map={}, fold=True, **kwargs):
19 | json.JSONEncoder.__init__(self, **kwargs)
20 | MapperDumper.__init__(self, objects_map)
21 | self.fold = fold
22 |
23 | def _fill_obj_dict(self, result, obj, prop, value):
24 | value = self.map(obj, prop, value)
25 | if value is None:
26 | return
27 | if (
28 | isinstance(value, DBObject)
29 | or isinstance(value, DBDict)
30 | or isinstance(value, DBList)
31 | ):
32 | result[prop] = self.default(value)
33 | else:
34 | result[prop] = value
35 |
36 | def default(self, obj: Any) -> Any:
37 | if isinstance(obj, DBObjectRange):
38 | return str(obj.rangeset)
39 | elif isinstance(obj, DBObjectRangeId):
40 | return obj.start
41 | elif isinstance(obj, DBDict):
42 | if self.fold:
43 | # Force iteration over the values of the dictionnary to avoid automatic
44 | # expansion performed by DBDict iterator.
45 | return [item for item in obj.values()]
46 | else:
47 | # Use DBDict iterator to expand potential DBExpandableObject.
48 | return [item for item in obj]
49 | elif isinstance(obj, DBList):
50 | if self.fold:
51 | return [item for item in obj.itervalues()]
52 | else:
53 | # As a DBList is also a standard iterable Python list, json.JSONEncoder
54 | # will iterate itself over the DBList, thus expanding potential
55 | # expandable objects automatically. There is nothing more to do in this
56 | # case.
57 | return obj
58 | elif isinstance(obj, DBObject):
59 | result = {}
60 | for prop in obj._schema.properties:
61 | try:
62 | self._fill_obj_dict(result, obj, prop.name, getattr(obj, prop.name))
63 | except AttributeError:
64 | continue
65 | return result
66 | # Let the base class default method raise the TypeError
67 | return json.JSONEncoder.default(self, obj)
68 |
69 |
70 | class DBDumperJSON:
71 | def __init__(self, show_types=False, objects_map={}, fold=True):
72 | self.objects_map = objects_map
73 | self.fold = fold
74 |
75 | def dump(self, obj: Any) -> str:
76 | # DBDict are also standard python dictionnaries, then json.JSONEncoder thinks it
77 | # can handle without hurdle and it does not call GenericJSONEncoder.default()
78 | # for this obj type. However:
79 | #
80 | # - DBDict must be represented as a list of values in dumps, the keys must not
81 | # be represented as they are just defined for pratical reasons to facilitate
82 | # data manipulation in library.
83 | # - Keys can be DBObjectRange objects that cannot be represented by standard
84 | # json.JSONEncoder.
85 | #
86 | # For these reasons, DBDict is converted here as a standard list of values.
87 | if isinstance(obj, DBDict):
88 | if self.fold:
89 | obj = [item for item in obj.values()]
90 | else:
91 | obj = [item for item in obj]
92 | return GenericJSONEncoder(objects_map=self.objects_map, fold=self.fold).encode(
93 | obj
94 | )
95 |
--------------------------------------------------------------------------------
/docs/utils/schema-objs.adoc.j2:
--------------------------------------------------------------------------------
1 | {#
2 | Warn people opening the resulting file it is generated using this template
3 | and the accompanying script.
4 | -#}
5 | ////
6 | Do not modify this file directly, it is automatically generated by combining
7 | the Python script `docs/utils/schema-objs.py` and the template
8 | `docs/utils/schema-objs.adoc.j2`. Please refer to the Python script comments
9 | to discover how it is used.
10 | ////
11 | {#
12 | Macro to represent the type of an object attribute
13 | #}
14 | {%- macro represent_type(data_type) -%}
15 | {%- if data_type.__class__.__name__ == 'SchemaContainerList' -%}
16 | {symbol-seq}{nbsp}{{ represent_type(data_type.content) }}
17 | {%- elif data_type.__class__.__name__ == 'SchemaReference' -%}
18 | {symbol-ref}{nbsp}{{ represent_type(data_type.obj) }}{% if data_type.prop is not none %}.{{data_type.prop}}{% endif %}
19 | {%- elif data_type.__class__.__name__ == 'SchemaBackReference' -%}
20 | {{ represent_type(data_type.obj) }}{% if data_type.prop is not none %}.{{data_type.prop}}{% endif %}
21 | {%- elif data_type.__class__.__name__ == 'SchemaObject' -%}
22 | xref:#obj-{{ data_type.name|lower() }}[{symbol-obj}{nbsp}{{ data_type.name }}]
23 | {%- elif 'SchemaDefinedType' in data_type|bases -%}
24 | xref:#deftype-{{ data_type.name[deftype_prefix|length:]|lower() }}[{symbol-deftype}{nbsp}~{{ data_type.name[deftype_prefix|length:] }}]
25 | {%- else -%}
26 | {{ data_type }}
27 | {%- endif -%}
28 | {%- endmacro -%}
29 |
30 | {%- macro represent_automatic_prop_name(prop) -%}
31 | {%- if prop.type.__class__.__name__ == 'SchemaBackReference' -%}
32 | {symbol-backref}
33 | {%- elif prop.computed -%}
34 | {symbol-computed}
35 | {%- endif -%}
36 | {nbsp}{{ prop.name }}
37 | {%- endmacro -%}
38 | {#
39 | Macro to render obj attributes table
40 | #}
41 | {%- macro obj_attributes(obj) -%}
42 | .Properties
43 | [cols="{tbl-obj-props-cols-specs}"]
44 | |===
45 | |Property|Description|Type|Required
46 | {% for prop in obj.properties if not prop.type.__class__.__name__ == 'SchemaBackReference' and not prop.computed %}
47 | |{{ prop.name }}{% if prop.key is true %}{nbsp}{symbol-key}{% endif %}
48 | |{{ prop.description }}
49 | {% if prop.default is not none %}
50 | {%- if prop.default is mapping %}
51 | *Default value:*
52 |
53 | [source,yaml]
54 | ----
55 | {{prop.default|toyaml}}
56 | ----
57 | {%- else %}
58 | *Default value:* `{{prop.default}}`
59 | {%- endif %}
60 | {%- endif %}
61 | |{{ represent_type(prop.type) }}
62 | |{% if prop.required is false %}[.grey]#-#{% else %}[.green]#icon:check[]#{% endif %}
63 | {% endfor -%}
64 | |===
65 | {%- endmacro -%}
66 | {#
67 | Macro to render obj backrefs table
68 | #}
69 | {%- macro obj_backrefs(obj) %}
70 |
71 | .Automatic properties
72 | [cols="{tbl-obj-backrefs-cols-specs}"]
73 | |===
74 | |Property|Description|Type
75 | {% for prop in obj.properties if prop.type.__class__.__name__ == 'SchemaBackReference' or prop.computed %}
76 | |{{ represent_automatic_prop_name(prop) }}
77 | |{{ prop.description }}
78 | |{{ represent_type(prop.type) }}
79 | {% endfor -%}
80 | |===
81 | {%- endmacro -%}
82 | :tbl-obj-props-cols-specs: 2m,6a,4,^.^1
83 | :tbl-obj-backrefs-cols-specs: 4m,6a,4
84 |
85 | [#obj-root]
86 | == Database Root
87 |
88 | Library class type: `{{object_prefix}}`
89 |
90 | {{ obj_attributes(schema.content) }}
91 |
92 | [#objects]
93 | == Objects
94 | {#-
95 | Iterate over the various objects sorted in lexicographical order.
96 | -#}
97 | {% for obj in schema.objects.values()|sort(attribute='name') %}
98 |
99 | [#obj-{{ obj.name|lower() }}]
100 | === {{ obj.name }}
101 |
102 | Library class type: `{{object_prefix}}{{ obj.name }}`
103 | {% if obj.description is not none %}
104 | {{ obj.description }}
105 | {% endif %}
106 | {{ obj_attributes(obj) }}
107 | {%- if obj.has_backref -%}
108 | {{ obj_backrefs(obj) }}
109 | {%- endif -%}
110 | {%- endfor %}
111 |
--------------------------------------------------------------------------------
/docs/modules/overview/pages/overview.adoc:
--------------------------------------------------------------------------------
1 | = Overview
2 |
3 | == Purpose
4 |
5 | *RacksDB* is an _open source_ solution for modeling your datacenters
6 | infrastructures. It provides a simple database schema to store information about
7 | the equipments in your datacenters, with tools and library to request this
8 | database. This database can be used as *reference source* for many purposes in
9 | IT management.
10 |
11 | image::overview:racksdb_overview.png[RacksDB Overview]
12 |
13 | * **Inventory**: Get permanent reference list of equipments charactistics and
14 | enable conformity testing.
15 | * **Automation**: Adopt Infrastructure-as-Code by coupling generic configuration
16 | management logic with infrastructures model.
17 | * **Continuous deployment**: Define advanced deployment rules based on nodes
18 | characteristics declared in RacksDB.
19 | * **Monitoring**: Synchronize monitoring services with equipments database and
20 | define dynamic dashboard.
21 | * **Documentation**: Get updated architecture diagrams and define generic
22 | adaptative procedures.
23 |
24 | :wiki-cmdb: https://en.wikipedia.org/wiki/Configuration_management_database
25 | :wiki-dcim: https://en.wikipedia.org/wiki/Data_center_management#Data_center_infrastructure_management
26 |
27 | Generally speaking, *RacksDB* is a specialized
28 | {wiki-cmdb}[CMDB]footnote:[Configuration management database] dedicated
29 | to {wiki-dcim}[DCIM]footnote:[Data center-infrastructure management].
30 |
31 | Compared to others products, *RacksDB* can be considered lightweight
32 | alternative to more advanced tools such as https://netbox.dev/[NetBox] and
33 | https://www.racktables.org/[RackTables]. Discover the xref:#characteristics[main
34 | characteristics] that makes it unique among other solutions.
35 |
36 | [#characteristics]
37 | == Characteristics
38 |
39 | The main characteristics of *RacksDB* are the following:
40 |
41 | * **YAML based.** The data are stored in plain files using human-readable YAML
42 | format, easily managed with Git.
43 | * **Simple and pragmatic.** The database schema is intuitive and practical,
44 | infrastructures can be described in few minutes.
45 | * **Tag-based.** Easy filtering of data and equipments based on associated tags.
46 | * **Decentralized architecture.** RacksDB can be deployed without central
47 | server, just by replicating few plain YAML files.
48 | * **Extensibility.** In addition to RacksDB simple format, custom schema
49 | extensions can be defined to store specific data.
50 |
51 | == Interfaces
52 |
53 | image::overview:racksdb_interfaces.png[RacksDB Interfaces]
54 |
55 | Once the database is defined, data can be searched and extracted using the
56 | xref:usage:racksdb.adoc[`racksdb` CLI]. A xref:usage:ui.adoc[Web UI] is also
57 | available to explore its content.
58 |
59 | image::overview:racksdb_web_ui_screenshots.webp[RacksDB Web UI,width=600]
60 |
61 | For full integration with your software, a xref:usage:lib.adoc[Python library]
62 | and a xref:usage:rest.adoc[REST API] can also be used to stay continuously
63 | synchronized with database content.
64 |
65 | [sidebar]
66 | --
67 | .More links
68 | * xref:usage:racksdb.adoc[`racksdb` command manual]
69 | * xref:usage:ui.adoc[Web UI user guide] with screenshots and features list
70 | * xref:usage:lib.adoc[Python Library reference] documentation with examples
71 | * xref:usage:rest.adoc[REST API reference] documentation with examples
72 | --
73 |
74 | == Diagrams
75 |
76 | RacksDB can be used to generate diagrams of your datacenter rooms and the racks
77 | with all their equipments, including _axonometric views_ for 3D representations.
78 |
79 | image::overview:racksdb_diagrams.png[RacksDB Diagrams,xref=image$racksdb_diagrams.svg]
80 |
81 | These diagrams can be generated in various formats (PNG, SVG, PDF) and be
82 | customized with many xref:usage:drawparams.adoc[drawing parameters].
83 |
84 | [sidebar]
85 | --
86 | .More links
87 | * xref:usage:racksdb.adoc#draw[`racksdb` CLI drawing feature]
88 | * xref:usage:drawparams.adoc[Drawing parameters howto and reference
89 | documentation]
90 | --
91 |
--------------------------------------------------------------------------------
/frontend/src/views/DatacentersView.vue:
--------------------------------------------------------------------------------
1 |
6 |
7 |
106 |
107 |
108 |
109 |
110 |
115 |
116 |
117 |
118 |
--------------------------------------------------------------------------------
/frontend/tests/components/InfrastructureFilters.spec.ts:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2025 Rackslab
3 |
4 | This file is part of RacksDB.
5 |
6 | SPDX-License-Identifier: MIT
7 | */
8 |
9 | import { describe, test, expect } from 'vitest'
10 | import { mount } from '@vue/test-utils'
11 | import { nextTick } from 'vue'
12 |
13 | import InfrastructureFilters from '@/components/InfrastructureFilters.vue'
14 |
15 | describe('InfrastructureFilters', () => {
16 | test('renders filter sections when slider is shown', async () => {
17 | const wrapper = mount(InfrastructureFilters, {
18 | props: {
19 | showSlider: true,
20 | racks: ['R01', 'R02'],
21 | equipmentCategories: ['nodes', 'storage'],
22 | equipmentTypes: ['server', 'switch'],
23 | tags: ['prod', 'test'],
24 | selectedRacks: [],
25 | selectedEquipmentTypes: [],
26 | selectedCategories: [],
27 | selectedTags: [],
28 | inputEquipmentName: ''
29 | }
30 | })
31 |
32 | await nextTick()
33 |
34 | // Test that the dialog component exists (even if not visible due to teleport)
35 | expect(wrapper.findComponent({ name: 'Dialog' }).exists()).toBe(true)
36 |
37 | // Test that the component renders without errors
38 | expect(wrapper.exists()).toBe(true)
39 |
40 | // Test that the props are passed correctly
41 | expect(wrapper.props('showSlider')).toBe(true)
42 | expect(wrapper.props('racks')).toEqual(['R01', 'R02'])
43 | expect(wrapper.props('equipmentCategories')).toEqual(['nodes', 'storage'])
44 | expect(wrapper.props('equipmentTypes')).toEqual(['server', 'switch'])
45 | expect(wrapper.props('tags')).toEqual(['prod', 'test'])
46 | })
47 |
48 | test('filters racks based on query', async () => {
49 | const wrapper = mount(InfrastructureFilters, {
50 | props: {
51 | showSlider: true,
52 | racks: ['R01', 'R02', 'R10'],
53 | equipmentCategories: [],
54 | equipmentTypes: [],
55 | tags: [],
56 | selectedRacks: [],
57 | selectedEquipmentTypes: [],
58 | selectedCategories: [],
59 | selectedTags: [],
60 | inputEquipmentName: ''
61 | }
62 | })
63 |
64 | await nextTick()
65 |
66 | // Set query to filter racks
67 | wrapper.vm.queryRacks = 'R0'
68 | await nextTick()
69 |
70 | const filteredRacks = wrapper.vm.filteredRacks
71 | expect(filteredRacks).toEqual(['R01', 'R02'])
72 | })
73 |
74 | test('filters equipment types based on query', async () => {
75 | const wrapper = mount(InfrastructureFilters, {
76 | props: {
77 | showSlider: true,
78 | racks: [],
79 | equipmentCategories: [],
80 | equipmentTypes: ['server', 'switch', 'storage'],
81 | tags: [],
82 | selectedRacks: [],
83 | selectedEquipmentTypes: [],
84 | selectedCategories: [],
85 | selectedTags: [],
86 | inputEquipmentName: ''
87 | }
88 | })
89 |
90 | await nextTick()
91 |
92 | // Set query to filter equipment types
93 | wrapper.vm.queryEquipmentTypes = 'ser'
94 | await nextTick()
95 |
96 | const filteredEquipmentTypes = wrapper.vm.filteredEquipmentTypes
97 | expect(filteredEquipmentTypes).toEqual(['server'])
98 | })
99 |
100 | test('emits toggleSlider when close button is clicked', async () => {
101 | const wrapper = mount(InfrastructureFilters, {
102 | props: {
103 | showSlider: true,
104 | racks: [],
105 | equipmentCategories: [],
106 | equipmentTypes: [],
107 | tags: [],
108 | selectedRacks: [],
109 | selectedEquipmentTypes: [],
110 | selectedCategories: [],
111 | selectedTags: [],
112 | inputEquipmentName: ''
113 | }
114 | })
115 |
116 | await nextTick()
117 |
118 | // Test that the component renders without errors
119 | expect(wrapper.exists()).toBe(true)
120 |
121 | // Test that the component can emit toggleSlider event
122 | await wrapper.vm.$emit('toggleSlider')
123 | expect(wrapper.emitted('toggleSlider')).toBeTruthy()
124 | })
125 | })
126 |
--------------------------------------------------------------------------------
/frontend/src/components/HomeViewCards.vue:
--------------------------------------------------------------------------------
1 |
6 |
7 |
32 |
33 |
34 |
35 |
116 |
117 |
--------------------------------------------------------------------------------
/docs/update-materials:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | #
3 | # Copyright (c) 2024 Rackslab
4 | #
5 | # This file is part of RacksDB.
6 | #
7 | # SPDX-License-Identifier: GPL-3.0-or-later
8 |
9 | import sys
10 | import yaml
11 | from pathlib import Path
12 |
13 | from rfl.build.ninja import NinjaBuilder
14 | from rfl.build.projectversion import project_version
15 |
16 | # Sizes names and associated DPI
17 | SVG_SIZES = {"tiny": 32, "small": 64, "medium": 96, "large": 128, "xlarge": 192}
18 | TARGETS = ["all", "man", "schema-ref", "drawing-ref", "openapi", "png", "clean"]
19 | MANPAGE_SOURCE = f"RacksDB {project_version()}"
20 | DOCS_DIR = Path(__file__).parent
21 | RACKSDB_SCHEMA = DOCS_DIR.parent / "schemas/racksdb.yml"
22 | RACKSDB_REF = DOCS_DIR / "modules/db/partials/objects.adoc"
23 | DRAWINGS_SCHEMA = DOCS_DIR.parent / "schemas/drawings.yml"
24 | DRAWINGS_REF = DOCS_DIR / "modules/usage/partials/drawing-objects.adoc"
25 | OPENAPI = DOCS_DIR / "modules/usage/attachments/openapi.yml"
26 |
27 |
28 | def main():
29 | targets = sys.argv[1:]
30 |
31 | if any([target not in TARGETS for target in targets]):
32 | print(f"Supported targets are: {TARGETS}")
33 | sys.exit(1)
34 |
35 | if not (len(targets)):
36 | targets = ["all"]
37 |
38 | builder = NinjaBuilder()
39 |
40 | with open(DOCS_DIR / "utils/build.yaml") as fh:
41 | rules = yaml.safe_load(fh.read())
42 |
43 | # clean target
44 | if "clean" in targets:
45 | manpages = (DOCS_DIR / "man").glob("*.1")
46 | for manpage in manpages:
47 | print(f"Removing manpage {manpage}")
48 | manpage.unlink()
49 | generated_pngs = [
50 | (DOCS_DIR / svg_s).with_suffix(".png") for svg_s in rules["diagrams"].keys()
51 | ]
52 | for generated_png in generated_pngs:
53 | print(f"Removing generated PNG image {generated_png}")
54 | generated_png.unlink()
55 | print(f"Removing RacksDB schema reference documentation {RACKSDB_REF}")
56 | RACKSDB_REF.unlink()
57 | print(f"Removing RacksDB drawing schema reference documentation {DRAWINGS_REF}")
58 | DRAWINGS_REF.unlink()
59 | print(f"Removing OpenAPI description {OPENAPI}")
60 | OPENAPI.unlink()
61 |
62 | for size, dpi in SVG_SIZES.items():
63 | builder.rule(
64 | name=f"png-{size}",
65 | command=(
66 | f"inkscape $in --export-type=png --export-overwrite --export-dpi={dpi} "
67 | "--export-filename=$out"
68 | ),
69 | )
70 |
71 | builder.rule(
72 | name="manpage",
73 | command=(
74 | f"asciidoctor --backend manpage --attribute mansource='{MANPAGE_SOURCE}' "
75 | "$in"
76 | ),
77 | )
78 |
79 | builder.rule(name="schema-ref", command="python3 utils/schema-objs.py > $out")
80 |
81 | builder.rule(
82 | name="drawing-ref", command="python3 utils/drawings-schema-objs.py > $out"
83 | )
84 | builder.rule(name="openapi", command="python3 utils/gen-openapi.py > $out")
85 |
86 | if "man" in targets or "all" in targets:
87 | manpages = (DOCS_DIR / "man").glob("*.adoc")
88 | for manpage in manpages:
89 | implicit = DOCS_DIR / "modules/usage/pages" / manpage.name
90 | target = (DOCS_DIR / "man" / manpage.stem).with_suffix(".1")
91 | builder.build(
92 | outputs=[target], rule="manpage", inputs=[manpage], implicit=[implicit]
93 | )
94 |
95 | if "schema-ref" in targets or "all" in targets:
96 | builder.build(
97 | outputs=[RACKSDB_REF], rule="schema-ref", implicit=[RACKSDB_SCHEMA]
98 | )
99 |
100 | if "drawing-ref" in targets or "all" in targets:
101 | builder.build(
102 | outputs=[DRAWINGS_REF], rule="drawing-ref", implicit=[DRAWINGS_SCHEMA]
103 | )
104 |
105 | if "openapi" in targets or "all" in targets:
106 | builder.build(
107 | outputs=[OPENAPI],
108 | rule="openapi",
109 | implicit=[RACKSDB_SCHEMA, DRAWINGS_SCHEMA],
110 | )
111 |
112 | if "png" in targets or "all" in targets:
113 | svg_rules = rules["diagrams"]
114 | for svg_s, size in svg_rules.items():
115 | svg = DOCS_DIR / svg_s
116 | png = svg.with_suffix(".png")
117 | builder.build(outputs=[png], rule=f"png-{size}", inputs=[svg])
118 |
119 | builder.run()
120 |
121 |
122 | if __name__ == "__main__":
123 | main()
124 |
--------------------------------------------------------------------------------
38 |
74 |
75 |
39 |
40 |
47 |
48 |
49 | 43 | {{ datacenters.length }} datacenter 44 | s 45 |
46 |
50 |
73 |
51 |
52 | {{ datacenter.name }}
56 |
57 |
58 |
72 |
59 | {{ datacenter.rooms.length }} rooms
60 | {{ datacenter.rooms.length }} room
61 |
62 |
68 |
63 |
67 |
64 | #{{ tag }}
65 |
66 |
69 |
70 |
71 | 70 |
78 |
115 |
79 |
80 |
87 |
88 |
89 | 83 | {{ infrastructures.length }} infrastructure 84 | s 85 |
86 |
90 |
114 |
91 |
94 | {{ infrastructure.name }}
98 |
99 |
100 |
113 |
101 | {{ infrastructure.description }}
102 |
103 |
109 |
104 |
108 |
105 | #{{ tag }}
106 |
107 |
110 |
111 |
112 | 111 |