Java tutorial
/** * This file is part of Waarp Project (named also Waarp or GG). * * Copyright 2009, Frederic Bregier, and individual contributors by the @author * tags. See the COPYRIGHT.txt in the distribution for a full listing of * individual contributors. * * All Waarp Project is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or (at your * option) any later version. * * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with * Waarp . If not, see <http://www.gnu.org/licenses/>. */ package org.waarp.openr66.protocol.http.rest; import java.net.InetSocketAddress; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.http.HttpResponseStatus; import org.waarp.common.command.exception.Reply421Exception; import org.waarp.common.command.exception.Reply530Exception; import org.waarp.common.database.DbSession; import org.waarp.common.database.exception.WaarpDatabaseException; import org.waarp.common.database.exception.WaarpDatabaseNoConnectionException; import org.waarp.common.digest.FilesystemBasedDigest; import org.waarp.common.logging.WaarpLogger; import org.waarp.common.logging.WaarpLoggerFactory; import org.waarp.common.utility.WaarpNettyUtil; import org.waarp.common.utility.WaarpStringUtils; import org.waarp.gateway.kernel.exception.HttpInvalidAuthenticationException; import org.waarp.gateway.kernel.rest.HttpRestHandler; import org.waarp.gateway.kernel.rest.RestConfiguration; import org.waarp.openr66.context.R66Session; import org.waarp.openr66.database.DbConstant; import org.waarp.openr66.database.data.DbHostAuth; import org.waarp.openr66.protocol.configuration.Configuration; import org.waarp.openr66.protocol.http.rest.handler.DbConfigurationR66RestMethodHandler; import org.waarp.openr66.protocol.http.rest.handler.DbHostAuthR66RestMethodHandler; import org.waarp.openr66.protocol.http.rest.handler.DbHostConfigurationR66RestMethodHandler; import org.waarp.openr66.protocol.http.rest.handler.DbRuleR66RestMethodHandler; import org.waarp.openr66.protocol.http.rest.handler.DbTaskRunnerR66RestMethodHandler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestBandwidthR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestBusinessR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestConfigR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestInformationR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestLogR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestServerR66Handler; import org.waarp.openr66.protocol.http.rest.handler.HttpRestControlR66Handler; import org.waarp.openr66.protocol.localhandler.ServerActions; /** * Handler for Rest HTTP support for R66 * * @author Frederic Bregier * */ public class HttpRestR66Handler extends HttpRestHandler { /** * Internal Logger */ private static final WaarpLogger logger = WaarpLoggerFactory.getLogger(HttpRestR66Handler.class); private static HashMap<String, DbSession> dbSessionFromUser = new HashMap<String, DbSession>(); public static enum RESTHANDLERS { DbHostAuth(DbHostAuthR66RestMethodHandler.BASEURI, org.waarp.openr66.database.data.DbHostAuth.class), DbRule(DbRuleR66RestMethodHandler.BASEURI, org.waarp.openr66.database.data.DbRule.class), DbTaskRunner( DbTaskRunnerR66RestMethodHandler.BASEURI, org.waarp.openr66.database.data.DbTaskRunner.class), DbHostConfiguration( DbHostConfigurationR66RestMethodHandler.BASEURI, org.waarp.openr66.database.data.DbHostConfiguration.class), DbConfiguration( DbConfigurationR66RestMethodHandler.BASEURI, org.waarp.openr66.database.data.DbConfiguration.class), Bandwidth( HttpRestBandwidthR66Handler.BASEURI, null), Business(HttpRestBusinessR66Handler.BASEURI, null), Config(HttpRestConfigR66Handler.BASEURI, null), Information( HttpRestInformationR66Handler.BASEURI, null), Log( HttpRestLogR66Handler.BASEURI, null), Server( HttpRestServerR66Handler.BASEURI, null), Control( HttpRestControlR66Handler.BASEURI, null); public String uri; @SuppressWarnings("rawtypes") public Class clasz; @SuppressWarnings("rawtypes") RESTHANDLERS(String uri, Class clasz) { this.uri = uri; this.clasz = clasz; } public static RESTHANDLERS getRESTHANDLER(String baseUri) { for (RESTHANDLERS resthandler : RESTHANDLERS.values()) { if (resthandler.uri.equals(baseUri)) { return resthandler; } } return null; } } /** * To be called once to ensure default is built */ public static void defaultHandlers() { synchronized (defaultConfiguration) { if (defaultConfiguration.restHashMap.isEmpty()) { defaultConfiguration.REST_AUTHENTICATED = true; defaultConfiguration.RESTHANDLERS_CRUD = new byte[RESTHANDLERS.values().length]; for (int i = 0; i < defaultConfiguration.RESTHANDLERS_CRUD.length; i++) { defaultConfiguration.RESTHANDLERS_CRUD[i] = 0x0F; } METHOD[] methods = METHOD.values(); defaultConfiguration.restHashMap.put(RESTHANDLERS.DbTaskRunner.uri, new DbTaskRunnerR66RestMethodHandler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.DbHostAuth.uri, new DbHostAuthR66RestMethodHandler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.DbRule.uri, new DbRuleR66RestMethodHandler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.DbHostConfiguration.uri, new DbHostConfigurationR66RestMethodHandler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.DbConfiguration.uri, new DbConfigurationR66RestMethodHandler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Bandwidth.uri, new HttpRestBandwidthR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Business.uri, new HttpRestBusinessR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Config.uri, new HttpRestConfigR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Information.uri, new HttpRestInformationR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Log.uri, new HttpRestLogR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Server.uri, new HttpRestServerR66Handler(defaultConfiguration, methods)); defaultConfiguration.restHashMap.put(RESTHANDLERS.Control.uri, new HttpRestControlR66Handler(defaultConfiguration, methods)); } } } public HttpRestR66Handler(RestConfiguration config) { super(config); restHashMap = config.restHashMap; } protected static METHOD[] getMethods(byte check) { List<METHOD> methods = new ArrayList<METHOD>(); if (RestConfiguration.CRUD.CREATE.isValid(check)) { methods.add(METHOD.POST); } if (RestConfiguration.CRUD.READ.isValid(check)) { methods.add(METHOD.GET); } if (RestConfiguration.CRUD.UPDATE.isValid(check)) { methods.add(METHOD.PUT); } if (RestConfiguration.CRUD.DELETE.isValid(check)) { methods.add(METHOD.DELETE); } return methods.toArray(new METHOD[0]); } public static void instantiateHandlers(RestConfiguration restConfiguration) { defaultHandlers(); byte check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.DbTaskRunner.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.DbTaskRunner.uri, new DbTaskRunnerR66RestMethodHandler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.DbHostAuth.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.DbHostAuth.uri, new DbHostAuthR66RestMethodHandler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.DbRule.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.DbRule.uri, new DbRuleR66RestMethodHandler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.DbHostConfiguration.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.DbHostConfiguration.uri, new DbHostConfigurationR66RestMethodHandler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.DbConfiguration.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.DbConfiguration.uri, new DbConfigurationR66RestMethodHandler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Bandwidth.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Bandwidth.uri, new HttpRestBandwidthR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Business.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Business.uri, new HttpRestBusinessR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Config.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Config.uri, new HttpRestConfigR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Information.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Information.uri, new HttpRestInformationR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Log.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Log.uri, new HttpRestLogR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Server.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Server.uri, new HttpRestServerR66Handler(restConfiguration, methods)); } check = restConfiguration.RESTHANDLERS_CRUD[RESTHANDLERS.Control.ordinal()]; if (check != 0) { METHOD[] methods = getMethods(check); restConfiguration.restHashMap.put(RESTHANDLERS.Control.uri, new HttpRestControlR66Handler(restConfiguration, methods)); } logger.debug("Initialized handler: " + RESTHANDLERS.values().length); } /** * Server Actions handler */ private ServerActions serverHandler = new ServerActions(); @Override protected void checkConnection(ChannelHandlerContext ctx) throws HttpInvalidAuthenticationException { logger.debug("Request: {} ### {}", arguments, response); String user = null; String key = null; if (restConfiguration.REST_AUTHENTICATED) { user = arguments.getXAuthUser(); if (user == null || user.isEmpty()) { status = HttpResponseStatus.UNAUTHORIZED; throw new HttpInvalidAuthenticationException("Empty Authentication"); } DbHostAuth host; try { host = new DbHostAuth(DbConstant.admin.getSession(), user); key = new String(host.getHostkey(), WaarpStringUtils.UTF8); } catch (WaarpDatabaseException e) { // might be global Admin if (user.equals(Configuration.configuration.getADMINNAME())) { key = new String(Configuration.configuration.getSERVERADMINKEY(), WaarpStringUtils.UTF8); } } if (key == null || key.isEmpty()) { status = HttpResponseStatus.UNAUTHORIZED; throw new HttpInvalidAuthenticationException("Wrong Authentication"); } if (restConfiguration.REST_SIGNATURE) { arguments.checkBaseAuthent(restConfiguration.hmacSha256, key, restConfiguration.REST_TIME_LIMIT); } else { arguments.checkTime(restConfiguration.REST_TIME_LIMIT); } } else { // User set only for right access, not for signature check user = Configuration.configuration.getADMINNAME(); if (restConfiguration.REST_SIGNATURE) { arguments.checkBaseAuthent(restConfiguration.hmacSha256, null, restConfiguration.REST_TIME_LIMIT); } else { arguments.checkTime(restConfiguration.REST_TIME_LIMIT); } } getServerHandler().newSession(); R66Session session = getServerHandler().getSession(); if (!restConfiguration.REST_AUTHENTICATED) { // Default is Admin session.getAuth().specialNoSessionAuth(true, Configuration.configuration.getHOST_SSLID()); } else { // we have one DbSession per connection, only after authentication DbSession temp = getDbSessionFromUser().get(user); if (temp == null) { try { temp = new DbSession(DbConstant.admin, false); getDbSessionFromUser().put(user, temp); } catch (WaarpDatabaseNoConnectionException e) { } } if (temp != null) { temp.useConnection(); this.dbSession = temp; } try { session.getAuth().connectionHttps(getDbSession(), user, FilesystemBasedDigest.passwdCrypt(key.getBytes(WaarpStringUtils.UTF8))); } catch (Reply530Exception e) { status = HttpResponseStatus.UNAUTHORIZED; throw new HttpInvalidAuthenticationException("Wrong Authentication", e); } catch (Reply421Exception e) { status = HttpResponseStatus.SERVICE_UNAVAILABLE; throw new HttpInvalidAuthenticationException("Service unavailable", e); } } arguments.setXAuthRole(session.getAuth().getRole()); arguments.methodFromUri(); arguments.methodFromHeader(); } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { super.channelInactive(ctx); getServerHandler().channelClosed(ctx); } /** * Called at the beginning of every new request * * Override if needed */ protected void initialize() { super.initialize(); } /** * Initialize the REST service (server side) for one restConfiguration * * @param restConfiguration */ public static void initializeService(RestConfiguration restConfiguration) { instantiateHandlers(restConfiguration); if (group == null) { group = Configuration.configuration.getHttpChannelGroup(); } // Configure the server. ServerBootstrap httpBootstrap = new ServerBootstrap(); WaarpNettyUtil.setServerBootstrap(httpBootstrap, Configuration.configuration.getHttpBossGroup(), Configuration.configuration.getHttpWorkerGroup(), (int) Configuration.configuration.getTIMEOUTCON()); // Set up the event pipeline factory. if (restConfiguration.REST_SSL) { httpBootstrap.childHandler(new HttpRestR66Initializer(false, Configuration.getWaarpSslContextFactory(), restConfiguration)); } else { httpBootstrap.childHandler(new HttpRestR66Initializer(false, null, restConfiguration)); } // Bind and start to accept incoming connections. ChannelFuture future; if (restConfiguration != null && restConfiguration.REST_ADDRESS != null && !restConfiguration.REST_ADDRESS.isEmpty()) { future = httpBootstrap .bind(new InetSocketAddress(restConfiguration.REST_ADDRESS, restConfiguration.REST_PORT)); } else { future = httpBootstrap.bind(new InetSocketAddress(restConfiguration.REST_PORT)); } try { future.await(); } catch (InterruptedException e) { } if (future.isSuccess()) { group.add(future.channel()); } } /** * @return the dbSessionFromUser */ public static HashMap<String, DbSession> getDbSessionFromUser() { return dbSessionFromUser; } /** * @return the serverHandler */ public ServerActions getServerHandler() { return serverHandler; } }