Java DefaultIdentityService类代码示例

import org.eclipse.jetty.security.DefaultIdentityService; //导入依赖的package包/类
static ConstraintSecurityHandler createSecurityHandler(String realm, List<String> roles) {
  final ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler();
  Constraint constraint = new Constraint();
  constraint.setAuthenticate(true);
  constraint.setRoles(roles.toArray(new String[0]));
  ConstraintMapping constraintMapping = new ConstraintMapping();
  constraintMapping.setConstraint(constraint);
  constraintMapping.setMethod("*");
  constraintMapping.setPathSpec("/*");
  securityHandler.addConstraintMapping(constraintMapping);
  securityHandler.setAuthenticator(new BasicAuthenticator());
  securityHandler.setLoginService(new JAASLoginService(realm));
  securityHandler.setIdentityService(new DefaultIdentityService());
  securityHandler.setRealmName(realm);
  return securityHandler;
}
 

import org.eclipse.jetty.security.DefaultIdentityService; //导入依赖的package包/类
public DrillSpnegoLoginService(DrillbitContext drillBitContext) throws DrillException {
  super(DrillSpnegoLoginService.class.getName());
  setIdentityService(new DefaultIdentityService());
  drillContext = drillBitContext;

  // Load and verify SPNEGO config. Then Login using creds to get an UGI instance
  spnegoConfig = new SpnegoConfig(drillBitContext.getConfig());
  spnegoConfig.validateSpnegoConfig();
  loggedInUgi = spnegoConfig.getLoggedInUgi();
}
 

import org.eclipse.jetty.security.DefaultIdentityService; //导入依赖的package包/类
/**
 * Inject custom {@link LoginService} and {@link Authenticator}
 * implementations into the specified {@link ConstraintSecurityHandler}.
 */
public static void configureSecurityHandler(
    ConstraintSecurityHandler handler, VmRuntimeTrustedAddressChecker checker) {

  LoginService loginService = new AppEngineLoginService();
  LoginAuthenticator authenticator = new AppEngineAuthenticator(checker);
  DefaultIdentityService identityService = new DefaultIdentityService();

  // Set allowed roles.
  handler.setRoles(new HashSet<String>(Arrays.asList(new String[] {USER_ROLE, ADMIN_ROLE})));
  handler.setLoginService(loginService);
  handler.setAuthenticator(authenticator);
  handler.setIdentityService(identityService);
  authenticator.setConfiguration(handler);
}
 

import org.eclipse.jetty.security.DefaultIdentityService; //导入依赖的package包/类
@BeforeClass
public static void setupTest() throws Exception {
  spnegoHelper = new KerberosHelper(TestSpnegoAuthentication.class.getSimpleName(), primaryName);
  spnegoHelper.setupKdc(dirTestWatcher.getTmpDir());


  sun.security.krb5.Config.refresh();

  // (2) Reset the default realm.
  final Field defaultRealm = KerberosName.class.getDeclaredField("defaultRealm");
  defaultRealm.setAccessible(true);
  defaultRealm.set(null, KerberosUtil.getDefaultRealm());

  // Create a DrillbitContext with service principal and keytab for DrillSpnegoLoginService
  final DrillConfig newConfig = new DrillConfig(DrillConfig.create()
      .withValue(ExecConstants.HTTP_AUTHENTICATION_MECHANISMS,
          ConfigValueFactory.fromIterable(Lists.newArrayList("spnego")))
      .withValue(ExecConstants.HTTP_SPNEGO_PRINCIPAL,
          ConfigValueFactory.fromAnyRef(spnegoHelper.SERVER_PRINCIPAL))
      .withValue(ExecConstants.HTTP_SPNEGO_KEYTAB,
          ConfigValueFactory.fromAnyRef(spnegoHelper.serverKeytab.toString())),
      false);

  // Create mock objects for optionManager and AuthConfiguration
  final SystemOptionManager optionManager = Mockito.mock(SystemOptionManager.class);
  Mockito.when(optionManager.getOption(ExecConstants.ADMIN_USERS_VALIDATOR))
      .thenReturn(ExecConstants.ADMIN_USERS_VALIDATOR.DEFAULT_ADMIN_USERS);
  Mockito.when(optionManager.getOption(ExecConstants.ADMIN_USER_GROUPS_VALIDATOR))
      .thenReturn(ExecConstants.ADMIN_USER_GROUPS_VALIDATOR.DEFAULT_ADMIN_USER_GROUPS);

  final DrillbitContext drillbitContext = Mockito.mock(DrillbitContext.class);
  Mockito.when(drillbitContext.getConfig()).thenReturn(newConfig);
  Mockito.when(drillbitContext.getOptionManager()).thenReturn(optionManager);

  Authenticator.AuthConfiguration authConfiguration = Mockito.mock(Authenticator.AuthConfiguration.class);

  spnegoAuthenticator = new DrillSpnegoAuthenticator("SPNEGO");
  DrillSpnegoLoginService spnegoLoginService = new DrillSpnegoLoginService(drillbitContext);

  Mockito.when(authConfiguration.getLoginService()).thenReturn(spnegoLoginService);
  Mockito.when(authConfiguration.getIdentityService()).thenReturn(new DefaultIdentityService());
  Mockito.when(authConfiguration.isSessionRenewedOnAuthentication()).thenReturn(true);

  // Set the login service and identity service inside SpnegoAuthenticator
  spnegoAuthenticator.setConfiguration(authConfiguration);
}
 

