Examples with ProxyHttpConnector com.twinsoft.convertigo.beans.connectors.ProxyHttpConnector used on opensource projects

Example 1 with ProxyHttpConnector

use of com.twinsoft.convertigo.beans.connectors.ProxyHttpConnector in project convertigo by convertigo.

the class ProxyServletRequester method coreProcessRequest.

protected Object coreProcessRequest() throws Exception {
    // The proxy converts HTML data on the fly
    ParameterShuttle infoShuttle = threadParameterShuttle.get();
    HttpClient httpClient = threadHttpClient.get();
    HttpServletRequest request = (HttpServletRequest) inputData;
    InputStream siteIn = null;
    try {
        try {
            getUserRequest(infoShuttle, context, request);
            // Loading project
            if (context.projectName == null)
                throw new EngineException("The project name has not been specified!");
            Project currentProject;
            if (Engine.isStudioMode()) {
                currentProject = Engine.objectsProvider.getProject(context.projectName);
                if (currentProject == null) {
                    throw new EngineException("No project has been opened in the Studio. A project should be opened in the Studio in order that the Convertigo engine can work.");
                } else if (!currentProject.getName().equalsIgnoreCase(context.projectName)) {
                    throw new EngineException("The requested project (\"" + context.projectName + "\") does not match with the opened project (\"" + currentProject.getName() + "\") in the Studio.\nYou cannot make a request on a different project than the one opened in the Studio.");
                }
                Engine.logEngine.debug("Using project from Studio");
                context.project = currentProject;
            } else {
                if ((context.project == null) || (context.isNewSession)) {
                    Engine.logEngine.debug("New project requested: '" + context.projectName + "'");
                    context.project = Engine.theApp.databaseObjectsManager.getProjectByName(context.projectName);
                    Engine.logEngine.debug("Project loaded: " + context.project.getName());
                }
            }
            // Loading sequence
            if (context.sequenceName != null) {
                context.requestedObject = context.project.getSequenceByName(context.sequenceName);
                Engine.logEngine.debug("Loaded sequence: " + context.requestedObject.getName());
            }
            // Loading connector
            context.loadConnector();
            if (context.requestedObject != null)
                context.requestedObject.context = context;
            if (context.getConnector() != null)
                context.getConnector().context = context;
            if (Boolean.parseBoolean(EnginePropertiesManager.getProperty(PropertyName.SSL_DEBUG))) {
                System.setProperty("javax.net.debug", "all");
                Engine.logEngine.trace("(ProxyServletRequester) Enabling SSL debug mode");
            } else {
                System.setProperty("javax.net.debug", "");
                Engine.logEngine.debug("(ProxyServletRequester) Disabling SSL debug mode");
            }
            if (context.getConnector().isTasAuthenticationRequired() && (context.tasSessionKey == null)) {
                throw new EngineException("A Carioca authentication is required in order to process the transaction.");
            }
            infoShuttle.userID = context.tasUserName;
            infoShuttle.userIP = context.remoteAddr;
            // gather user id, parameters, headers from request
            gatherRequestInfo(infoShuttle, request);
            String t = context.statistics.start(EngineStatistics.APPLY_USER_REQUEST);
            try {
                // get connected
                httpClient.connect(infoShuttle);
            } finally {
                context.statistics.stop(t);
            }
            if (infoShuttle.siteInputStream == null) {
                Engine.logEngine.debug("(ProxyServletRequester) No input stream!");
                return null;
            }
            siteIn = infoShuttle.siteInputStream;
            Engine.logEngine.debug("(ProxyServletRequester) Start of document retransmission");
            Object result;
            ProxyHttpConnector proxyHttpConnector = (ProxyHttpConnector) infoShuttle.context.getConnector();
            String host = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort();
            String newBaseUrl = host + request.getRequestURI() + "?" + Parameter.Connector.getName() + "=" + proxyHttpConnector.getName() + "&" + Parameter.ProxyGoto.getName() + "=";
            String newBaseUrlThen = newBaseUrl + URLEncoder.encode(infoShuttle.siteURL.getPath(), "UTF-8") + "&" + Parameter.ProxyThen.getName() + "=";
            if (isDynamicContent(infoShuttle.siteURL.getPath(), proxyHttpConnector.getDynamicContentFiles())) {
                Engine.logEngine.debug("(ProxyServletRequester) Dynamic content");
                String sResponse;
                StringBuffer sbResponse = new StringBuffer("");
                t = context.statistics.start(EngineStatistics.APPLY_USER_REQUEST);
                try {
                    int c = siteIn.read();
                    char cc;
                    while (c > -1) {
                        cc = (char) c;
                        sbResponse.append(cc);
                        c = siteIn.read();
                    }
                } finally {
                    context.statistics.stop(t, true);
                }
                sResponse = sbResponse.toString();
                result = sResponse;
                if (infoShuttle.siteContentType == null) {
                    Engine.logEngine.warn("(ProxyServletRequester) Aborting string replacements because of null mimetype! Resource: " + infoShuttle.siteURL);
                } else {
                    Engine.logEngine.debug("(ProxyServletRequester) String replacements");
                    // Text/html replacements
                    Engine.logEngine.debug("(ProxyServletRequester) Replacements for mime type '" + infoShuttle.siteContentType + "'");
                    Replacements replacements = proxyHttpConnector.getReplacementsForMimeType(infoShuttle.siteContentType);
                    if (!replacements.isEmpty()) {
                        StringEx sxResponse = new StringEx(sResponse);
                        StringEx sx;
                        String strSearched, strReplacing;
                        for (int i = 0; i < replacements.strReplacing.length; i++) {
                            strSearched = replacements.strSearched[i];
                            sx = new StringEx(strSearched);
                            sx.replaceAll("{tab}", "\t");
                            sx.replaceAll("{apos0x92}", "" + (char) 146);
                            sx.replaceAll("{newBaseUrl}", newBaseUrl);
                            sx.replaceAll("{newBaseUrlThen}", newBaseUrlThen);
                            strSearched = sx.toString();
                            replacements.strSearched[i] = strSearched;
                            Engine.logEngine.debug("(ProxyServletRequester) Replacing: " + strSearched);
                            strReplacing = replacements.strReplacing[i];
                            sx = new StringEx(strReplacing);
                            sx.replaceAll("{newBaseUrl}", newBaseUrl);
                            sx.replaceAll("{newBaseUrlThen}", newBaseUrlThen);
                            strReplacing = sx.toString();
                            replacements.strReplacing[i] = strReplacing;
                            Engine.logEngine.debug("(ProxyServletRequester) By: " + strReplacing);
                        }
                        Engine.logEngine.debug("(ProxyServletRequester) Replacements in progress");
                        sxResponse.replaceAll(replacements.strSearched, replacements.strReplacing);
                        Engine.logEngine.debug("(ProxyServletRequester) Replacements done!");
                        if (Engine.isStudioMode()) {
                            sxResponse.replaceAll("?" + Parameter.Connector.getName() + "=", "?" + Parameter.Context.getName() + "=" + infoShuttle.context.name + "&" + Parameter.Connector.getName() + "=");
                        }
                        result = sxResponse.toString();
                    }
                }
                infoShuttle.siteContentSize = ((String) result).length();
                Engine.logEngine.debug("(ProxyServletRequester) HTML data retrieved!");
                String billingClassName = context.getConnector().getBillingClassName();
                if (billingClassName != null) {
                    try {
                        Engine.logContext.debug("Billing class name required: " + billingClassName);
                        AbstractBiller biller = (AbstractBiller) Class.forName(billingClassName).getConstructor().newInstance();
                        Engine.logContext.debug("Executing the biller");
                        biller.insertBilling(context);
                    } catch (Throwable e) {
                        Engine.logContext.warn("Unable to execute the biller (the billing is thus ignored): [" + e.getClass().getName() + "] " + e.getMessage());
                    }
                }
            } else {
                Engine.logEngine.debug("(ProxyServletRequester) Static content: " + infoShuttle.siteContentType);
                ByteArrayOutputStream baos = new ByteArrayOutputStream(2048);
                t = context.statistics.start(EngineStatistics.APPLY_USER_REQUEST);
                try {
                    // Read either from the cache, either from the remote server
                    int c = siteIn.read();
                    while (c > -1) {
                        baos.write(c);
                        c = siteIn.read();
                    }
                } finally {
                    context.statistics.stop(t, true);
                }
                result = baos.toByteArray();
                Engine.logEngine.debug("(ProxyServletRequester) Static data retrieved!");
                // Determine if the resource has already been cached or not
                String resourceUrl = infoShuttle.siteURL.toString();
                CacheEntry cacheEntry = ProxyServletRequester.proxyCacheManager.getCacheEntry(resourceUrl);
                if (cacheEntry == null) {
                    // Managing text replacements
                    Engine.logEngine.debug("(ProxyServletRequester) Replacements for mime type '" + infoShuttle.siteContentType + "'");
                    Replacements replacements = proxyHttpConnector.getReplacementsForMimeType(infoShuttle.siteContentType);
                    if (!replacements.isEmpty()) {
                        String sResult = new String((byte[]) result);
                        StringEx sxResponse = new StringEx(sResult);
                        StringEx sx;
                        String strSearched, strReplacing;
                        for (int i = 0; i < replacements.strReplacing.length; i++) {
                            strSearched = replacements.strSearched[i];
                            sx = new StringEx(strSearched);
                            sx.replaceAll("{tab}", "\t");
                            sx.replaceAll("{newBaseUrl}", newBaseUrl);
                            sx.replaceAll("{newBaseUrlThen}", newBaseUrlThen);
                            strSearched = sx.toString();
                            replacements.strSearched[i] = strSearched;
                            Engine.logEngine.debug("(ProxyServletRequester) Replacing: " + strSearched);
                            strReplacing = replacements.strReplacing[i];
                            sx = new StringEx(strReplacing);
                            sx.replaceAll("{newBaseUrl}", newBaseUrl);
                            sx.replaceAll("{newBaseUrlThen}", newBaseUrlThen);
                            strReplacing = sx.toString();
                            replacements.strReplacing[i] = strReplacing;
                            Engine.logEngine.debug("(ProxyServletRequester) By: " + strReplacing);
                        }
                        Engine.logEngine.debug("(ProxyServletRequester) Replacements in progress");
                        sxResponse.replaceAll(replacements.strSearched, replacements.strReplacing);
                        Engine.logEngine.debug("(ProxyServletRequester) Replacements done!");
                        result = sxResponse.toString().getBytes();
                    }
                    if (infoShuttle.httpCode == 200) {
                        Engine.logEngine.debug("(ProxyServletRequester) Resource stored: " + resourceUrl);
                        cacheEntry = proxyCacheManager.storeResponse(resourceUrl, (byte[]) result);
                        cacheEntry.contentLength = ((byte[]) result).length;
                        infoShuttle.siteContentSize = cacheEntry.contentLength;
                        cacheEntry.contentType = infoShuttle.siteContentType;
                    }
                } else {
                    infoShuttle.httpCode = 200;
                    infoShuttle.siteContentSize = cacheEntry.contentLength;
                    infoShuttle.siteContentType = cacheEntry.contentType;
                }
                baos.close();
            }
            Engine.logEngine.debug("(ProxyServletRequester) End of document retransmission");
            return result;
        } finally {
            if (siteIn != null) {
                try {
                    siteIn.close();
                } catch (Exception e) {
                }
            }
        }
    } finally {
        context.contentType = infoShuttle.siteContentType;
        httpClient.disconnect();
    }
}

