--- /dev/null
+<!--
+
+lxc-autostart
+
+(C) Copyright 2013 Canonical Ltd.
+
+Authors:
+Stéphane Graber <stgraber@ubuntu.com>
+
+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, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+-->
+
+<!DOCTYPE refentry PUBLIC @docdtd@ [
+ <!ENTITY commonoptions SYSTEM "@builddir@/common_options.sgml">
+ <!ENTITY seealso SYSTEM "@builddir@/see_also.sgml">
+]>
+
+<refentry>
+ <docinfo><date>@LXC_GENERATE_DATE@</date></docinfo>
+ <refmeta>
+ <refentrytitle>lxc-autostart</refentrytitle>
+ <manvolnum>1</manvolnum>
+ </refmeta>
+
+ <refnamediv>
+ <refname>lxc-autostart</refname>
+
+ <refpurpose>
+ start/stop/kill auto-started containers
+ </refpurpose>
+ </refnamediv>
+
+ <refsynopsisdiv>
+ <cmdsynopsis>
+ <command>lxc-autostart</command>
+ <arg choice="opt">-k</arg>
+ <arg choice="opt">-L</arg>
+ <arg choice="opt">-r</arg>
+ <arg choice="opt">-s</arg>
+ <arg choice="opt">-a</arg>
+ <arg choice="opt">-g <replaceable>groups</replaceable></arg>
+ <arg choice="opt">-t <replaceable>timeout</replaceable></arg>
+ </cmdsynopsis>
+ </refsynopsisdiv>
+
+ <refsect1>
+ <title>Description</title>
+
+ <para>
+ <command>lxc-autostart</command> processes containers
+ with lxc.start.auto set. It lets the user start, shutdown,
+ kill, restart containers in the right order, waiting the
+ right time. Supports filtering by lxc.group or just run
+ against all defined containers. It can also be used by
+ external tools in list mode where no action will be performed
+ and the list of affected containers (and if relevant, delays)
+ will be shown.
+ </para>
+
+ <para>
+ The <optional>-r</optional>, <optional>-s</optional>
+ and <optional>-k</optional> options specify the action to perform.
+ If none is specified, then the containers will be started.
+ <optional>-a</optional> and <optional>-g</optional> are used to
+ specify which containers will be affected. By default only
+ containers without a lxc.group set will be affected.
+ <optional>-t TIMEOUT</optional> specifies the maximum amount
+ of time to wait for the container to complete the shutdown
+ or reboot.
+ </para>
+ </refsect1>
+
+ <refsect1>
+ <title>Options</title>
+ <variablelist>
+ <varlistentry>
+ <term>
+ <option>-r,--reboot </option>
+ </term>
+ <listitem>
+ <para>
+ Request a reboot of the container.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <option>-s,--shutdown </option>
+ </term>
+ <listitem>
+ <para>
+ Only request a clean shutdown, do not kill the
+ container tasks if the clean shutdown fails.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <option>-k,--kill </option>
+ </term>
+ <listitem>
+ <para>
+ Rather than requesting a clean shutdown of the
+ container, explicitly kill all tasks in the container.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <option>-L,--list </option>
+ </term>
+ <listitem>
+ <para>
+ Rather than performing the action, just print
+ the container name.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <option>-t,--timeout <replaceable>TIMEOUT</replaceable></option>
+ </term>
+ <listitem>
+ <para>
+ Wait TIMEOUT seconds before hard-stopping the
+ container of (in the reboot case) returning failure.
+ </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </refsect1>
+
+ &seealso;
+
+ <refsect1>
+ <title>Author</title>
+ <para>Stéphane Graber <email>stgraber@ubuntu.com</email></para>
+ </refsect1>
+</refentry>
+
+<!-- Keep this comment at the end of the file
+Local variables:
+mode: sgml
+sgml-omittag:t
+sgml-shorttag:t
+sgml-minimize-attributes:nil
+sgml-always-quote-attributes:t
+sgml-indent-step:2
+sgml-indent-data:t
+sgml-parent-document:nil
+sgml-default-dtd-file:nil
+sgml-exposed-tags:nil
+sgml-local-catalogs:nil
+sgml-local-ecat-files:nil
+End:
+-->
--- /dev/null
+/* lxc_autostart
+ *
+ * Copyright © 2013 Stéphane Graber <stgraber@ubuntu.com>
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <unistd.h>
+
+#include <lxc/lxccontainer.h>
+
+#include "arguments.h"
+#include "list.h"
+#include "log.h"
+
+static int my_parser(struct lxc_arguments* args, int c, char* arg)
+{
+ switch (c) {
+ case 'k': args->hardstop = 1; break;
+ case 'L': args->list = 1; break;
+ case 'r': args->reboot = 1; break;
+ case 's': args->shutdown = 1; break;
+ case 'a': args->all = 1; break;
+ case 'g': args->groups = arg; break;
+ case 't': args->timeout = atoi(arg); break;
+ }
+ return 0;
+}
+
+static const struct option my_longopts[] = {
+ {"kill", no_argument, 0, 'k'},
+ {"list", no_argument, 0, 'L'},
+ {"reboot", no_argument, 0, 'r'},
+ {"shutdown", no_argument, 0, 's'},
+ {"all", no_argument, 0, 'a'},
+ {"groups", required_argument, 0, 'g'},
+ {"timeout", required_argument, 0, 't'},
+ {"help", no_argument, 0, 'h'},
+ LXC_COMMON_OPTIONS
+};
+
+static struct lxc_arguments my_args = {
+ .progname = "lxc-autostart",
+ .help = "\
+\n\
+lxc-autostart managed auto-started containers\n\
+\n\
+Options:\n\
+ -k, --kill kill the containers instead of starting them\n\
+ -L, --list list all affected containers and wait delay\n\
+ -r, --reboot reboot the containers instead of starting them\n\
+ -s, --shutdown shutdown the containers instead of starting them\n\
+\n\
+ -a, --all list all auto-started containers (ignore groups)\n\
+ -g, --groups list of groups (comma separated) to select\n\
+ -t, --timeout=T wait T seconds before hard-stopping\n",
+ .options = my_longopts,
+ .parser = my_parser,
+ .checker = NULL,
+ .timeout = 30,
+};
+
+int lists_contain_common_entry(struct lxc_list *p1, struct lxc_list *p2) {
+ struct lxc_list *it1;
+ struct lxc_list *it2;
+
+ if (!p1 && !p2)
+ return 1;
+
+ if (!p1)
+ return 0;
+
+ if (!p2)
+ return 0;
+
+ lxc_list_for_each(it1, p1) {
+ lxc_list_for_each(it2, p2) {
+ if (strcmp(it1->elem, it2->elem) == 0)
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+struct lxc_list *get_list(char *input, char *delimiter) {
+ char *workstr = NULL;
+ char *workptr = NULL;
+ char *sptr = NULL;
+ char *token = NULL;
+ struct lxc_list *worklist;
+ struct lxc_list *workstr_list;
+
+ workstr_list = malloc(sizeof(*workstr_list));
+ lxc_list_init(workstr_list);
+
+ workstr = strdup(input);
+ if (!workstr)
+ return NULL;
+
+ for (workptr = workstr;;workptr = NULL) {
+ token = strtok_r(workptr, delimiter, &sptr);
+ if (!token) {
+ break;
+ }
+
+ worklist = malloc(sizeof(*worklist));
+ if (!worklist)
+ break;
+
+ worklist->elem = strdup(token);
+ if (!worklist->elem) {
+ free(worklist);
+ break;
+ }
+
+ lxc_list_add_tail(workstr_list, worklist);
+ }
+
+ free(workstr);
+
+ return workstr_list;
+}
+
+struct lxc_list *get_config_list(struct lxc_container *c, char *key) {
+ int len = 0;
+ char* value = NULL;
+ struct lxc_list *config_list = NULL;
+
+ len = c->get_config_item(c, key, NULL, 0);
+ if (len < 0)
+ return NULL;
+
+ value = (char*) malloc(sizeof(char)*len + 1);
+ if (value == NULL)
+ return NULL;
+
+ if (c->get_config_item(c, key, value, len + 1) != len) {
+ free(value);
+ return NULL;
+ }
+
+ if (strlen(value) == 0) {
+ free(value);
+ return NULL;
+ }
+
+ config_list = get_list(value, "\n");
+ free(value);
+
+ return config_list;
+}
+
+int get_config_integer(struct lxc_container *c, char *key) {
+ int len = 0;
+ int ret = 0;
+ char* value = NULL;
+
+ len = c->get_config_item(c, key, NULL, 0);
+ if (len < 0)
+ return 0;
+
+ value = (char*) malloc(sizeof(char)*len + 1);
+ if (value == NULL)
+ return 0;
+
+ if (c->get_config_item(c, key, value, len + 1) != len) {
+ free(value);
+ return 0;
+ }
+
+ ret = atoi(value);
+ free(value);
+
+ return ret;
+}
+
+static int cmporder(const void *p1, const void *p2) {
+ struct lxc_container *c1 = *(struct lxc_container **)p1;
+ struct lxc_container *c2 = *(struct lxc_container **)p2;
+
+ int c1_order = get_config_integer(c1, "lxc.start.order");
+ int c2_order = get_config_integer(c2, "lxc.start.order");
+
+ if (c1_order == c2_order)
+ return strcmp(c1->name, c2->name);
+ else
+ return (c1_order - c2_order) * -1;
+}
+
+int main(int argc, char *argv[])
+{
+ int count = 0;
+ int i = 0;
+ int ret = 0;
+ struct lxc_container **containers = NULL;
+ struct lxc_list *cmd_groups_list = NULL;
+ struct lxc_list *c_groups_list = NULL;
+ struct lxc_list *it, *next;
+ char *const default_start_args[] = {
+ "/sbin/init",
+ '\0',
+ };
+
+ if (lxc_arguments_parse(&my_args, argc, argv))
+ return 1;
+
+ count = list_defined_containers(NULL, NULL, &containers);
+
+ if (count < 0)
+ return 1;
+
+ qsort(&containers[0], count, sizeof(struct lxc_container *), cmporder);
+
+ if (my_args.groups && !my_args.all)
+ cmd_groups_list = get_list((char*)my_args.groups, ",");
+
+ for (i = 0; i < count; i++) {
+ struct lxc_container *c = containers[i];
+
+ if (!c->may_control(c)) {
+ lxc_container_put(c);
+ continue;
+ }
+
+ if (get_config_integer(c, "lxc.start.auto") != 1) {
+ lxc_container_put(c);
+ continue;
+ }
+
+ if (!my_args.all) {
+ /* Filter by group */
+ c_groups_list = get_config_list(c, "lxc.group");
+
+ ret = lists_contain_common_entry(cmd_groups_list, c_groups_list);
+
+ if (c_groups_list) {
+ lxc_list_for_each_safe(it, c_groups_list, next) {
+ lxc_list_del(it);
+ free(it->elem);
+ free(it);
+ }
+ free(c_groups_list);
+ }
+
+ if (ret == 0) {
+ lxc_container_put(c);
+ continue;
+ }
+ }
+
+ c->want_daemonize(c, 1);
+
+ if (my_args.shutdown) {
+ /* Shutdown the container */
+ if (c->is_running(c)) {
+ if (my_args.list)
+ printf("%s\n", c->name);
+ else {
+ if (!c->shutdown(c, my_args.timeout))
+ fprintf(stderr, "Error shutting down container: %s\n", c->name);
+ }
+ }
+ }
+ else if (my_args.hardstop) {
+ /* Kill the container */
+ if (c->is_running(c)) {
+ if (my_args.list)
+ printf("%s\n", c->name);
+ else {
+ if (!c->stop(c))
+ fprintf(stderr, "Error killing container: %s\n", c->name);
+ }
+ }
+ }
+ else if (my_args.reboot) {
+ /* Reboot the container */
+ if (c->is_running(c)) {
+ if (my_args.list)
+ printf("%s %d\n", c->name,
+ get_config_integer(c, "lxc.start.delay"));
+ else {
+ if (!c->reboot(c))
+ fprintf(stderr, "Error rebooting container: %s\n", c->name);
+ else
+ sleep(get_config_integer(c, "lxc.start.delay"));
+ }
+ }
+ }
+ else {
+ /* Start the container */
+ if (!c->is_running(c)) {
+ if (my_args.list)
+ printf("%s %d\n", c->name,
+ get_config_integer(c, "lxc.start.delay"));
+ else {
+ if (!c->start(c, 0, default_start_args))
+ fprintf(stderr, "Error starting container: %s\n", c->name);
+ else
+ sleep(get_config_integer(c, "lxc.start.delay"));
+ }
+ }
+ }
+
+
+ lxc_container_put(c);
+ }
+
+ if (cmd_groups_list) {
+ lxc_list_for_each_safe(it, cmd_groups_list, next) {
+ lxc_list_del(it);
+ free(it->elem);
+ free(it);
+ }
+ free(cmd_groups_list);
+ }
+
+ free(containers);
+
+ return 0;
+}
projects / thirdparty / lxc.git / commitdiff
