If we don't yet have a uaa cache we need to
        initialize it.  As there may be more than one
        UAA instance we index by issuer and then store
        any clients, users, etc.
192656
def _initialize_uaa_cache(self):
        
        try:
            os.makedirs(os.path.dirname(self._cache_path))
        except OSError as exc:
            if exc.errno != errno.EEXIST:
                raise

        data = {}
        data[self.uri] = []

        return data
1125956
protected synchronized void initialize() {
        String invocationServiceName = this.invocationServiceName;
        invocationService = (InvocationService)
                CacheFactory.getService(invocationServiceName);
        if (invocationService == null) {
            throw new IllegalArgumentException("Invocation service ["
                                               + invocationServiceName
                                               + "] is not defined.");
        }

        invocationService.addMemberListener(this);
        serviceMembers = invocationService.getInfo().getServiceMembers();
        memberIterator = serviceMembers.iterator();
    }
870094
function storeAssociation($server_url, $association)
    {
        // create memcached keys for association itself
        // and list of associations for this server
        $associationKey = $this->associationKey($server_url,
            $association->handle);
        $serverKey = $this->associationServerKey($server_url);

        // get list of associations
        $serverAssociations = $this->connection->get($serverKey);

        // if no such list, initialize it with empty array
        if (!$serverAssociations) {
            $serverAssociations = array();
        }
        // and store given association key in it
        $serverAssociations[$association->issued] = $associationKey;

        // save associations' keys list
        $this->connection->set(
            $serverKey,
            $serverAssociations,
            $this->compress
        );
        // save association itself
        $this->connection->set(
            $associationKey,
            $association,
            $this->compress,
            $association->issued + $association->lifetime);
    }
461937
private void userInfoInit() {
		boolean first = true;
		userId = null;
		userLocale = null;
		userName = null;
		userOrganization = null;
		userDivision = null;
		if (null != authentications) {
			for (Authentication auth : authentications) {
				userId = combine(userId, auth.getUserId());
				userName = combine(userName, auth.getUserName());
				if (first) {
					userLocale = auth.getUserLocale();
					first = false;
				} else {
					if (null != auth.getUserLocale() &&
							(null == userLocale || !userLocale.equals(auth.getUserLocale()))) {
						userLocale = null;
					}
				}
				userOrganization = combine(userOrganization, auth.getUserOrganization());
				userDivision = combine(userDivision, auth.getUserDivision());
			}
		}

		// now calculate the "id" for this context, this should be independent of the data order, so sort
		Map<String, List<String>> idParts = new HashMap<String, List<String>>();
		if (null != authentications) {
			for (Authentication auth : authentications) {
				List<String> auths = new ArrayList<String>();
				for (BaseAuthorization ba : auth.getAuthorizations()) {
					auths.add(ba.getId());
				}
				Collections.sort(auths);
				idParts.put(auth.getSecurityServiceId(), auths);
			}
		}
		StringBuilder sb = new StringBuilder();
		List<String> sortedKeys = new ArrayList<String>(idParts.keySet());
		Collections.sort(sortedKeys);
		for (String key : sortedKeys) {
			if (sb.length() > 0) {
				sb.append('|');
			}
			List<String> auths = idParts.get(key);
			first = true;
			for (String ak : auths) {
				if (first) {
					first = false;
				} else {
					sb.append('|');
				}
				sb.append(ak);
			}
			sb.append('@');
			sb.append(key);
		}
		id = sb.toString();
	}
