[PATCH 25/27] vz: Move error messages onto a single line

Friday, 25 August 2023

Error messages are exempt from the 80 columns rule. Move them
onto one line.

Signed-off-by: Michal Privoznik <mprivozn(a)redhat.com&gt;
---
 src/vz/vz_driver.c |  15 ++---
 src/vz/vz_sdk.c    | 135 +++++++++++++++------------------------------
 src/vz/vz_utils.c  |  66 ++++++++--------------
 3 files changed, 72 insertions(+), 144 deletions(-)

diff --git a/src/vz/vz_driver.c b/src/vz/vz_driver.c
index 401ca041ed..c7ceec2339 100644
--- a/src/vz/vz_driver.c
+++ b/src/vz/vz_driver.c
@@ -842,8 +842,7 @@ vzDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned
int flags)
 
             if (!virDomainDefCheckABIStability(dom->def, def, driver->xmlopt)) {
                 virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                               _("Can't change domain configuration "
-                                 "in managed save state"));
+                               _("Can't change domain configuration in managed
save state"));
                 goto cleanup;
             }
         } else {
@@ -1461,15 +1460,13 @@ static int vzCheckConfigUpdateFlags(virDomainObj *dom, unsigned
int *flags)
 
     if (!(*flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("domain config update needs VIR_DOMAIN_AFFECT_CONFIG
"
-                         "flag to be set"));
+                       _("domain config update needs VIR_DOMAIN_AFFECT_CONFIG flag
to be set"));
         return -1;
     }
 
     if (virDomainObjIsActive(dom) && !(*flags & VIR_DOMAIN_AFFECT_LIVE)) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("Updates on a running domain need "
-                         "VIR_DOMAIN_AFFECT_LIVE flag"));
+                       _("Updates on a running domain need VIR_DOMAIN_AFFECT_LIVE
flag"));
         return -1;
     }
 
@@ -2793,8 +2790,7 @@ vzEatCookie(const char *cookiein, int cookieinlen, unsigned int
flags)
         if ((!(tmp = virXPathString("string(./session-uuid[1])", ctx))
             || (virUUIDParse(tmp, mig->session_uuid) < 0))) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("missing or malformed session-uuid element "
-                             "in migration data"));
+                           _("missing or malformed session-uuid element in migration
data"));
             goto error;
         }
     }
@@ -2921,8 +2917,7 @@ vzMigrationCreateURI(void)
 
     if (STRPREFIX(hostname, "localhost")) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("hostname on destination resolved to localhost,"
-                         " but migration requires an FQDN"));
+                       _("hostname on destination resolved to localhost, but
migration requires an FQDN"));
         goto cleanup;
     }
 
diff --git a/src/vz/vz_sdk.c b/src/vz/vz_sdk.c
index 286b52a29e..6a15d60577 100644
--- a/src/vz/vz_sdk.c
+++ b/src/vz/vz_sdk.c
@@ -2415,15 +2415,13 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef
*def)
 
     if (def->blkio.ndevices > 0) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("blkio parameters are not supported "
-                         "by vz driver"));
+                       _("blkio parameters are not supported by vz driver"));
         return -1;
     }
 
     if (virDomainDefGetMemoryTotal(def) != def->mem.cur_balloon) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing balloon parameters is not supported "
-                         "by vz driver"));
+                       _("changing balloon parameters is not supported by vz
driver"));
         return -1;
     }
 
@@ -2440,8 +2438,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
         virMemoryLimitIsSet(def->mem.swap_hard_limit)) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Memory parameter is not supported "
-                         "by vz driver"));
+                       _("Memory parameter is not supported by vz driver"));
         return -1;
     }
 
@@ -2453,8 +2450,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
 
     if (def->placement_mode) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing cpu placement mode is not supported "
-                         "by vz driver"));
+                       _("changing cpu placement mode is not supported by vz
driver"));
         return -1;
     }
 
