source: ogServer-Git/src/json.c

Last change on this file was 7325a86, checked in by Javier Sánchez Parra <jsanchez@…>, 3 years ago

#915 Add POST /task/add method

Adds the possibility to create a task with procedures and other tasks
integrated as steps.

Note: "steps" parameter is optional and "steps" array object order
defines execution order.

Request:
POST /task/add
{

"center": "1",
"name": "task",
"description": "My task",
"steps": [

{

"procedure": 4

},
{

"task": 1

},
{

"procedure": 24

}

]

}

Response:
200 OK

This commit also add task case to procedure's step processing.
Otherwise, gcc prints the following warning:

src/rest.c: In function ‘og_procedure_add_steps’:
src/rest.c:4089:17: warning: enumeration value ‘OG_STEP_TASK’ not handled in switch [-Wswitch]

4089 | switch (step->type) {

| ~

  • Property mode set to 100644
File size: 5.4 KB
Line 
1/*
2 * Copyright (C) 2020-2021 Soleta Networks <info@soleta.eu>
3 *
4 * This program is free software: you can redistribute it and/or modify it under
5 * the terms of the GNU Affero General Public License as published by the
6 * Free Software Foundation; either version 3 of the License, or
7 * (at your option) any later version.
8 */
9
10#include "json.h"
11#include <stdint.h>
12
13int og_json_parse_string(const json_t *element, const char **str)
14{
15        if (json_typeof(element) != JSON_STRING)
16                return -1;
17
18        *str = json_string_value(element);
19        return 0;
20}
21
22int og_json_parse_string_copy(const json_t *element, char *str, size_t size)
23{
24        const char *reference_str;
25        int err = 0;
26
27        err = og_json_parse_string(element, &reference_str);
28        if (err != 0)
29                return err;
30
31        err = snprintf(str, size, "%s", reference_str);
32        if (err >= size)
33                return -1;
34        return 0;
35}
36
37int og_json_parse_uint64(const json_t *element, uint64_t *integer)
38{
39        if (json_typeof(element) != JSON_INTEGER)
40                return -1;
41
42        *integer = json_integer_value(element);
43        return 0;
44}
45
46int og_json_parse_uint(const json_t *element, uint32_t *integer)
47{
48        if (json_typeof(element) != JSON_INTEGER)
49                return -1;
50
51        *integer = json_integer_value(element);
52        return 0;
53}
54
55int og_json_parse_bool(const json_t *element, bool *value)
56{
57        if (json_typeof(element) == JSON_TRUE)
58                *value = true;
59        else if (json_typeof(element) == JSON_FALSE)
60                *value = false;
61        else
62                return -1;
63
64        return 0;
65}
66
67int og_json_parse_scope(json_t *element, struct og_scope *scope,
68                        const uint64_t required_flags)
69{
70        uint64_t flags = 0UL;
71        const char *key;
72        json_t *value;
73        int err = 0;
74
75        json_object_foreach(element, key, value) {
76                if (!strcmp(key, "id")) {
77                        err = og_json_parse_uint(value, &scope->id);
78                        flags |= OG_PARAM_SCOPE_ID;
79                } else if (!strcmp(key, "type")) {
80                        err = og_json_parse_string(value, &scope->type);
81                        flags |= OG_PARAM_SCOPE_TYPE;
82                } else {
83                        err = -1;
84                }
85
86                if (err < 0)
87                        return err;
88        }
89
90        if (flags != required_flags)
91                return -1;
92
93        return err;
94}
95
96int og_json_parse_partition(json_t *element, struct og_partition *part,
97                            uint64_t required_flags)
98{
99        uint64_t flags = 0UL;
100        const char *key;
101        json_t *value;
102        int err = 0;
103
104        json_object_foreach(element, key, value) {
105                if (!strcmp(key, "partition")) {
106                        err = og_json_parse_string(value, &part->number);
107                        flags |= OG_PARAM_PART_NUMBER;
108                } else if (!strcmp(key, "code")) {
109                        err = og_json_parse_string(value, &part->code);
110                        flags |= OG_PARAM_PART_CODE;
111                } else if (!strcmp(key, "filesystem")) {
112                        err = og_json_parse_string(value, &part->filesystem);
113                        flags |= OG_PARAM_PART_FILESYSTEM;
114                } else if (!strcmp(key, "size")) {
115                        err = og_json_parse_string(value, &part->size);
116                        flags |= OG_PARAM_PART_SIZE;
117                } else if (!strcmp(key, "format")) {
118                        err = og_json_parse_string(value, &part->format);
119                        flags |= OG_PARAM_PART_FORMAT;
120                } else if (!strcmp(key, "disk")) {
121                        err = og_json_parse_string(value, &part->disk);
122                        flags |= OG_PARAM_PART_DISK;
123                } else if (!strcmp(key, "disk_type")) {
124                        err = og_json_parse_string(value, &part->disk_type);
125                        flags |= OG_PARAM_PART_DISK_TYPE;
126                } else if (!strcmp(key, "os")) {
127                        err = og_json_parse_string(value, &part->os);
128                        flags |= OG_PARAM_PART_OS;
129                } else if (!strcmp(key, "used_size")) {
130                        err = og_json_parse_string(value, &part->used_size);
131                        flags |= OG_PARAM_PART_USED_SIZE;
132                }
133
134                if (err < 0)
135                        return err;
136        }
137
138        if ((flags & required_flags) != required_flags)
139                return -1;
140
141        return err;
142}
143
144static int og_json_parse_procedure_cmd(json_t *element, int position,
145                                       struct og_procedure *proc)
146{
147        struct og_procedure_step *step;
148        uint32_t err = 0;
149        const char *key;
150        json_t *value;
151
152        step = &proc->steps[proc->num_steps++];
153        step->type = OG_STEP_COMMAND;
154        step->position = position;
155
156        json_object_foreach(element, key, value) {
157                if (!strcmp(key, "command"))
158                        err = og_json_parse_string(value, &step->cmd.type);
159                else if (!strcmp(key, "params"))
160                        step->cmd.json = value;
161                else
162                        return -1;
163        }
164
165        return err;
166}
167
168static int og_json_parse_procedure_call(json_t *element, int position,
169                                        struct og_procedure *proc)
170{
171        struct og_procedure_step *step;
172        uint32_t err = 0;
173        const char *key;
174        json_t *value;
175
176        step = &proc->steps[proc->num_steps++];
177        step->type = OG_STEP_PROCEDURE;
178        step->position = position;
179
180        json_object_foreach(element, key, value) {
181                if (!strcmp(key, "procedure"))
182                        err = og_json_parse_uint64(value, &step->procedure.id);
183                else
184                        return -1;
185        }
186
187        return err;
188}
189
190static int og_json_parse_task_call(json_t *element, int position,
191                                   struct og_procedure *task)
192{
193        struct og_procedure_step *step;
194        uint32_t err = 0;
195        const char *key;
196        json_t *value;
197
198        step = &task->steps[task->num_steps++];
199        step->type = OG_STEP_TASK;
200        step->position = position;
201
202        json_object_foreach(element, key, value) {
203                if (!strcmp(key, "task"))
204                        err = og_json_parse_uint64(value, &step->procedure.id);
205                else
206                        return -1;
207        }
208
209        return err;
210}
211
212int og_json_parse_procedure(json_t *element, struct og_procedure *proc)
213{
214        unsigned int i;
215        json_t *item;
216        int err = 0;
217
218        if (json_typeof(element) != JSON_ARRAY)
219                return -1;
220
221        for (i = 0; i < json_array_size(element) && i < OG_PROCEDURE_STEPS_MAX; ++i) {
222                item = json_array_get(element, i);
223
224                if (json_object_get(item, "command"))
225                        err = og_json_parse_procedure_cmd(item, i, proc);
226                else if (json_object_get(item, "procedure"))
227                        err = og_json_parse_procedure_call(item, i, proc);
228                else if (json_object_get(item, "task"))
229                        err = og_json_parse_task_call(item, i, proc);
230                else
231                        err = -1;
232
233                if (err)
234                        break;
235        }
236
237        return err;
238}
Note: See TracBrowser for help on using the repository browser.