815307
public static void initialize()
    {
        if (InfinispanCache.get().exists(AccessSet.UUIDCACHE)) {
            InfinispanCache.get().<UUID, AccessSet>getCache(AccessSet.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, AccessSet>getCache(AccessSet.UUIDCACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
        if (InfinispanCache.get().exists(AccessSet.IDCACHE)) {
            InfinispanCache.get().<Long, AccessSet>getCache(AccessSet.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, AccessSet>getCache(AccessSet.IDCACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
        if (InfinispanCache.get().exists(AccessSet.NAMECACHE)) {
            InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
    }
1366813
public static void initialize()
    {
        if (AppConfigHandler.get().isQueryCacheDeactivated()) {
            QueryCache.NOOP = new NoOpQueryCache();
        } else {
            if (InfinispanCache.get().exists(QueryCache.INDEXCACHE)) {
                InfinispanCache.get().<String, QueryKey>getCache(QueryCache.INDEXCACHE).clear();
            } else {
                final Cache<String, QueryKey> cache = InfinispanCache.get().<String, QueryKey>getCache(
                                QueryCache.INDEXCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
            }
            if (InfinispanCache.get().exists(QueryCache.SQLCACHE)) {
                InfinispanCache.get().<QueryKey, Object>getCache(QueryCache.SQLCACHE).clear();
            } else {
                final Cache<QueryKey, Object> cache = InfinispanCache.get().<QueryKey, Object>getCache(
                                QueryCache.SQLCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
                cache.addListener(new SqlCacheListener());
            }
        }
    }
33107
protected function init()
    {
        try {
            $lastUpdate = $this->initFromFiles();
        } catch (ShopgateLibraryException $e) {
            // If this fails with an exception we have a most likely permanent problem.
            // In that case the lists _MUST NOT_ be fetched from the API as chances are high this would happen for
            // every request to the merchant's desktop site.
            return;
        }

        if ($this->disableUpdate || !$this->expired($lastUpdate)) {
            return;
        }

        try {
            $this->update();
        } catch (Exception $e) {
            // if fetching from API fails, try again in 5 minutes; meanwhile use the cached keywords
            $this->saveAllKeywordsToFiles($newUpdateTimestamp = (time() - ($this->cacheTimeout * 3600)) + 300);
        }
    }
795388
public void initialize(NewRelicCache cache)
    {
        String apiKey = cache.getApiKey();
        if(apiKey == null)
            throw new IllegalArgumentException("null API key");

        logger.info("Initialising the clients");

        initialized = false;
        if(cache.isAlertsEnabled())
        {
            apiClient = NewRelicApi.builder().apiKey(apiKey).build();
            infraApiClient = NewRelicInfraApi.builder().apiKey(apiKey).build();
            syntheticsApiClient = NewRelicSyntheticsApi.builder().apiKey(apiKey).build();
        }

        logger.info("Initialised the clients");

        initialized = true;
    }
141690
@PostConstruct
    public synchronized void initialize() {
        final FwCoreDirection direction = assistCoreDirection();
        final SecurityResourceProvider provider = direction.assistSecurityResourceProvider();
        invertibleCryptographer = provider.providePrimaryInvertibleCryptographer();
        if (invertibleCryptographer == null) {
            String msg = "The provider returned null invertible cryptographer: " + provider;
            throw new FwRequiredAssistNotFoundException(msg);
        }
        oneWayCryptographer = provider.providePrimaryOneWayCryptographer();
        if (oneWayCryptographer == null) {
            String msg = "The provider returned null one-way cryptographer: " + provider;
            throw new FwRequiredAssistNotFoundException(msg);
        }
        showBootLogging();
    }
1349486
def init_indexes(self):
        """"""
        state = self.app_state

        for name, schema in self.schemas.items():
            if current_app.testing:
                storage = TestingStorage()
            else:
                index_path = (Path(state.whoosh_base) / name).absolute()
                if not index_path.exists():
                    index_path.mkdir(parents=True)
                storage = FileStorage(str(index_path))

            if storage.index_exists(name):
                index = FileIndex(storage, schema, name)
            else:
                index = FileIndex.create(storage, schema, name)

            state.indexes[name] = index
1323599
def _read_uaa_cache(self):
        
        self._cache_path = os.path.expanduser('~/.predix/uaa.json')
        if not os.path.exists(self._cache_path):
            return self._initialize_uaa_cache()

        with open(self._cache_path, 'r') as data:
            return json.load(data)
446651
@Override
  public void initialize() {
    if(databaseConnection == null) {
      return; // Supposedly we initialized already.
    }
    if(LOG.isDebugging()) {
      LOG.debugFine("Loading data from database connection.");
    }
    MultipleObjectsBundle bundle = databaseConnection.loadData();
    // Run at most once.
    databaseConnection = null;

    // Find DBIDs for bundle
    {
      DBIDs bids = bundle.getDBIDs();
      if(bids instanceof ArrayStaticDBIDs) {
        this.ids = (ArrayStaticDBIDs) bids;
      }
      else if(bids == null) {
        this.ids = DBIDUtil.generateStaticDBIDRange(bundle.dataLength());
      }
      else {
        this.ids = (ArrayStaticDBIDs) DBIDUtil.makeUnmodifiable(DBIDUtil.ensureArray(bids));
      }
    }
    // Replace id representation (it would be nicer if we would not need
    // DBIDView at all)
    this.idrep = new DBIDView(this.ids);
    relations.add(this.idrep);
    getHierarchy().add(this, idrep);

    DBIDArrayIter it = this.ids.iter();

    int numrel = bundle.metaLength();
    for(int i = 0; i < numrel; i++) {
      SimpleTypeInformation<?> meta = bundle.meta(i);
      @SuppressWarnings("unchecked")
      SimpleTypeInformation<Object> ometa = (SimpleTypeInformation<Object>) meta;
      WritableDataStore<Object> store = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_DB, ometa.getRestrictionClass());
      for(it.seek(0); it.valid(); it.advance()) {
        store.put(it, bundle.data(it.getOffset(), i));
      }
      Relation<?> relation = new MaterializedRelation<>(ometa, ids, null, store);
      relations.add(relation);
      getHierarchy().add(this, relation);

      // Try to add indexes where appropriate
      for(IndexFactory<?> factory : indexFactories) {
        if(factory.getInputTypeRestriction().isAssignableFromType(ometa)) {
          @SuppressWarnings("unchecked")
          final IndexFactory<Object> ofact = (IndexFactory<Object>) factory;
          @SuppressWarnings("unchecked")
          final Relation<Object> orep = (Relation<Object>) relation;
          final Index index = ofact.instantiate(orep);
          Duration duration = LOG.isStatistics() ? LOG.newDuration(index.getClass().getName() + ".construction").begin() : null;
          index.initialize();
          if(duration != null) {
            LOG.statistics(duration.end());
          }
          getHierarchy().add(relation, index);
        }
      }
    }

    // fire insertion event
    eventManager.fireObjectsInserted(ids);
  }
816113
public void initialize(Configuration config) {
        try {
            //EdgeStore & VertexIndexStore
            KeyColumnValueStore idStore = storeManager.openDatabase(ID_STORE_NAME);

            idAuthority = null;
            if (storeFeatures.isKeyConsistent()) {
                idAuthority = new ConsistentKeyIDAuthority(idStore, storeManager, config);
            } else {
                throw new IllegalStateException("Store needs to support consistent key or transactional operations for ID manager to guarantee proper id allocations");
            }

            KeyColumnValueStore edgeStoreRaw = storeManagerLocking.openDatabase(EDGESTORE_NAME);
            KeyColumnValueStore indexStoreRaw = storeManagerLocking.openDatabase(INDEXSTORE_NAME);

            //Configure caches
            if (cacheEnabled) {
                long expirationTime = configuration.get(DB_CACHE_TIME);
                Preconditions.checkArgument(expirationTime>=0,"Invalid cache expiration time: %s",expirationTime);
                if (expirationTime==0) expirationTime=ETERNAL_CACHE_EXPIRATION;

                long cacheSizeBytes;
                double cachesize = configuration.get(DB_CACHE_SIZE);
                Preconditions.checkArgument(cachesize>0.0,"Invalid cache size specified: %s",cachesize);
                if (cachesize<1.0) {
                    //Its a percentage
                    Runtime runtime = Runtime.getRuntime();
                    cacheSizeBytes = (long)((runtime.maxMemory()-(runtime.totalMemory()-runtime.freeMemory())) * cachesize);
                } else {
                    Preconditions.checkArgument(cachesize>1000,"Cache size is too small: %s",cachesize);
                    cacheSizeBytes = (long)cachesize;
                }
                log.info("Configuring total store cache size: {}",cacheSizeBytes);
                long cleanWaitTime = configuration.get(DB_CACHE_CLEAN_WAIT);
                Preconditions.checkArgument(EDGESTORE_CACHE_PERCENT + INDEXSTORE_CACHE_PERCENT == 1.0,"Cache percentages don't add up!");
                long edgeStoreCacheSize = Math.round(cacheSizeBytes * EDGESTORE_CACHE_PERCENT);
                long indexStoreCacheSize = Math.round(cacheSizeBytes * INDEXSTORE_CACHE_PERCENT);

                edgeStore = new ExpirationKCVSCache(edgeStoreRaw,getMetricsCacheName(EDGESTORE_NAME),expirationTime,cleanWaitTime,edgeStoreCacheSize);
                indexStore = new ExpirationKCVSCache(indexStoreRaw,getMetricsCacheName(INDEXSTORE_NAME),expirationTime,cleanWaitTime,indexStoreCacheSize);
            } else {
                edgeStore = new NoKCVSCache(edgeStoreRaw);
                indexStore = new NoKCVSCache(indexStoreRaw);
            }

            //Just open them so that they are cached
            txLogManager.openLog(SYSTEM_TX_LOG_NAME);
            mgmtLogManager.openLog(SYSTEM_MGMT_LOG_NAME);
            txLogStore = new NoKCVSCache(storeManager.openDatabase(SYSTEM_TX_LOG_NAME));


            //Open global configuration
            KeyColumnValueStore systemConfigStore = storeManagerLocking.openDatabase(SYSTEM_PROPERTIES_STORE_NAME);
            systemConfig = getGlobalConfiguration(new BackendOperation.TransactionalProvider() {
                @Override
                public StoreTransaction openTx() throws BackendException {
                    return storeManagerLocking.beginTransaction(StandardBaseTransactionConfig.of(
                            configuration.get(TIMESTAMP_PROVIDER),
                            storeFeatures.getKeyConsistentTxConfig()));
                }

                @Override
                public void close() throws BackendException {
                    //Do nothing, storeManager is closed explicitly by Backend
                }
            },systemConfigStore,configuration);
            userConfig = getConfiguration(new BackendOperation.TransactionalProvider() {
                @Override
                public StoreTransaction openTx() throws BackendException {
                    return storeManagerLocking.beginTransaction(StandardBaseTransactionConfig.of(configuration.get(TIMESTAMP_PROVIDER)));
                }

                @Override
                public void close() throws BackendException {
                    //Do nothing, storeManager is closed explicitly by Backend
                }
            },systemConfigStore,USER_CONFIGURATION_IDENTIFIER,configuration);

        } catch (BackendException e) {
            throw new TitanException("Could not initialize backend", e);
        }
    }
1208055
private void putInCache(MembershipImpl membership)
   {
      cache.put(cache.getMembershipKey(membership), membership, CacheType.MEMBERSHIP);
   }
195676
void initialize(ScheduledExecutorService executor, String cacheName, Configuration cfg) {
      this.executor = executor;
      this.configuration = cfg;
      this.cacheName = cacheName;
   }
1143591
private function initServer()
    {
        $this
            ->setSessionStorage($this->sessionStorage)
            ->setAccessTokenStorage($this->accessTokenStorage)
            ->setClientStorage($this->clientStorage)
            ->setScopeStorage($this->scopeStorage)
        ;
    }
1283818
public static void init(final AuthAPI authzAPI, AuthzFacade facade) throws Exception {

		/**
		 * Clear Cache Segment
		 */
		authzAPI.route(DELETE,"/mgmt/cache/:area/:segments",API.VOID,new Code(facade,"Clear Cache by Segment", true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				Result<Void> r = context.cacheClear(trans, pathParam(req,"area"), pathParam(req,"segments"));
				switch(r.status) {
					case OK:
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200); 
						break;
					default:
						context.error(trans,resp,r);
				}
			}
		});
		
		/**
		 * Clear Cache
		 */
		authzAPI.route(DELETE,"/mgmt/cache/:area",API.VOID,new Code(facade,"Clear Cache", true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				Result<Void> r;
				String area;
				r = context.cacheClear(trans, area=pathParam(req,"area"));
				switch(r.status) {
					case OK:
						trans.audit().log("Cache " + area + " has been cleared by "+trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200); 
						break;
					default:
						context.error(trans,resp,r);
				}
			}
		});

		/**
		 * Clear DB Sessions
		 */
		authzAPI.route(DELETE,"/mgmt/dbsession",API.VOID,new Code(facade,"Clear DBSessions", true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				try {
					if(req.isUserInRole(Define.ROOT_NS+".db|pool|clear")) {
						SessionFilter.clear();
						context.dbReset(trans);

						trans.audit().log("DB Sessions have been cleared by "+trans.user());

						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200);
						return;
					}
					context.error(trans,resp,Result.err(Result.ERR_Denied,"%s is not allowed to clear dbsessions",trans.user()));
				} catch(Exception e) {
					trans.error().log(e, "clearing dbsession");
					context.error(trans,resp,Result.err(e));
				}
			}
		});

		/**
		 * Deny an IP 
		 */
		authzAPI.route(POST, "/mgmt/deny/ip/:ip", API.VOID, new Code(facade,"Deny IP",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String ip = pathParam(req,":ip");
				if(req.isUserInRole(Define.ROOT_NS+".deny|"+Define.ROOT_COMPANY+"|ip")) {
					if(DenialOfServiceTaf.denyIP(ip)) {
						trans.audit().log(ip+" has been set to deny by "+trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);

						resp.setStatus(HttpStatus.CREATED_201);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_ConflictAlreadyExists, 
								ip + " is already being denied"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to deny",ip,"without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to set IP Denial"));
				}
			}
		});
		
		/**
		 * Stop Denying an IP
		 */
		authzAPI.route(DELETE, "/mgmt/deny/ip/:ip", API.VOID, new Code(facade,"Stop Denying IP",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String ip = pathParam(req,":ip");
				if(req.isUserInRole(Define.ROOT_NS+".deny|"+Define.ROOT_COMPANY+"|ip")) {
					if(DenialOfServiceTaf.removeDenyIP(ip)) {
						trans.audit().log(ip+" has been removed from denial by "+trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_NotFound, 
								ip + " is not on the denial list"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to remove",ip," from being denied without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to remove IP Denial"));
				}
			}
		});

		/**
		 * Deny an ID 
		 */
		authzAPI.route(POST, "/mgmt/deny/id/:id", API.VOID, new Code(facade,"Deny ID",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String id = pathParam(req,":id");
				if(req.isUserInRole(Define.ROOT_NS+".deny|"+Define.ROOT_COMPANY+"|id")) {
					if(DenialOfServiceTaf.denyID(id)) {
						trans.audit().log(id+" has been set to deny by "+trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.CREATED_201);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_ConflictAlreadyExists, 
								id + " is already being denied"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to deny",id,"without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to set ID Denial"));
				}
			}
		});
		
		/**
		 * Stop Denying an ID
		 */
		authzAPI.route(DELETE, "/mgmt/deny/id/:id", API.VOID, new Code(facade,"Stop Denying ID",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String id = pathParam(req,":id");
				if(req.isUserInRole(Define.ROOT_NS+".deny|"+Define.ROOT_COMPANY+"|id")) {
					if(DenialOfServiceTaf.removeDenyID(id)) {
						trans.audit().log(id+" has been removed from denial by " + trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_NotFound, 
								id + " is not on the denial list"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to remove",id," from being denied without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to remove ID Denial"));
				}
			}
		});

		/**
		 * Deny an ID 
		 */
		authzAPI.route(POST, "/mgmt/log/id/:id", API.VOID, new Code(facade,"Special Log ID",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String id = pathParam(req,":id");
				if(req.isUserInRole(Define.ROOT_NS+".log|"+Define.ROOT_COMPANY+"|id")) {
					if(Question.specialLogOn(trans,id)) {
						trans.audit().log(id+" has been set to special Log by "+trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.CREATED_201);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_ConflictAlreadyExists, 
								id + " is already being special Logged"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to special Log",id,"without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to set ID special Logging"));
				}
			}
		});
		
		/**
		 * Stop Denying an ID
		 */
		authzAPI.route(DELETE, "/mgmt/log/id/:id", API.VOID, new Code(facade,"Stop Special Log ID",true) {
			@Override
			public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
				String id = pathParam(req,":id");
				if(req.isUserInRole(Define.ROOT_NS+".log|"+Define.ROOT_COMPANY+"|id")) {
					if(Question.specialLogOff(trans,id)) {
						trans.audit().log(id+" has been removed from special Logging by " + trans.user());
						trans.checkpoint(SUCCESS,Trans.ALWAYS);
						resp.setStatus(HttpStatus.OK_200);
					} else {
						context.error(trans,resp,Result.err(Status.ERR_NotFound, 
								id + " is not on the special Logging list"));
					}
				} else {
					trans.audit().log(trans.user(),"has attempted to remove",id," from being special Logged without authorization");
					context.error(trans,resp,Result.err(Status.ERR_Denied, 
						trans.getUserPrincipal().getName() + " is not allowed to remove ID special Logging"));
				}
			}
		});


	}