Java tutorial
/* * Copyright (c) 2012. Piraso Alvin R. de Leon. All Rights Reserved. * * See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The Piraso licenses this file to You 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 org.piraso.server.spring.web; import org.apache.commons.lang.Validate; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.piraso.api.JacksonUtils; import org.piraso.api.entry.Entry; import org.piraso.api.entry.RawEntry; import org.piraso.server.PirasoContextIDGenerator; import org.piraso.server.service.*; import org.piraso.web.base.PirasoHttpServletRequest; import org.piraso.web.base.PirasoHttpServletResponse; import org.springframework.web.HttpRequestHandler; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; import java.util.Map; import static org.piraso.api.PirasoConstants.*; /** * Entry point for requesting a starting and stopping log monitor activity. */ public class PirasoServlet implements HttpRequestHandler { /** * final class logging instance. */ private static final Log LOG = LogFactory.getLog(PirasoServlet.class); public static final long DEFAULT_STOP_TIMEOUT = 10000l; private Integer maxQueueForceKillSize; private Long maxIdleTimeout; private Long stopTimeout = DEFAULT_STOP_TIMEOUT; private String version; public void setVersion(String version) { this.version = version; } public void setMaxIdleTimeout(Long maxIdleTimeout) { this.maxIdleTimeout = maxIdleTimeout; } public void setMaxQueueForceKillSize(Integer maxQueueForceKillSize) { this.maxQueueForceKillSize = maxQueueForceKillSize; } public void setStopTimeout(Long stopTimeout) { this.stopTimeout = stopTimeout; } public UserRegistry getRegistry() { return (UserRegistry) LoggerRegistrySingleton.INSTANCE.getRegistry(); } private void writeResponse(HttpServletResponse response, String contentType, String str) throws IOException { PrintWriter out = response.getWriter(); try { response.setContentType(contentType); response.setCharacterEncoding(ENCODING_UTF_8); out.write(str); out.flush(); } finally { out.close(); } } public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { if (request.getParameter(SERVICE_PARAMETER) == null) { response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Request Parameter 'service' is required."); return; } User user = getRegistry().createOrGetUser(new PirasoHttpServletRequest(request)); if (SERVICE_GET_REGISTRY_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { retrieveRegistry(response); } else if (SERVICE_LOG_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { log(request); writeResponse(response, PLAIN_CONTENT_TYPE, "OK"); } else if (SERVICE_REQUEST_ID_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { writeResponse(response, PLAIN_CONTENT_TYPE, String.valueOf(PirasoContextIDGenerator.INSTANCE.next())); } else if (SERVICE_START_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { startLoggerService(request, response, user); } else if (SERVICE_STOP_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { stopService(response, user); writeResponse(response, PLAIN_CONTENT_TYPE, "OK"); } else if (SERVICE_TEST_PARAMETER_VALUE.equals(request.getParameter(SERVICE_PARAMETER))) { writeResponse(response, JSON_CONTENT_TYPE, String.format( "{\"status\":\"%s\", \"version\":\"%s\", \"bridgeSupported\": true}", STATUS_OK, version)); } else { response.sendError(HttpServletResponse.SC_BAD_REQUEST, String.format("Request Parameter 'service' with value '%s' is invalid.", request.getParameter(SERVICE_PARAMETER))); } } private void retrieveRegistry(HttpServletResponse response) throws IOException { BridgeRegistry bridgeRegistry = new BridgeRegistry(); for (Map.Entry<User, ResponseLoggerService> entry : getRegistry().getUserLoggerMap().entrySet()) { bridgeRegistry.addLogger(new BridgeLogger(entry.getValue())); } writeResponse(response, JSON_CONTENT_TYPE, JacksonUtils.MAPPER.writeValueAsString(bridgeRegistry)); } private void log(HttpServletRequest request) throws IOException { String userContent = request.getParameter(USER_PARAMETER); String requestId = request.getParameter(ENTRY_REQUEST_ID_PARAMETER); String entryContent = request.getParameter(ENTRY_PARAMETER); String entryClassName = request.getParameter(ENTRY_CLASS_NAME_PARAMETER); Validate.notNull(userContent, "userContent should not be null."); User user = JacksonUtils.MAPPER.readValue(userContent, User.class); ResponseLoggerService service = getRegistry().getLogger(user); if (service != null && service.isAlive()) { Validate.notNull(entryContent, "entryContent should not be null."); Validate.notNull(entryClassName, "entryClassName should not be null."); Entry entry = new RawEntry(Long.valueOf(requestId), entryClassName, entryContent); service.log(entry); } } private void stopService(HttpServletResponse response, User user) throws IOException { ResponseLoggerService service = getRegistry().getLogger(user); if (service == null) { response.sendError(HttpServletResponse.SC_NOT_FOUND, String.format("Service for user '%s' not found.", user.toString())); return; } if (!service.isAlive()) { response.sendError(HttpServletResponse.SC_CONFLICT, String.format("Service for user '%s' not active.", user.toString())); getRegistry().removeUser(user); return; } try { // gracefully stop the service service.stopAndWait(stopTimeout); if (service.isAlive()) { response.sendError(HttpServletResponse.SC_REQUEST_TIMEOUT, String.format("Service for user '%s' stop timeout.", user.toString())); } } catch (InterruptedException ignored) { } } private void startLoggerService(HttpServletRequest request, HttpServletResponse response, User user) throws IOException, ServletException { ResponseLoggerServiceImpl service = new ResponseLoggerServiceImpl(user, new PirasoHttpServletRequest(request), new PirasoHttpServletResponse(response)); if (maxQueueForceKillSize != null) { service.setMaxQueueForceKillSize(maxQueueForceKillSize); } if (maxIdleTimeout != null) { service.setMaxIdleTimeout(maxIdleTimeout); } try { getRegistry().associate(user, service); service.start(); } catch (Exception e) { LOG.warn(e.getMessage(), e); } finally { getRegistry().removeUser(user); } } }