Example usage for com.fasterxml.jackson.core JsonGenerator close

List of usage examples for com.fasterxml.jackson.core JsonGenerator close

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.core.*
  5. JsonGenerator
  6. close

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonGenerator close.

Prototype

@Override
public abstract void close() throws IOException;

Source Link

Document

Method called to close this generator, so that no more content can be written.

Usage

From source file:net.opentsdb.meta.UIDMeta.java

/**
 * Formats the JSON output for writing to storage. It drops objects we don't
 * need or want to store (such as the UIDMeta objects or the total dps) to
 * save space. It also serializes in order so that we can make a proper CAS
 * call. Otherwise the POJO serializer may place the fields in any order
 * and CAS calls would fail all the time.
 * @return A byte array to write to storage
 *//*from   ww w.j a  v a  2s. c o m*/
private byte[] getStorageJSON() {
    // 256 bytes is a good starting value, assumes default info
    final ByteArrayOutputStream output = new ByteArrayOutputStream(256);
    try {
        final JsonGenerator json = JSON.getFactory().createGenerator(output);
        json.writeStartObject();
        json.writeStringField("type", type.toString());
        json.writeStringField("displayName", display_name);
        json.writeStringField("description", description);
        json.writeStringField("notes", notes);
        json.writeNumberField("created", created);
        if (custom == null) {
            json.writeNullField("custom");
        } else {
            json.writeObjectFieldStart("custom");
            for (Map.Entry<String, String> entry : custom.entrySet()) {
                json.writeStringField(entry.getKey(), entry.getValue());
            }
            json.writeEndObject();
        }

        json.writeEndObject();
        json.close();
        return output.toByteArray();
    } catch (IOException e) {
        throw new RuntimeException("Unable to serialize UIDMeta", e);
    }
}

From source file:com.greplin.gec.GecLogbackAppender.java

/**
 * Writes a formatted exception to the given writer.
 *
 * @param message   the log message//from   ww w .  j a va 2  s . c  o  m
 * @param throwableProxy the exception
 * @param level     the error level
 * @param out       the destination
 * @throws IOException if there are IO errors in the destination
 */
private void writeFormattedException(final String message, final IThrowableProxy throwableProxy,
        final Level level, final Writer out) throws IOException {
    JsonGenerator generator = new JsonFactory().createJsonGenerator(out);

    IThrowableProxy rootThrowable = throwableProxy;
    while (this.passthroughExceptions.contains(rootThrowable.getClassName())
            && rootThrowable.getCause() != null) {
        rootThrowable = rootThrowable.getCause();
    }

    generator.writeStartObject();
    generator.writeStringField("project", this.project);
    generator.writeStringField("environment", this.environment);
    generator.writeStringField("serverName", this.serverName);
    // FIXME this was 'throwable'
    generator.writeStringField("backtrace", getStackTrace(rootThrowable));
    generator.writeStringField("message", rootThrowable.getMessage());
    generator.writeStringField("logMessage", message);
    generator.writeStringField("type", rootThrowable.getClassName());
    if (level != Level.ERROR) {
        generator.writeStringField("errorLevel", level.toString());
    }
    writeContext(generator);
    generator.writeEndObject();
    generator.close();
}

From source file:com.greplin.gec.GecLog4jAppender.java

/**
 * Writes a formatted msg for errors that don't have exceptions.
 *
 * @param message the log message//from  ww  w.  ja  v  a 2 s .com
 * @param level   the error level
 * @param out     the destination
 * @throws IOException if there are IO errors in the destination
 */
void writeFormattedException(final String message, final Level level, final Writer out) throws IOException {
    JsonGenerator generator = new JsonFactory().createJsonGenerator(out);

    String backtrace = ExceptionUtils.getFullStackTrace(new Exception());
    String[] lines = backtrace.split("\n");
    StringBuilder builder = new StringBuilder();
    for (String line : lines) {
        if (!line.contains("com.greplin.gec.GecLog4jAppender.")) {
            builder.append(line);
            builder.append("\n");
        }
    }
    backtrace = builder.toString();

    generator.writeStartObject();
    generator.writeStringField("project", this.project);
    generator.writeStringField("environment", this.environment);
    generator.writeStringField("serverName", this.serverName);
    generator.writeStringField("backtrace", backtrace);
    generator.writeStringField("message", message);
    generator.writeStringField("logMessage", message);
    generator.writeStringField("type", "N/A");
    if (level != Level.ERROR) {
        generator.writeStringField("errorLevel", level.toString());
    }
    writeContext(generator);
    generator.writeEndObject();
    generator.close();
}

