예제 #1
0
def _item_spec_tcp_connections():
    return TextInput(
        title=_("Connection name"),
        help=_("Specify an arbitrary name of this connection here"),
        allow_empty=False,
    )
예제 #2
0
def _item_spec_raid_disk():
    return TextInput(
        title=_("Number or ID of the disk"),
        help=_("How the disks are named depends on the type of hardware being "
               "used. Please look at already discovered checks for examples."),
    )
예제 #3
0
                            (1, "Other"),
                            (2, "No Error"),
                            (3, "Low Paper"),
                            (4, "No Paper"),
                            (5, "Low Toner"),
                            (6, "No Toner"),
                            (7, "Door Open"),
                            (8, "Jammed"),
                            (9, "Offline"),
                            (10, "Service Requested"),
                            (11, "Output Bin Full"),
                        ],
                        default_value=[8, 11],
                    ),
                ),
            ],
        ),
        forth=windows_printer_queues_forth,
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="windows_printer_queues",
        group=RulespecGroupCheckParametersPrinters,
        item_spec=lambda: TextInput(title=_("Printer Name"), allow_empty=True),
        parameter_valuespec=_parameter_valuespec_windows_printer_queues,
        title=lambda: _("Windows printers: number of open jobs"),
    )
)
예제 #4
0
)


def _parameter_valuespec_enterasys_powersupply():
    return Dictionary(
        elements=[
            ("redundancy_ok_states",
             ListChoice(
                 title=_("States treated as OK"),
                 choices=[
                     (1, 'redundant'),
                     (2, 'notRedundant'),
                     (3, 'notSupported'),
                 ],
                 default_value=[1],
             )),
        ],
        optional_keys=False,
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="enterasys_powersupply",
        group=RulespecGroupCheckParametersNetworking,
        item_spec=lambda: TextInput(title=_("Number of Powersupply"), ),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_enterasys_powersupply,
        title=lambda: _("Enterasys Power Supply Settings"),
    ))
예제 #5
0
                    elements=[
                        Float(title="warn", ),
                        Float(title="crit", ),
                    ],
                ),
            ),
        ],
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="couchbase_ops",
        group=RulespecGroupCheckParametersApplications,
        match_type="dict",
        item_spec=lambda: TextInput(title=_("Node or bucket name")),
        parameter_valuespec=_parameter_valuespec_couchbase_operations,
        title=lambda: _("Couchbase Operations"),
    ))

rulespec_registry.register(
    CheckParameterRulespecWithoutItem(
        check_group_name="couchbase_ops_nodes",
        group=RulespecGroupCheckParametersApplications,
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_couchbase_operations,
        title=lambda: _("Couchbase Total Node Operations"),
    ))

rulespec_registry.register(
    CheckParameterRulespecWithoutItem(
예제 #6
0
                                            default_value=120,
                                        ),
                                    ],
                                ),
                            ),
                        ],
                        optional_keys=[
                            "trend_levels", "trend_levels_lower",
                            "trend_timeleft"
                        ],
                    ),
                ),
            ],
            ignored_keys=["_item_key"],
        ),
        forth=lambda v: isinstance(v, tuple) and {"levels": v} or v,
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="temperature",
        group=RulespecGroupCheckParametersEnvironment,
        item_spec=lambda: TextInput(
            title=_("Sensor ID"),
            help=_("The identifier of the thermal sensor.")),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_temperature,
        title=lambda: _("Temperature"),
    ))
예제 #7
0
        (
            "levels",
            Tuple(
                title=_("Levels for used configured reserve"),
                elements=[
                    Percentage(title=_("Warning at or above"),
                               unit="%",
                               default_value=85.0),
                    Percentage(title=_("Critical at or above"),
                               unit="%",
                               default_value=90.0),
                ],
            ),
        ),
        (
            "state_noreserve",
            MonitoringState(title=_("State if no reserve is configured"), ),
        ),
    ], )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="netapp_snapshots",
        group=RulespecGroupCheckParametersStorage,
        item_spec=lambda: TextInput(title=_("Volume name")),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_netapp_snapshots,
        title=lambda: _("NetApp Snapshot Reserve"),
    ))