@@ -2489,8 +2485,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
          memMode == VIR_DOMAIN_NUMATUNE_MEM_STRICT) ||
         virDomainNumatuneHasPerNodeBinding(def->numa)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("numa parameters are not supported "
-                         "by vz driver"));
+                       _("numa parameters are not supported by vz driver"));
         return -1;
     }
 
@@ -2499,8 +2494,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
         def->onCrash != VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("on_reboot, on_poweroff and on_crash parameters "
-                         "are not supported by vz driver"));
+                       _("on_reboot, on_poweroff and on_crash parameters are not
supported by vz driver"));
         return -1;
     }
 
@@ -2516,8 +2510,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
         def->os.bios.useserial != 0) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing OS parameters is not supported "
-                         "by vz driver"));
+                       _("changing OS parameters is not supported by vz
driver"));
         return -1;
     }
 
@@ -2531,8 +2524,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
         !(vmType == PVT_CT && IS_CT(def))) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing OS type is not supported "
-                         "by vz driver"));
+                       _("changing OS type is not supported by vz driver"));
         return -1;
     }
 
@@ -2555,16 +2547,14 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef
*def)
 
     if (def->emulator) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing emulator is not supported "
-                         "by vz driver"));
+                       _("changing emulator is not supported by vz driver"));
         return -1;
     }
 
     for (i = 0; i < VIR_DOMAIN_FEATURE_LAST; i++) {
         if (def->features[i]) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("changing features is not supported "
-                             "by vz driver"));
+                           _("changing features is not supported by vz
driver"));
             return -1;
         }
     }
@@ -2573,15 +2563,13 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef
*def)
         def->clock.ntimers != 0) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing clock parameters is not supported "
-                         "by vz driver"));
+                       _("changing clock parameters is not supported by vz
driver"));
         return -1;
     }
 
     if (!IS_CT(def) && def->nfss != 0) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Filesystems in VMs are not supported "
-                         "by vz driver"));
+                       _("Filesystems in VMs are not supported by vz
driver"));
         return -1;
     }
 
@@ -2591,8 +2579,7 @@ prlsdkCheckUnsupportedParams(PRL_HANDLE sdkdom, virDomainDef *def)
         def->nleases != 0 || def->nhubs != 0) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("changing devices parameters is not supported "
-                         "by vz driver"));
+                       _("changing devices parameters is not supported by vz
driver"));
         return -1;
     }
 
@@ -2716,15 +2703,13 @@ static int prlsdkCheckVideoUnsupportedParams(virDomainDef *def)
             return 0;
         } else {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("Video adapters are not supported "
-                             "int containers."));
+                           _("Video adapters are not supported int
containers."));
             return -1;
         }
     } else {
         if (def->nvideos != 1) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("vz driver supports "
-                             "only one video adapter."));
+                           _("vz driver supports only one video adapter."));
             return -1;
         }
     }
@@ -2733,22 +2718,19 @@ static int prlsdkCheckVideoUnsupportedParams(virDomainDef *def)
 
     if (v->type != VIR_DOMAIN_VIDEO_TYPE_VGA) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver supports "
-                         "only VGA video adapters."));
+                       _("vz driver supports only VGA video adapters."));
         return -1;
     }
 
     if (v->heads != 1) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "multihead video adapters."));
+                       _("vz driver doesn't support multihead video
adapters."));
         return -1;
     }
 
     if (v->accel != NULL && (v->accel->accel2d ||
v->accel->accel3d)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "setting video acceleration parameters."));
+                       _("vz driver doesn't support setting video acceleration
parameters."));
         return -1;
     }
 
@@ -2759,15 +2741,13 @@ static int prlsdkCheckSerialUnsupportedParams(virDomainChrDef
*chr)
 {
     if (chr->deviceType != VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Specified character device type is not supported "
-                         "by vz driver."));
+                       _("Specified character device type is not supported by vz
driver."));
         return -1;
     }
 
     if (chr->targetType != VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_NONE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Specified character device target type is not "
-                         "supported by vz driver."));
+                       _("Specified character device target type is not supported by
vz driver."));
         return -1;
     }
 
