mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-29 20:11:16 +00:00
Use ATTRIBUTE_FALLTHROUGH, introduced by commit
5d84f5961b
, instead of comments to
indicate that the fall through is an intentional behavior.
Signed-off-by: Marc Hartmayer <mhartmay@linux.vnet.ibm.com>
Reviewed-by: Boris Fiuczynski <fiuczy@linux.vnet.ibm.com>
Reviewed-by: Bjoern Walk <bwalk@linux.vnet.ibm.com>
1571 lines
43 KiB
C
1571 lines
43 KiB
C
/*
|
|
* virt-admin.c: a shell to exercise the libvirt admin API
|
|
*
|
|
* Copyright (C) 2015 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
* Authors:
|
|
* Erik Skultety <eskultet@redhat.com>
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include "virt-admin.h"
|
|
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
|
|
#if WITH_READLINE
|
|
# include <readline/readline.h>
|
|
# include <readline/history.h>
|
|
#endif
|
|
|
|
#include "internal.h"
|
|
#include "viralloc.h"
|
|
#include "virerror.h"
|
|
#include "virfile.h"
|
|
#include "virstring.h"
|
|
#include "virthread.h"
|
|
#include "virgettext.h"
|
|
#include "virtime.h"
|
|
|
|
/* Gnulib doesn't guarantee SA_SIGINFO support. */
|
|
#ifndef SA_SIGINFO
|
|
# define SA_SIGINFO 0
|
|
#endif
|
|
|
|
#define VIRT_ADMIN_PROMPT "virt-admin # "
|
|
|
|
/* we don't need precision to milliseconds in this module */
|
|
#define VIRT_ADMIN_TIME_BUFLEN VIR_TIME_STRING_BUFLEN - 3
|
|
|
|
static char *progname;
|
|
|
|
static const vshCmdGrp cmdGroups[];
|
|
static const vshClientHooks hooks;
|
|
|
|
VIR_ENUM_DECL(virClientTransport)
|
|
VIR_ENUM_IMPL(virClientTransport,
|
|
VIR_CLIENT_TRANS_LAST,
|
|
N_("unix"),
|
|
N_("tcp"),
|
|
N_("tls"))
|
|
|
|
static const char *
|
|
vshAdmClientTransportToString(int transport)
|
|
{
|
|
const char *str = virClientTransportTypeToString(transport);
|
|
return str ? _(str) : _("unknown");
|
|
}
|
|
|
|
/*
|
|
* vshAdmGetTimeStr:
|
|
*
|
|
* Produces string representation (local time) of @then
|
|
* (seconds since epoch UTC) using format 'YYYY-MM-DD HH:MM:SS+ZZZZ'.
|
|
*
|
|
* Returns 0 if conversion finished successfully, -1 in case of an error.
|
|
* Caller is responsible for freeing the string returned.
|
|
*/
|
|
static int
|
|
vshAdmGetTimeStr(vshControl *ctl, time_t then, char **result)
|
|
{
|
|
|
|
char *tmp = NULL;
|
|
struct tm timeinfo;
|
|
|
|
if (!localtime_r(&then, &timeinfo))
|
|
goto error;
|
|
|
|
if (VIR_ALLOC_N(tmp, VIRT_ADMIN_TIME_BUFLEN) < 0)
|
|
goto error;
|
|
|
|
if (strftime(tmp, VIRT_ADMIN_TIME_BUFLEN, "%Y-%m-%d %H:%M:%S%z",
|
|
&timeinfo) == 0) {
|
|
VIR_FREE(tmp);
|
|
goto error;
|
|
}
|
|
|
|
*result = tmp;
|
|
return 0;
|
|
|
|
error:
|
|
vshError(ctl, "%s", _("Timestamp string conversion failed"));
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* vshAdmCatchDisconnect:
|
|
*
|
|
* We get here when the connection was closed. Unlike virsh, we do not save
|
|
* the fact that the event was raised, since there is virAdmConnectIsAlive to
|
|
* check if the communication channel has not been closed by remote party.
|
|
*/
|
|
static void
|
|
vshAdmCatchDisconnect(virAdmConnectPtr conn ATTRIBUTE_UNUSED,
|
|
int reason,
|
|
void *opaque)
|
|
{
|
|
vshControl *ctl = opaque;
|
|
const char *str = "unknown reason";
|
|
virErrorPtr error;
|
|
char *uri = NULL;
|
|
|
|
if (reason == VIR_CONNECT_CLOSE_REASON_CLIENT)
|
|
return;
|
|
|
|
error = virSaveLastError();
|
|
uri = virAdmConnectGetURI(conn);
|
|
|
|
switch ((virConnectCloseReason) reason) {
|
|
case VIR_CONNECT_CLOSE_REASON_ERROR:
|
|
str = N_("Disconnected from %s due to I/O error");
|
|
break;
|
|
case VIR_CONNECT_CLOSE_REASON_EOF:
|
|
str = N_("Disconnected from %s due to end of file");
|
|
break;
|
|
case VIR_CONNECT_CLOSE_REASON_KEEPALIVE:
|
|
str = N_("Disconnected from %s due to keepalive timeout");
|
|
break;
|
|
/* coverity[dead_error_condition] */
|
|
case VIR_CONNECT_CLOSE_REASON_CLIENT:
|
|
case VIR_CONNECT_CLOSE_REASON_LAST:
|
|
break;
|
|
}
|
|
|
|
vshError(ctl, _(str), NULLSTR(uri));
|
|
VIR_FREE(uri);
|
|
|
|
if (error) {
|
|
virSetError(error);
|
|
virFreeError(error);
|
|
}
|
|
}
|
|
|
|
static int
|
|
vshAdmConnect(vshControl *ctl, unsigned int flags)
|
|
{
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
priv->conn = virAdmConnectOpen(ctl->connname, flags);
|
|
|
|
if (!priv->conn) {
|
|
if (priv->wantReconnect)
|
|
vshError(ctl, "%s", _("Failed to reconnect to the admin server"));
|
|
else
|
|
vshError(ctl, "%s", _("Failed to connect to the admin server"));
|
|
return -1;
|
|
} else {
|
|
if (virAdmConnectRegisterCloseCallback(priv->conn, vshAdmCatchDisconnect,
|
|
NULL, NULL) < 0)
|
|
vshError(ctl, "%s", _("Unable to register disconnect callback"));
|
|
|
|
if (priv->wantReconnect)
|
|
vshPrint(ctl, "%s\n", _("Reconnected to the admin server"));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
vshAdmDisconnect(vshControl *ctl)
|
|
{
|
|
int ret = 0;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (!priv->conn)
|
|
return ret;
|
|
|
|
virAdmConnectUnregisterCloseCallback(priv->conn, vshAdmCatchDisconnect);
|
|
ret = virAdmConnectClose(priv->conn);
|
|
if (ret < 0)
|
|
vshError(ctl, "%s", _("Failed to disconnect from the admin server"));
|
|
else if (ret > 0)
|
|
vshError(ctl, "%s", _("One or more references were leaked after "
|
|
"disconnect from the hypervisor"));
|
|
priv->conn = NULL;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* vshAdmReconnect:
|
|
*
|
|
* Reconnect to a daemon's admin server
|
|
*
|
|
*/
|
|
static void
|
|
vshAdmReconnect(vshControl *ctl)
|
|
{
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
if (priv->conn)
|
|
priv->wantReconnect = true;
|
|
|
|
vshAdmDisconnect(ctl);
|
|
vshAdmConnect(ctl, 0);
|
|
|
|
priv->wantReconnect = false;
|
|
}
|
|
|
|
/*
|
|
* 'uri' command
|
|
*/
|
|
|
|
static const vshCmdInfo info_uri[] = {
|
|
{.name = "help",
|
|
.data = N_("print the admin server URI")
|
|
},
|
|
{.name = "desc",
|
|
.data = ""
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdURI(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
|
|
{
|
|
char *uri;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
uri = virAdmConnectGetURI(priv->conn);
|
|
if (!uri) {
|
|
vshError(ctl, "%s", _("failed to get URI"));
|
|
return false;
|
|
}
|
|
|
|
vshPrint(ctl, "%s\n", uri);
|
|
VIR_FREE(uri);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "version" command
|
|
*/
|
|
|
|
static const vshCmdInfo info_version[] = {
|
|
{.name = "help",
|
|
.data = N_("show version")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Display the system and also the daemon version information.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdVersion(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
|
|
{
|
|
unsigned long libVersion;
|
|
unsigned long long includeVersion;
|
|
unsigned long long daemonVersion;
|
|
int ret;
|
|
unsigned int major;
|
|
unsigned int minor;
|
|
unsigned int rel;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
includeVersion = LIBVIR_VERSION_NUMBER;
|
|
major = includeVersion / 1000000;
|
|
includeVersion %= 1000000;
|
|
minor = includeVersion / 1000;
|
|
rel = includeVersion % 1000;
|
|
vshPrint(ctl, _("Compiled against library: libvirt %d.%d.%d\n"),
|
|
major, minor, rel);
|
|
|
|
ret = virGetVersion(&libVersion, NULL, NULL);
|
|
if (ret < 0) {
|
|
vshError(ctl, "%s", _("failed to get the library version"));
|
|
return false;
|
|
}
|
|
major = libVersion / 1000000;
|
|
libVersion %= 1000000;
|
|
minor = libVersion / 1000;
|
|
rel = libVersion % 1000;
|
|
vshPrint(ctl, _("Using library: libvirt %d.%d.%d\n"),
|
|
major, minor, rel);
|
|
|
|
ret = virAdmConnectGetLibVersion(priv->conn, &daemonVersion);
|
|
if (ret < 0) {
|
|
vshError(ctl, "%s", _("failed to get the daemon version"));
|
|
} else {
|
|
major = daemonVersion / 1000000;
|
|
daemonVersion %= 1000000;
|
|
minor = daemonVersion / 1000;
|
|
rel = daemonVersion % 1000;
|
|
vshPrint(ctl, _("Running against daemon: %d.%d.%d\n"),
|
|
major, minor, rel);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/* ---------------
|
|
* Command Connect
|
|
* ---------------
|
|
*/
|
|
|
|
static const vshCmdOptDef opts_connect[] = {
|
|
{.name = "name",
|
|
.type = VSH_OT_STRING,
|
|
.flags = VSH_OFLAG_EMPTY_OK,
|
|
.help = N_("daemon's admin server connection URI")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdInfo info_connect[] = {
|
|
{.name = "help",
|
|
.data = N_("connect to daemon's admin server")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Connect to a daemon's administrating server.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdConnect(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
const char *name = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
bool connected = priv->conn;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0)
|
|
return false;
|
|
|
|
if (name) {
|
|
VIR_FREE(ctl->connname);
|
|
ctl->connname = vshStrdup(ctl, name);
|
|
}
|
|
|
|
vshAdmReconnect(ctl);
|
|
if (!connected && priv->conn)
|
|
vshPrint(ctl, "%s\n", _("Connected to the admin server"));
|
|
|
|
return !!priv->conn;
|
|
}
|
|
|
|
|
|
/* ---------------
|
|
* Command srv-list
|
|
* ---------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_list[] = {
|
|
{.name = "help",
|
|
.data = N_("list available servers on a daemon")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("List all manageable servers on a daemon.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
|
|
{
|
|
int nsrvs = 0;
|
|
size_t i;
|
|
bool ret = false;
|
|
char *uri = NULL;
|
|
virAdmServerPtr *srvs = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
/* Obtain a list of available servers on the daemon */
|
|
if ((nsrvs = virAdmConnectListServers(priv->conn, &srvs, 0)) < 0) {
|
|
uri = virAdmConnectGetURI(priv->conn);
|
|
vshError(ctl, _("failed to obtain list of available servers from %s"),
|
|
NULLSTR(uri));
|
|
goto cleanup;
|
|
}
|
|
|
|
vshPrintExtra(ctl, " %-5s %-15s\n", "Id", "Name");
|
|
vshPrintExtra(ctl, "---------------\n");
|
|
for (i = 0; i < nsrvs; i++)
|
|
vshPrint(ctl, " %-5zu %-15s\n", i, virAdmServerGetName(srvs[i]));
|
|
|
|
ret = true;
|
|
cleanup:
|
|
if (srvs) {
|
|
for (i = 0; i < nsrvs; i++)
|
|
virAdmServerFree(srvs[i]);
|
|
VIR_FREE(srvs);
|
|
}
|
|
VIR_FREE(uri);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ---------------------------
|
|
* Command srv-threadpool-info
|
|
* ---------------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_threadpool_info[] = {
|
|
{.name = "help",
|
|
.data = N_("get server workerpool parameters")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Retrieve threadpool attributes from a server. ")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_srv_threadpool_info[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("Server to retrieve threadpool attributes from."),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvThreadpoolInfo(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
size_t i;
|
|
const char *srvname = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
if (virAdmServerGetThreadPoolParameters(srv, ¶ms,
|
|
&nparams, 0) < 0) {
|
|
vshError(ctl, "%s",
|
|
_("Unable to get server workerpool parameters"));
|
|
goto cleanup;
|
|
}
|
|
|
|
for (i = 0; i < nparams; i++)
|
|
vshPrint(ctl, "%-15s: %u\n", params[i].field, params[i].value.ui);
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virTypedParamsFree(params, nparams);
|
|
if (srv)
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
}
|
|
|
|
/* --------------------------
|
|
* Command srv-threadpool-set
|
|
* --------------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_threadpool_set[] = {
|
|
{.name = "help",
|
|
.data = N_("set server workerpool parameters")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Tune threadpool attributes on a server. See OPTIONS for "
|
|
"currently supported attributes.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_srv_threadpool_set[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("Server to alter threadpool attributes on."),
|
|
},
|
|
{.name = "min-workers",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("Change bottom limit to number of workers."),
|
|
},
|
|
{.name = "max-workers",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("Change upper limit to number of workers."),
|
|
},
|
|
{.name = "priority-workers",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("Change the current number of priority workers"),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvThreadpoolSet(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
int rv = 0;
|
|
unsigned int val, min, max;
|
|
int maxparams = 0;
|
|
int nparams = 0;
|
|
const char *srvname = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
#define PARSE_CMD_TYPED_PARAM(NAME, FIELD) \
|
|
if ((rv = vshCommandOptUInt(ctl, cmd, NAME, &val)) < 0) { \
|
|
vshError(ctl, _("Unable to parse integer parameter '%s'"), NAME); \
|
|
goto cleanup; \
|
|
} else if (rv > 0) { \
|
|
if (virTypedParamsAddUInt(¶ms, &nparams, &maxparams, \
|
|
FIELD, val) < 0) \
|
|
goto save_error; \
|
|
}
|
|
|
|
PARSE_CMD_TYPED_PARAM("max-workers", VIR_THREADPOOL_WORKERS_MAX);
|
|
PARSE_CMD_TYPED_PARAM("min-workers", VIR_THREADPOOL_WORKERS_MIN);
|
|
PARSE_CMD_TYPED_PARAM("priority-workers", VIR_THREADPOOL_WORKERS_PRIORITY);
|
|
|
|
#undef PARSE_CMD_TYPED_PARAM
|
|
|
|
if (!nparams) {
|
|
vshError(ctl, "%s",
|
|
_("At least one of options --min-workers, --max-workers, "
|
|
"--priority-workers is mandatory "));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virTypedParamsGetUInt(params, nparams,
|
|
VIR_THREADPOOL_WORKERS_MAX, &max) &&
|
|
virTypedParamsGetUInt(params, nparams,
|
|
VIR_THREADPOOL_WORKERS_MIN, &min) && min > max) {
|
|
vshError(ctl, "%s", _("--min-workers must be less than --max-workers"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
if (virAdmServerSetThreadPoolParameters(srv, params,
|
|
nparams, 0) < 0)
|
|
goto error;
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virTypedParamsFree(params, nparams);
|
|
if (srv)
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
|
|
save_error:
|
|
vshSaveLibvirtError();
|
|
|
|
error:
|
|
vshError(ctl, "%s", _("Unable to change server workerpool parameters"));
|
|
goto cleanup;
|
|
}
|
|
|
|
/* ------------------------
|
|
* Command srv-clients-list
|
|
* ------------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_clients_list[] = {
|
|
{.name = "help",
|
|
.data = N_("list clients connected to <server>")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("List all manageable clients connected to <server>.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_srv_clients_list[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("server which to list connected clients from"),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvClientsList(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
int nclts = 0;
|
|
size_t i;
|
|
bool ret = false;
|
|
const char *srvname = NULL;
|
|
unsigned long long id;
|
|
virClientTransport transport;
|
|
char *timestr = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
virAdmClientPtr *clts = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
/* Obtain a list of clients connected to server @srv */
|
|
if ((nclts = virAdmServerListClients(srv, &clts, 0)) < 0) {
|
|
vshError(ctl, _("failed to obtain list of connected clients "
|
|
"from server '%s'"), virAdmServerGetName(srv));
|
|
goto cleanup;
|
|
}
|
|
|
|
vshPrintExtra(ctl, " %-5s %-15s %-15s\n%s\n", _("Id"), _("Transport"),
|
|
_("Connected since"),
|
|
"-------------------------"
|
|
"-------------------------");
|
|
|
|
for (i = 0; i < nclts; i++) {
|
|
virAdmClientPtr client = clts[i];
|
|
id = virAdmClientGetID(client);
|
|
transport = virAdmClientGetTransport(client);
|
|
if (vshAdmGetTimeStr(ctl, virAdmClientGetTimestamp(client),
|
|
×tr) < 0)
|
|
goto cleanup;
|
|
|
|
vshPrint(ctl, " %-5llu %-15s %-15s\n",
|
|
id, vshAdmClientTransportToString(transport), timestr);
|
|
VIR_FREE(timestr);
|
|
}
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
if (clts) {
|
|
for (i = 0; i < nclts; i++)
|
|
virAdmClientFree(clts[i]);
|
|
VIR_FREE(clts);
|
|
}
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
}
|
|
|
|
/* -------------------
|
|
* Command client-info
|
|
* -------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_client_info[] = {
|
|
{.name = "help",
|
|
.data = N_("retrieve client's identity info from server")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Retrieve identity details about <client> from <server>")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_client_info[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("server to which <client> is connected to"),
|
|
},
|
|
{.name = "client",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("client which to retrieve identity information for"),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdClientInfo(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
size_t i;
|
|
unsigned long long id;
|
|
const char *srvname = NULL;
|
|
char *timestr = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
virAdmClientPtr clnt = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptULongLong(ctl, cmd, "client", &id) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)) ||
|
|
!(clnt = virAdmServerLookupClient(srv, id, 0)))
|
|
goto cleanup;
|
|
|
|
/* Retrieve client identity info */
|
|
if (virAdmClientGetInfo(clnt, ¶ms, &nparams, 0) < 0) {
|
|
vshError(ctl, _("failed to retrieve client identity information for "
|
|
"client '%llu' connected to server '%s'"),
|
|
id, virAdmServerGetName(srv));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (vshAdmGetTimeStr(ctl, virAdmClientGetTimestamp(clnt), ×tr) < 0)
|
|
goto cleanup;
|
|
|
|
/* this info is provided by the client object itself */
|
|
vshPrint(ctl, "%-15s: %llu\n", "id", virAdmClientGetID(clnt));
|
|
vshPrint(ctl, "%-15s: %s\n", "connection_time", timestr);
|
|
vshPrint(ctl, "%-15s: %s\n", "transport",
|
|
vshAdmClientTransportToString(virAdmClientGetTransport(clnt)));
|
|
|
|
for (i = 0; i < nparams; i++) {
|
|
char *str = vshGetTypedParamValue(ctl, ¶ms[i]);
|
|
vshPrint(ctl, "%-15s: %s\n", params[i].field, str);
|
|
VIR_FREE(str);
|
|
}
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virTypedParamsFree(params, nparams);
|
|
virAdmServerFree(srv);
|
|
virAdmClientFree(clnt);
|
|
VIR_FREE(timestr);
|
|
return ret;
|
|
}
|
|
|
|
/* -------------------------
|
|
* Command client-disconnect
|
|
* -------------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_client_disconnect[] = {
|
|
{.name = "help",
|
|
.data = N_("force disconnect a client from the given server")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Force close a specific client's connection to the given "
|
|
"server.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_client_disconnect[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("server which the client is currently connected to"),
|
|
},
|
|
{.name = "client",
|
|
.type = VSH_OT_INT,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("client which to disconnect, specified by ID"),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdClientDisconnect(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
const char *srvname = NULL;
|
|
unsigned long long id = 0;
|
|
virAdmServerPtr srv = NULL;
|
|
virAdmClientPtr client = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptULongLongWrap(ctl, cmd, "client", &id) < 0)
|
|
return false;
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
if (!(client = virAdmServerLookupClient(srv, id, 0)))
|
|
goto cleanup;
|
|
|
|
if (virAdmClientClose(client, 0) < 0) {
|
|
vshError(ctl, _("Failed to disconnect client '%llu' from server %s"),
|
|
id, virAdmServerGetName(srv));
|
|
goto cleanup;
|
|
}
|
|
|
|
vshPrint(ctl, _("Client '%llu' disconnected"), id);
|
|
ret = true;
|
|
cleanup:
|
|
virAdmClientFree(client);
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
}
|
|
|
|
/* ------------------------
|
|
* Command srv-clients-info
|
|
* ------------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_clients_info[] = {
|
|
{.name = "help",
|
|
.data = N_("get server's client-related configuration limits")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Retrieve server's client-related configuration limits ")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_srv_clients_info[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("Server to retrieve the client limits from."),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvClientsInfo(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
virTypedParameterPtr params = NULL;
|
|
int nparams = 0;
|
|
size_t i;
|
|
const char *srvname = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
if (virAdmServerGetClientLimits(srv, ¶ms, &nparams, 0) < 0) {
|
|
vshError(ctl, "%s", _("Unable to retrieve client limits "
|
|
"from server's configuration"));
|
|
goto cleanup;
|
|
}
|
|
|
|
for (i = 0; i < nparams; i++)
|
|
vshPrint(ctl, "%-20s: %u\n", params[i].field, params[i].value.ui);
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virTypedParamsFree(params, nparams);
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
}
|
|
|
|
/* -----------------------
|
|
* Command srv-clients-set
|
|
* -----------------------
|
|
*/
|
|
|
|
static const vshCmdInfo info_srv_clients_set[] = {
|
|
{.name = "help",
|
|
.data = N_("set server's client-related configuration limits")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Tune server's client-related configuration limits. "
|
|
"See OPTIONS for currently supported attributes.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_srv_clients_set[] = {
|
|
{.name = "server",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.help = N_("Server to alter the client-related configuration limits on."),
|
|
},
|
|
{.name = "max-clients",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("Change the upper limit to overall number of clients "
|
|
"connected to the server."),
|
|
},
|
|
{.name = "max-unauth-clients",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("Change the upper limit to number of clients waiting for "
|
|
"authentication to be connected to the server"),
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdSrvClientsSet(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool ret = false;
|
|
int rv = 0;
|
|
unsigned int val, max, unauth_max;
|
|
int maxparams = 0;
|
|
int nparams = 0;
|
|
const char *srvname = NULL;
|
|
virAdmServerPtr srv = NULL;
|
|
virTypedParameterPtr params = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "server", &srvname) < 0)
|
|
return false;
|
|
|
|
#define PARSE_CMD_TYPED_PARAM(NAME, FIELD) \
|
|
if ((rv = vshCommandOptUInt(ctl, cmd, NAME, &val)) < 0) { \
|
|
vshError(ctl, _("Unable to parse integer parameter '%s'"), NAME); \
|
|
goto cleanup; \
|
|
} else if (rv > 0) { \
|
|
if (virTypedParamsAddUInt(¶ms, &nparams, &maxparams, \
|
|
FIELD, val) < 0) \
|
|
goto save_error; \
|
|
}
|
|
|
|
PARSE_CMD_TYPED_PARAM("max-clients", VIR_SERVER_CLIENTS_MAX);
|
|
PARSE_CMD_TYPED_PARAM("max-unauth-clients", VIR_SERVER_CLIENTS_UNAUTH_MAX);
|
|
|
|
#undef PARSE_CMD_TYPED_PARAM
|
|
|
|
if (!nparams) {
|
|
vshError(ctl, "%s", _("At least one of options --max-clients, "
|
|
"--max-unauth-clients is mandatory"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virTypedParamsGetUInt(params, nparams,
|
|
VIR_SERVER_CLIENTS_MAX, &max) &&
|
|
virTypedParamsGetUInt(params, nparams,
|
|
VIR_SERVER_CLIENTS_UNAUTH_MAX, &unauth_max) &&
|
|
unauth_max > max) {
|
|
vshError(ctl, "%s", _("--max-unauth-clients must be less than "
|
|
"--max-clients"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!(srv = virAdmConnectLookupServer(priv->conn, srvname, 0)))
|
|
goto cleanup;
|
|
|
|
if (virAdmServerSetClientLimits(srv, params, nparams, 0) < 0)
|
|
goto error;
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
virTypedParamsFree(params, nparams);
|
|
virAdmServerFree(srv);
|
|
return ret;
|
|
|
|
save_error:
|
|
vshSaveLibvirtError();
|
|
|
|
error:
|
|
vshError(ctl, "%s", _("Unable to change server's client-related "
|
|
"configuration limits"));
|
|
goto cleanup;
|
|
}
|
|
|
|
/* --------------------------
|
|
* Command daemon-log-filters
|
|
* --------------------------
|
|
*/
|
|
static const vshCmdInfo info_daemon_log_filters[] = {
|
|
{.name = "help",
|
|
.data = N_("fetch or set the currently defined set of logging filters on "
|
|
"daemon")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Depending on whether run with or without options, the command "
|
|
"fetches or redefines the existing active set of filters on "
|
|
"daemon.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_daemon_log_filters[] = {
|
|
{.name = "filters",
|
|
.type = VSH_OT_STRING,
|
|
.help = N_("redefine the existing set of logging filters"),
|
|
.flags = VSH_OFLAG_EMPTY_OK
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDaemonLogFilters(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
int nfilters;
|
|
char *filters = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptBool(cmd, "filters")) {
|
|
if ((vshCommandOptStringReq(ctl, cmd, "filters",
|
|
(const char **) &filters) < 0 ||
|
|
virAdmConnectSetLoggingFilters(priv->conn, filters, 0) < 0)) {
|
|
vshError(ctl, _("Unable to change daemon logging settings"));
|
|
return false;
|
|
}
|
|
} else {
|
|
if ((nfilters = virAdmConnectGetLoggingFilters(priv->conn,
|
|
&filters, 0)) < 0) {
|
|
vshError(ctl, _("Unable to get daemon logging filters information"));
|
|
return false;
|
|
}
|
|
|
|
vshPrintExtra(ctl, " %-15s", _("Logging filters: "));
|
|
vshPrint(ctl, "%s\n", filters ? filters : "");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* --------------------------
|
|
* Command daemon-log-outputs
|
|
* --------------------------
|
|
*/
|
|
static const vshCmdInfo info_daemon_log_outputs[] = {
|
|
{.name = "help",
|
|
.data = N_("fetch or set the currently defined set of logging outputs on "
|
|
"daemon")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Depending on whether run with or without options, the command "
|
|
"fetches or redefines the existing active set of outputs on "
|
|
"daemon.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_daemon_log_outputs[] = {
|
|
{.name = "outputs",
|
|
.type = VSH_OT_STRING,
|
|
.help = N_("redefine the existing set of logging outputs"),
|
|
.flags = VSH_OFLAG_EMPTY_OK
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDaemonLogOutputs(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
int noutputs;
|
|
char *outputs = NULL;
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (vshCommandOptBool(cmd, "outputs")) {
|
|
if ((vshCommandOptStringReq(ctl, cmd, "outputs",
|
|
(const char **) &outputs) < 0 ||
|
|
virAdmConnectSetLoggingOutputs(priv->conn, outputs, 0) < 0)) {
|
|
vshError(ctl, _("Unable to change daemon logging settings"));
|
|
return false;
|
|
}
|
|
} else {
|
|
if ((noutputs = virAdmConnectGetLoggingOutputs(priv->conn,
|
|
&outputs, 0)) < 0) {
|
|
vshError(ctl, _("Unable to get daemon logging outputs information"));
|
|
return false;
|
|
}
|
|
|
|
vshPrintExtra(ctl, " %-15s", _("Logging outputs: "));
|
|
vshPrint(ctl, "%s\n", outputs ? outputs : "");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void *
|
|
vshAdmConnectionHandler(vshControl *ctl)
|
|
{
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
if (!virAdmConnectIsAlive(priv->conn))
|
|
vshAdmReconnect(ctl);
|
|
|
|
if (!virAdmConnectIsAlive(priv->conn)) {
|
|
vshError(ctl, "%s", _("no valid connection"));
|
|
return NULL;
|
|
}
|
|
|
|
return priv->conn;
|
|
}
|
|
|
|
/*
|
|
* Initialize connection.
|
|
*/
|
|
static bool
|
|
vshAdmInit(vshControl *ctl)
|
|
{
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
/* Since we have the commandline arguments parsed, we need to
|
|
* reload our initial settings to make debugging and readline
|
|
* work properly */
|
|
vshInitReload(ctl);
|
|
|
|
if (priv->conn)
|
|
return false;
|
|
|
|
/* set up the library error handler */
|
|
virSetErrorFunc(NULL, vshErrorHandler);
|
|
|
|
if (virEventRegisterDefaultImpl() < 0)
|
|
return false;
|
|
|
|
if (virThreadCreate(&ctl->eventLoop, true, vshEventLoop, ctl) < 0)
|
|
return false;
|
|
ctl->eventLoopStarted = true;
|
|
|
|
if (ctl->connname) {
|
|
vshAdmReconnect(ctl);
|
|
/* Connecting to a named connection must succeed, but we delay
|
|
* connecting to the default connection until we need it
|
|
* (since the first command might be 'connect' which allows a
|
|
* non-default connection, or might be 'help' which needs no
|
|
* connection).
|
|
*/
|
|
if (!priv->conn) {
|
|
vshReportError(ctl);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
vshAdmDeinitTimer(int timer ATTRIBUTE_UNUSED, void *opaque ATTRIBUTE_UNUSED)
|
|
{
|
|
/* nothing to be done here */
|
|
}
|
|
|
|
/*
|
|
* Deinitialize virt-admin
|
|
*/
|
|
static void
|
|
vshAdmDeinit(vshControl *ctl)
|
|
{
|
|
vshAdmControlPtr priv = ctl->privData;
|
|
|
|
vshDeinit(ctl);
|
|
VIR_FREE(ctl->connname);
|
|
|
|
if (priv->conn)
|
|
vshAdmDisconnect(ctl);
|
|
|
|
virResetLastError();
|
|
|
|
if (ctl->eventLoopStarted) {
|
|
int timer;
|
|
|
|
virMutexLock(&ctl->lock);
|
|
ctl->quit = true;
|
|
/* HACK: Add a dummy timeout to break event loop */
|
|
timer = virEventAddTimeout(0, vshAdmDeinitTimer, NULL, NULL);
|
|
virMutexUnlock(&ctl->lock);
|
|
|
|
virThreadJoin(&ctl->eventLoop);
|
|
|
|
if (timer != -1)
|
|
virEventRemoveTimeout(timer);
|
|
|
|
ctl->eventLoopStarted = false;
|
|
}
|
|
|
|
virMutexDestroy(&ctl->lock);
|
|
}
|
|
|
|
/*
|
|
* Print usage
|
|
*/
|
|
static void
|
|
vshAdmUsage(void)
|
|
{
|
|
const vshCmdGrp *grp;
|
|
const vshCmdDef *cmd;
|
|
|
|
fprintf(stdout, _("\n%s [options]... [<command_string>]"
|
|
"\n%s [options]... <command> [args...]\n\n"
|
|
" options:\n"
|
|
" -c | --connect=URI daemon admin connection URI\n"
|
|
" -d | --debug=NUM debug level [0-4]\n"
|
|
" -h | --help this help\n"
|
|
" -l | --log=FILE output logging to file\n"
|
|
" -q | --quiet quiet mode\n"
|
|
" -v short version\n"
|
|
" -V long version\n"
|
|
" --version[=TYPE] version, TYPE is short or long (default short)\n"
|
|
" commands (non interactive mode):\n\n"), progname,
|
|
progname);
|
|
|
|
for (grp = cmdGroups; grp->name; grp++) {
|
|
fprintf(stdout, _(" %s (help keyword '%s')\n"),
|
|
grp->name, grp->keyword);
|
|
for (cmd = grp->commands; cmd->name; cmd++) {
|
|
if (cmd->flags & VSH_CMD_FLAG_ALIAS)
|
|
continue;
|
|
fprintf(stdout,
|
|
" %-30s %s\n", cmd->name,
|
|
_(vshCmddefGetInfo(cmd, "help")));
|
|
}
|
|
fprintf(stdout, "\n");
|
|
}
|
|
|
|
fprintf(stdout, "%s",
|
|
_("\n (specify help <group> for details about the commands in the group)\n"));
|
|
fprintf(stdout, "%s",
|
|
_("\n (specify help <command> for details about the command)\n\n"));
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Show version and options compiled in
|
|
*/
|
|
static void
|
|
vshAdmShowVersion(vshControl *ctl ATTRIBUTE_UNUSED)
|
|
{
|
|
/* FIXME - list a copyright blurb, as in GNU programs? */
|
|
vshPrint(ctl, _("Virt-admin command line tool of libvirt %s\n"), VERSION);
|
|
vshPrint(ctl, _("See web site at %s\n\n"), "http://libvirt.org/");
|
|
|
|
vshPrint(ctl, "%s", _("Compiled with support for:"));
|
|
#ifdef WITH_LIBVIRTD
|
|
vshPrint(ctl, " Daemon");
|
|
#endif
|
|
#ifdef ENABLE_DEBUG
|
|
vshPrint(ctl, " Debug");
|
|
#endif
|
|
#if WITH_READLINE
|
|
vshPrint(ctl, " Readline");
|
|
#endif
|
|
vshPrint(ctl, "\n");
|
|
}
|
|
|
|
static bool
|
|
vshAdmParseArgv(vshControl *ctl, int argc, char **argv)
|
|
{
|
|
int arg, debug;
|
|
size_t i;
|
|
int longindex = -1;
|
|
struct option opt[] = {
|
|
{"connect", required_argument, NULL, 'c'},
|
|
{"debug", required_argument, NULL, 'd'},
|
|
{"help", no_argument, NULL, 'h'},
|
|
{"log", required_argument, NULL, 'l'},
|
|
{"quiet", no_argument, NULL, 'q'},
|
|
{"version", optional_argument, NULL, 'v'},
|
|
{NULL, 0, NULL, 0}
|
|
};
|
|
|
|
/* Standard (non-command) options. The leading + ensures that no
|
|
* argument reordering takes place, so that command options are
|
|
* not confused with top-level virt-admin options. */
|
|
while ((arg = getopt_long(argc, argv, "+:c:d:hl:qvV", opt, &longindex)) != -1) {
|
|
switch (arg) {
|
|
case 'c':
|
|
VIR_FREE(ctl->connname);
|
|
ctl->connname = vshStrdup(ctl, optarg);
|
|
break;
|
|
case 'd':
|
|
if (virStrToLong_i(optarg, NULL, 10, &debug) < 0) {
|
|
vshError(ctl, _("option %s takes a numeric argument"),
|
|
longindex == -1 ? "-d" : "--debug");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (debug < VSH_ERR_DEBUG || debug > VSH_ERR_ERROR)
|
|
vshError(ctl, _("ignoring debug level %d out of range [%d-%d]"),
|
|
debug, VSH_ERR_DEBUG, VSH_ERR_ERROR);
|
|
else
|
|
ctl->debug = debug;
|
|
break;
|
|
case 'h':
|
|
vshAdmUsage();
|
|
exit(EXIT_SUCCESS);
|
|
break;
|
|
case 'l':
|
|
vshCloseLogFile(ctl);
|
|
ctl->logfile = vshStrdup(ctl, optarg);
|
|
vshOpenLogFile(ctl);
|
|
break;
|
|
case 'q':
|
|
ctl->quiet = true;
|
|
break;
|
|
case 'v':
|
|
if (STRNEQ_NULLABLE(optarg, "long")) {
|
|
puts(VERSION);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
ATTRIBUTE_FALLTHROUGH;
|
|
case 'V':
|
|
vshAdmShowVersion(ctl);
|
|
exit(EXIT_SUCCESS);
|
|
case ':':
|
|
for (i = 0; opt[i].name != NULL; i++) {
|
|
if (opt[i].val == optopt)
|
|
break;
|
|
}
|
|
if (opt[i].name)
|
|
vshError(ctl, _("option '-%c'/'--%s' requires an argument"),
|
|
optopt, opt[i].name);
|
|
else
|
|
vshError(ctl, _("option '-%c' requires an argument"), optopt);
|
|
exit(EXIT_FAILURE);
|
|
case '?':
|
|
if (optopt)
|
|
vshError(ctl, _("unsupported option '-%c'. See --help."), optopt);
|
|
else
|
|
vshError(ctl, _("unsupported option '%s'. See --help."), argv[optind - 1]);
|
|
exit(EXIT_FAILURE);
|
|
default:
|
|
vshError(ctl, _("unknown option"));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
longindex = -1;
|
|
}
|
|
|
|
if (argc == optind) {
|
|
ctl->imode = true;
|
|
} else {
|
|
/* parse command */
|
|
ctl->imode = false;
|
|
if (argc - optind == 1) {
|
|
vshDebug(ctl, VSH_ERR_INFO, "commands: \"%s\"\n", argv[optind]);
|
|
return vshCommandStringParse(ctl, argv[optind]);
|
|
} else {
|
|
return vshCommandArgvParse(ctl, argc - optind, argv + optind);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static const vshCmdDef vshAdmCmds[] = {
|
|
VSH_CMD_CD,
|
|
VSH_CMD_ECHO,
|
|
VSH_CMD_EXIT,
|
|
VSH_CMD_HELP,
|
|
VSH_CMD_PWD,
|
|
VSH_CMD_QUIT,
|
|
VSH_CMD_SELF_TEST,
|
|
{.name = "uri",
|
|
.handler = cmdURI,
|
|
.opts = NULL,
|
|
.info = info_uri,
|
|
.flags = 0
|
|
},
|
|
{.name = "version",
|
|
.handler = cmdVersion,
|
|
.opts = NULL,
|
|
.info = info_version,
|
|
.flags = 0
|
|
},
|
|
{.name = "connect",
|
|
.handler = cmdConnect,
|
|
.opts = opts_connect,
|
|
.info = info_connect,
|
|
.flags = VSH_CMD_FLAG_NOCONNECT
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdDef monitoringCmds[] = {
|
|
{.name = "srv-list",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "server-list"
|
|
},
|
|
{.name = "server-list",
|
|
.handler = cmdSrvList,
|
|
.opts = NULL,
|
|
.info = info_srv_list,
|
|
.flags = 0
|
|
},
|
|
{.name = "srv-threadpool-info",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "server-threadpool-info"
|
|
},
|
|
{.name = "server-threadpool-info",
|
|
.handler = cmdSrvThreadpoolInfo,
|
|
.opts = opts_srv_threadpool_info,
|
|
.info = info_srv_threadpool_info,
|
|
.flags = 0
|
|
},
|
|
{.name = "srv-clients-list",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "client-list"
|
|
},
|
|
{.name = "client-list",
|
|
.handler = cmdSrvClientsList,
|
|
.opts = opts_srv_clients_list,
|
|
.info = info_srv_clients_list,
|
|
.flags = 0
|
|
},
|
|
{.name = "client-info",
|
|
.handler = cmdClientInfo,
|
|
.opts = opts_client_info,
|
|
.info = info_client_info,
|
|
.flags = 0
|
|
},
|
|
{.name = "srv-clients-info",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "server-clients-info"
|
|
},
|
|
{.name = "server-clients-info",
|
|
.handler = cmdSrvClientsInfo,
|
|
.opts = opts_srv_clients_info,
|
|
.info = info_srv_clients_info,
|
|
.flags = 0
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdDef managementCmds[] = {
|
|
{.name = "srv-threadpool-set",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "server-threadpool-set"
|
|
},
|
|
{.name = "server-threadpool-set",
|
|
.handler = cmdSrvThreadpoolSet,
|
|
.opts = opts_srv_threadpool_set,
|
|
.info = info_srv_threadpool_set,
|
|
.flags = 0
|
|
},
|
|
{.name = "client-disconnect",
|
|
.handler = cmdClientDisconnect,
|
|
.opts = opts_client_disconnect,
|
|
.info = info_client_disconnect,
|
|
.flags = 0
|
|
},
|
|
{.name = "srv-clients-set",
|
|
.flags = VSH_CMD_FLAG_ALIAS,
|
|
.alias = "server-clients-set"
|
|
},
|
|
{.name = "server-clients-set",
|
|
.handler = cmdSrvClientsSet,
|
|
.opts = opts_srv_clients_set,
|
|
.info = info_srv_clients_set,
|
|
.flags = 0
|
|
},
|
|
{.name = "daemon-log-filters",
|
|
.handler = cmdDaemonLogFilters,
|
|
.opts = opts_daemon_log_filters,
|
|
.info = info_daemon_log_filters,
|
|
.flags = 0
|
|
},
|
|
{.name = "daemon-log-outputs",
|
|
.handler = cmdDaemonLogOutputs,
|
|
.opts = opts_daemon_log_outputs,
|
|
.info = info_daemon_log_outputs,
|
|
.flags = 0
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdGrp cmdGroups[] = {
|
|
{"Virt-admin itself", "virt-admin", vshAdmCmds},
|
|
{"Monitoring commands", "monitor", monitoringCmds},
|
|
{"Management commands", "management", managementCmds},
|
|
{NULL, NULL, NULL}
|
|
};
|
|
|
|
static const vshClientHooks hooks = {
|
|
.connHandler = vshAdmConnectionHandler
|
|
};
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
vshControl _ctl, *ctl = &_ctl;
|
|
vshAdmControl virtAdminCtl;
|
|
bool ret = true;
|
|
|
|
memset(ctl, 0, sizeof(vshControl));
|
|
memset(&virtAdminCtl, 0, sizeof(vshAdmControl));
|
|
ctl->name = "virt-admin"; /* hardcoded name of the binary */
|
|
ctl->env_prefix = "VIRT_ADMIN";
|
|
ctl->log_fd = -1; /* Initialize log file descriptor */
|
|
ctl->debug = VSH_DEBUG_DEFAULT;
|
|
ctl->hooks = &hooks;
|
|
|
|
ctl->eventPipe[0] = -1;
|
|
ctl->eventPipe[1] = -1;
|
|
ctl->privData = &virtAdminCtl;
|
|
|
|
if (!(progname = strrchr(argv[0], '/')))
|
|
progname = argv[0];
|
|
else
|
|
progname++;
|
|
ctl->progname = progname;
|
|
|
|
if (virGettextInitialize() < 0)
|
|
return EXIT_FAILURE;
|
|
|
|
if (isatty(STDIN_FILENO)) {
|
|
ctl->istty = true;
|
|
|
|
#ifndef WIN32
|
|
if (tcgetattr(STDIN_FILENO, &ctl->termattr) < 0)
|
|
ctl->istty = false;
|
|
#endif
|
|
}
|
|
|
|
if (virMutexInit(&ctl->lock) < 0) {
|
|
vshError(ctl, "%s", _("Failed to initialize mutex"));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (virAdmInitialize() < 0) {
|
|
vshError(ctl, "%s", _("Failed to initialize libvirt"));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
virFileActivateDirOverride(argv[0]);
|
|
|
|
if (!vshInit(ctl, cmdGroups, NULL))
|
|
exit(EXIT_FAILURE);
|
|
|
|
if (!vshAdmParseArgv(ctl, argc, argv) ||
|
|
!vshAdmInit(ctl)) {
|
|
vshAdmDeinit(ctl);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (!ctl->imode) {
|
|
ret = vshCommandRun(ctl, ctl->cmd);
|
|
} else {
|
|
/* interactive mode */
|
|
if (!ctl->quiet) {
|
|
vshPrint(ctl,
|
|
_("Welcome to %s, the administrating virtualization "
|
|
"interactive terminal.\n\n"),
|
|
progname);
|
|
vshPrint(ctl, "%s",
|
|
_("Type: 'help' for help with commands\n"
|
|
" 'quit' to quit\n\n"));
|
|
}
|
|
|
|
do {
|
|
ctl->cmdstr = vshReadline(ctl, VIRT_ADMIN_PROMPT);
|
|
if (ctl->cmdstr == NULL)
|
|
break; /* EOF */
|
|
if (*ctl->cmdstr) {
|
|
#if WITH_READLINE
|
|
add_history(ctl->cmdstr);
|
|
#endif
|
|
if (vshCommandStringParse(ctl, ctl->cmdstr))
|
|
vshCommandRun(ctl, ctl->cmd);
|
|
}
|
|
VIR_FREE(ctl->cmdstr);
|
|
} while (ctl->imode);
|
|
|
|
if (ctl->cmdstr == NULL)
|
|
fputc('\n', stdout); /* line break after alone prompt */
|
|
}
|
|
|
|
vshAdmDeinit(ctl);
|
|
exit(ret ? EXIT_SUCCESS : EXIT_FAILURE);
|
|
}
|