From source file:org.teiid.olingo.TeiidODataJsonSerializer.java

public SerializerResult complexCollection(final ServiceMetadata metadata,
        final List<List<ComplexReturnType>> result, final ContextURL contextURL, final URI nextLink)
        throws SerializerException {
    CircleStreamBuffer buffer = new CircleStreamBuffer();
    try {/* w ww.j av  a2s  .  c om*/
        JsonGenerator json = new JsonFactory().createGenerator(buffer.getOutputStream());
        json.writeStartObject();

        if (contextURL != null && (isODataMetadataFull || !isODataMetadataNone)) {
            json.writeStringField(Constants.JSON_CONTEXT, ContextURLBuilder.create(contextURL).toASCIIString());
        }
        json.writeFieldName(Constants.VALUE);
        json.writeStartArray();
        for (List<ComplexReturnType> ct : result) {
            json.writeStartObject();
            for (final ComplexReturnType type : ct) {
                if (!type.isExpand()) {
                    json.writeStringField(type.getName() + Constants.JSON_NAVIGATION_LINK,
                            type.getEntity().getId().toASCIIString());
                } else {
                    json.writeFieldName(type.getName());
                    writeEntity(metadata, type.getEdmEntityType(), type.getEntity(), null, null, null, null,
                            false, null, type.getName(), json);
                }
            }
            json.writeEndObject();
        }
        json.writeEndArray();

        if (nextLink != null) {
            json.writeStringField(Constants.JSON_NEXT_LINK, nextLink.toASCIIString());
        }

        json.close();
    } catch (final IOException | DecoderException e) {
        throw new SerializerException("An I/O exception occurred.", e,
                SerializerException.MessageKeys.IO_EXCEPTION);
    }
    return SerializerResultImpl.with().content(buffer.getInputStream()).build();
}

From source file:com.greplin.gec.GecLogbackAppender.java

/**
 * Writes a formatted msg for errors that don't have exceptions.
 *
 * @param message the log message//w  w w .  j av  a  2 s.c  om
 * @param level   the error level
 * @param out     the destination
 * @throws IOException if there are IO errors in the destination
 */
void writeFormattedException(final String message, final Level level, final Writer out) throws IOException {
    JsonGenerator generator = new JsonFactory().createJsonGenerator(out);

    String backtrace = GecLogbackAppender.getStackTrace(new Throwable());
    String[] lines = backtrace.split("\n");
    StringBuilder builder = new StringBuilder();
    for (String line : lines) {
        if (!line.contains("com.greplin.gec.GecLogbackAppender.")) {
            builder.append(line);
            builder.append("\n");
        }
    }
    backtrace = builder.toString();

    generator.writeStartObject();
    generator.writeStringField("project", this.project);
    generator.writeStringField("environment", this.environment);
    generator.writeStringField("serverName", this.serverName);
    generator.writeStringField("backtrace", backtrace);
    generator.writeStringField("message", message);
    generator.writeStringField("logMessage", message);
    generator.writeStringField("type", "N/A");
    if (level != Level.ERROR) {
        generator.writeStringField("errorLevel", level.toString());
    }
    writeContext(generator);
    generator.writeEndObject();
    generator.close();
}

From source file:org.openiot.security.oauth.lsm.LSMOAuth20PermissionController.java