@@ -2779,22 +2759,19 @@ static int prlsdkCheckSerialUnsupportedParams(virDomainChrDef
*chr)
 
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Specified character device source type is not "
-                         "supported by vz driver."));
+                       _("Specified character device source type is not supported by
vz driver."));
         return -1;
     }
 
     if (chr->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting device info for character devices is not "
-                         "supported by vz driver."));
+                       _("Setting device info for character devices is not supported
by vz driver."));
         return -1;
     }
 
     if (chr->source->nseclabels > 0) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting security labels is not "
-                         "supported by vz driver."));
+                       _("Setting security labels is not supported by vz
driver."));
         return -1;
     }
 
@@ -2812,8 +2789,7 @@ static int prlsdkCheckSerialUnsupportedParams(virDomainChrDef *chr)
          STRNEQ(chr->source->data.udp.bindService,
                 chr->source->data.udp.connectService))) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Different bind and connect parameters for "
-                         "udp character device is not supported."));
+                       _("Different bind and connect parameters for udp character
device is not supported."));
         return -1;
     }
 
@@ -2825,71 +2801,61 @@ static int prlsdkCheckNetUnsupportedParams(virDomainNetDef *net)
     if (net->type != VIR_DOMAIN_NET_TYPE_NETWORK &&
         net->type != VIR_DOMAIN_NET_TYPE_BRIDGE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Specified network adapter type is not "
-                         "supported by vz driver."));
+                       _("Specified network adapter type is not supported by vz
driver."));
         return -1;
     }
 
     if (net->backend.tap || net->backend.vhost) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Interface backend parameters are not "
-                         "supported by vz driver."));
+                       _("Interface backend parameters are not supported by vz
driver."));
         return -1;
     }
 
     if (net->data.network.portgroup) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Virtual network portgroups are not "
-                         "supported by vz driver."));
+                       _("Virtual network portgroups are not supported by vz
driver."));
         return -1;
     }
 
     if (net->tune.sndbuf_specified) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting interface sndbuf is not "
-                         "supported by vz driver."));
+                       _("Setting interface sndbuf is not supported by vz
driver."));
         return -1;
     }
 
     if (net->script) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting interface script is not "
-                         "supported by vz driver."));
+                       _("Setting interface script is not supported by vz
driver."));
         return -1;
     }
 
     if (net->ifname_guest) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting guest interface name is not "
-                         "supported by vz driver."));
+                       _("Setting guest interface name is not supported by vz
driver."));
         return -1;
     }
 
     if (net->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting device info for network devices is not "
-                         "supported by vz driver."));
+                       _("Setting device info for network devices is not supported
by vz driver."));
         return -1;
     }
 
     if (net->filter) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting network filter is not "
-                         "supported by vz driver."));
+                       _("Setting network filter is not supported by vz
driver."));
         return -1;
     }
 
     if (net->bandwidth) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting network bandwidth is not "
-                         "supported by vz driver."));
+                       _("Setting network bandwidth is not supported by vz
driver."));
         return -1;
     }
 
     if (net->vlan.trunk) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting up vlans is not "
-                         "supported by vz driver."));
+                       _("Setting up vlans is not supported by vz driver."));
         return -1;
     }
 
@@ -2901,50 +2867,43 @@ static int prlsdkCheckFSUnsupportedParams(virDomainFSDef *fs)
     if (fs->type != VIR_DOMAIN_FS_TYPE_FILE &&
         fs->type != VIR_DOMAIN_FS_TYPE_VOLUME) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only file based or volume based filesystems "
-                         "are supported by vz driver."));
+                       _("Only file based or volume based filesystems are supported
by vz driver."));
         return -1;
     }
 
     if (fs->fsdriver != VIR_DOMAIN_FS_DRIVER_TYPE_PLOOP) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only ploop fs driver is "
-                         "supported by vz driver."));
+                       _("Only ploop fs driver is supported by vz driver."));
         return -1;
     }
 
     if (fs->accessmode != VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Changing fs access mode is not "
-                         "supported by vz driver."));
+                       _("Changing fs access mode is not supported by vz
driver."));
         return -1;
     }
 
     if (fs->wrpolicy != VIR_DOMAIN_FS_WRPOLICY_DEFAULT) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Changing fs write policy is not "