예제 #8
0
def _item_spec_sap_hana_license():
    return TextInput(title=_("The instance name"))
예제 #9
0
def _parameter_valuespec_uptime():
    return Dictionary(elements=[
        ("min",
         Tuple(
             title=_("Minimum required uptime"),
             elements=[
                 Age(title=_("Warning if below")),
                 Age(title=_("Critical if below")),
             ],
         )),
        ("max",
         Tuple(
             title=_("Maximum allowed uptime"),
             elements=[
                 Age(title=_("Warning at")),
                 Age(title=_("Critical at")),
             ],
         )),
    ],)


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="uptime_multiitem",
        group=RulespecGroupCheckParametersOperatingSystem,
        item_spec=lambda: TextInput(title=_("Module name"), allow_empty=False),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_uptime,
        title=lambda: _("Uptime since last reboot of devices with modules"),
    ))
예제 #10
0
                      Tuple(elements=[
                          Percentage(title=_("Warning at a memory usage of"),
                                     default_value=80.0,
                                     maxvalue=None),
                          Percentage(title=_("Critical at a memory usage of"),
                                     default_value=90.0,
                                     maxvalue=None)
                      ], )),
                     ("abs_free", _("Absolute levels for free memory"),
                      Tuple(elements=[
                          Filesize(title=_("Warning below")),
                          Filesize(title=_("Critical below"))
                      ], )),
                     ("ignore", _("Do not impose levels")),
                 ],
             )),
        ],
        optional_keys=[],
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="sap_hana_memory",
        group=RulespecGroupCheckParametersApplications,
        item_spec=lambda: TextInput(title=_("The instance name")),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_sap_hana_memory,
        title=lambda: _("SAP HANA Memory"),
    ))
예제 #11
0
def _item_spec_sap_hana_backup():
    return TextInput(title=_("The instance name and backup type"))
예제 #12
0
 def valuespec(self) -> ValueSpec:
     return TextInput(title="title")
예제 #13
0
                                maxvalue=None,
                            ),
                        ],
                    ),
                    Tuple(
                        title=_("Specify levels in absolute usage values"),
                        elements=[
                            Integer(title=_("Warning at"), unit=_("MB")),
                            Integer(title=_("Critical at"), unit=_("MB")),
                        ],
                    ),
                ],
            ),
        ),
    ]
    return Transform(
        Dictionary(elements=elements + size_trend_elements),
        forth=_transform_wrapper,
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="cisco_mem",
        group=RulespecGroupCheckParametersOperatingSystem,
        item_spec=lambda: TextInput(title=_("Memory Pool Name"),
                                    allow_empty=False),
        parameter_valuespec=_parameter_valuespec_cisco_mem,
        title=lambda: _("Cisco Memory Usage"),
    ))
예제 #14
0
파일: local.py 프로젝트: petrows/checkmk
from cmk.gui.i18n import _
from cmk.gui.plugins.wato import (
    CheckParameterRulespecWithItem,
    ManualCheckParameterRulespec,
    rulespec_registry,
    RulespecGroupCheckParametersApplications,
    RulespecGroupEnforcedServicesApplications,
)
from cmk.gui.valuespec import Dictionary, DropdownChoice, TextInput, Transform

rulespec_registry.register(
    ManualCheckParameterRulespec(
        check_group_name="local",
        group=RulespecGroupEnforcedServicesApplications,
        item_spec=lambda: TextInput(title=_("Name of local item")),
        parameter_valuespec=lambda: Transform(Dictionary(elements=[]), forth=lambda p: {}),
        title=lambda: _("Local checks"),
    ))

# We only need the above, there are no "true" parameters to this check plugin.


def _deprecation_message() -> str:
    return _('This ruleset is deprecated. Please use the ruleset <i>"%s"</i> instead.') % _(
        "Aggregation options for clustered services")


