/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF 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.apache.usergrid.rest;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.jaxrs.json.annotation.JSONP;
import com.google.common.collect.BiMap;
import com.google.inject.Injector;
import com.yammer.metrics.Metrics;
import com.yammer.metrics.core.*;
import com.yammer.metrics.stats.Snapshot;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.usergrid.corepersistence.asyncevents.AsyncEventService;
import org.apache.usergrid.persistence.core.util.Health;
import org.apache.usergrid.persistence.index.query.Identifier;
import org.apache.usergrid.rest.applications.ApplicationResource;
import org.apache.usergrid.rest.exceptions.NoOpException;
import org.apache.usergrid.rest.organizations.OrganizationResource;
import org.apache.usergrid.rest.security.annotations.RequireSystemAccess;
import org.apache.usergrid.system.UsergridSystemMonitor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import javax.ws.rs.*;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.ResponseBuilder;
import javax.ws.rs.core.UriInfo;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Map;
import java.util.SortedMap;
import java.util.UUID;
/** @author ed@anuff.com */
@Path("/")
@Component
@Scope("singleton")
@Produces({
MediaType.APPLICATION_JSON, "application/javascript", "application/x-javascript", "text/ecmascript",
"application/ecmascript", "text/jscript"
})
public class RootResource extends AbstractContextResource implements MetricProcessor<RootResource.MetricContext> {
static final class MetricContext {
final boolean showFullSamples;
final ObjectNode objectNode;
MetricContext( ObjectNode objectNode, boolean showFullSamples ) {
this.objectNode = objectNode;
this.showFullSamples = showFullSamples;
}
}
private static final Logger logger = LoggerFactory.getLogger( RootResource.class );
long started = System.currentTimeMillis();
@Autowired
private UsergridSystemMonitor usergridSystemMonitor;
@Autowired
private Injector injector;
public RootResource() {
}
@RequireSystemAccess
@GET
@Path("applications")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public ApiResponse getAllApplications(
@Context UriInfo ui,
@QueryParam("deleted") @DefaultValue("false") Boolean deleted,
@QueryParam("callback") @DefaultValue("callback") String callback ) throws URISyntaxException {
if (logger.isTraceEnabled()) {
logger.trace("RootResource.getData");
}
ApiResponse response = createApiResponse();
response.setAction( "get applications" );
Map<String, UUID> applications = null;
try {
if ( deleted ) {
applications = emf.getDeletedApplications();
} else {
applications = emf.getApplications();
}
response.setSuccess();
response.setApplications( applications );
}
catch ( Exception e ) {
logger.info( "Unable to retrieve applications", e );
response.setError( "Unable to retrieve applications" );
}
return response;
}
@RequireSystemAccess
@GET
@Path("apps")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public ApiResponse getAllApplications2( @Context UriInfo ui,
@QueryParam("callback") @DefaultValue("callback") String callback )
throws URISyntaxException {
return getAllApplications( ui, false, callback );
}
@GET
public Response getRoot( @Context UriInfo ui ) throws URISyntaxException {
String redirect_root = properties.getRedirectRoot();
if ( StringUtils.isNotBlank( redirect_root ) ) {
ResponseBuilder response = Response.temporaryRedirect( new URI( redirect_root ) );
return response.build();
}
else {
ResponseBuilder response = Response.temporaryRedirect( new URI( "/status" ) );
return response.build();
}
}
/**
* Return status of this Usergrid instance in JSON format.
*
* By Default this end-point will ignore errors but if you call it with ignore_status=false
* then it will return HTTP 500 if either the Entity store or the Index for the management
* application are in a bad state.
*
* @param ignoreError Ignore any errors and return status no matter what.
*/
@GET
@Path("status")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public ApiResponse getStatus(
@QueryParam("ignore_error") @DefaultValue("true") Boolean ignoreError,
@QueryParam("callback") @DefaultValue("callback") String callback ) {
ApiResponse response = createApiResponse();
if ( !ignoreError ) {
if ( !emf.getEntityStoreHealth().equals( Health.GREEN )) {
throw new RuntimeException("Error connecting to datastore");
}
if ( emf.getIndexHealth().equals( Health.RED) ) {
throw new RuntimeException("Management app index is status RED");
}
}
ObjectNode node = JsonNodeFactory.instance.objectNode();
node.put( "started", started );
node.put( "uptime", System.currentTimeMillis() - started );
node.put( "version", usergridSystemMonitor.getBuildNumber());
// Hector status, for backwards compatibility
node.put("cassandraAvailable", usergridSystemMonitor.getIsCassandraAlive());
// Core Persistence Collections module status
node.put( "cassandraStatus", emf.getEntityStoreHealth().toString() );
// Core Persistence Query Index module status for Management App Index
node.put( "managementAppIndexStatus", emf.getIndexHealth().toString() );
dumpMetrics(node);
response.setProperty( "status", node );
return response;
}
@GET
@Path("lb-status")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public Response getLbStatus() {
ResponseBuilder response;
if ( usergridSystemMonitor.getIsCassandraAlive() ) {
response = Response.noContent().status( Response.Status.OK );
}
else {
response = Response.noContent().status( Response.Status.SERVICE_UNAVAILABLE );
}
return response.build();
}
@GET
@Path("/status/queue")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public ApiResponse getQueueDepth(){
ApiResponse response = createApiResponse();
AsyncEventService eventService = injector.getInstance(AsyncEventService.class);
ObjectNode node = JsonNodeFactory.instance.objectNode();
String provider = "LOCAL";
String queueManagerClass = eventService.getQueueManagerClass();
if(queueManagerClass.contains("SNS") || queueManagerClass.contains("SQS")){
provider = "AWS";
}
node.put( "provider", provider );
node.put( "depth", eventService.getQueueDepth() );
response.setProperty( "status", node );
return response;
}
@GET
@Path("/status/heap")
@JSONP
@Produces({MediaType.APPLICATION_JSON, "application/javascript"})
public ApiResponse getHeapStats(){
ApiResponse response = createApiResponse();
ObjectNode node = JsonNodeFactory.instance.objectNode();
long heapAllocatedSize = Runtime.getRuntime().totalMemory();
long heapMaxSize = Runtime.getRuntime().maxMemory();
long heapFreeSize = Runtime.getRuntime().freeMemory();
long heapUsedSize = heapAllocatedSize - heapFreeSize;
node.put( "used", org.apache.usergrid.utils.StringUtils.readableByteSize(heapUsedSize) );
node.put( "free", org.apache.usergrid.utils.StringUtils.readableByteSize(heapFreeSize) );
node.put( "allocated", org.apache.usergrid.utils.StringUtils.readableByteSize(heapAllocatedSize) );
node.put( "max", org.apache.usergrid.utils.StringUtils.readableByteSize(heapMaxSize) );
response.setProperty( "status", node );
return response;
}
private void dumpMetrics( ObjectNode node ) {
MetricsRegistry registry = Metrics.defaultRegistry();
for ( Map.Entry<String, SortedMap<MetricName, Metric>> entry : registry.groupedMetrics().entrySet() ) {
ObjectNode meterNode = JsonNodeFactory.instance.objectNode();
for ( Map.Entry<MetricName, Metric> subEntry : entry.getValue().entrySet() ) {
ObjectNode metricNode = JsonNodeFactory.instance.objectNode();
try {
subEntry.getValue().processWith( this, subEntry.getKey(), new MetricContext( metricNode, true ) );
}
catch ( Exception e ) {
logger.warn( "Error writing out {}", subEntry.getKey(), e );
}
meterNode.put( subEntry.getKey().getName(), metricNode );
}
node.put( entry.getKey(), meterNode );
}
}
@Path("{applicationId: [A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}}")
public ApplicationResource getApplicationById( @PathParam("applicationId") String applicationIdStr )
throws Exception {
if ( "options".equalsIgnoreCase( request.getMethod() ) ) {
throw new NoOpException();
}
UUID applicationId = UUID.fromString( applicationIdStr );
if ( applicationId == null ) {
return null;
}
return appResourceFor( applicationId );
}
private ApplicationResource appResourceFor( UUID applicationId ) throws Exception {
if ( applicationId.equals( emf.getManagementAppId() ) ) {
throw new UnauthorizedException();
}
return getSubResource( ApplicationResource.class ).init( applicationId );
}
@Path("applications/"+APPLICATION_ID_PATH)
public ApplicationResource getApplicationById2( @PathParam("applicationId") String applicationId )
throws Exception {
return getApplicationById( applicationId );
}
@Path("apps/"+APPLICATION_ID_PATH)
public ApplicationResource getApplicationById3( @PathParam("applicationId") String applicationId )
throws Exception {
return getApplicationById( applicationId );
}
public static final String APPLICATION_ID_PATH = "{applicationId: " + Identifier.UUID_REX + "}";
public static final String ORGANIZATION_ID_PATH = "{organizationId: " + Identifier.UUID_REX + "}";
public static final String USER_ID_PATH = "{userId: " + Identifier.UUID_REX + "}";
public static final String ENTITY_ID_PATH = "{entityId: " + Identifier.UUID_REX + "}";
public static final String EMAIL_PATH = "{email: " + Identifier.EMAIL_REX + "}";
@Path(ORGANIZATION_ID_PATH+"/"+APPLICATION_ID_PATH)
public ApplicationResource getApplicationByUuids( @PathParam("organizationId") String organizationIdStr,
@PathParam("applicationId") String applicationIdStr )
throws Exception {
UUID applicationId = UUID.fromString( applicationIdStr );
UUID organizationId = UUID.fromString( organizationIdStr );
if ( applicationId == null || organizationId == null ) {
return null;
}
BiMap<UUID, String> apps = management.getApplicationsForOrganization( organizationId );
if ( apps.get( applicationId ) == null ) {
return null;
}
return appResourceFor( applicationId );
}
private OrganizationResource orgResourceFor( String organizationName ) throws Exception {
return getSubResource( OrganizationResource.class ).init( organizationName );
}
@Path("{organizationName}")
public OrganizationResource getOrganizationByName( @PathParam("organizationName") String organizationName )
throws Exception {
if ( "options".equalsIgnoreCase( request.getMethod() ) ) {
throw new NoOpException();
}
return orgResourceFor( organizationName );
}
@Path("organizations/{organizationName}")
public OrganizationResource getOrganizationByName2( @PathParam("organizationName") String organizationName )
throws Exception {
return getOrganizationByName( organizationName );
}
@Path("orgs/{organizationName}")
public OrganizationResource getOrganizationByName3( @PathParam("organizationName") String organizationName )
throws Exception {
if (logger.isTraceEnabled()) {
logger.trace("getOrganizationByName3");
}
return getOrganizationByName( organizationName );
}
@Path("o/{organizationName}")
public OrganizationResource getOrganizationByName4( @PathParam("organizationName") String organizationName )
throws Exception {
return getOrganizationByName( organizationName );
}
@Override
public void processHistogram( MetricName name, Histogram histogram, MetricContext context ) throws Exception {
final ObjectNode node = context.objectNode;
node.put( "type", "histogram" );
node.put( "count", histogram.count() );
writeSummarizable( histogram, node );
writeSampling( histogram, node );
}
@Override
public void processCounter( MetricName name, Counter counter, MetricContext context ) throws Exception {
final ObjectNode node = context.objectNode;
node.put( "type", "counter" );
node.put( "count", counter.count() );
}
@Override
public void processGauge( MetricName name, Gauge<?> gauge, MetricContext context ) throws Exception {
final ObjectNode node = context.objectNode;
node.put( "type", "gauge" );
node.put( "vale", "[disabled]" );
}
@Override
public void processMeter( MetricName name, Metered meter, MetricContext context ) throws Exception {
final ObjectNode node = context.objectNode;
node.put( "type", "meter" );
node.put( "event_type", meter.eventType() );
writeMeteredFields( meter, node );
}
@Override
public void processTimer( MetricName name, Timer timer, MetricContext context ) throws Exception {
final ObjectNode node = context.objectNode;
node.put( "type", "timer" );
// json.writeFieldName("duration");
node.put( "unit", timer.durationUnit().toString().toLowerCase() );
ObjectNode durationNode = JsonNodeFactory.instance.objectNode();
writeSummarizable( timer, durationNode );
writeSampling( timer, durationNode );
node.put( "duration", durationNode );
writeMeteredFields( timer, node );
}
private static void writeSummarizable( Summarizable metric, ObjectNode mNode ) throws IOException {
mNode.put( "min", metric.min() );
mNode.put( "max", metric.max() );
mNode.put( "mean", metric.mean() );
mNode.put( "std_dev", metric.stdDev() );
}
private static void writeSampling( Sampling metric, ObjectNode mNode ) throws IOException {
final Snapshot snapshot = metric.getSnapshot();
mNode.put( "median", snapshot.getMedian() );
mNode.put( "p75", snapshot.get75thPercentile() );
mNode.put( "p95", snapshot.get95thPercentile() );
mNode.put( "p98", snapshot.get98thPercentile() );
mNode.put( "p99", snapshot.get99thPercentile() );
mNode.put( "p999", snapshot.get999thPercentile() );
}
private static void writeMeteredFields( Metered metered, ObjectNode node ) throws IOException {
ObjectNode mNode = JsonNodeFactory.instance.objectNode();
mNode.put( "unit", metered.rateUnit().toString().toLowerCase() );
mNode.put( "count", metered.count() );
mNode.put( "mean", metered.meanRate() );
mNode.put( "m1", metered.oneMinuteRate() );
mNode.put( "m5", metered.fiveMinuteRate() );
mNode.put( "m15", metered.fifteenMinuteRate() );
node.put( "rate", mNode );
}
}