Examples with GfSseEventReceiverProprietaryReader com.sun.enterprise.admin.remote.sse.GfSseEventReceiverProprietaryReader used on opensource projects

Example 1 with GfSseEventReceiverProprietaryReader

use of com.sun.enterprise.admin.remote.sse.GfSseEventReceiverProprietaryReader in project Payara by payara.

the class RemoteRestAdminCommand method executeRemoteCommand.

/**
 * Actually execute the remote command.
 */
private void executeRemoteCommand(final ParameterMap params) throws CommandException {
    doHttpCommand(getCommandURI(), "POST", new HttpCommand() {

        @Override
        public void prepareConnection(final HttpURLConnection urlConnection) throws IOException {
            try {
                if (useSse()) {
                    urlConnection.addRequestProperty("Accept", MEDIATYPE_SSE);
                } else {
                    urlConnection.addRequestProperty("Accept", MEDIATYPE_JSON + "; q=0.8, " + MEDIATYPE_MULTIPART + "; q=0.9");
                }
            } catch (CommandException cex) {
                throw new IOException(cex.getLocalizedMessage(), cex);
            }
            // add any user-specified headers
            for (Header h : requestHeaders) {
                urlConnection.addRequestProperty(h.getName(), h.getValue());
            }
            // Write data
            ParamsWithPayload pwp;
            if (doUpload) {
                urlConnection.setChunkedStreamingMode(0);
                pwp = new ParamsWithPayload(outboundPayload, params);
            } else {
                pwp = new ParamsWithPayload(null, params);
            }
            ProprietaryWriter writer = ProprietaryWriterFactory.getWriter(pwp);
            if (logger.isLoggable(Level.FINER)) {
                logger.log(Level.FINER, "Writer to use {0}", writer.getClass().getName());
            }
            writer.writeTo(pwp, urlConnection);
        }

        @Override
        public void useConnection(final HttpURLConnection urlConnection) throws CommandException, IOException {
            String resultMediaType = urlConnection.getContentType();
            if (logger.isLoggable(Level.FINER)) {
                logger.log(Level.FINER, "Result type is {0}", resultMediaType);
                logger.log(Level.FINER, "URL connection is {0}", urlConnection.getClass().getName());
            }
            if (resultMediaType != null && resultMediaType.startsWith(MEDIATYPE_SSE)) {
                String instanceId = null;
                boolean retryableCommand = false;
                try {
                    logger.log(Level.FINEST, "Response is SSE - about to read events");
                    closeSse = false;
                    ProprietaryReader<GfSseEventReceiver> reader = new GfSseEventReceiverProprietaryReader();
                    GfSseEventReceiver eventReceiver = reader.readFrom(urlConnection.getInputStream(), resultMediaType);
                    GfSseInboundEvent event;
                    do {
                        event = eventReceiver.readEvent();
                        if (event != null) {
                            if (logger.isLoggable(Level.FINEST)) {
                                logger.log(Level.FINEST, "Event: {0}", event.getName());
                            }
                            fireEvent(event.getName(), event);
                            if (AdminCommandState.EVENT_STATE_CHANGED.equals(event.getName())) {
                                AdminCommandState acs = event.getData(AdminCommandState.class, MEDIATYPE_JSON);
                                if (acs.getId() != null) {
                                    instanceId = acs.getId();
                                    if (logger.isLoggable(Level.FINEST)) {
                                        logger.log(Level.FINEST, "Command instance ID: {0}", instanceId);
                                    }
                                }
                                switch(acs.getState()) {
                                    case COMPLETED:
                                    case RECORDED:
                                    case REVERTED:
                                        if (acs.getActionReport() != null) {
                                            setActionReport(acs.getActionReport());
                                        }
                                        closeSse = true;
                                        if (!acs.isOutboundPayloadEmpty()) {
                                            logger.log(Level.FINEST, "Romote command holds data. Must load it");
                                            downloadPayloadFromManaged(instanceId);
                                        }
                                        break;
                                    case FAILED_RETRYABLE:
                                        logger.log(Level.INFO, STRINGS.get("remotecommand.failedretryable", acs.getId()));
                                        if (acs.getActionReport() != null) {
                                            setActionReport(acs.getActionReport());
                                        }
                                        closeSse = true;
                                        break;
                                    case RUNNING_RETRYABLE:
                                        logger.log(Level.FINEST, "Command stores checkpoint and is retryable");
                                        retryableCommand = true;
                                        break;
                                    default:
                                        break;
                                }
                            }
                        }
                    } while (event != null && !eventReceiver.isClosed() && !closeSse);
                    if (closeSse) {
                        try {
                            eventReceiver.close();
                        } catch (Exception exc) {
                        }
                    }
                } catch (IOException ioex) {
                    if (instanceId != null && "Premature EOF".equals(ioex.getMessage())) {
                        if (retryableCommand) {
                            throw new CommandException(STRINGS.get("remotecommand.lostConnection.retryableCommand", new Object[] { instanceId }), ioex);
                        } else {
                            throw new CommandException(STRINGS.get("remotecommand.lostConnection", new Object[] { instanceId }), ioex);
                        }
                    } else {
                        throw new CommandException(ioex.getMessage(), ioex);
                    }
                } catch (Exception ex) {
                    throw new CommandException(ex.getMessage(), ex);
                }
            } else {
                ProprietaryReader<ParamsWithPayload> reader = ProprietaryReaderFactory.getReader(ParamsWithPayload.class, resultMediaType);
                if (urlConnection.getResponseCode() == HttpURLConnection.HTTP_INTERNAL_ERROR) {
                    ActionReport report;
                    if (reader == null) {
                        report = new CliActionReport();
                        report.setActionExitCode(ExitCode.FAILURE);
                        report.setMessage(urlConnection.getResponseMessage());
                    } else {
                        report = reader.readFrom(urlConnection.getErrorStream(), resultMediaType).getActionReport();
                    }
                    setActionReport(report);
                } else {
                    ParamsWithPayload pwp = reader.readFrom(urlConnection.getInputStream(), resultMediaType);
                    if (pwp.getPayloadInbound() == null) {
                        setActionReport(pwp.getActionReport());
                    } else if (resultMediaType.startsWith("multipart/")) {
                        RestPayloadImpl.Inbound inbound = pwp.getPayloadInbound();
                        setActionReport(pwp.getActionReport());
                        if (logger.isLoggable(Level.FINER)) {
                            logger.log(Level.FINER, "------ PAYLOAD ------");
                            Iterator<Payload.Part> parts = inbound.parts();
                            while (parts.hasNext()) {
                                Payload.Part part = parts.next();
                                logger.log(Level.FINER, " - {0} [{1}]", new Object[] { part.getName(), part.getContentType() });
                            }
                            logger.log(Level.FINER, "---- END PAYLOAD ----");
                        }
                        PayloadFilesManager downloadedFilesMgr = new PayloadFilesManager.Perm(fileOutputDir, null, logger, null);
                        try {
                            downloadedFilesMgr.processParts(inbound);
                        } catch (CommandException cex) {
                            throw cex;
                        } catch (Exception ex) {
                            throw new CommandException(ex.getMessage(), ex);
                        }
                    }
                }
            }
        }
    });
    if (actionReport == null) {
        this.output = null;
        throw new CommandException(STRINGS.get("emptyResponse"));
    }
    if (actionReport.getActionExitCode() == ExitCode.FAILURE) {
        throw new CommandException(STRINGS.getString("remote.failure.prefix", "remote failure:") + " " + this.output);
    }
}