← Back to branch summary

~jamesodhunt/upstart/async-spawn.20140310

« back to all changes in this revision

Viewing changes to init/state.c

  • Committer: James Hunt
  • Date: 2013-06-04 16:51:55 UTC
  • mto: This revision was merged to the branch mainline in revision 1479.
  • Revision ID: james.hunt@ubuntu.com-20130604165155-1d4cgoqy90crwvk6
* init/event.c: event_deserialise(): Revert to checking JSON for
  blockers to avoid reliance on JSON serialisation data format version.
* init/event_operator.h: Fix misplacement of NIH_END_EXTERN.
* init/state.c: Remove serialisation version code since the autoconf
  approach of detecting the format of the JSON is safer.
* init/state.h: Remove STATE_VERSION.

Show diffs side-by-side

added added

removed removed

Lines of Context:
init/state.c
75
75
 **/
76
76
int write_state_file = FALSE;
77
77
 
78
 
/**
79
 
 * serialisation_version:
80
 
 *
81
 
 * Set to a positive integer (representing the serialisation format
82
 
 * verison) as the start of the deserialisation process to allow further
83
 
 * deserialisation to be modified based on its value.
84
 
 *
85
 
 * The value -1 denotes that the serialisation version cannot be determined
86
 
 * (generally caused by old-style JSON state data being read that does not encode
87
 
 * the serialisation version).
88
 
 **/
89
 
int serialisation_version = -1;
90
 
 
91
78
/* Prototypes for static functions */
92
79
static JobClass *
93
80
state_index_to_job_class (int job_class_index)
95
82
 
96
83
static void state_write_file (NihIoBuffer *buffer);
97
84
 
98
 
static json_object *state_create_header (void)
99
 
        __attribute__ ((warn_unused_result));
100
 
 
101
 
static int
102
 
state_read_header (json_object *json)
103
 
        __attribute__ ((warn_unused_result));
104
 
 
105
85
/**
106
86
 * state_read:
107
87
 *
359
339
state_to_string (char **json_string, size_t *len)
360
340
{
361
341
        json_object  *json;
362
 
        json_object  *json_header;
363
342
        const char   *value;
364
343
 
365
344
        nih_assert (json_string);
370
349
        if (! json)
371
350
                return -1;
372
351
 
373
 
        json_header = state_create_header ();
374
 
        if (! json_header) {
375
 
                nih_error ("%s header", _("Failed to serialise"));
376
 
                goto error;
377
 
        }
378
 
 
379
 
        json_object_object_add (json, "header", json_header);
380
 
 
381
352
        json_sessions = session_serialise_all ();
382
353
        if (! json_sessions) {
383
354
                nih_error ("%s Sessions", _("Failed to serialise"));
465
436
        if (! state_check_json_type (json, object))
466
437
                goto out;
467
438
 
468
 
        /* We cannot error in this scenario as the JSON state data being
469
 
         * read may be an old-style format that does not encode a
470
 
         * header.
471
 
         */
472
 
        if (state_read_header (json) < 0)
473
 
                nih_warn ("%s", _("No header present in state data"));
474
 
 
475
439
        if (session_deserialise_all (json) < 0) {
476
440
                nih_error ("%s Sessions", _("Failed to deserialise"));
477
441
                goto out;
2136
2100
                }
2137
2101
        }
2138
2102
}
2139
 
 
2140
 
/**
2141
 
 * state_create_header:
2142
 
 *
2143
 
 * Returns: JSON object containing meta-data header,
2144
 
 * or NULL on error.
2145
 
 **/
2146
 
static json_object *
2147
 
state_create_header (void)
2148
 
{
2149
 
        json_object *json;
2150
 
 
2151
 
        json = json_object_new_object ();
2152
 
 
2153
 
        if (! json)
2154
 
                return NULL;
2155
 
 
2156
 
        if (! state_set_json_int_var (json, "version", STATE_VERSION))
2157
 
                goto error;
2158
 
 
2159
 
        return json;
2160
 
 
2161
 
error:
2162
 
        json_object_put (json);
2163
 
        return NULL;
2164
 
}
2165
 
 
2166
 
/**
2167
 
 * state_read_header:
2168
 
 *
2169
 
 * @json: JSON,
2170
 
 *
2171
 
 * Returns: 0 on success, -1 on error.
2172
 
 **/
2173
 
static int
2174
 
state_read_header (json_object *json)
2175
 
{
2176
 
        json_object *json_header;
2177
 
 
2178
 
        nih_assert (json);
2179
 
 
2180
 
        if (! json_object_object_get_ex (json, "header", &json_header))
2181
 
                goto error;
2182
 
 
2183
 
        if (! state_get_json_int_var (json_header, "version", serialisation_version))
2184
 
                goto error;
2185
 
 
2186
 
        return 0;
2187
 
 
2188
 
error:
2189
 
        return -1;
2190
 
 
2191
 
}
2192
 
 
2193
 
/**
2194
 
 * state_get_version:
2195
 
 *
2196
 
 * Determine version of serialisation data that has been read.
2197
 
 *
2198
 
 * Only valid to call if state_from_string() has been (or is being)
2199
 
 * called.
2200
 
 **/
2201
 
int
2202
 
state_get_version (void)
2203
 
{
2204
 
        return serialisation_version;
2205
 
}