@Override
protected ModelAndView handleRequestInternal(final HttpServletRequest request,
        final HttpServletResponse response) throws Exception {

    final String clientId = request.getParameter(OAuthConstants.CLIENT_ID);
    log.debug("clientId : {}", clientId);
    final String accessToken = request.getParameter(OAuthConstants.ACCESS_TOKEN);
    log.debug("accessToken : {}", accessToken);

    final String callerClientId = request.getParameter(CALLER_CLIENT_ID);
    log.debug("callerClientId : {}", callerClientId);
    final String callerAccessToken = request.getParameter(CALLER_ACCESS_TOKEN);
    log.debug("callerAccessToken : {}", callerAccessToken);

    final String userClientId = request.getParameter(USER_CLIENT_ID);
    log.debug("userClientId : {}", userClientId);

    final String userAccessToken = request.getParameter(USER_ACCESS_TOKEN);
    log.debug("userAccessToken : {}", userAccessToken);

    final String targetClientId = request.getParameter(TARGET_CLIENT_ID);
    log.debug("targetClientId : {}", targetClientId);

    response.setContentType("application/json");

    // accessToken is required
    if (StringUtils.isBlank(accessToken)) {
        log.error("missing accessToken");
        writeErrorMessage(response, OAuthConstants.MISSING_ACCESS_TOKEN);
        return null;
    }/*from   w w w.j  a v a  2 s .  c om*/

    // clientId is required
    if (StringUtils.isBlank(clientId)) {
        log.error("missing clientId");
        writeErrorMessage(response, MISSING_CLIENT_ID);
        return null;
    }

    // userToken is required
    if (StringUtils.isBlank(userAccessToken)) {
        log.error("missing user accessToken");
        writeErrorMessage(response, "missing_userAccessToken");
        return null;
    }

    // target clientId is required
    if (StringUtils.isBlank(targetClientId)) {
        log.error("missing target clientId");
        writeErrorMessage(response, MISSING_CLIENT_ID + "for_target");
        return null;
    }

    // caller accessToken and clientId are required if one of them is provided
    if (!StringUtils.isBlank(callerAccessToken) || !StringUtils.isBlank(callerClientId)) {
        if (StringUtils.isBlank(callerAccessToken)) {
            log.error("missing caller accessToken");
            writeErrorMessage(response, "missing_callerAccessToken");
            return null;
        } else if (StringUtils.isBlank(callerClientId)) {
            log.error("missing caller clientId");
            writeErrorMessage(response, "missing_callerClientId");
            return null;
        }
    }

    // get ticket granting ticket
    final TicketGrantingTicket ticketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry
            .getTicket(accessToken);
    if (ticketGrantingTicket == null || ticketGrantingTicket.isExpired()) {
        log.error("expired accessToken : {}", accessToken);
        writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN);
        return null;
    }

    // get ticket granting ticket for the user
    final TicketGrantingTicket userTicketGrantingTicket;
    if (StringUtils.equals(accessToken, userAccessToken))
        userTicketGrantingTicket = ticketGrantingTicket;
    else {
        userTicketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry.getTicket(userAccessToken);
        if (userTicketGrantingTicket == null || userTicketGrantingTicket.isExpired()) {
            log.error("expired user accessToken : {}", userAccessToken);
            writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN + "_for_user");
            return null;
        }
    }

    // Retrieve all registered services
    final Collection<RegisteredService> services = servicesManager.getAllServices();

    // If called accessToken and clientId are provided, check their validity
    if (!StringUtils.isBlank(callerAccessToken)) {
        // get ticket granting ticket for the caller
        final TicketGrantingTicket callerTicketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry
                .getTicket(callerAccessToken);
        if (callerTicketGrantingTicket == null || callerTicketGrantingTicket.isExpired()) {
            log.error("expired accessToken : {}", callerAccessToken);
            writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN + "_for_caller");
            return null;
        }

        // name of the CAS service for caller
        RegisteredService callerService = null;
        for (final RegisteredService aService : services) {
            if (StringUtils.equals(aService.getName(), callerClientId)) {
                callerService = aService;
                break;
            }
        }

        if (callerService == null) {
            log.error("nonexistent caller clientId : {}", callerClientId);
            writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "for_caller");
            return null;
        }
    }

    // if user clienId is provided, check its validity
    if (!StringUtils.isBlank(userClientId)) {
        RegisteredService userService = null;
        for (final RegisteredService aService : services) {
            if (StringUtils.equals(aService.getName(), userClientId)) {
                userService = aService;
                break;
            }
        }

        if (userService == null) {
            log.error("nonexistent clientId : {}", userClientId);
            writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "_for_user");
            return null;
        }
    }

    // check validity of clientId
    RegisteredService service = null;
    for (final RegisteredService aService : services) {
        if (StringUtils.equals(aService.getName(), clientId)) {
            service = aService;
            break;
        }
    }

    if (service == null) {
        log.error("nonexistent clientId : {}", clientId);
        writeErrorMessage(response, NONEXISTENT_CLIENT_ID);
        return null;
    }

    // check validity of target clientId
    RegisteredService targetService = null;
    for (final RegisteredService aService : services) {
        if (StringUtils.equals(aService.getName(), targetClientId)) {
            targetService = aService;
            break;
        }
    }

    if (targetService == null) {
        log.error("nonexistent target clientId : {}", clientId);
        writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "for_target");
        return null;
    }

    // TODO: check if the TGT is granted to the client?!
    // final TicketGrantingTicket rawTicket =
    // ((AbstractDistributedTicketRegistry.TicketGrantingTicketDelegator)ticketGrantingTicket).getTicket();
    // final Field servicesField =
    // rawTicket.getClass().getDeclaredField("services");
    // servicesField.setAccessible(true);
    // HashMap<String, Service> servicesMap = new HashMap<String,
    // Service>();
    // servicesMap = (HashMap<String, Service>)
    // servicesField.get(rawTicket);
    // log.error("ServiceMaps is empty ? {}", servicesMap.isEmpty());
    // for(Map.Entry<String, Service> entry : servicesMap.entrySet()){
    // AbstractWebApplicationService webAppService =
    // (AbstractWebApplicationService) entry.getValue();
    // log.error("Service for ticket {} is {}", rawTicket.getId(),
    // webAppService.getId());
    // }
    // if (!servicesMap.containsKey(service.getId()) ||
    // !servicesMap.get(service.getId()).equals(service)) {
    // log.error("Ticket is not granted to client : {}", clientId);
    // jsonGenerator.writeStartObject();
    // jsonGenerator.writeStringField("error", TICKET_NOT_GRANTED);
    // jsonGenerator.writeEndObject();
    // jsonGenerator.close();
    // response.flushBuffer();
    // return null;
    // }

    // Check if the caller has permission for retrieving permission information
    if (!targetClientId.equals(clientId)) {
        final Principal principal = ticketGrantingTicket.getAuthentication().getPrincipal();
        if (!isPermitted(principal.getId(), targetService.getId())) {
            log.error("[{} from {}] is not permitted to retrieve permission information on [{}]",
                    principal.getId(), clientId, targetClientId);
            writeErrorMessage(response, "permission_denied");
            return null;
        }
    }

    final JsonFactory jsonFactory = new JsonFactory();
    final JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(response.getWriter());

    final Principal principal = userTicketGrantingTicket.getAuthentication().getPrincipal();
    final Map<String, Set<String>> permissions = extractPermissions(targetService.getId(), principal.getId());

    jsonGenerator.writeStartObject();
    jsonGenerator.writeStringField(CasWrapperProfile.ID, principal.getId());

    jsonGenerator.writeArrayFieldStart("role_permissions");

    for (final String roleName : permissions.keySet()) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeArrayFieldStart(roleName);

        for (final String permission : permissions.get(roleName))
            jsonGenerator.writeString(permission);

        jsonGenerator.writeEndArray();
        jsonGenerator.writeEndObject();
    }

    jsonGenerator.writeEndArray();
    jsonGenerator.writeEndObject();
    jsonGenerator.close();
    response.flushBuffer();

    return null;
}

