CNlucius | 5b2fff1 | 2015-08-20 14:13:46 +0800 | [diff] [blame] | 1 | /*
|
| 2 | * Copyright 2015 Open Networking Laboratory
|
| 3 | *
|
| 4 | * Licensed under the Apache License, Version 2.0 (the "License");
|
| 5 | * you may not use this file except in compliance with the License.
|
| 6 | * You may obtain a copy of the License at
|
| 7 | *
|
| 8 | * http://www.apache.org/licenses/LICENSE-2.0
|
| 9 | *
|
| 10 | * Unless required by applicable law or agreed to in writing, software
|
| 11 | * distributed under the License is distributed on an "AS IS" BASIS,
|
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| 13 | * See the License for the specific language governing permissions and
|
| 14 | * limitations under the License.
|
| 15 | */
|
| 16 | package org.onosproject.vtnweb.resources;
|
| 17 |
|
| 18 | import static com.google.common.base.Preconditions.checkNotNull;
|
jiangrui | bac6283 | 2015-08-25 20:30:16 +0800 | [diff] [blame] | 19 | import static com.google.common.base.Preconditions.checkArgument;
|
CNlucius | 5b2fff1 | 2015-08-20 14:13:46 +0800 | [diff] [blame] | 20 | import static javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
|
| 21 | import static javax.ws.rs.core.Response.Status.OK;
|
| 22 |
|
| 23 | import java.io.InputStream;
|
| 24 | import java.util.Collections;
|
| 25 | import java.util.HashSet;
|
| 26 | import java.util.Iterator;
|
| 27 | import java.util.Set;
|
| 28 | import java.util.concurrent.ConcurrentMap;
|
| 29 |
|
| 30 | import javax.ws.rs.Consumes;
|
| 31 | import javax.ws.rs.DELETE;
|
| 32 | import javax.ws.rs.GET;
|
| 33 | import javax.ws.rs.POST;
|
| 34 | import javax.ws.rs.PUT;
|
| 35 | import javax.ws.rs.Path;
|
| 36 | import javax.ws.rs.PathParam;
|
| 37 | import javax.ws.rs.Produces;
|
| 38 | import javax.ws.rs.QueryParam;
|
| 39 | import javax.ws.rs.core.MediaType;
|
| 40 | import javax.ws.rs.core.Response;
|
| 41 |
|
| 42 | import org.onlab.util.ItemNotFoundException;
|
| 43 | import org.onosproject.rest.AbstractWebResource;
|
| 44 | import org.onosproject.vtnrsc.DefaultTenantNetwork;
|
| 45 | import org.onosproject.vtnrsc.PhysicalNetwork;
|
| 46 | import org.onosproject.vtnrsc.SegmentationId;
|
| 47 | import org.onosproject.vtnrsc.TenantId;
|
| 48 | import org.onosproject.vtnrsc.TenantNetwork;
|
| 49 | import org.onosproject.vtnrsc.TenantNetworkId;
|
| 50 | import org.onosproject.vtnrsc.TenantNetwork.State;
|
| 51 | import org.onosproject.vtnrsc.TenantNetwork.Type;
|
| 52 | import org.onosproject.vtnrsc.tenantnetwork.TenantNetworkService;
|
| 53 | import org.onosproject.vtnrsc.web.TenantNetworkCodec;
|
| 54 | import org.slf4j.Logger;
|
| 55 | import org.slf4j.LoggerFactory;
|
| 56 |
|
| 57 | import com.fasterxml.jackson.databind.JsonNode;
|
| 58 | import com.fasterxml.jackson.databind.ObjectMapper;
|
| 59 | import com.fasterxml.jackson.databind.node.ObjectNode;
|
| 60 | import com.google.common.collect.Maps;
|
| 61 |
|
| 62 | /**
|
| 63 | * REST resource for interacting with the inventory of networks.
|
| 64 | */
|
| 65 | @Path("networks")
|
| 66 | public class TenantNetworkWebResource extends AbstractWebResource {
|
| 67 | public static final String NETWORK_NOT_FOUND = "Network is not found";
|
| 68 | public static final String NETWORK_ID_EXIST = "Network id is existed";
|
| 69 | public static final String NETWORK_ID_NOT_EXIST = "Network id is not existed";
|
| 70 | public static final String CREATE_NETWORK = "create network";
|
| 71 | public static final String UPDATE_NETWORK = "update network";
|
| 72 | public static final String DELETE_NETWORK = "delete network";
|
| 73 | public static final String JSON_NOT_NULL = "JsonNode can not be null";
|
| 74 |
|
| 75 | protected static final Logger log = LoggerFactory
|
| 76 | .getLogger(TenantNetworkWebResource.class);
|
| 77 | private final ConcurrentMap<TenantNetworkId, TenantNetwork> networksMap = Maps
|
| 78 | .newConcurrentMap();
|
| 79 |
|
| 80 | @GET
|
| 81 | @Produces({ MediaType.APPLICATION_JSON })
|
| 82 | public Response getNetworks(@QueryParam("id") String queryId,
|
| 83 | @QueryParam("name") String queryName,
|
| 84 | @QueryParam("admin_state_up") String queryadminStateUp,
|
| 85 | @QueryParam("status") String querystate,
|
| 86 | @QueryParam("shared") String queryshared,
|
| 87 | @QueryParam("tenant_id") String querytenantId,
|
| 88 | @QueryParam("router:external") String routerExternal,
|
| 89 | @QueryParam("provider:network_type") String type,
|
| 90 | @QueryParam("provider:physical_network") String physicalNetwork,
|
| 91 | @QueryParam("provider:segmentation_id") String segmentationId) {
|
| 92 | Iterable<TenantNetwork> networks = get(TenantNetworkService.class)
|
| 93 | .getNetworks();
|
| 94 | Iterator<TenantNetwork> networkors = networks.iterator();
|
| 95 | while (networkors.hasNext()) {
|
| 96 | TenantNetwork network = networkors.next();
|
| 97 | if ((queryId == null || queryId.equals(network.id().toString()))
|
| 98 | && (queryName == null || queryName.equals(network.name()
|
| 99 | .toString()))
|
| 100 | && (queryadminStateUp == null || queryadminStateUp
|
| 101 | .equals(network.adminStateUp()))
|
| 102 | && (querystate == null || querystate.equals(network.state()
|
| 103 | .toString()))
|
| 104 | && (queryshared == null || queryshared.equals(network
|
| 105 | .shared()))
|
| 106 | && (querytenantId == null || querytenantId.equals(network
|
| 107 | .tenantId().toString()))
|
| 108 | && (routerExternal == null || routerExternal.equals(network
|
| 109 | .routerExternal()))
|
| 110 | && (type == null || type.equals(network.type()))
|
| 111 | && (physicalNetwork == null || physicalNetwork
|
| 112 | .equals(network.physicalNetwork()))
|
| 113 | && (segmentationId == null || segmentationId.equals(network
|
| 114 | .segmentationId()))) {
|
| 115 | networksMap.putIfAbsent(network.id(), network);
|
| 116 | }
|
| 117 | }
|
| 118 | networks = Collections.unmodifiableCollection(networksMap.values());
|
| 119 | ObjectNode result = new ObjectMapper().createObjectNode();
|
| 120 | result.set("networks", new TenantNetworkCodec().encode(networks, this));
|
| 121 |
|
| 122 | return ok(result.toString()).build();
|
| 123 | }
|
| 124 |
|
| 125 | private State isState(String state) {
|
| 126 | if (state.equals("ACTIVE")) {
|
| 127 | return TenantNetwork.State.ACTIVE;
|
| 128 | } else if (state.equals("BUILD")) {
|
| 129 | return TenantNetwork.State.BUILD;
|
| 130 | } else if (state.equals("DOWN")) {
|
| 131 | return TenantNetwork.State.DOWN;
|
| 132 | } else if (state.equals("ERROR")) {
|
| 133 | return TenantNetwork.State.ERROR;
|
| 134 | } else {
|
| 135 | return null;
|
| 136 | }
|
| 137 | }
|
| 138 |
|
| 139 | private Type isType(String type) {
|
| 140 | if (type.equals("LOCAL")) {
|
| 141 | return TenantNetwork.Type.LOCAL;
|
| 142 | } else {
|
| 143 | return null;
|
| 144 | }
|
| 145 | }
|
| 146 |
|
| 147 | @GET
|
| 148 | @Path("{id}")
|
| 149 | @Produces({ MediaType.APPLICATION_JSON })
|
| 150 | public Response getNetwork(@PathParam("id") String id) {
|
| 151 |
|
| 152 | if (!get(TenantNetworkService.class).exists(TenantNetworkId
|
| 153 | .networkId(id))) {
|
| 154 | return ok("The tenantNetwork does not exists").build();
|
| 155 | }
|
| 156 | TenantNetwork network = nullIsNotFound(get(TenantNetworkService.class)
|
| 157 | .getNetwork(TenantNetworkId.networkId(id)), NETWORK_NOT_FOUND);
|
| 158 | ObjectNode result = new ObjectMapper().createObjectNode();
|
| 159 | result.set("network", new TenantNetworkCodec().encode(network, this));
|
| 160 |
|
| 161 | return ok(result.toString()).build();
|
| 162 |
|
| 163 | }
|
| 164 |
|
| 165 | @POST
|
| 166 | @Produces(MediaType.APPLICATION_JSON)
|
| 167 | @Consumes(MediaType.APPLICATION_JSON)
|
| 168 | public Response createNetworks(InputStream input) {
|
| 169 | try {
|
| 170 | ObjectMapper mapper = new ObjectMapper();
|
| 171 | JsonNode cfg = mapper.readTree(input);
|
| 172 | JsonNode nodes = null;
|
| 173 | Iterable<TenantNetwork> networks = null;
|
| 174 | if (cfg.get("network") != null) {
|
| 175 | nodes = cfg.get("network");
|
| 176 | if (nodes.isArray()) {
|
| 177 | networks = changeJson2objs(nodes);
|
| 178 | } else {
|
| 179 | networks = changeJson2obj(CREATE_NETWORK, null, nodes);
|
| 180 | }
|
| 181 | } else if (cfg.get("networks") != null) {
|
| 182 | nodes = cfg.get("networks");
|
| 183 | networks = changeJson2objs(nodes);
|
| 184 | }
|
| 185 | Boolean issuccess = nullIsNotFound((get(TenantNetworkService.class)
|
| 186 | .createNetworks(networks)),
|
| 187 | NETWORK_NOT_FOUND);
|
| 188 |
|
| 189 | if (!issuccess) {
|
| 190 | return Response.status(INTERNAL_SERVER_ERROR)
|
| 191 | .entity(NETWORK_ID_EXIST).build();
|
| 192 | }
|
| 193 | return Response.status(OK).entity(issuccess.toString()).build();
|
| 194 | } catch (Exception e) {
|
| 195 | log.error("Creates tenantNetwork exception {}.", e.toString());
|
| 196 | return Response.status(INTERNAL_SERVER_ERROR).entity(e.toString())
|
| 197 | .build();
|
| 198 | }
|
| 199 | }
|
| 200 |
|
| 201 | @PUT
|
| 202 | @Path("{id}")
|
| 203 | @Produces(MediaType.APPLICATION_JSON)
|
| 204 | @Consumes(MediaType.APPLICATION_JSON)
|
| 205 | public Response updateNetworks(@PathParam("id") String id, InputStream input) {
|
| 206 | try {
|
| 207 | ObjectMapper mapper = new ObjectMapper();
|
| 208 | JsonNode cfg = mapper.readTree(input);
|
| 209 | JsonNode nodes = null;
|
| 210 | Iterable<TenantNetwork> networks = null;
|
| 211 | if (cfg.get("network") != null) {
|
| 212 | nodes = cfg.get("network");
|
| 213 | if (nodes.isArray()) {
|
| 214 | networks = changeJson2objs(nodes);
|
| 215 | } else {
|
| 216 | networks = changeJson2obj(UPDATE_NETWORK,
|
| 217 | TenantNetworkId.networkId(id),
|
| 218 | nodes);
|
| 219 | }
|
| 220 | } else if (cfg.get("networks") != null) {
|
| 221 | nodes = cfg.get("networks");
|
| 222 | networks = changeJson2objs(nodes);
|
| 223 | }
|
| 224 | Boolean issuccess = nullIsNotFound((get(TenantNetworkService.class)
|
| 225 | .updateNetworks(networks)),
|
| 226 | NETWORK_NOT_FOUND);
|
| 227 | if (!issuccess) {
|
| 228 | return Response.status(INTERNAL_SERVER_ERROR)
|
| 229 | .entity(NETWORK_ID_NOT_EXIST).build();
|
| 230 | }
|
| 231 | return Response.status(OK).entity(issuccess.toString()).build();
|
| 232 | } catch (Exception e) {
|
| 233 | log.error("Updates tenantNetwork failed because of exception {}.",
|
| 234 | e.toString());
|
| 235 | return Response.status(INTERNAL_SERVER_ERROR).entity(e.toString())
|
| 236 | .build();
|
| 237 | }
|
| 238 | }
|
| 239 |
|
| 240 | @DELETE
|
| 241 | @Path("{id}")
|
| 242 | public Response deleteNetworks(@PathParam("id") String id) {
|
| 243 | log.debug("Deletes network by identifier {}.", id);
|
| 244 | Set<TenantNetworkId> networkSet = new HashSet<TenantNetworkId>();
|
| 245 | networkSet.add(TenantNetworkId.networkId(id));
|
| 246 | Boolean issuccess = nullIsNotFound(get(TenantNetworkService.class)
|
| 247 | .removeNetworks(networkSet), NETWORK_NOT_FOUND);
|
| 248 | if (!issuccess) {
|
| 249 | log.debug("Network identifier {} is not existed", id);
|
| 250 | return Response.status(INTERNAL_SERVER_ERROR)
|
| 251 | .entity(NETWORK_ID_NOT_EXIST).build();
|
| 252 | }
|
| 253 | return Response.status(OK).entity(issuccess.toString()).build();
|
| 254 | }
|
| 255 |
|
| 256 | /**
|
| 257 | * Returns a collection of tenantNetworks.
|
| 258 | *
|
| 259 | * @param flag the flag
|
| 260 | * @param networkId network identifier
|
| 261 | * @param node the network json node
|
| 262 | * @return a collection of tenantNetworks
|
| 263 | */
|
| 264 | public Iterable<TenantNetwork> changeJson2obj(String flag,
|
| 265 | TenantNetworkId networkId,
|
| 266 | JsonNode node) {
|
| 267 | checkNotNull(node, JSON_NOT_NULL);
|
| 268 | TenantNetwork network = null;
|
| 269 | ConcurrentMap<TenantNetworkId, TenantNetwork> networksMap = Maps
|
| 270 | .newConcurrentMap();
|
| 271 | if (node != null) {
|
jiangrui | f4da26c | 2015-08-26 13:03:40 +0800 | [diff] [blame] | 272 | checkArgument(node.get("admin_state_up").isBoolean(), "admin_state_up should be boolean");
|
| 273 | checkArgument(node.get("shared").isBoolean(), "shared should be boolean");
|
| 274 | checkArgument(node.get("router:external").isBoolean(), "router:external should be boolean");
|
CNlucius | 5b2fff1 | 2015-08-20 14:13:46 +0800 | [diff] [blame] | 275 | String name = node.get("name").asText();
|
| 276 | boolean adminStateUp = node.get("admin_state_up").asBoolean();
|
| 277 | String state = node.get("status").asText();
|
| 278 | boolean shared = node.get("shared").asBoolean();
|
| 279 | String tenantId = node.get("tenant_id").asText();
|
| 280 | boolean routerExternal = node.get("router:external").asBoolean();
|
| 281 | String type = node.get("provider:network_type").asText();
|
| 282 | String physicalNetwork = node.get("provider:physical_network")
|
| 283 | .asText();
|
| 284 | String segmentationId = node.get("provider:segmentation_id")
|
| 285 | .asText();
|
| 286 | TenantNetworkId id = null;
|
| 287 | if (flag == CREATE_NETWORK) {
|
| 288 | id = TenantNetworkId.networkId(node.get("id").asText());
|
| 289 | } else if (flag == UPDATE_NETWORK) {
|
| 290 | id = networkId;
|
| 291 | }
|
| 292 | network = new DefaultTenantNetwork(
|
| 293 | id,
|
| 294 | name,
|
| 295 | adminStateUp,
|
| 296 | isState(state),
|
| 297 | shared,
|
| 298 | TenantId.tenantId(tenantId),
|
| 299 | routerExternal,
|
| 300 | isType(type),
|
| 301 | PhysicalNetwork
|
| 302 | .physicalNetwork(physicalNetwork),
|
| 303 | SegmentationId
|
| 304 | .segmentationId(segmentationId));
|
| 305 | networksMap.putIfAbsent(id, network);
|
| 306 | }
|
| 307 | return Collections.unmodifiableCollection(networksMap.values());
|
| 308 | }
|
| 309 |
|
| 310 | /**
|
| 311 | * Returns a collection of tenantNetworks.
|
| 312 | *
|
| 313 | * @param nodes the network jsonnodes
|
| 314 | * @return a collection of tenantNetworks
|
| 315 | */
|
| 316 | public Iterable<TenantNetwork> changeJson2objs(JsonNode nodes) {
|
| 317 | checkNotNull(nodes, JSON_NOT_NULL);
|
| 318 | TenantNetwork network = null;
|
| 319 | ConcurrentMap<TenantNetworkId, TenantNetwork> networksMap = Maps
|
| 320 | .newConcurrentMap();
|
| 321 | if (nodes != null) {
|
| 322 | for (JsonNode node : nodes) {
|
| 323 | String id = node.get("id").asText();
|
| 324 | String name = node.get("name").asText();
|
| 325 | boolean adminStateUp = node.get("admin_state_up").asBoolean();
|
| 326 | String state = node.get("status").asText();
|
| 327 | boolean shared = node.get("shared").asBoolean();
|
| 328 | String tenantId = node.get("tenant_id").asText();
|
| 329 | boolean routerExternal = node.get("router:external")
|
| 330 | .asBoolean();
|
| 331 | String type = node.get("provider:network_type").asText();
|
| 332 | String physicalNetwork = node.get("provider:physical_network")
|
| 333 | .asText();
|
| 334 | String segmentationId = node.get("provider:segmentation_id")
|
| 335 | .asText();
|
| 336 | network = new DefaultTenantNetwork(
|
| 337 | TenantNetworkId
|
| 338 | .networkId(id),
|
| 339 | name,
|
| 340 | adminStateUp,
|
| 341 | isState(state),
|
| 342 | shared,
|
| 343 | TenantId.tenantId(tenantId),
|
| 344 | routerExternal,
|
| 345 | isType(type),
|
| 346 | PhysicalNetwork
|
| 347 | .physicalNetwork(physicalNetwork),
|
| 348 | SegmentationId
|
| 349 | .segmentationId(segmentationId));
|
| 350 | networksMap.putIfAbsent(TenantNetworkId.networkId(id), network);
|
| 351 | }
|
| 352 | }
|
| 353 | return Collections.unmodifiableCollection(networksMap.values());
|
| 354 | }
|
| 355 |
|
| 356 | /**
|
| 357 | * Returns the specified item if that items is null; otherwise throws not
|
| 358 | * found exception.
|
| 359 | *
|
| 360 | * @param item item to check
|
| 361 | * @param <T> item type
|
| 362 | * @param message not found message
|
| 363 | * @return item if not null
|
| 364 | * @throws org.onlab.util.ItemNotFoundException if item is null
|
| 365 | */
|
| 366 | protected <T> T nullIsNotFound(T item, String message) {
|
| 367 | if (item == null) {
|
| 368 | throw new ItemNotFoundException(message);
|
| 369 | }
|
| 370 | return item;
|
| 371 | }
|
| 372 | }
|