Java Code Examples for java.security.AccessController

/** 
 * Warning: calling the method more than once may result in undefined behaviour if logout() method is not invoked before.
 */
public void login() throws LoginException {
  PrivilegedExceptionAction<Void> action=new PrivilegedExceptionAction<Void>(){
    public Void run() throws LoginException {
      loginImpl();
      return null;
    }
  }
;
  try {
    if (userProvidedConfig) {
      AccessController.doPrivileged(action,userContext);
    }
 else {
      AccessController.doPrivileged(action);
    }
  }
 catch (  PrivilegedActionException ex) {
    throw (LoginException)ex.getException();
  }
}
 

private void setupThreads(){
  debug("setupThreads()");
  sendThread=(Thread)AccessController.doPrivileged(new PrivilegedAction(){
    public Object run(){
      return getSendThread();
    }
  }
);
  rcvThread=(Thread)AccessController.doPrivileged(new PrivilegedAction(){
    public Object run(){
      return getRcvThread();
    }
  }
);
}
 

private ClassLoader getClassLoader(){
  SecurityManager sm=System.getSecurityManager();
  if (sm != null) {
    return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>(){
      public ClassLoader run(){
        return Thread.currentThread().getContextClassLoader();
      }
    }
);
  }
 else {
    return Thread.currentThread().getContextClassLoader();
  }
}
 

public ProtocolMetaData deploy(Archive<?> archive) throws DeploymentException {
  prepareArchive(archive);
  FixedExplodedExporter exporter=new FixedExplodedExporter(archive,AccessController.doPrivileged(new PrivilegedAction<File>(){
    public File run(){
      return new File(System.getProperty("java.io.tmpdir"));
    }
  }
));
  appLocation=exporter.export();
  return doDeploy(archive);
}
 

static String getProperty(final String key){
  try {
    String value=AccessController.doPrivileged(new PrivilegedExceptionAction<String>(){
      public String run(){
        return System.getProperty(key);
      }
    }
);
    return value;
  }
 catch (  final PrivilegedActionException pae) {
    final Throwable t=pae.getCause();
    if (t instanceof SecurityException) {
      throw (SecurityException)t;
    }
    if (t instanceof NullPointerException) {
      throw (NullPointerException)t;
    }
 else     if (t instanceof IllegalArgumentException) {
      throw (IllegalArgumentException)t;
    }
 else {
      try {
        throw (RuntimeException)t;
      }
 catch (      final ClassCastException cce) {
        throw new RuntimeException("Obtained unchecked Exception; this code should never be reached",t);
      }
    }
  }
}
 

@Override public void validate() throws ConfigurationException {
  super.validate();
  Validate.configurationDirectoryExists(catalinaHome,"Either CATALINA_HOME environment variable or catalinaHome property in Arquillian configuration must be set and point to a valid directory! " + catalinaHome + " is not valid directory!");
  Validate.configurationDirectoryExists(javaHome,"Either JAVA_HOME environment variable or javaHome property in Arquillian configuration must be set and point to a valid directory! " + javaHome + " is not valid directory!");
  Validate.isValidFile(catalinaHome + "/conf/" + serverConfig,"The server configuration file denoted by serverConfig property has to exist! This file: " + catalinaHome + "/conf/"+ serverConfig+ " does not!");
  this.outputToConsole=AccessController.doPrivileged(new PrivilegedAction<Boolean>(){
    @Override public Boolean run(){
      String val=System.getProperty("org.apache.tomcat.writeconsole");
      return val == null || !"false".equals(val);
    }
  }
);
}
 

public String getProperty(final String name,final String defaultValue){
  final PrivilegedAction<String> action=new PrivilegedAction<String>(){
    public String run(){
      return System.getProperty(name,defaultValue);
    }
  }
;
  return (String)AccessController.doPrivileged(action);
}
 

/** 
 * Obtains the Constructor specified from the given Class and argument types
 * @param clazz
 * @param argumentTypes
 * @return
 * @throws NoSuchMethodException
 */
static Constructor<?> getConstructor(final Class<?> clazz,final Class<?>... argumentTypes) throws NoSuchMethodException {
  try {
    return AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>(){
      public Constructor<?> run() throws NoSuchMethodException {
        return clazz.getConstructor(argumentTypes);
      }
    }
);
  }
 catch (  final PrivilegedActionException pae) {
    final Throwable t=pae.getCause();
    if (t instanceof NoSuchMethodException) {
      throw (NoSuchMethodException)t;
    }
 else {
      try {
        throw (RuntimeException)t;
      }
 catch (      final ClassCastException cce) {
        throw new RuntimeException("Obtained unchecked Exception; this code should never be reached",t);
      }
    }
  }
}
 