-                         "supported by vz driver."));
+                       _("Changing fs write policy is not supported by vz
driver."));
         return -1;
     }
 
     if (fs->format != VIR_STORAGE_FILE_PLOOP) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only ploop disk images are "
-                         "supported by vz driver."));
+                       _("Only ploop disk images are supported by vz
driver."));
         return -1;
     }
 
     if (fs->readonly) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting readonly for filesystems is "
-                         "not supported by vz driver."));
+                       _("Setting readonly for filesystems is not supported by vz
driver."));
         return -1;
     }
 
     if (fs->space_hard_limit || fs->space_soft_limit) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting fs quotas is not "
-                         "supported by vz driver."));
+                       _("Setting fs quotas is not supported by vz driver."));
         return -1;
     }
 
@@ -3053,8 +3012,7 @@ static int prlsdkAddSerial(PRL_HANDLE sdkdom, virDomainChrDef *chr)
         break;
     default:
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "specified serial source type."));
+                       _("vz driver doesn't support specified serial source
type."));
         goto cleanup;
     }
 
@@ -3280,8 +3238,7 @@ static int prlsdkConfigureNet(struct _vzDriver *driver
G_GNUC_UNUSED,
             pret = PrlVmDevNet_SetAdapterType(sdknet, PNT_VIRTIO);
         } else {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("Specified network adapter model is not "
-                             "supported by vz driver."));
+                           _("Specified network adapter model is not supported by vz
driver."));
             goto cleanup;
         }
         prlsdkCheckRetGoto(pret, cleanup);
@@ -3434,8 +3391,7 @@ static int prlsdkConfigureDisk(struct _vzDriver *driver,
     case VIR_DOMAIN_DISK_BUS_LAST:
     default:
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Specified disk bus is not "
-                         "supported by vz driver."));
+                       _("Specified disk bus is not supported by vz
driver."));
         goto cleanup;
     }
 
@@ -4276,8 +4232,7 @@ prlsdkUnregisterDomain(struct _vzDriver *driver, virDomainObj *dom,
unsigned int
         !(flags & VIR_DOMAIN_UNDEFINE_MANAGED_SAVE)) {
 
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("Refusing to undefine while domain managed "
-                         "save image exists"));
+                       _("Refusing to undefine while domain managed save image
exists"));
         return -1;
     }
 
diff --git a/src/vz/vz_utils.c b/src/vz/vz_utils.c
index 7db7dbd419..be1879a58b 100644
--- a/src/vz/vz_utils.c
+++ b/src/vz/vz_utils.c
@@ -273,16 +273,14 @@ vzCheckDiskUnsupportedParams(virDomainDiskDef *disk)
         disk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only hard disks and cdroms are supported "
-                         "by vz driver."));
+                       _("Only hard disks and cdroms are supported by vz
driver."));
         return -1;
     }
 
     if (disk->blockio.logical_block_size ||
         disk->blockio.physical_block_size) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk block sizes is not "
-                         "supported by vz driver."));
+                       _("Setting disk block sizes is not supported by vz
driver."));
         return -1;
     }
 
@@ -294,56 +292,48 @@ vzCheckDiskUnsupportedParams(virDomainDiskDef *disk)
         disk->blkdeviotune.write_iops_sec) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk io limits is not "
