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 #include "asterisk/channel.h"
36
37 void ast_ari_endpoints_list(struct ast_variable *headers,
38         struct ast_ari_endpoints_list_args *args,
39         struct ast_ari_response *response)
40 {
41         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
42         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
43         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
44         struct ao2_iterator i;
45         void *obj;
46
47         cache = ast_endpoint_cache();
48         if (!cache) {
49                 ast_ari_response_error(
50                         response, 500, "Internal Server Error",
51                         "Message bus not initialized");
52                 return;
53         }
54         ao2_ref(cache, +1);
55
56         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
57         if (!snapshots) {
58                 ast_ari_response_alloc_failed(response);
59                 return;
60         }
61
62         json = ast_json_array_create();
63         if (!json) {
64                 ast_ari_response_alloc_failed(response);
65                 return;
66         }
67
68         i = ao2_iterator_init(snapshots, 0);
69         while ((obj = ao2_iterator_next(&i))) {
70                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
71                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
72                 int r = ast_json_array_append(
73                         json, ast_endpoint_snapshot_to_json(snapshot));
74                 if (r != 0) {
75                         ast_ari_response_alloc_failed(response);
76                         return;
77                 }
78         }
79         ao2_iterator_destroy(&i);
80
81         ast_ari_response_ok(response, ast_json_ref(json));
82 }
83 void ast_ari_endpoints_list_by_tech(struct ast_variable *headers,
84         struct ast_ari_endpoints_list_by_tech_args *args,
85         struct ast_ari_response *response)
86 {
87         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
88         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
89         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
90         struct ao2_iterator i;
91         void *obj;
92
93         if (!ast_get_channel_tech(args->tech)) {
94                 ast_ari_response_error(response, 404, "Not Found",
95                                        "No Endpoints found - invalid tech %s", args->tech);
96                 return;
97         }
98
99         cache = ast_endpoint_cache();
100         if (!cache) {
101                 ast_ari_response_error(
102                         response, 500, "Internal Server Error",
103                         "Message bus not initialized");
104                 return;
105         }
106         ao2_ref(cache, +1);
107
108         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
109         if (!snapshots) {
110                 ast_ari_response_alloc_failed(response);
111                 return;
112         }
113
114         json = ast_json_array_create();
115         if (!json) {
116                 ast_ari_response_alloc_failed(response);
117                 return;
118         }
119
120         i = ao2_iterator_init(snapshots, 0);
121         while ((obj = ao2_iterator_next(&i))) {
122                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
123                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
124                 int r;
125
126                 if (strcasecmp(args->tech, snapshot->tech) != 0) {
127                         continue;
128                 }
129
130                 r = ast_json_array_append(
131                         json, ast_endpoint_snapshot_to_json(snapshot));
132                 if (r != 0) {
133                         ast_ari_response_alloc_failed(response);
134                         return;
135                 }
136         }
137         ao2_iterator_destroy(&i);
138         ast_ari_response_ok(response, ast_json_ref(json));
139 }
140 void ast_ari_endpoints_get(struct ast_variable *headers,
141         struct ast_ari_endpoints_get_args *args,
142         struct ast_ari_response *response)
143 {
144         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
145         RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
146
147         snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
148         if (!snapshot) {
149                 ast_ari_response_error(response, 404, "Not Found",
150                         "Endpoint not found");
151                 return;
152         }
153
154         json = ast_endpoint_snapshot_to_json(snapshot);
155         if (!json) {
156                 ast_ari_response_alloc_failed(response);
157                 return;
158         }
159
160         ast_ari_response_ok(response, ast_json_ref(json));
161 }