static Map<String,Field> getAccessableFields(final Class<?> source){
  Map<String,Field> declaredAccessableFields=AccessController.doPrivileged(new PrivilegedAction<Map<String,Field>>(){
    public Map<String,Field> run(){
      Map<String,Field> foundFields=new LinkedHashMap<String,Field>();
      for (      Field field : source.getDeclaredFields()) {
        if (Modifier.isFinal(field.getModifiers())) {
          continue;
        }
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        foundFields.put(field.getName(),field);
      }
      return foundFields;
    }
  }
);
  return declaredAccessableFields;
}
 

static List<Field> getAccessibleFields(final Class<?> source){
  List<Field> declaredAccessableFields=AccessController.doPrivileged(new PrivilegedAction<List<Field>>(){
    public List<Field> run(){
      List<Field> foundFields=new ArrayList<Field>();
      for (      Field field : source.getDeclaredFields()) {
        if (Modifier.isFinal(field.getModifiers())) {
          continue;
        }
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        foundFields.add(field);
      }
      return foundFields;
    }
  }
);
  return declaredAccessableFields;
}
 

static List<Field> getAccessibleFields(final Class<?> source){
  List<Field> declaredAccessableFields=AccessController.doPrivileged(new PrivilegedAction<List<Field>>(){
    public List<Field> run(){
      List<Field> foundFields=new ArrayList<Field>();
      for (      Field field : source.getDeclaredFields()) {
        if (Modifier.isFinal(field.getModifiers())) {
          continue;
        }
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        foundFields.add(field);
      }
      return foundFields;
    }
  }
);
  return declaredAccessableFields;
}
 

/** 
 * <p>Retrieves current thread class loader.</p>
 * @return the class loader
 */
private static ClassLoader getThreadContextClassLoader(){
  return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>(){
    public ClassLoader run(){
      return Thread.currentThread().getContextClassLoader();
    }
  }
);
}
 

/** 
 * Obtains the Constructor specified from the given Class and argument types
 * @param clazz
 * @param argumentTypes
 * @return
 * @throws NoSuchMethodException
 */
static Constructor<?> getConstructor(final Class<?> clazz,final Class<?>... argumentTypes) throws NoSuchMethodException {
  try {
    return AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>(){
      public Constructor<?> run() throws NoSuchMethodException {
        return clazz.getConstructor(argumentTypes);
      }
    }
);
  }
 catch (  final PrivilegedActionException pae) {
    final Throwable t=pae.getCause();
    if (t instanceof NoSuchMethodException) {
      throw (NoSuchMethodException)t;
    }
 else {
      try {
        throw (RuntimeException)t;
      }
 catch (      final ClassCastException cce) {
        throw new RuntimeException("Obtained unchecked Exception; this code should never be reached",t);
      }
    }
  }
}
 

static Map<String,Field> getAccessableFields(final Class<?> source){
  Map<String,Field> declaredAccessableFields=AccessController.doPrivileged(new PrivilegedAction<Map<String,Field>>(){
    public Map<String,Field> run(){
      Map<String,Field> foundFields=new LinkedHashMap<String,Field>();
      for (      Field field : source.getDeclaredFields()) {
        if (Modifier.isFinal(field.getModifiers())) {
          continue;
        }
        if (!field.isAccessible()) {
          field.setAccessible(true);
        }
        foundFields.put(field.getName(),field);
      }
      return foundFields;
    }
  }
);
  return declaredAccessableFields;
}
 

/** 
 * Obtains the Constructor specified from the given Class and argument types
 * @param clazz
 * @param argumentTypes
 * @return
 * @throws NoSuchMethodException
 */
public static Constructor<?> getConstructor(final Class<?> clazz,final Class<?>... argumentTypes) throws NoSuchMethodException {
  try {
    return AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>(){
      public Constructor<?> run() throws NoSuchMethodException {
        return clazz.getConstructor(argumentTypes);
      }
    }
);
  }
 catch (  final PrivilegedActionException pae) {
    final Throwable t=pae.getCause();
    if (t instanceof NoSuchMethodException) {
      throw (NoSuchMethodException)t;
    }
 else {
      try {
        throw (RuntimeException)t;
      }
 catch (      final ClassCastException cce) {
        throw new RuntimeException("Obtained unchecked Exception; this code should never be reached",t);
      }
    }
  }
}
 

/** 
 * {@inheritDoc}
 * @see org.jboss.arquillian.testenricher.ejb.EJBInjectionEnricher#enrich(org.jboss.arquillian.spi.Context,java.lang.Object)
 */