-                         "supported by vz driver yet."));
+                       _("Setting disk io limits is not supported by vz driver
yet."));
         return -1;
     }
 
     if (disk->serial && disk->device != VIR_DOMAIN_DISK_DEVICE_DISK) {
-        VIR_INFO("%s", _("Setting disk serial number is "
-                         "supported only for disk devices."));
+        VIR_INFO("%s", _("Setting disk serial number is supported only for
disk devices."));
     }
 
     if (disk->wwn) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk wwn id is not "
-                         "supported by vz driver."));
+                       _("Setting disk wwn id is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->vendor) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk vendor is not "
-                         "supported by vz driver."));
+                       _("Setting disk vendor is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->product) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk product id is not "
-                         "supported by vz driver."));
+                       _("Setting disk product id is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->error_policy != VIR_DOMAIN_DISK_ERROR_POLICY_DEFAULT) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting disk error policy is not "
-                         "supported by vz driver."));
+                       _("Setting disk error policy is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->iomode != VIR_DOMAIN_DISK_IO_DEFAULT &&
         disk->iomode != VIR_DOMAIN_DISK_IO_NATIVE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only native iomode is "
-                         "supported by vz driver."));
+                       _("Only native iomode is supported by vz driver."));
         return -1;
     }
 
     if (disk->copy_on_read) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Disk copy_on_read is not "
-                         "supported by vz driver."));
+                       _("Disk copy_on_read is not supported by vz driver."));
         return -1;
     }
 
@@ -355,29 +345,25 @@ vzCheckDiskUnsupportedParams(virDomainDiskDef *disk)
 
     if (disk->startupPolicy != VIR_DOMAIN_STARTUP_POLICY_DEFAULT) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting up disk startup policy is not "
-                         "supported by vz driver."));
+                       _("Setting up disk startup policy is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->transient) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Transient disks are not "
-                         "supported by vz driver."));
+                       _("Transient disks are not supported by vz driver."));
         return -1;
     }
 
     if (disk->discard) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting up disk discard parameter is not "
-                         "supported by vz driver."));
+                       _("Setting up disk discard parameter is not supported by vz
driver."));
         return -1;
     }
 
     if (disk->iothread) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Setting up disk io thread # is not "
-                         "supported by vz driver."));
+                       _("Setting up disk io thread # is not supported by vz
driver."));
         return -1;
     }
 
@@ -385,8 +371,7 @@ vzCheckDiskUnsupportedParams(virDomainDiskDef *disk)
         disk->src->type != VIR_STORAGE_TYPE_BLOCK) {
 
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only disk and block storage types are "
-                         "supported by vz driver."));
+                       _("Only disk and block storage types are supported by vz
driver."));
         return -1;
 
     }
@@ -503,52 +488,45 @@ int vzCheckUnsupportedGraphics(virDomainGraphicsDef *gr)
 {
     if (gr->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver supports only "
-                         "VNC graphics."));
+                       _("vz driver supports only VNC graphics."));
         return -1;
     }
 
     if (gr->data.vnc.websocket != 0) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "websockets for VNC graphics."));
+                       _("vz driver doesn't support websockets for VNC
graphics."));
         return -1;
     }
 
     if (gr->data.vnc.keymap != 0 &&
         STRNEQ(gr->data.vnc.keymap, "en-us")) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver supports only "
-                         "\"en-us\" keymap for VNC graphics."));
+                       _("vz driver supports only \"en-us\" keymap for VNC
graphics."));
         return -1;
     }
 
     if (gr->data.vnc.sharePolicy == VIR_DOMAIN_GRAPHICS_VNC_SHARE_ALLOW_EXCLUSIVE) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "exclusive share policy for VNC graphics."));
+                       _("vz driver doesn't support exclusive share policy for
VNC graphics."));
         return -1;
     }
 
     if (gr->data.vnc.auth.connected == VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_FAIL ||
         gr->data.vnc.auth.connected == VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_KEEP) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "given action in case of password change."));
+                       _("vz driver doesn't support given action in case of
password change."));
         return -1;
     }
 
     if (gr->data.vnc.auth.expires) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vz driver doesn't support "
-                         "setting password expire time."));
+                       _("vz driver doesn't support setting password expire
time."));
         return -1;
     }
 
     if (gr->nListens > 1) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("vz driver doesn't support more than "
-                         "one listening VNC server per domain"));
+                       _("vz driver doesn't support more than one listening VNC
server per domain"));
         return -1;
     }
 
-- 
2.41.0


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[PATCH 25/27] vz: Move error messages onto a single line