From source file:org.apache.olingo.server.core.serializer.json.ODataJsonSerializer.java

@Override
public SerializerResult error(final ODataServerError error) throws SerializerException {
    OutputStream outputStream = null;
    SerializerException cachedException = null;
    try {//  w ww. j a  v a  2s  . c o  m
        CircleStreamBuffer buffer = new CircleStreamBuffer();
        outputStream = buffer.getOutputStream();
        JsonGenerator json = new JsonFactory().createGenerator(outputStream);
        new ODataErrorSerializer().writeErrorDocument(json, error);

        json.close();
        outputStream.close();
        return SerializerResultImpl.with().content(buffer.getInputStream()).build();
    } catch (final IOException e) {
        cachedException = new SerializerException(IO_EXCEPTION_TEXT, e,
                SerializerException.MessageKeys.IO_EXCEPTION);
        throw cachedException;
    } finally {
        closeCircleStreamBufferOutput(outputStream, cachedException);
    }
}

From source file:com.github.jknack.handlebars.Jackson2Helper.java

@Override
public CharSequence apply(final Object context, final Options options) throws IOException {
    if (context == null) {
        return options.hash("default", "");
    }//from w  w  w. jav  a2s .  c  o  m
    String viewName = options.hash("view", "");
    JsonGenerator generator = null;
    try {
        final ObjectWriter writer;
        // do we need to use a view?
        if (!isEmpty(viewName)) {
            Class<?> viewClass = alias.get(viewName);
            if (viewClass == null) {
                viewClass = getClass().getClassLoader().loadClass(viewName);
            }
            writer = mapper.writerWithView(viewClass);
        } else {
            writer = mapper.writer();
        }
        JsonFactory jsonFactory = mapper.getFactory();

        SegmentedStringWriter output = new SegmentedStringWriter(jsonFactory._getBufferRecycler());

        // creates a json generator.
        generator = jsonFactory.createJsonGenerator(output);

        Boolean escapeHtml = options.hash("escapeHTML", Boolean.FALSE);
        // do we need to escape html?
        if (escapeHtml) {
            generator.setCharacterEscapes(new HtmlEscapes());
        }

        Boolean pretty = options.hash("pretty", Boolean.FALSE);

        // write the JSON output.
        if (pretty) {
            writer.withDefaultPrettyPrinter().writeValue(generator, context);
        } else {
            writer.writeValue(generator, context);
        }

        generator.close();

        return new Handlebars.SafeString(output.getAndClear());
    } catch (ClassNotFoundException ex) {
        throw new IllegalArgumentException(viewName, ex);
    } finally {
        if (generator != null && !generator.isClosed()) {
            generator.close();
        }
    }
}