@Override public void enrich(Object testCase){
  super.enrich(testCase);
  final Class<? extends Annotation> inject=(Class<? extends Annotation>)Inject.class;
  List<Field> fieldsWithInject=this.getFieldsWithAnnotation(testCase.getClass(),inject);
  for (  final Field field : fieldsWithInject) {
    if (!field.isAccessible()) {
      AccessController.doPrivileged(new PrivilegedAction<Void>(){
        public Void run(){
          field.setAccessible(true);
          return null;
        }
      }
);
    }
    try {
      final Object resolvedVaue;
      final ArquillianContext arquillianContext=this.getArquillianContext();
      final Class<?> type=field.getType();
      if (field.isAnnotationPresent(Properties.class)) {
        final Properties properties=field.getAnnotation(Properties.class);
        resolvedVaue=arquillianContext.get(type,properties);
      }
 else       if (field.isAnnotationPresent(Property.class)) {
        final Property property=field.getAnnotation(Property.class);
        final Properties properties=new PropertiesImpl(new Property[]{property});
        resolvedVaue=arquillianContext.get(type,properties);
      }
 else {
        resolvedVaue=arquillianContext.get(type);
      }
      field.set(testCase,resolvedVaue);
    }
 catch (    final IllegalAccessException e) {
      throw new RuntimeException("Could not inject into " + field.getName() + " of test case: "+ testCase,e);
    }
  }
}
 

/** 
 * Warning: calling the method more than once may result in undefined behaviour if logout() method is not invoked before.
 */
public void login() throws LoginException {
  PrivilegedExceptionAction<Void> action=new PrivilegedExceptionAction<Void>(){
    public Void run() throws LoginException {
      loginImpl();
      return null;
    }
  }
;
  try {
    if (userProvidedConfig) {
      AccessController.doPrivileged(action,userContext);
    }
 else {
      AccessController.doPrivileged(action);
    }
  }
 catch (  PrivilegedActionException ex) {
    throw (LoginException)ex.getException();
  }
}
 

@Before public void setUp(){
  final AviatorClassLoader classloader=AccessController.doPrivileged(new PrivilegedAction<AviatorClassLoader>(){
    public AviatorClassLoader run(){
      return new AviatorClassLoader(Thread.currentThread().getContextClassLoader());
    }
  }
);
  this.codeGenerator=new ASMCodeGenerator(classloader,System.out,true);
  this.codeGenerator.start();
}
 

public static List<ValidationProvider<?>> getValidationProviderList(){
  final GetValidationProviderList action=new GetValidationProviderList();
  if (System.getSecurityManager() != null) {
    return AccessController.doPrivileged(action);
  }
 else {
    return action.run();
  }
}
 

public boolean canConvert(final Object fromValue,final ReifiedType toType){
  if (fromValue == null) {
    return true;
  }
  if (isAssignable(fromValue,toType)) {
    return true;
  }
  boolean canConvert=false;
  AccessControlContext acc=blueprintContainer.getAccessControlContext();
  if (acc == null) {
    canConvert=canConvertWithConverters(fromValue,toType);
  }
 else {
    canConvert=AccessController.doPrivileged(new PrivilegedAction<Boolean>(){
      public Boolean run(){
        return canConvertWithConverters(fromValue,toType);
      }
    }
,acc);
  }
  if (canConvert) {
    return true;
  }
  try {
    convert(fromValue,toType);
    return true;
  }
 catch (  Exception e) {
    return false;
  }
}
 

/** 
 * Use the system property
 */
public static Object loadFromSystemProperty(String propertyName,String defaultFactory){
  Object factory=null;
  ClassLoader loader=Thread.currentThread().getContextClassLoader();
  PrivilegedAction action=new PropertyAccessAction(propertyName);
  String factoryName=(String)AccessController.doPrivileged(action);
  if (factoryName != null) {
    try {
      Class factoryClass=loader.loadClass(factoryName);
      factory=factoryClass.newInstance();
    }
 catch (    Throwable t) {
      throw new IllegalStateException("Failed to load " + propertyName + ": "+ factoryName,t);
    }
  }
  if (factory == null && defaultFactory != null) {
    factory=loadDefault(defaultFactory);
  }
  return factory;
}
 

static ClassLoader getClassLoader(final Class<?> clazz){
  SecurityManager sm=System.getSecurityManager();
  if (sm == null)   return clazz.getClassLoader();
 else   return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>(){
    public ClassLoader run(){
      return clazz.getClassLoader();
    }
  }
);
}