Example 2 with ProxyHttpConnector

use of com.twinsoft.convertigo.beans.connectors.ProxyHttpConnector in project convertigo by convertigo.

the class ReverseProxyServlet method doRequest.

/**
 * Executes the {@link HttpMethod} passed in and sends the proxy response
 * back to the client via the given {@link HttpServletResponse}
 *
 * @param httpMethodProxyRequest
 *            An object representing the proxy request to be made
 * @param httpServletResponse
 *            An object by which we can send the proxied response back to
 *            the client
 * @throws IOException
 *             Can be thrown by the {@link HttpClient}.executeMethod
 * @throws ServletException
 *             Can be thrown to indicate that another error has occurred
 * @throws EngineException
 */
private void doRequest(HttpMethodType httpMethodType, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException {
    try {
        Engine.logEngine.debug("(ReverseProxyServlet) Starting request handling");
        if (Boolean.parseBoolean(EnginePropertiesManager.getProperty(PropertyName.SSL_DEBUG))) {
            System.setProperty("javax.net.debug", "all");
            Engine.logEngine.trace("(ReverseProxyServlet) Enabling SSL debug mode");
        } else {
            System.setProperty("javax.net.debug", "");
            Engine.logEngine.debug("(ReverseProxyServlet) Disabling SSL debug mode");
        }
        String baseUrl;
        String projectName;
        String connectorName;
        String contextName;
        String extraPath;
        {
            String requestURI = httpServletRequest.getRequestURI();
            Engine.logEngine.trace("(ReverseProxyServlet) Requested URI : " + requestURI);
            Matcher m = reg_fields.matcher(requestURI);
            if (m.matches() && m.groupCount() >= 5) {
                baseUrl = m.group(1);
                projectName = m.group(2);
                connectorName = m.group(3);
                contextName = m.group(4);
                extraPath = m.group(5);
            } else {
                throw new MalformedURLException("The request doesn't contains needed fields : projectName, connectorName and contextName");
            }
        }
        String sessionID = httpServletRequest.getSession().getId();
        Engine.logEngine.debug("(ReverseProxyServlet) baseUrl : " + baseUrl + " ; projectName : " + projectName + " ; connectorName : " + connectorName + " ; contextName : " + contextName + " ; extraPath : " + extraPath + " ; sessionID : " + sessionID);
        Context context = Engine.theApp.contextManager.get(null, contextName, sessionID, null, projectName, connectorName, null);
        Project project = Engine.theApp.databaseObjectsManager.getProjectByName(projectName);
        context.projectName = projectName;
        context.project = project;
        ProxyHttpConnector proxyHttpConnector = (ProxyHttpConnector) project.getConnectorByName(connectorName);
        context.connector = proxyHttpConnector;
        context.connectorName = proxyHttpConnector.getName();
        HostConfiguration hostConfiguration = proxyHttpConnector.hostConfiguration;
        // Proxy configuration
        String proxyServer = Engine.theApp.proxyManager.getProxyServer();
        String proxyUser = Engine.theApp.proxyManager.getProxyUser();
        String proxyPassword = Engine.theApp.proxyManager.getProxyPassword();
        int proxyPort = Engine.theApp.proxyManager.getProxyPort();
        if (!proxyServer.equals("")) {
            hostConfiguration.setProxy(proxyServer, proxyPort);
            Engine.logEngine.debug("(ReverseProxyServlet) Using proxy: " + proxyServer + ":" + proxyPort);
        } else {
            // Remove old proxy configuration
            hostConfiguration.setProxyHost(null);
        }
        String targetHost = proxyHttpConnector.getServer();
        Engine.logEngine.debug("(ReverseProxyServlet) Target host: " + targetHost);
        int targetPort = proxyHttpConnector.getPort();
        Engine.logEngine.debug("(ReverseProxyServlet) Target port: " + targetPort);
        // Configuration SSL
        Engine.logEngine.debug("(ReverseProxyServlet) Https: " + proxyHttpConnector.isHttps());
        CertificateManager certificateManager = proxyHttpConnector.certificateManager;
        boolean trustAllServerCertificates = proxyHttpConnector.isTrustAllServerCertificates();
        if (proxyHttpConnector.isHttps()) {
            Engine.logEngine.debug("(ReverseProxyServlet) Setting up SSL properties");
            certificateManager.collectStoreInformation(context);
            Engine.logEngine.debug("(ReverseProxyServlet) CertificateManager has changed: " + certificateManager.hasChanged);
            if (certificateManager.hasChanged || (!targetHost.equalsIgnoreCase(hostConfiguration.getHost())) || (hostConfiguration.getPort() != targetPort)) {
                Engine.logEngine.debug("(ReverseProxyServlet) Using MySSLSocketFactory for creating the SSL socket");
                Protocol myhttps = new Protocol("https", MySSLSocketFactory.getSSLSocketFactory(certificateManager.keyStore, certificateManager.keyStorePassword, certificateManager.trustStore, certificateManager.trustStorePassword, trustAllServerCertificates), targetPort);
                hostConfiguration.setHost(targetHost, targetPort, myhttps);
            }
            Engine.logEngine.debug("(ReverseProxyServlet) Updated host configuration for SSL purposes");
        } else {
            hostConfiguration.setHost(targetHost, targetPort);
        }
        HttpMethod httpMethodProxyRequest;
        String targetPath = proxyHttpConnector.getBaseDir() + extraPath;
        // Handle the query string
        if (httpServletRequest.getQueryString() != null) {
            targetPath += "?" + httpServletRequest.getQueryString();
        }
        Engine.logEngine.debug("(ReverseProxyServlet) Target path: " + targetPath);
        Engine.logEngine.debug("(ReverseProxyServlet) Requested method: " + httpMethodType);
        if (httpMethodType == HttpMethodType.GET) {
            // Create a GET request
            httpMethodProxyRequest = new GetMethod();
        } else if (httpMethodType == HttpMethodType.POST) {
            // Create a standard POST request
            httpMethodProxyRequest = new PostMethod();
            ((PostMethod) httpMethodProxyRequest).setRequestEntity(new InputStreamRequestEntity(httpServletRequest.getInputStream()));
        } else {
            throw new IllegalArgumentException("Unknown HTTP method: " + httpMethodType);
        }
        String charset = httpMethodProxyRequest.getParams().getUriCharset();
        URI targetURI;
        try {
            targetURI = new URI(targetPath, true, charset);
        } catch (URIException e) {
            // Bugfix #1484
            String newTargetPath = "";
            for (String part : targetPath.split("&")) {
                if (!newTargetPath.equals("")) {
                    newTargetPath += "&";
                }
                String[] pair = part.split("=");
                try {
                    newTargetPath += URLDecoder.decode(pair[0], "UTF-8") + "=" + (pair.length > 1 ? URLEncoder.encode(URLDecoder.decode(pair[1], "UTF-8"), "UTF-8") : "");
                } catch (UnsupportedEncodingException ee) {
                    newTargetPath = targetPath;
                }
            }
            targetURI = new URI(newTargetPath, true, charset);
        }
        httpMethodProxyRequest.setURI(targetURI);
        // Tells the method to automatically handle authentication.
        httpMethodProxyRequest.setDoAuthentication(true);
        HttpState httpState = getHttpState(proxyHttpConnector, context);
        String basicUser = proxyHttpConnector.getAuthUser();
        String basicPassword = proxyHttpConnector.getAuthPassword();
        String givenBasicUser = proxyHttpConnector.getGivenAuthUser();
        String givenBasicPassword = proxyHttpConnector.getGivenAuthPassword();
        // Basic authentication configuration
        String realm = null;
        if (!basicUser.equals("") || (basicUser.equals("") && (givenBasicUser != null))) {
            String userName = ((givenBasicUser == null) ? basicUser : givenBasicUser);
            String userPassword = ((givenBasicPassword == null) ? basicPassword : givenBasicPassword);
            httpState.setCredentials(new AuthScope(targetHost, targetPort, realm), new UsernamePasswordCredentials(userName, userPassword));
            Engine.logEngine.debug("(ReverseProxyServlet) Credentials: " + userName + ":******");
        }
        // Setting basic authentication for proxy
        if (!proxyServer.equals("") && !proxyUser.equals("")) {
            httpState.setProxyCredentials(new AuthScope(proxyServer, proxyPort), new UsernamePasswordCredentials(proxyUser, proxyPassword));
            Engine.logEngine.debug("(ReverseProxyServlet) Proxy credentials: " + proxyUser + ":******");
        }
        // Forward the request headers
        setProxyRequestHeaders(httpServletRequest, httpMethodProxyRequest, proxyHttpConnector);
        // Use the CEMS HttpClient
        HttpClient httpClient = Engine.theApp.httpClient;
        httpMethodProxyRequest.setFollowRedirects(false);
        // Execute the request
        int intProxyResponseCode = httpClient.executeMethod(hostConfiguration, httpMethodProxyRequest, httpState);
        // Hooray for open source software
        if (intProxyResponseCode >= HttpServletResponse.SC_MULTIPLE_CHOICES && /* 300 */
        intProxyResponseCode < HttpServletResponse.SC_NOT_MODIFIED) /* 304 */
        {
            String stringStatusCode = Integer.toString(intProxyResponseCode);
            String stringLocation = httpMethodProxyRequest.getResponseHeader(STRING_LOCATION_HEADER).getValue();
            if (stringLocation == null) {
                throw new ServletException("Received status code: " + stringStatusCode + " but no " + STRING_LOCATION_HEADER + " header was found in the response");
            }
            // Modify the redirect to go to this proxy servlet rather that
            // the
            // proxied host
            String redirect = handleRedirect(stringLocation, baseUrl, proxyHttpConnector);
            httpServletResponse.sendRedirect(redirect);
            Engine.logEngine.debug("(ReverseProxyServlet) Send redirect (" + redirect + ")");
            return;
        } else if (intProxyResponseCode == HttpServletResponse.SC_NOT_MODIFIED) {
            // 304 needs special handling. See:
            // http://www.ics.uci.edu/pub/ietf/http/rfc1945.html#Code304
            // We get a 304 whenever passed an 'If-Modified-Since'
            // header and the data on disk has not changed; server
            // responds w/ a 304 saying I'm not going to send the
            // body because the file has not changed.
            httpServletResponse.setIntHeader(STRING_CONTENT_LENGTH_HEADER_NAME, 0);
            httpServletResponse.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            Engine.logEngine.debug("(ReverseProxyServlet) NOT MODIFIED (304)");
            return;
        }
        // Pass the response code back to the client
        httpServletResponse.setStatus(intProxyResponseCode);
        // Pass response headers back to the client
        Engine.logEngine.debug("(ReverseProxyServlet) Response headers back to the client:");
        Header[] headerArrayResponse = httpMethodProxyRequest.getResponseHeaders();
        for (Header header : headerArrayResponse) {
            String headerName = header.getName();
            String headerValue = header.getValue();
            if (!headerName.equalsIgnoreCase("Transfer-Encoding") && !headerName.equalsIgnoreCase("Set-Cookie")) {
                httpServletResponse.setHeader(headerName, headerValue);
                Engine.logEngine.debug("   " + headerName + "=" + headerValue);
            }
        }
        String contentType = null;
        Header[] contentTypeHeaders = httpMethodProxyRequest.getResponseHeaders("Content-Type");
        for (Header contentTypeHeader : contentTypeHeaders) {
            contentType = contentTypeHeader.getValue();
            break;
        }
        String pageCharset = "UTF-8";
        if (contentType != null) {
            int iCharset = contentType.indexOf("charset=");
            if (iCharset != -1) {
                pageCharset = contentType.substring(iCharset + "charset=".length()).trim();
            }
            Engine.logEngine.debug("(ReverseProxyServlet) Using charset: " + pageCharset);
        }
        InputStream siteIn = httpMethodProxyRequest.getResponseBodyAsStream();
        // Handle gzipped content
        Header[] contentEncodingHeaders = httpMethodProxyRequest.getResponseHeaders("Content-Encoding");
        boolean bGZip = false, bDeflate = false;
        for (Header contentEncodingHeader : contentEncodingHeaders) {
            HeaderElement[] els = contentEncodingHeader.getElements();
            for (int j = 0; j < els.length; j++) {
                if ("gzip".equals(els[j].getName())) {
                    Engine.logBeans.debug("(ReverseProxyServlet) Decode GZip stream");
                    siteIn = new GZIPInputStream(siteIn);
                    bGZip = true;
                } else if ("deflate".equals(els[j].getName())) {
                    Engine.logBeans.debug("(ReverseProxyServlet) Decode Deflate stream");
                    siteIn = new InflaterInputStream(siteIn, new Inflater(true));
                    bDeflate = true;
                }
            }
        }
        byte[] bytesDataResult;
        ByteArrayOutputStream baos = new ByteArrayOutputStream(2048);
        // String resourceUrl = projectName + targetPath;
        String t = context.statistics.start(EngineStatistics.APPLY_USER_REQUEST);
        try {
            // Read either from the cache, either from the remote server
            // InputStream is = proxyCacheManager.getResource(resourceUrl);
            // if (is != null) {
            // Engine.logEngine.debug("(ReverseProxyServlet) Getting data from cache");
            // siteIn = is;
            // }
            int c = siteIn.read();
            while (c > -1) {
                baos.write(c);
                c = siteIn.read();
            }
        // if (is != null) is.close();
        } finally {
            context.statistics.stop(t, true);
        }
        bytesDataResult = baos.toByteArray();
        baos.close();
        Engine.logEngine.debug("(ReverseProxyServlet) Data retrieved!");
        // if (isDynamicContent(httpServletRequest.getPathInfo(),
        // proxyHttpConnector.getDynamicContentFiles())) {
        Engine.logEngine.debug("(ReverseProxyServlet) Dynamic content");
        bytesDataResult = handleStringReplacements(baseUrl, contentType, pageCharset, proxyHttpConnector, bytesDataResult);
        String billingClassName = context.getConnector().getBillingClassName();
        if (billingClassName != null) {
            try {
                Engine.logContext.debug("Billing class name required: " + billingClassName);
                AbstractBiller biller = (AbstractBiller) Class.forName(billingClassName).getConstructor().newInstance();
                Engine.logContext.debug("Executing the biller");
                biller.insertBilling(context);
            } catch (Throwable e) {
                Engine.logContext.warn("Unable to execute the biller (the billing is thus ignored): [" + e.getClass().getName() + "] " + e.getMessage());
            }
        }
        // Send the content to the client
        if (Engine.logEngine.isDebugEnabled() && MimeType.Html.is(contentType)) {
            Engine.logEngine.debug("Data proxied:\n" + new String(bytesDataResult, pageCharset));
        }
        if (bGZip || bDeflate) {
            baos = new ByteArrayOutputStream();
            OutputStream compressedOutputStream = bGZip ? new GZIPOutputStream(baos) : new DeflaterOutputStream(baos, new Deflater(Deflater.DEFAULT_COMPRESSION | Deflater.DEFAULT_STRATEGY, true));
            compressedOutputStream.write(bytesDataResult);
            compressedOutputStream.close();
            bytesDataResult = baos.toByteArray();
            baos.close();
        }
        httpServletResponse.setContentLength(bytesDataResult.length);
        OutputStream outputStreamClientResponse = httpServletResponse.getOutputStream();
        outputStreamClientResponse.write(bytesDataResult);
        Engine.logEngine.debug("(ReverseProxyServlet) End of document retransmission");
    } catch (Exception e) {
        Engine.logEngine.error("Error while trying to proxy page", e);
        throw new ServletException("Error while trying to proxy page", e);
    }
}

Example 3 with ProxyHttpConnector

use of com.twinsoft.convertigo.beans.connectors.ProxyHttpConnector in project convertigo by convertigo.

the class ReverseProxyServlet method handleRedirect.

private String handleRedirect(String stringLocation, String baseUrl, ProxyHttpConnector currentProxyHttpConnector) {
    Engine.logEngine.debug("ReverseProxyServlet:handleRedirect() requested redirect location: " + stringLocation);
    Engine.logEngine.debug("ReverseProxyServlet:handleRedirect() reverse proxy base url: " + baseUrl);
    for (Connector connector : currentProxyHttpConnector.getProject().getConnectorsList()) {
        if (connector instanceof ProxyHttpConnector) {
            String redirectLocation = stringLocation;
            Engine.logEngine.debug("ReverseProxyServlet:handleRedirect() analyzing connector " + connector.getName());
            ProxyHttpConnector proxyHttpConnector = (ProxyHttpConnector) connector;
            String baseDir = proxyHttpConnector.getBaseDir();
            // comment of #1798
            if ("/".equals(baseDir)) {
                baseDir = "";
            }
            Engine.logEngine.debug("ReverseProxyServlet:handleRedirect()   connector baseDir=" + baseDir);
            String proxyDomainAndPort = "http" + (proxyHttpConnector.isHttps() ? "s" : "") + "://" + getProxyHostAndPort(proxyHttpConnector);
            String proxyBaseUrl = proxyDomainAndPort + baseDir;
            Engine.logEngine.debug("ReverseProxyServlet:handleRedirect()   proxyBaseUrl=" + proxyBaseUrl);
            // Bugfix for #1891
            if (redirectLocation.startsWith("/")) {
                redirectLocation = proxyDomainAndPort + redirectLocation;
                Engine.logEngine.debug("ReverseProxyServlet:handleRedirect()   asbolute path redirect => redirectLocation=" + redirectLocation);
            }
            // Bugfix for #1798 regression about #1718
            if (!redirectLocation.matches(proxyBaseUrl + "((/.*)|$)")) {
                // Bugfix #1718: it probably means the standard port number
                // (80 or 443) has been included
                proxyBaseUrl = "http" + (proxyHttpConnector.isHttps() ? "s" : "") + "://" + proxyHttpConnector.getServer() + ":" + proxyHttpConnector.getPort() + baseDir;
                Engine.logEngine.debug("ReverseProxyServlet:handleRedirect()   update proxyBaseUrl=" + proxyBaseUrl);
            }
            // Bugfix for #1798 regression about #1718
            if (redirectLocation.matches(proxyBaseUrl + "((/.*)|$)")) {
                String newBaseUrl = switchConnector(baseUrl, connector.getName());
                Engine.logEngine.debug("ReverseProxyServlet:handleRedirect()   newBaseUrl=" + newBaseUrl);
                redirectLocation = redirectLocation.replace(proxyBaseUrl, newBaseUrl);
                Engine.logEngine.debug("ReverseProxyServlet:handleRedirect() final redirect location: " + redirectLocation);
                return redirectLocation;
            }
        }
    }
    // Default case: no connector match
    return stringLocation;
}