org.glassfish.jersey.filter.LoggingFilter Java Examples

@Override
protected void serviceInit(Configuration conf) throws Exception {
  GsonFeature gsonFeature = new GsonFeature(PlanGsonHelper.registerAdapters());
  
  ClientApplication clientApplication = new ClientApplication(masterContext);
  ResourceConfig resourceConfig = ResourceConfig.forApplication(clientApplication)
      .register(gsonFeature)
      .register(LoggingFilter.class)
      .property(ServerProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ServerProperties.METAINF_SERVICES_LOOKUP_DISABLE, true);
  TajoConf tajoConf = (TajoConf) conf;

  InetSocketAddress address = tajoConf.getSocketAddrVar(TajoConf.ConfVars.REST_SERVICE_ADDRESS);
  URI restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  int workerCount = TajoConf.getIntVar(tajoConf, TajoConf.ConfVars.REST_SERVICE_RPC_SERVER_WORKER_THREAD_NUM);
  restServer = NettyRestServerFactory.createNettyRestServer(restServiceURI, resourceConfig, workerCount, false);

  super.serviceInit(conf);
  
  LOG.info("Tajo Rest Service initialized.");
}
 

void start() {
    try {
        Config config = stargraph.getMainConfig();
        String urlStr = config.getString("networking.rest-url");
        ResourceConfig rc = new ResourceConfig();
        rc.register(LoggingFilter.class);
        rc.register(JacksonFeature.class);
        rc.register(MultiPartFeature.class);
        rc.register(CatchAllExceptionMapper.class);
        rc.register(SerializationExceptionMapper.class);
        rc.register(AdminResourceImpl.class);
        rc.register(new KBResourceImpl(stargraph));
        rc.register(new QueryResourceImpl(stargraph));
        httpServer = GrizzlyHttpServerFactory.createHttpServer(URI.create(urlStr), rc, true);
        logger.info(marker, "Stargraph listening on {}", urlStr);
    } catch (Exception e) {
        throw new StarGraphException(e);
    }
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  functionsURI = new URI(restServiceURI + "/functions");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

private static Client createClient(boolean logging, WnsProxyProperties proxyProps) {
    ClientConfig clientConfig = new ClientConfig(JacksonJaxbXMLProvider.class, JacksonJsonProvider.class);

    setProxyCredentials(clientConfig, proxyProps);

    Client client = ClientBuilder.newClient(clientConfig);
    if (logging) {
        LoggingFilter loggingFilter = new LoggingFilter(
                Logger.getLogger(WnsClient.class.getName()), true);

        client = client.register(loggingFilter);
    }
    return client;
}
 

@Test
public void simpleResourceTest() throws UnsupportedEncodingException
{
	
	ClientIdentifier cliendId = new ClientIdentifier(clientEntity.getClientId(), clientEntity.getClientSecret());
	
	Builder<?> flowBuilder = OAuth2ClientSupport.authorizationCodeGrantFlowBuilder(cliendId, "http://localhost:9998/testsuite/oauth2/auth", "http://localhost:9998/testsuite/oauth2/accessToken");
	OAuth2CodeGrantFlow flow = flowBuilder.scope("test1 test2").redirectUri("http://localhost:9998/testsuite").build();
	String authUrl = flow.start();
	
	Map<String, String> map = retrieveCode(authUrl);
	String code = map.get("code");
	String state = map.get("state"); 
	
	TokenResult tokenResult = flow.finish(code, state);

	client = ClientBuilder.newClient();
	client.register(LoggingFilter.class);
	client.register(OAuth2ClientSupport.feature(tokenResult.getAccessToken()));
	client.register(JacksonFeature.class);
	Invocation.Builder builder = client.target("http://localhost:9998/testsuite/rest/sample/1").request();
	Response response = builder.get();
	
	assertEquals(200, response.getStatus());
	SampleEntity entity = response.readEntity(SampleEntity.class);
	assertNotNull(entity);
}
 

@Before
public void setUp()
{
	super.setUp();
	ClientConfig clientConfig = new ClientConfig();
	clientConfig.property(ClientProperties.FOLLOW_REDIRECTS, false);
	client = ClientBuilder.newClient(clientConfig);
	client.register(new HttpBasicAuthFilter("manager", "test"));
	client.register(LoggingFilter.class);
	authClient.authorizeClient(clientEntity, "test1 test2");
}
 

public JerseyConfig() {
    property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true);
    property(ServerProperties.JSON_PROCESSING_FEATURE_DISABLE, false);
    property(ServerProperties.MOXY_JSON_FEATURE_DISABLE, true);
    property(ServerProperties.WADL_FEATURE_DISABLE, true);
    register(LoggingFilter.class);
    register(JacksonFeature.class);
    register(HelloService.class);
}
 

