cf.spring.ServiceBrokerHandler.java Source code

Introduction

Here is the source code for cf.spring.ServiceBrokerHandler.java

Source

/*
 *   Copyright (c) 2013 Intellectual Reserve, Inc.  All rights reserved.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 */
package cf.spring;

import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StreamUtils;
import org.springframework.web.HttpRequestHandler;
import org.springframework.web.servlet.handler.AbstractUrlHandlerMapping;

import cf.service.AuthenticationException;
import cf.service.BadRequestException;
import cf.service.Provisioner;
import cf.service.ResourceNotFoundException;
import cf.service.ServiceBroker;
import cf.service.ServiceBrokerException;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * @author Mike Heath <elcapo@gmail.com>
 * @deprecated Use the V2 services.
 */
public class ServiceBrokerHandler extends AbstractUrlHandlerMapping {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceBrokerHandler.class);

    public static class ServiceBrokerHandlerBuilder {
        private final ServiceBroker serviceBroker;
        private int order = 0;

        public ServiceBrokerHandlerBuilder(ServiceBroker serviceBroker) {
            this.serviceBroker = serviceBroker;
        }

        public ServiceBrokerHandlerBuilder(Provisioner provisioner, String authToken) {
            this.serviceBroker = new ServiceBroker(provisioner, authToken);
        }

        public ServiceBrokerHandlerBuilder order(int order) {
            this.order = order;
            return this;
        }

        public ServiceBrokerHandler build() {
            return new ServiceBrokerHandler(this);
        }

    }

    private final ServiceBroker serviceBroker;
    private final ObjectMapper objectMapper = new ObjectMapper();

    private ServiceBrokerHandler(ServiceBrokerHandlerBuilder builder) {
        this.serviceBroker = builder.serviceBroker;
        setOrder(builder.order);
        registerHandlers();
    }

    private void registerHandlers() {
        // Create service
        registerHandler("/gateway/v1/configurations", new RequestHandler("POST") {
            @Override
            protected String handleRequest(HttpServletRequest request, HttpServletResponse response,
                    String authToken, byte[] body) throws ServiceBrokerException {
                return serviceBroker.createService(authToken, body);
            }
        });

        registerHandler("/gateway/v1/configurations/**", new RequestHandler("DELETE", "POST") {
            @Override
            protected String handleRequest(HttpServletRequest request, HttpServletResponse response,
                    String authToken, byte[] body) throws ServiceBrokerException {
                final String requestUri = request.getRequestURI();
                final Matcher bindingMatcher = ServiceBroker.BINDING_PATTERN.matcher(requestUri);
                if (bindingMatcher.matches()) {
                    switch (request.getMethod()) {
                    case "DELETE":
                        return serviceBroker.unbindService(authToken, requestUri);
                    case "POST":
                        return serviceBroker.bindService(authToken, body);
                    }
                }
                final Matcher instanceMatcher = ServiceBroker.INSTANCE_PATTERN.matcher(requestUri);
                if (instanceMatcher.matches() && "DELETE".equals(request.getMethod())) {
                    return serviceBroker.deleteService(authToken, requestUri);
                }
                throw new ResourceNotFoundException();
            }
        });

    }

    private abstract class RequestHandler implements HttpRequestHandler {

        private final Set<String> allowedHttpMethods = new HashSet<>();

        public RequestHandler(String... allowedHttpMethods) {
            Collections.addAll(this.allowedHttpMethods, allowedHttpMethods);
        }

        @Override
        public final void handleRequest(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            if (!allowedHttpMethods.contains(request.getMethod())) {
                response.setStatus(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
                return;
            }
            final String authToken = request.getHeader(ServiceBroker.VCAP_SERVICE_TOKEN_HEADER);
            final byte[] body = StreamUtils.copyToByteArray(request.getInputStream());
            try {
                String responseBody = handleRequest(request, response, authToken, body);
                response.setContentType("application/json;charset=utf-8");
                response.getWriter().write(responseBody);
            } catch (AuthenticationException e) {
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                objectMapper.writeValue(response.getWriter(),
                        objectMapper.createObjectNode().put("description", e.getMessage()));
            } catch (BadRequestException e) {
                response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
                objectMapper.writeValue(response.getWriter(),
                        objectMapper.createObjectNode().put("description", e.getMessage()));
            } catch (ResourceNotFoundException e) {
                response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                objectMapper.writeValue(response.getWriter(),
                        objectMapper.createObjectNode().put("description", e.getMessage()));
            } catch (ServiceBrokerException e) {
                LOGGER.error("Unexpected Error", e);
                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                objectMapper.writeValue(response.getWriter(),
                        objectMapper.createObjectNode().put("description", e.getMessage()));
            } catch (Exception e) {
                LOGGER.error("Unexpected Error", e);
                response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                objectMapper.writeValue(response.getWriter(),
                        objectMapper.createObjectNode().put("description", e.getMessage()));
            }
        }

        protected abstract String handleRequest(HttpServletRequest request, HttpServletResponse response,
                String authToken, byte[] body) throws ServiceBrokerException;

    }

}