def _parameter_valuespec_local():
    return Dictionary(elements=[
        ("outcome_on_cluster",
예제 #15
0
파일: job.py 프로젝트: troelsarvin/checkmk
                  "If you happen to define the same exit code multiple times the first entry will be used."
                  ),
                allow_empty=False,
            ),
        ),
        (
            "outcome_on_cluster",
            DropdownChoice(
                title="%s - %s" % (
                    _("Clusters: Preferred check result of local checks"),
                    _deprecation_message(),
                ),
                choices=[],
                deprecated_choices=("worst", "best"),
                invalid_choice_title=_(
                    'Old setting: "%s". Choose that in the new ruleset.'),
            ),
        ),
    ], )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="job",
        group=RulespecGroupCheckParametersApplications,
        item_spec=lambda: TextInput(title=_("Job name"), ),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_job,
        title=lambda: _("mk-job job age"),
    ))
예제 #16
0
def _item_spec_cooling_cap():
    return TextInput(
        title=_("Cooling device"),
        help=_("This name corresponds to the cooling device to be monitored."),
        allow_empty=True)
예제 #17
0
                    help=_(
                        "Here you can specify levels for different policies which overrule the levels "
                        "from the <i>Default levels</i> parameter. This setting only works in NetApp Clustermode setups."
                    ),
                    allow_empty=False,
                ),
            ),
        ],
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="snapvault",
        group=RulespecGroupCheckParametersStorage,
        item_spec=lambda: TextInput(title=_("Source Path"), allow_empty=False),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_snapvault,
        title=lambda: _("NetApp Snapvaults / Snapmirror Lag Time"),
    )
)


