~ubuntu-branches/ubuntu/quantal/lxc/quantal-201208232243

« back to all changes in this revision

Viewing changes to .pc/0096-lxc-wait-add-timeout.patch/src/lxc/lxc_wait.c

  • Committer: Serge Hallyn
  • Date: 2012-07-26 17:58:42 UTC
  • Revision ID: serge@serge-laptop-20120726175842-uvip2ssxtfakmhpq
[ Serge Hallyn ]
* lxc.lxc-net.upstart: replace the check for USE_LXC_BRIDGE (which could be
  changed from true to false after starting lxc-net) with one for the
  existence /var/run/lxc.  (LP: #1019290)
* 0095-lxc-clone-change-uuid-on-xfs.patch: give each cloned xfs-backed
  lvm partition a unique uuid so they can be mounted simultaneously.
  (LP: #1013549)
* 0096-lxc-wait-add-timeout.patch: patch submitted upstream to add a timeout
  option to lxc-wait.  (LP: #1020179)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * lxc: linux Container library
 
3
 *
 
4
 * (C) Copyright IBM Corp. 2007, 2008
 
5
 *
 
6
 * Authors:
 
7
 * Daniel Lezcano <dlezcano at fr.ibm.com>
 
8
 *
 
9
 * This library is free software; you can redistribute it and/or
 
10
 * modify it under the terms of the GNU Lesser General Public
 
11
 * License as published by the Free Software Foundation; either
 
12
 * version 2.1 of the License, or (at your option) any later version.
 
13
 *
 
14
 * This library is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
 * Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with this library; if not, write to the Free Software
 
21
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
22
 */
 
23
#include <stdio.h>
 
24
#include <string.h>
 
25
#include <libgen.h>
 
26
#include <unistd.h>
 
27
#include <sys/types.h>
 
28
 
 
29
#include <lxc/lxc.h>
 
30
#include <lxc/log.h>
 
31
#include <lxc/monitor.h>
 
32
#include "arguments.h"
 
33
 
 
34
lxc_log_define(lxc_wait_ui, lxc_monitor);
 
35
 
 
36
static int my_checker(const struct lxc_arguments* args)
 
37
{
 
38
        if (!args->states) {
 
39
                lxc_error(args, "missing state option to wait for.");
 
40
                return -1;
 
41
        }
 
42
        return 0;
 
43
}
 
44
 
 
45
static int my_parser(struct lxc_arguments* args, int c, char* arg)
 
46
{
 
47
        switch (c) {
 
48
        case 's': args->states = optarg; break;
 
49
        }
 
50
        return 0;
 
51
}
 
52
 
 
53
static const struct option my_longopts[] = {
 
54
        {"state", required_argument, 0, 's'},
 
55
        LXC_COMMON_OPTIONS
 
56
};
 
57
 
 
58
static struct lxc_arguments my_args = {
 
59
        .progname = "lxc-wait",
 
60
        .help     = "\
 
61
--name=NAME --state=STATE\n\
 
62
\n\
 
63
lxc-wait waits for NAME container state to reach STATE\n\
 
64
\n\
 
65
Options :\n\
 
66
  -n, --name=NAME   NAME for name of the container\n\
 
67
  -s, --state=STATE ORed states to wait for\n\
 
68
                    STOPPED, STARTING, RUNNING, STOPPING,\n\
 
69
                    ABORTING, FREEZING, FROZEN\n",
 
70
        .options  = my_longopts,
 
71
        .parser   = my_parser,
 
72
        .checker  = my_checker,
 
73
};
 
74
 
 
75
static int fillwaitedstates(char *strstates, int *states)
 
76
{
 
77
        char *token, *saveptr = NULL;
 
78
        int state;
 
79
 
 
80
        token = strtok_r(strstates, "|", &saveptr);
 
81
        while (token) {
 
82
 
 
83
                state = lxc_str2state(token);
 
84
                if (state < 0)
 
85
                        return -1;
 
86
 
 
87
                states[state] = 1;
 
88
 
 
89
                token = strtok_r(NULL, "|", &saveptr);
 
90
        }
 
91
        return 0;
 
92
}
 
93
 
 
94
int main(int argc, char *argv[])
 
95
{
 
96
        struct lxc_msg msg;
 
97
        int s[MAX_STATE] = { }, fd;
 
98
        int state, ret;
 
99
 
 
100
        if (lxc_arguments_parse(&my_args, argc, argv))
 
101
                return -1;
 
102
 
 
103
        if (lxc_log_init(my_args.log_file, my_args.log_priority,
 
104
                         my_args.progname, my_args.quiet))
 
105
                return -1;
 
106
 
 
107
        if (fillwaitedstates(my_args.states, s))
 
108
                return -1;
 
109
 
 
110
        fd = lxc_monitor_open();
 
111
        if (fd < 0)
 
112
                return -1;
 
113
 
 
114
        /*
 
115
         * if container present,
 
116
         * then check if already in requested state
 
117
         */
 
118
        ret = -1;
 
119
        state = lxc_getstate(my_args.name);
 
120
        if (state < 0) {
 
121
                goto out_close;
 
122
        } else if ((state >= 0) && (s[state])) {
 
123
                ret = 0;
 
124
                goto out_close;
 
125
        }
 
126
 
 
127
        for (;;) {
 
128
                if (lxc_monitor_read(fd, &msg) < 0)
 
129
                        goto out_close;
 
130
 
 
131
                if (strcmp(my_args.name, msg.name))
 
132
                        continue;
 
133
 
 
134
                switch (msg.type) {
 
135
                case lxc_msg_state:
 
136
                        if (msg.value < 0 || msg.value >= MAX_STATE) {
 
137
                                ERROR("Receive an invalid state number '%d'",
 
138
                                        msg.value);
 
139
                                goto out_close;
 
140
                        }
 
141
 
 
142
                        if (s[msg.value]) {
 
143
                                ret = 0;
 
144
                                goto out_close;
 
145
                        }
 
146
                        break;
 
147
                default:
 
148
                        /* just ignore garbage */
 
149
                        break;
 
150
                }
 
151
        }
 
152
 
 
153
out_close:
 
154
        lxc_monitor_close(fd);
 
155
        return ret;
 
156
}