import org.eclipse.jetty.security.DefaultIdentityService; //导入依赖的package包/类
private ServletContextHandler createServletContextHandlerSpnego() {
	GlobalConfigurationJsonStore config = injector().getInstance(GlobalConfigurationJsonStore.class);
	ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS
			| ServletContextHandler.SECURITY);

	Constraint constraint = new Constraint();
	constraint.setName(Constraint.__SPNEGO_AUTH);
	constraint.setRoles(config.get().roles());
	constraint.setAuthenticate(true);

	ConstraintMapping constraintMapping = new ConstraintMapping();
	constraintMapping.setConstraint(constraint);
	constraintMapping.setPathSpec("/*");

	ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler(){
		@Override
		public void handle(String pathInContext, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
	    {
			response.addHeader("Access-Control-Allow-Origin", "*");
			if (request.getHeader("Access-Control-Request-Method") != null && "OPTIONS".equals(request.getMethod())) {
				response.addHeader("Access-Control-Allow-Methods","GET, POST, PUT, DELETE");
				response.addHeader("Access-Control-Allow-Headers",
				"X-Requested-With,Origin,Content-Type, Accept");
			}
			super.handle(pathInContext, baseRequest, request, response);
	    }
	};
	
	Constraint constraint2 = new Constraint();
	constraint2.setAuthenticate(false);
	constraint.setName("reporter");
	constraint.setRoles(config.get().roles());
	ConstraintMapping constraintMapping2 = new ConstraintMapping();
	constraintMapping2.setConstraint(constraint2);
	constraintMapping2.setPathSpec(Constants.apiContext(Constants.REPORTER_CONTEXT));
	
	Constraint constraint3 = new Constraint();
	constraint3.setAuthenticate(false);
	constraint.setName("api_with_token");
	constraint.setRoles(config.get().roles());
	ConstraintMapping constraintMapping3 = new ConstraintMapping();
	constraintMapping3.setConstraint(constraint3);
	constraintMapping3.setPathSpec(Constants.apiTokenContext("/*"));

	securityHandler.addConstraintMapping(constraintMapping3);
	securityHandler.addConstraintMapping(constraintMapping2);
	securityHandler.addConstraintMapping(constraintMapping);
	SpnegoLoginService loginService = new SpnegoLoginService(null, Constants.getSpnegoPropertiesPath());
	securityHandler.setLoginService(loginService);
	
	final DefaultIdentityService idService = new DefaultIdentityService();
	loginService.setIdentityService(idService);
	SpnegoAuthenticator authenticator = new SpnegoAuthenticator();
	securityHandler.setAuthenticator(authenticator);

	context.setSecurityHandler(securityHandler);
	return context;
}