public ApplicationConfig() {
    register(RequestContextFilter.class);
    register(RolesAllowedDynamicFeature.class);
    register(Jackson2Feature.class);

    register(AuthorizationRequestFilter.class);
    register(QuestionnairResource.class);
    register(LoggingFilter.class);

    // register(JerseyResource.class);
    // register(SpringSingletonResource.class);
    // register(SpringRequestResource.class);
    // register(CustomExceptionMapper.class);

}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  sessionsURI = new URI(restServiceURI + "/sessions");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  sessionsURI = new URI(restServiceURI + "/sessions");
  queriesURI = new URI(restServiceURI + "/queries");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  tablesURI = new URI(restServiceURI + "/databases/" + defaultDatabaseName + "/tables");
queriesURI = new URI(restServiceURI + "/queries");
sessionsURI = new URI(restServiceURI + "/sessions");
restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  sessionsURI = new URI(restServiceURI + "/sessions");
  queriesURI = new URI(restServiceURI + "/queries");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  clusterURI = new URI(restServiceURI + "/cluster");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

@Before
public void setUp() throws Exception {
  InetSocketAddress address = testBase.getTestingCluster().getConfiguration().getSocketAddrVar(ConfVars.REST_SERVICE_ADDRESS);
  restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  databasesURI = new URI(restServiceURI + "/databases");
  restClient = ClientBuilder.newBuilder()
      .register(new GsonFeature(PlanGsonHelper.registerAdapters()))
      .register(LoggingFilter.class)
      .property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ClientProperties.METAINF_SERVICES_LOOKUP_DISABLE, true)
      .build();
}
 

public JerseyConfig() {
    register(InMemoryDiscoveryServer.class);
    property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, false);
    register(new LoggingFilter(LOGGER, true));
    property(JsonGenerator.PRETTY_PRINTING, true);
    register(JacksonFeature.class);
}
 

@Override
public void run(final ApiConfiguration configuration,
                final Environment environment) {

  // Common initializations
  EsInstanceStore cmdbInstanceStore = new EsInstanceStore();
  ServiceMappingStore serviceMappingStore = new EsServiceMappingStore();
  InstanceCounterStore instanceCounterStore = new EsInstanceCounterStore();

  // Health checks
  final EsHealthChecker esHealthChecker = new EsHealthChecker(cmdbInstanceStore);
  environment.healthChecks().register("cmdbStore", esHealthChecker);

  // Logging inbound request/response
  environment.jersey().register(
      new LoggingFilter(java.util.logging.Logger.getLogger("InboundRequestResponse"), true));

  // Add API endpoints here
  final Instance instance = new Instance(cmdbInstanceStore);
  environment.jersey().register(instance);

  final Health health = new Health();
  environment.jersey().register(health);

  final Query query = new Query(cmdbInstanceStore);
  environment.jersey().register(query);

  final InstanceCounter instanceCounter = new InstanceCounter(instanceCounterStore);
  environment.jersey().register(instanceCounter);

  final DailySnapshot dailySnapshot = new DailySnapshot();
  environment.jersey().register(dailySnapshot);
}
 

public RestResourceConfig() {
	log.info("-----------------------------loading JERSEY2 restful---------------------------");
 	packages("com.framework.rest.service");
 register(RestAuthRequestFilter.class);
 register(RestResponseFilter.class);
 register(LoggingFilter.class);
 register(JacksonFeature.class);
 register(DeflateEncoder.class);
 EncodingFilter.enableFor(this, GZipEncoder.class);
}
 

/**
 * Build the Client used to make HTTP requests.
 * @param debugging Debug setting
 * @return Client
 */
private Client buildHttpClient(boolean debugging) {
  final ClientConfig clientConfig = new ClientConfig();
  clientConfig.register(MultiPartFeature.class);
  clientConfig.register(json);
  clientConfig.register(JacksonFeature.class);
  if (debugging) {
    clientConfig.register(LoggingFilter.class);
  }
  return ClientBuilder.newClient(clientConfig);
}
 

private WebTarget createMockWebTarget() {
  IMocksControl control = createControl();
  WebTarget wt = control.createMock(WebTarget.class);
  expect(wt.register(isA(LoggingFilter.class))).andReturn(wt).anyTimes();
  return wt;
}
 

public static void configClient(ClientConfig config) {
    config.register(LoggingFilter.class)
        .register(LocaleContextFilter.class)
        .register(ObjectMapperProviderTest.class)
        .register(JacksonFeature.class);
}