ari endpoints: GET /ari/endpoints/{invalid-tech} should return a 404
[asterisk/asterisk.git] / res / ari / resource_endpoints.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief /api-docs/endpoints.{format} implementation- Endpoint resources
22  *
23  * \author David M. Lee, II <dlee@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "resource_endpoints.h"
31
32 #include "asterisk/astobj2.h"
33 #include "asterisk/stasis.h"
34 #include "asterisk/stasis_endpoints.h"
35
36 void ast_ari_endpoints_list(struct ast_variable *headers,
37         struct ast_ari_endpoints_list_args *args,
38         struct ast_ari_response *response)
39 {
40         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
41         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
42         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
43         struct ao2_iterator i;
44         void *obj;
45
46         cache = ast_endpoint_cache();
47         if (!cache) {
48                 ast_ari_response_error(
49                         response, 500, "Internal Server Error",
50                         "Message bus not initialized");
51                 return;
52         }
53         ao2_ref(cache, +1);
54
55         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
56         if (!snapshots) {
57                 ast_ari_response_alloc_failed(response);
58                 return;
59         }
60
61         json = ast_json_array_create();
62         if (!json) {
63                 ast_ari_response_alloc_failed(response);
64                 return;
65         }
66
67         i = ao2_iterator_init(snapshots, 0);
68         while ((obj = ao2_iterator_next(&i))) {
69                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
70                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
71                 int r = ast_json_array_append(
72                         json, ast_endpoint_snapshot_to_json(snapshot));
73                 if (r != 0) {
74                         ast_ari_response_alloc_failed(response);
75                         return;
76                 }
77         }
78         ao2_iterator_destroy(&i);
79
80         ast_ari_response_ok(response, ast_json_ref(json));
81 }
82 void ast_ari_endpoints_list_by_tech(struct ast_variable *headers,
83         struct ast_ari_endpoints_list_by_tech_args *args,
84         struct ast_ari_response *response)
85 {
86         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
87         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
88         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
89         struct ao2_iterator i;
90         void *obj;
91
92         cache = ast_endpoint_cache();
93         if (!cache) {
94                 ast_ari_response_error(
95                         response, 500, "Internal Server Error",
96                         "Message bus not initialized");
97                 return;
98         }
99         ao2_ref(cache, +1);
100
101         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
102         if (!snapshots) {
103                 ast_ari_response_alloc_failed(response);
104                 return;
105         }
106
107         json = ast_json_array_create();
108         if (!json) {
109                 ast_ari_response_alloc_failed(response);
110                 return;
111         }
112
113         i = ao2_iterator_init(snapshots, 0);
114         while ((obj = ao2_iterator_next(&i))) {
115                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
116                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
117                 int r;
118
119                 if (strcmp(args->tech, snapshot->tech) != 0) {
120                         continue;
121                 }
122
123                 r = ast_json_array_append(
124                         json, ast_endpoint_snapshot_to_json(snapshot));
125                 if (r != 0) {
126                         ast_ari_response_alloc_failed(response);
127                         return;
128                 }
129         }
130         ao2_iterator_destroy(&i);
131
132         if (ast_json_array_size(json)) {
133                 ast_ari_response_ok(response, ast_json_ref(json));
134         } else {
135                 ast_ari_response_error(response, 404, "Not Found",
136                                        "No Endpoints found with tech %s", args->tech);
137         }
138 }
139 void ast_ari_endpoints_get(struct ast_variable *headers,
140         struct ast_ari_endpoints_get_args *args,
141         struct ast_ari_response *response)
142 {
143         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
144         RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
145
146         snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
147         if (!snapshot) {
148                 ast_ari_response_error(response, 404, "Not Found",
149                         "Endpoint not found");
150                 return;
151         }
152
153         json = ast_endpoint_snapshot_to_json(snapshot);
154         if (!json) {
155                 ast_ari_response_alloc_failed(response);
156                 return;
157         }
158
159         ast_ari_response_ok(response, ast_json_ref(json));
160 }