181ce7a503ef3fd53fde23c6a1b184d6fe04140b
[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         /* TODO - if tech isn't a recognized type of endpoint, it should 404 */
93
94         cache = ast_endpoint_cache();
95         if (!cache) {
96                 ast_ari_response_error(
97                         response, 500, "Internal Server Error",
98                         "Message bus not initialized");
99                 return;
100         }
101         ao2_ref(cache, +1);
102
103         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
104         if (!snapshots) {
105                 ast_ari_response_alloc_failed(response);
106                 return;
107         }
108
109         json = ast_json_array_create();
110         if (!json) {
111                 ast_ari_response_alloc_failed(response);
112                 return;
113         }
114
115         i = ao2_iterator_init(snapshots, 0);
116         while ((obj = ao2_iterator_next(&i))) {
117                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
118                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
119                 int r;
120
121                 if (strcmp(args->tech, snapshot->tech) != 0) {
122                         continue;
123                 }
124
125                 r = ast_json_array_append(
126                         json, ast_endpoint_snapshot_to_json(snapshot));
127                 if (r != 0) {
128                         ast_ari_response_alloc_failed(response);
129                         return;
130                 }
131         }
132         ao2_iterator_destroy(&i);
133
134         ast_ari_response_ok(response, ast_json_ref(json));
135 }
136 void ast_ari_endpoints_get(struct ast_variable *headers,
137         struct ast_ari_endpoints_get_args *args,
138         struct ast_ari_response *response)
139 {
140         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
141         RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
142
143         snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
144         if (!snapshot) {
145                 ast_ari_response_error(response, 404, "Not Found",
146                         "Endpoint not found");
147                 return;
148         }
149
150         json = ast_endpoint_snapshot_to_json(snapshot);
151         if (!json) {
152                 ast_ari_response_alloc_failed(response);
153                 return;
154         }
155
156         ast_ari_response_ok(response, ast_json_ref(json));
157 }