From source file:org.codehaus.modello.plugin.jsonschema.JsonSchemaGenerator.java

private void generateJsonSchema(Properties parameters) throws IOException, ModelloException {
    Model objectModel = getModel();/*w  ww  .ja  v  a2 s.co  m*/

    File directory = getOutputDirectory();

    if (isPackageWithVersion()) {
        directory = new File(directory, getGeneratedVersion().toString());
    }

    if (!directory.exists()) {
        directory.mkdirs();
    }

    // we assume parameters not null
    String schemaFileName = parameters.getProperty(ModelloParameterConstants.OUTPUT_JSONSCHEMA_FILE_NAME);

    File schemaFile;

    if (schemaFileName != null) {
        schemaFile = new File(directory, schemaFileName);
    } else {
        schemaFile = new File(directory, objectModel.getId() + "-" + getGeneratedVersion() + ".schema.json");
    }

    JsonGenerator generator = new JsonFactory().enable(Feature.AUTO_CLOSE_JSON_CONTENT)
            .enable(Feature.AUTO_CLOSE_TARGET).enable(Feature.ESCAPE_NON_ASCII)
            .enable(Feature.FLUSH_PASSED_TO_STREAM).enable(Feature.QUOTE_FIELD_NAMES)
            .enable(Feature.QUOTE_NON_NUMERIC_NUMBERS).disable(Feature.WRITE_NUMBERS_AS_STRINGS)
            .createGenerator(schemaFile, JsonEncoding.UTF8);

    generator.useDefaultPrettyPrinter();

    ModelClass root = objectModel.getClass(objectModel.getRoot(getGeneratedVersion()), getGeneratedVersion());

    try {
        generator.writeStartObject();
        generator.writeStringField("$schema", "http://json-schema.org/draft-04/schema#");

        writeClassDocumentation(generator, root, true);

        generator.writeObjectFieldStart("definitions");

        for (ModelClass current : objectModel.getClasses(getGeneratedVersion())) {
            if (!root.equals(current)) {
                writeClassDocumentation(generator, current, false);
            }
        }

        // end "definitions"
        generator.writeEndObject();

        // end main object
        generator.writeEndObject();
    } finally {
        generator.close();
    }
}

From source file:org.apache.olingo.server.core.serializer.json.ODataJsonSerializer.java

@Override
public SerializerResult metadataDocument(final ServiceMetadata serviceMetadata) throws SerializerException {
    OutputStream outputStream = null;
    SerializerException cachedException = null;

    try {/*from w  w  w  . ja  va  2s.  c  o  m*/
        CircleStreamBuffer buffer = new CircleStreamBuffer();
        outputStream = buffer.getOutputStream();
        JsonGenerator json = new JsonFactory().createGenerator(outputStream);
        new MetadataDocumentJsonSerializer(serviceMetadata).writeMetadataDocument(json);

        json.close();
        outputStream.close();
        return SerializerResultImpl.with().content(buffer.getInputStream()).build();
    } catch (final IOException e) {
        cachedException = new SerializerException(IO_EXCEPTION_TEXT, e,
                SerializerException.MessageKeys.IO_EXCEPTION);
        throw cachedException;
    } finally {
        closeCircleStreamBufferOutput(outputStream, cachedException);
    }
}