def _discovery_valuespec_snapvault():
    return Dictionary(
        elements=[
            (
                "exclude_destination_vserver",
                Checkbox(
                    title=_("Exclude destination vserver"),
                    help=_(
예제 #18
0
def _valuespec_special_agents_kubernetes():
    return Transform(
        valuespec=Dictionary(
            elements=[
                (
                    "api-server-endpoint",
                    CascadingDropdown(
                        choices=[
                            (
                                "hostname",
                                _("Hostname"),
                                Dictionary(
                                    elements=_kubernetes_connection_elements(
                                    )),
                            ),
                            (
                                "ipaddress",
                                _("IP address"),
                                Dictionary(
                                    elements=_kubernetes_connection_elements(
                                    )),
                            ),
                            (
                                "url_custom",
                                _("Custom URL"),
                                TextInput(
                                    allow_empty=False,
                                    size=80,
                                ),
                            ),
                        ],
                        orientation="horizontal",
                        title=_("API server endpoint"),
                        help=
                        _('The URL that will be contacted for Kubernetes API calls. If the "Hostname" '
                          'or the "IP Address" options are selected, the DNS hostname or IP address and '
                          "a secure protocol (HTTPS) are used."),
                    ),
                ),
                (
                    "token",
                    IndividualOrStoredPassword(
                        title=_("Token"),
                        allow_empty=False,
                    ),
                ),
                (
                    "no-cert-check",
                    Alternative(
                        title=_("SSL certificate verification"),
                        elements=[
                            FixedValue(value=False,
                                       title=_("Verify the certificate"),
                                       totext=""),
                            FixedValue(
                                value=True,
                                title=_(
                                    "Ignore certificate errors (unsecure)"),
                                totext="",
                            ),
                        ],
                        default_value=False,
                    ),
                ),
                (
                    "namespaces",
                    Alternative(
                        title=_("Namespace prefix for hosts"),
                        elements=[
                            FixedValue(value=False,
                                       title=_("Don't use a namespace prefix"),
                                       totext=""),
                            FixedValue(value=True,
                                       title=_("Use a namespace prefix"),
                                       totext=""),
                        ],
                        help=
                        _("If a cluster uses multiple namespaces you need to activate this option. "
                          "Hosts for namespaced Kubernetes objects will then be prefixed with the "
                          "name of their namespace. This makes Kubernetes resources in different "
                          "namespaces that have the same name distinguishable, but results in "
                          "longer hostnames."),
                        default_value=False,
                    ),
                ),
                (
                    "infos",
                    ListChoice(
                        choices=[
                            ("nodes", _("Nodes")),
                            ("services", _("Services")),
                            ("ingresses", _("Ingresses")),
                            ("deployments", _("Deployments")),
                            ("pods", _("Pods")),
                            ("endpoints", _("Endpoints")),
                            ("daemon_sets", _("Daemon sets")),
                            ("stateful_sets", _("Stateful sets")),
                            ("jobs", _("Job")),
                        ],
                        default_value=[
                            "nodes",
                            "endpoints",
                            "ingresses",
                        ],
                        allow_empty=False,
                        title=_("Retrieve information about..."),
                    ),
                ),
                filter_kubernetes_namespace_element(),
            ],
            optional_keys=[
                "port", "url-prefix", "path-prefix",
                "namespace_include_patterns"
            ],
            title=_("Kubernetes (deprecated)"),
            help=_(
                "This special agent is deprecated and will be removed in "
                'Checkmk version 2.2.0. Please use the "Kubernetes" ruleset to '
                "configure the new special agent for Kubernetes."),
        ),
        forth=special_agents_kubernetes_transform,
    )
예제 #19
0
def _item_spec_msx_queues():
    return TextInput(
        title=_("Explicit Queue Names"),
        help=_("Specify queue names that the rule should apply to"),
    )
예제 #20
0
def _item_spec_adva_ifs():
    return TextInput(
        title=_("Interface"),
        allow_empty=False,
    )
예제 #21
0
def _item_spec_netapp_systemtime():
    return TextInput(
        title=_("Name of the node"),
        allow_empty=False,
    )
예제 #22
0
    rulespec_registry,
    RulespecGroupCheckParametersEnvironment,
)
from cmk.gui.valuespec import Dictionary, Percentage, TextInput, Tuple


def _parameter_valuespec_hw_psu():
    return Dictionary(elements=[
        (
            "levels",
            Tuple(
                title=_("PSU Capacity Levels"),
                elements=[
                    Percentage(title=_("Warning at"), default_value=80.0),
                    Percentage(title=_("Critical at"), default_value=90.0),
                ],
            ),
        ),
    ], )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="hw_psu",
        group=RulespecGroupCheckParametersEnvironment,
        item_spec=lambda: TextInput(title=_("PSU (Chassis/Bay)")),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_hw_psu,
        title=lambda: _("Power Supply Unit"),
    ))
예제 #23
0
def _item_spec_acme_certificates():
    return TextInput(
        title=_("Name of certificate"),
        allow_empty=False,
    )
예제 #24
0
from cmk.gui.valuespec import Dictionary, Percentage, TextInput, Tuple


def _parameter_valuespec_printer_input():
    return Dictionary(
        elements=[
            (
                "capacity_levels",
                Tuple(
                    title=_("Capacity remaining"),
                    elements=[
                        Percentage(title=_("Warning at"), default_value=0.0),
                        Percentage(title=_("Critical at"), default_value=0.0),
                    ],
                ),
            ),
        ],
        default_keys=["capacity_levels"],
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="printer_input",
        group=RulespecGroupCheckParametersPrinters,
        item_spec=lambda: TextInput(title=_("Unit Name"), allow_empty=True),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_printer_input,
        title=lambda: _("Printer Input Units"),
    ))
예제 #25
0
    def _vs_mandatory_elements(self) -> list[DictionaryEntry]:
        ident_attr: List = []
        if self._new:
            ident_attr = [
                (
                    "ident",
                    ID(
                        title=_("Unique ID"),
                        help=_(
                            "The ID must be a unique text. It will be used as an internal key "
                            "when objects refer to this object."),
                        default_value=self._default_id,
                        allow_empty=False,
                        size=80,
                    ),
                ),
            ]
        else:
            ident_attr = [
                (
                    "ident",
                    FixedValue(
                        value=self._ident,
                        title=_("Unique ID"),
                    ),
                ),
            ]

        if self._mode_type.is_site_specific():
            site_attr = [
                ("site", self._mode_type.site_valuespec()),
            ]
        else:
            site_attr = []

        if self._mode_type.can_be_disabled():
            disable_attr = [
                (
                    "disabled",
                    Checkbox(
                        title=_("Activation"),
                        help=
                        _("Disabled %s are kept in the configuration but are not active."
                          ) % self._mode_type.name_singular(),
                        label=_("do not activate this %s") %
                        self._mode_type.name_singular(),
                    ),
                ),
            ]
        else:
            disable_attr = []

        elements = (ident_attr + [
            (
                "title",
                TextInput(
                    title=_("Title"),
                    help=_(
                        "The title of the %s. It will be used as display name."
                    ) % (self._mode_type.name_singular()),
                    allow_empty=False,
                    size=80,
                ),
            ),
            ("comment", RuleComment()),
            ("docu_url", DocumentationURL()),
        ] + disable_attr + site_attr)

        return elements
예제 #26
0
def _item_spec_jvm_memory() -> TextInput:
    return TextInput(
        title=_("Name of the virtual machine"),
        help=_("The name of the application server"),
        allow_empty=False,
    )
예제 #27
0
파일: azure.py 프로젝트: m3rlinux/checkmk
def _valuespec_special_agents_azure():
    return Dictionary(
        title=_("Microsoft Azure"),
        help=
        _("To monitor Azure resources add this datasource to <b>one</b> host. "
          "The data will be transported using the piggyback mechanism, so make "
          "sure to create one host for every monitored resource group. You can "
          "learn about the discovered groups in the <i>Azure Agent Info</i> "
          "service of the host owning the datasource program."),
        # element names starting with "--" will be passed do cmd line w/o parsing!
        elements=[
            (
                "subscription",
                TextInput(
                    title=_("Subscription ID"),
                    allow_empty=False,
                    size=45,
                ),
            ),
            (
                "tenant",
                TextInput(
                    title=_("Tenant ID / Directory ID"),
                    allow_empty=False,
                    size=45,
                ),
            ),
            (
                "client",
                TextInput(
                    title=_("Client ID / Application ID"),
                    allow_empty=False,
                    size=45,
                ),
            ),
            (
                "secret",
                Password(
                    title=_("Client Secret"),
                    allow_empty=False,
                    size=45,
                ),
            ),
            (
                "config",
                Dictionary(
                    title=_("Retrieve information about..."),
                    # Since we introduced this, Microsoft has already reduced the number
                    # of allowed API requests. At the time of this writing (11/2018)
                    # you can find the number here:
                    # https://docs.microsoft.com/de-de/azure/azure-resource-manager/resource-manager-request-limits
                    help=
                    _("By default, all resources associated to the configured tenant ID"
                      " will be monitored.") + " " +
                    _("However, since Microsoft limits API calls to %s per hour"
                      " (%s per minute), you can restrict the monitoring to individual"
                      " resource groups and resources.") % ("12000", "200"),
                    elements=[
                        ("explicit",
                         _special_agents_azure_azure_explicit_config()),
                        ("tag_based",
                         _special_agents_azure_azure_tag_based_config()),
                    ],
                ),
            ),
            (
                "piggyback_vms",
                DropdownChoice(
                    title=_("Map data relating to VMs"),
                    help=
                    _("By default, data relating to a VM is sent to the group host"
                      " corresponding to the resource group of the VM, the same way"
                      " as for any other resource. If the VM is present in your "
                      " monitoring as a separate host, you can choose to send the data"
                      " to the VM itself."),
                    choices=[
                        ("grouphost", _("Map data to group host")),
                        ("self", _("Map data to the VM itself")),
                    ],
                ),
            ),
            (
                "sequential",
                DropdownChoice(
                    title=_("Force agent to run in single thread"),
                    help=_("Check this to turn off multiprocessing."
                           " Recommended for debugging purposes only."),
                    choices=[
                        (False, _("Run agent multithreaded")),
                        (True, _("Run agent in single thread")),
                    ],
                ),
            ),
        ],
        optional_keys=["subscription", "piggyback_vms", "sequential"],
    )
예제 #28
0
def dashlet_vs_general_settings(dashlet_type: Type[Dashlet],
                                single_infos: List[str]):
    return Dictionary(
        title=_("General Settings"),
        render="form",
        optional_keys=["title", "title_url"],
        elements=[
            (
                "type",
                FixedValue(
                    dashlet_type.type_name(),
                    totext=dashlet_type.title(),
                    title=_("Element type"),
                ),
            ),
            visuals.single_infos_spec(single_infos),
            (
                "background",
                Checkbox(
                    title=_("Colored background"),
                    label=_("Render background"),
                    help=
                    _("Render gray background color behind the elements content."
                      ),
                    default_value=True,
                ),
            ),
            (
                "show_title",
                DropdownChoice(
                    title=_("Show title header"),
                    help=
                    _("Render the titlebar including title and link above the element."
                      ),
                    choices=[
                        (False, _("Don't show any header")),
                        (True, _("Show header with highlighted background")),
                        ("transparent",
                         _("Show title without any background")),
                    ],
                    default_value=True,
                ),
            ),
            (
                "title",
                TextInput(
                    title=_("Custom title") + "<sup>*</sup>",
                    placeholder=_(
                        "This option is macro-capable, please check the inline help for more "
                        "information."),
                    help=" ".join((
                        _("Most elements have a hard coded static title and some are aware of their "
                          "content and set the title dynamically, like the view snapin, which "
                          "displays the title of the view. If you like to use any other title, set it "
                          "here."),
                        _title_help_text_for_macros(dashlet_type),
                    )),
                    size=75,
                ),
            ),
            (
                "title_url",
                TextInput(
                    title=_("Link of Title"),
                    help=
                    _("The URL of the target page the link of the element should link to."
                      ),
                    size=50,
                ),
            ),
        ],
    )
예제 #29
0
          "are applied on the number of used processes in percentage of the configured limit."
          ),
        elements=[
            (
                "levels",
                Tuple(
                    title=_("Levels for used processes"),
                    elements=[
                        Percentage(title=_("Warning if more than"),
                                   default_value=70.0),
                        Percentage(title=_("Critical if more than"),
                                   default_value=90.0),
                    ],
                ),
            ),
        ],
        optional_keys=False,
    )


rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="oracle_processes",
        group=RulespecGroupCheckParametersApplications,
        item_spec=lambda: TextInput(
            title=_("Database SID"), size=12, allow_empty=False),
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_oracle_processes,
        title=lambda: _("Oracle Processes"),
    ))
예제 #30
0
    def parameters(cls, mode):
        def bookmark_config_to_vs(v):
            if v:
                return (v["title"], v["url"], v["icon"], v["topic"])
            return v

        def bookmark_vs_to_config(v):
            return {
                "title": v[0],
                "url": v[1],
                "icon": v[2],
                "topic": v[3],
            }

        parameters = super().parameters(mode)

        parameters += [(
            _("Bookmarks"),
            [
                # sort-index, key, valuespec
                (
                    2.5,
                    "default_topic",
                    TextInput(
                        title=_("Default Topic") + "<sup>*</sup>",
                        size=50,
                        allow_empty=False,
                    ),
                ),
                (
                    3.0,
                    "bookmarks",
                    ListOf(
                        # For the editor we want a compact dialog. The tuple horizontal editin mechanism
                        # is exactly the thing we want. But we want to store the data as dict. This is a
                        # nasty hack to use the transform by default. Better would be to make Dict render
                        # the same way the tuple is rendered.
                        valuespec=Transform(
                            valuespec=Tuple(
                                elements=[
                                    (TextInput(
                                        title=_("Title") + "<sup>*</sup>",
                                        size=30,
                                        allow_empty=False,
                                    )),
                                    (TextInput(
                                        title=_("URL"),
                                        size=50,
                                        allow_empty=False,
                                        validate=cls.validate_url,
                                    )),
                                    (IconSelector(title=_("Icon"),
                                                  with_emblem=False)),
                                    (cls._vs_topic()),
                                ],
                                orientation="horizontal",
                                title=_("Bookmarks"),
                            ),
                            forth=bookmark_config_to_vs,
                            back=bookmark_vs_to_config,
                        )),
                ),
            ],
        )]

        return parameters