@DELETE @Produces({MediaType.APPLICATION_JSON}) @Path("{addressSpace}") public Response deleteAddressSpace(@Context SecurityContext securityContext, @PathParam("namespace") String namespace, @PathParam("addressSpace") String addressSpaceName) throws Exception { return doRequest("Error deleting address space " + addressSpaceName, () -> { verifyAuthorized(securityContext, namespace, ResourceVerb.delete); AddressSpace addressSpace = addressSpaceApi.getAddressSpaceWithName(namespace, addressSpaceName).orElse(null); if (addressSpace == null) { return Response.status(404).entity(Status.notFound("AddressSpace", addressSpaceName)).build(); } addressSpaceApi.deleteAddressSpace(addressSpace); return Response.ok(Status.successStatus(200, "AddressSpace", addressSpaceName, addressSpace.getMetadata().getUid())).build(); }); }
public void deleteAddresses(String namespace) { for (AddressSpace addressSpace : addressSpaceApi.listAddressSpaces(namespace)) { AddressApi addressApi = addressSpaceApi.withAddressSpace(addressSpace); addressApi.deleteAddresses(namespace); } } }
@GET @Produces({MediaType.APPLICATION_JSON}) public Response getAddressSpaceList(@Context SecurityContext securityContext, @HeaderParam("Accept") String acceptHeader, @PathParam("namespace") String namespace, @QueryParam("labelSelector") String labelSelector) throws Exception { return doRequest("Error getting address space list", () -> { verifyAuthorized(securityContext, namespace, ResourceVerb.list); Instant now = clock.instant(); if (labelSelector != null) { Map<String, String> labels = AddressApiHelper.parseLabelSelector(labelSelector); return Response.ok(formatResponse(acceptHeader, now, removeSecrets(addressSpaceApi.listAddressSpacesWithLabels(namespace, labels)))).build(); } else { return Response.ok(formatResponse(acceptHeader, now, removeSecrets(addressSpaceApi.listAddressSpaces(namespace)))).build(); } }); }
protected Collection<AddressSpace> getAddressSpaces(String namespace, String addressSpaceId) throws Exception { if (addressSpaceId == null) { if ( namespace == null || namespace.isEmpty() ) { return addressSpaceApi.listAllAddressSpaces(); } else { return addressSpaceApi.listAddressSpaces(namespace); } } else { return Collections.singleton(getAddressSpace(namespace, addressSpaceId)); } }
public Address deleteAddress(String namespace, String addressSpaceId, String name) throws Exception { AddressSpace addressSpace = getAddressSpace(namespace, addressSpaceId); AddressApi addressApi = addressSpaceApi.withAddressSpace(addressSpace); Optional<Address> addressOptional = addressApi.getAddressWithName(namespace, name); return addressOptional.filter(addressApi::deleteAddress).orElse(null); }
private AddressSpace getAddressSpace(String namespace, String addressSpaceId) throws Exception { return addressSpaceApi.getAddressSpaceWithName(namespace, addressSpaceId) .orElseThrow(() -> new NotFoundException("Address space " + addressSpaceId + " not found")); }
@POST @Consumes({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON}) public Response createAddressSpace(@Context SecurityContext securityContext, @Context UriInfo uriInfo, @PathParam("namespace") String namespace, @NotNull @Valid AddressSpace input) throws Exception { return doRequest("Error creating address space " + input.getMetadata().getName(), () -> { verifyAuthorized(securityContext, namespace, ResourceVerb.create); AddressSpace addressSpace = setAddressSpaceDefaults(securityContext, namespace, input, null); DefaultValidator.validate(addressSpace); AddressSpaceResolver addressSpaceResolver = new AddressSpaceResolver(schemaProvider.getSchema()); addressSpaceResolver.validate(addressSpace); addressSpaceApi.createAddressSpace(addressSpace); AddressSpace created = addressSpaceApi.getAddressSpaceWithName(namespace, addressSpace.getMetadata().getName()).orElse(addressSpace); UriBuilder builder = uriInfo.getAbsolutePathBuilder(); builder.path(created.getMetadata().getName()); return Response.created(builder.build()).entity(removeSecrets(created)).build(); }); }
@PUT @Consumes({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON}) @Path("{addressSpace}") public Response replaceAddressSpace(@Context SecurityContext securityContext, @PathParam("namespace") String namespace, @PathParam("addressSpace") String addressSpaceName, @NotNull @Valid AddressSpace payload) throws Exception { checkRequestBodyNotNull(payload); checkAddressSpaceObjectNameNotNull(payload, addressSpaceName); checkMatchingAddressSpaceName(addressSpaceName, payload); return doRequest("Error replacing address space " + payload.getMetadata().getName(), () -> { verifyAuthorized(securityContext, namespace, ResourceVerb.update); AddressSpace existing = addressSpaceApi.getAddressSpaceWithName(namespace, addressSpaceName).orElse(null); AddressSpace addressSpace = setAddressSpaceDefaults(securityContext, namespace, payload, existing); DefaultValidator.validate(addressSpace); AddressSpaceResolver addressSpaceResolver = new AddressSpaceResolver(schemaProvider.getSchema()); addressSpaceResolver.validate(addressSpace); if (!addressSpaceApi.replaceAddressSpace(addressSpace)) { return Response.status(404).entity(Status.notFound("AddressSpace", addressSpaceName)).build(); } AddressSpace replaced = addressSpaceApi.getAddressSpaceWithName(namespace, addressSpace.getMetadata().getName()).orElse(addressSpace); return Response.ok().entity(removeSecrets(replaced)).build(); }); }
public void start() throws Exception { checker = new ResourceChecker<>(this, recheckInterval); checker.start(); this.watch = addressSpaceApi.watchAddressSpaces(checker, resyncInterval); }
protected Optional<AddressSpace> findAddressSpaceByInstanceId(String serviceInstanceId) { return addressSpaceApi.listAddressSpacesWithLabels(namespace, Collections.singletonMap(LabelKeys.SERVICE_INSTANCE_ID, serviceInstanceId)).stream().findAny(); }
protected Optional<AddressSpace> findAddressSpaceByName(String name) { return addressSpaceApi.listAddressSpaces(namespace).stream().filter(a -> a.getMetadata().getName().equals(name)).findAny(); }
protected boolean deleteAddressSpace(AddressSpace addressSpace) { log.info("Deleting address space : {}", addressSpace.getMetadata().getName()); addressSpaceApi.deleteAddressSpace(addressSpace); return true; } }
@GET @Produces({MediaType.APPLICATION_JSON}) public Response getAddressSpaceList(@Context SecurityContext securityContext, @HeaderParam("Accept") String acceptHeader, @QueryParam("labelSelector") String labelSelector) throws Exception { return doRequest("Error getting address space list", () -> { verifyAuthorized(securityContext, ResourceVerb.list); Instant now = clock.instant(); if (labelSelector != null) { Map<String, String> labels = AddressApiHelper.parseLabelSelector(labelSelector); return Response.ok(formatResponse(acceptHeader, now, removeSecrets(addressSpaceApi.listAllAddressSpacesWithLabels(labels)))).build(); } else { return Response.ok(formatResponse(acceptHeader, now, removeSecrets(addressSpaceApi.listAllAddressSpaces()))).build(); } }); } }
addressSpaceApi.replaceAddressSpace(addressSpace); } catch (KubernetesClientException e) { log.warn("Error syncing address space {}", addressSpace.getMetadata().getName(), e);
protected AddressSpace createAddressSpace(String instanceId, String name, String type, String plan, String userId, String userName) throws Exception { AuthenticationService authService = new AuthenticationServiceBuilder() .withType(AuthenticationServiceType.STANDARD) .withDetails(Collections.emptyMap()) .build(); AddressSpace addressSpace = new AddressSpaceBuilder() .withNewMetadata() .withName(name) .addToAnnotations(AnnotationKeys.CREATED_BY, userName) .addToAnnotations(AnnotationKeys.CREATED_BY_UID, userId) .addToLabels(LabelKeys.SERVICE_INSTANCE_ID, instanceId) .endMetadata() .withNewSpec() .withType(type) .withPlan(plan) .withAuthenticationService(authService) .endSpec() .build(); addressSpace = setDefaults(addressSpace, namespace); addressSpaceApi.createAddressSpace(addressSpace); log.info("Created MaaS addressspace {}", addressSpace.getMetadata().getName()); return addressSpace; }
public AddressList getAllAddressesWithLabels(final Map<String, String> labels) throws Exception { return queryAddresses(addressSpaceApi.listAllAddressSpaces(), (ns, api) -> api.listAddressesWithLabels(ns, labels)); }
@DELETE @Produces({MediaType.APPLICATION_JSON}) public Response deleteAddressSpaces(@Context SecurityContext securityContext, @PathParam("namespace") String namespace) throws Exception { return doRequest("Error deleting address space s", () -> { verifyAuthorized(securityContext, namespace, ResourceVerb.delete); addressSpaceApi.deleteAddressSpaces(namespace); return Response.ok(Status.successStatus(200)).build(); }); }
protected AddressList queryAddresses(Collection<AddressSpace> addressSpaces, BiFunction<String, AddressApi, Collection<Address>> lister) throws Exception { final List<Address> list = new ArrayList<>(); for (final AddressSpace addressSpace : addressSpaces) { list.addAll(lister.apply(addressSpace.getMetadata().getNamespace(), addressSpaceApi.withAddressSpace(addressSpace))); } return new AddressList(list); }
@GET @Consumes({MediaType.APPLICATION_JSON}) @Produces({MediaType.APPLICATION_JSON}) @Path("{addressSpace}") public Response getConsole(@PathParam("addressSpace") String addressSpaceName) { return addressSpaceApi.getAddressSpaceWithName(namespace, addressSpaceName) .map(addressSpace -> getConsoleURL(addressSpace) .map(uri -> Response.temporaryRedirect(uri).build()) .orElse(Response.status(404).build())) .orElse(Response.status(404).build()); }
addressSpaceApi.watchAddressSpaces(resourceChecker, resyncInterval);