Accessed using OperationAccessor
330512
final Operation setCallTimeout(long callTimeout) {
        this.callTimeout = callTimeout;
        setFlag(callTimeout > Integer.MAX_VALUE, BITMASK_CALL_TIMEOUT_64_BIT);
        return this;
    }
657539
Symbol accessMethod(Symbol sym,
                  DiagnosticPosition pos,
                  Type site,
                  Name name,
                  boolean qualified,
                  List<Type> argtypes,
                  List<Type> typeargtypes) {
        return accessMethod(sym, pos, site.tsym, site, name, qualified, argtypes, typeargtypes);
    }
1111298
static void ensureAccessible(AccessibleObject accessibleObject) {
        if (accessibleObject != null) {
            if (!accessibleObject.isAccessible()) {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(SetAccessibleAction.of(accessibleObject));
                } else {
                    accessibleObject.setAccessible(true);
                }
            }
        }
    }
58120
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSDouble br_cpu_usage_validator = new MPSDouble();
		br_cpu_usage_validator.validate(operationType, br_cpu_usage, "\"br_cpu_usage\"");
		
		MPSDouble br_memory_usage_validator = new MPSDouble();
		br_memory_usage_validator.validate(operationType, br_memory_usage, "\"br_memory_usage\"");
		
		MPSDouble wan_out_validator = new MPSDouble();
		wan_out_validator.validate(operationType, wan_out, "\"wan_out\"");
		
		MPSDouble lan_out_validator = new MPSDouble();
		lan_out_validator.validate(operationType, lan_out, "\"lan_out\"");
		
		MPSString upsince_validator = new MPSString();
		upsince_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		upsince_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		upsince_validator.validate(operationType, upsince, "\"upsince\"");
		
		MPSString ha_peer_state_validator = new MPSString();
		ha_peer_state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		ha_peer_state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		ha_peer_state_validator.validate(operationType, ha_peer_state, "\"ha_peer_state\"");
		
		MPSString ha_state_validator = new MPSString();
		ha_state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		ha_state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		ha_state_validator.validate(operationType, ha_state, "\"ha_state\"");
		
		MPSIPAddress ha_peer_ip_address_validator = new MPSIPAddress();
		ha_peer_ip_address_validator.validate(operationType, ha_peer_ip_address, "\"ha_peer_ip_address\"");
		
		MPSDouble ha_peer_id_validator = new MPSDouble();
		ha_peer_id_validator.validate(operationType, ha_peer_id, "\"ha_peer_id\"");
		
		MPSString operation_status_validator = new MPSString();
		operation_status_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		operation_status_validator.validate(operationType, operation_status, "\"operation_status\"");
		
		MPSString bypass_validator = new MPSString();
		bypass_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		bypass_validator.validate(operationType, bypass, "\"bypass\"");
		
		MPSString bandwidth_mode_validator = new MPSString();
		bandwidth_mode_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		bandwidth_mode_validator.validate(operationType, bandwidth_mode, "\"bandwidth_mode\"");
		
		MPSDoubleLong bandwidth_limit_validator = new MPSDoubleLong();
		bandwidth_limit_validator.validate(operationType, bandwidth_limit, "\"bandwidth_limit\"");
		
		MPSIPAddress havmip_validator = new MPSIPAddress();
		havmip_validator.validate(operationType, havmip, "\"havmip\"");
		
		MPSString acl_connections_validator = new MPSString();
		acl_connections_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		acl_connections_validator.validate(operationType, acl_connections, "\"acl_connections\"");
		
		MPSString unacl_connections_validator = new MPSString();
		unacl_connections_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		unacl_connections_validator.validate(operationType, unacl_connections, "\"unacl_connections\"");
		
		MPSString connected_plugins_validator = new MPSString();
		connected_plugins_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		connected_plugins_validator.validate(operationType, connected_plugins, "\"connected_plugins\"");
		
		MPSString max_plugins_validator = new MPSString();
		max_plugins_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		max_plugins_validator.validate(operationType, max_plugins, "\"max_plugins\"");
		
		MPSDouble wan_in_validator = new MPSDouble();
		wan_in_validator.validate(operationType, wan_in, "\"wan_in\"");
		
		MPSDouble lan_in_validator = new MPSDouble();
		lan_in_validator.validate(operationType, lan_in, "\"lan_in\"");
		
		MPSDouble wan_out_prev_validator = new MPSDouble();
		wan_out_prev_validator.validate(operationType, wan_out_prev, "\"wan_out_prev\"");
		
		MPSDouble lan_out_prev_validator = new MPSDouble();
		lan_out_prev_validator.validate(operationType, lan_out_prev, "\"lan_out_prev\"");
		
		MPSDouble wan_in_prev_validator = new MPSDouble();
		wan_in_prev_validator.validate(operationType, wan_in_prev, "\"wan_in_prev\"");
		
		MPSDouble lan_in_prev_validator = new MPSDouble();
		lan_in_prev_validator.validate(operationType, lan_in_prev, "\"lan_in_prev\"");
		
		MPSDouble prev_poll_time_validator = new MPSDouble();
		prev_poll_time_validator.validate(operationType, prev_poll_time, "\"prev_poll_time\"");
		
		MPSIPAddress apa_ip_address_validator = new MPSIPAddress();
		apa_ip_address_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_ip_address_validator.validate(operationType, apa_ip_address, "\"apa_ip_address\"");
		
		MPSIPAddress apa_netmask_validator = new MPSIPAddress();
		apa_netmask_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_netmask_validator.validate(operationType, apa_netmask, "\"apa_netmask\"");
		
		MPSIPAddress apa_gateway_validator = new MPSIPAddress();
		apa_gateway_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_gateway_validator.validate(operationType, apa_gateway, "\"apa_gateway\"");
		
		MPSIPAddress plugin_ip_address_validator = new MPSIPAddress();
		plugin_ip_address_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		plugin_ip_address_validator.validate(operationType, plugin_ip_address, "\"plugin_ip_address\"");
		
		MPSDouble system_load_validator = new MPSDouble();
		system_load_validator.validate(operationType, system_load, "\"system_load\"");
		
		MPSDouble active_connections_validator = new MPSDouble();
		active_connections_validator.validate(operationType, active_connections, "\"active_connections\"");
		
		MPSIPAddress mgmt_ip_address_validator = new MPSIPAddress();
		mgmt_ip_address_validator.validate(operationType, mgmt_ip_address, "\"mgmt_ip_address\"");
		
		MPSString license_validator = new MPSString();
		license_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		license_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		license_validator.validate(operationType, license, "\"license\"");
		
	}
195737
private void checkAccess()
        throws EFapsException
    {
        // check the access for the given instances
        final Map<Instance, Boolean> accessmap = new HashMap<Instance, Boolean>();
        for (final Entry<Type, List<Instance>> entry : this.typeMapping.entrySet()) {
            accessmap.putAll(entry.getKey().checkAccess(entry.getValue(), AccessTypeEnums.SHOW.getAccessType()));
        }
        this.elements.entrySet().removeIf(entry -> accessmap.size() > 0 && (!accessmap.containsKey(entry.getKey())
                        || !accessmap.get(entry.getKey())));
    }
179004
private int getAccess(Collection.Key key) {
	Member member = getMember(ACCESS_PRIVATE, key, false, false);
	if (member == null) return Component.ACCESS_PRIVATE;
	return member.getAccess();
    }
927194
public void registerOngoingOperation(
			final K operationKey,
			final CompletableFuture<R> operationResultFuture) {
		final ResultAccessTracker<R> inProgress = ResultAccessTracker.inProgress();
		registeredOperationTriggers.put(operationKey, inProgress);
		operationResultFuture.whenComplete((result, error) -> {
			if (error == null) {
				completedOperations.put(operationKey, inProgress.finishOperation(Either.Right(result)));
			} else {
				completedOperations.put(operationKey, inProgress.finishOperation(Either.Left(error)));
			}
			registeredOperationTriggers.remove(operationKey);
		});
	}
640304
private OperationEntry getInheritableOperationEntryLocked(final String operationName) {
        final OperationEntry entry = operations == null ? null : operations.get(operationName);
        if (entry != null && entry.isInherited()) {
            return entry;
        }
        return null;
    }
69106
boolean checkAccessTopicFromControllers(UserContext ctx, String topic, Iterable<JsTopicAccessController> accessControls) throws IllegalAccessException {
		logger.debug("Looking for accessController for topic '{}' : '{}'", topic, accessControls);
		boolean tacPresent = false;
		if (null != accessControls) {
			for (JsTopicAccessController accessControl : accessControls) {
				accessControl.checkAccess(ctx, topic);
				tacPresent = true;
			}
		}
		return tacPresent;
	}
119111
public static Operator determineOperator(final String operatorId,
                                             final boolean isNegated) {
        Operator op = CACHE.get( getKey( operatorId,
                                         isNegated ) );
        return op;
    }
594630
@Override
	public OperationResult<R> tryOperation(Operation<CL, R> operation) throws ConnectionException {
	    Operation<CL, R> filteredOperation = config.getOperationFilterFactory().attachFilter(operation);
	    
        while (true) {
            attemptCounter++;
            
            try {
                connection = borrowConnection(filteredOperation);
                startTime = System.currentTimeMillis();
                OperationResult<R> result = connection.execute(filteredOperation);
                result.setAttemptsCount(attemptCounter);
                monitor.incOperationSuccess(getCurrentHost(), result.getLatency());
                return result;
            }
            catch (Exception e) {
                ConnectionException ce = (e instanceof ConnectionException) ? (ConnectionException) e
                        : new UnknownException(e);
            	try {
            		informException(ce);
                    monitor.incFailover(ce.getHost(), ce);
            	}
            	catch (ConnectionException ex) {
                    monitor.incOperationFailure(getCurrentHost(), ex);
                    throw ex;
            	}
            }
            finally {
            	releaseConnection();
            }
        }
    }
96480
private OperationHandler getHandler(String serviceName, String operationName) {
        if (serviceName == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Service Name was null!");
            }

            return null;
        }

        if (operationName == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Operation Name was null!");
            }

            return null;
        }

        Map<String, OperationHandler> handlers =
                m_serviceHandlers.get(serviceName);
        if (handlers == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("No Service Handlers found for: " + serviceName);
            }

            return null;
        }

        OperationHandler handler = handlers.get(operationName);
        if (handler == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Handler not found for: " + serviceName + "/"
                        + operationName);
            }
        }

        return handler;
    }
1208824
function makeAccessController(rerun) {
  // `accesses` is a map indexed by object,
  // containing "access" entries with values of `{names: [], observer}`.
  // `names` of null means to watch properties of any name.
  // It is built by calls to `notifyAccess`, invoked through `accessNotifier`.
  var accesses = new Map();

  function unobserve() {
    accesses.forEach(({observer}) => observer.unobserve());
  }

  function observe() {
    accesses.forEach(({observer}) => observer.observe(['update', 'add', 'delete']));
  }

  // Start capturing accessed dependencies.
  function capture() {
    accesses.clear();
    accessNotifier.push(notifyAccess);
  }

  // Stop capturing accessed dependencies.
  function uncapture() {
    accessNotifier.pop();
  }

  function start() {
    unobserve();
    capture();
  }

  function stop() {
    uncapture();
    observe();
  }

  // `notifyAccess` is the callback invoked by upwardables when a property is accessed.
  // It records the access in the `accesses` map.
  function notifyAccess({object, name}) {

    // Create an observer for changes in properties accessed during execution of this function.
    function makeAccessedObserver() {
      return Observer(object, function(changes) {
        changes.forEach(({type, name}) => {
          var {names} = accessEntry;
          if (!names || type === 'update' && names.indexOf(name) !== -1)
            rerun();
        });
      });
    }

    // Make a new entry in the access table, containing initial property name if any
    // and observer for properties accessed on the object.
    function makeAccessEntry() {
      accesses.set(object, {
        names:    name ? [name] : null,
        observer: makeAccessedObserver()
      });
    }

    // If properties on this object are already being watched, there is already an entry
    // in the access table for it. Add a new property name to the existing entry.
    function setAccessEntry() {
      if (name && accessEntry.names) accessEntry.names.push(name);
      else accessEntry.names = null;
    }

    var accessEntry = accesses.get(object);
    if (accessEntry) setAccessEntry();
    else makeAccessEntry();
  }

  return {start, stop};
}
1197032
private static boolean getAccessSetFromDB(final String _sql,
                                              final Object _criteria)
        throws CacheReloadException
    {
        boolean ret = false;
        Connection con = null;
        try {
            AccessSet accessSet = null;
            con = Context.getConnection();
            PreparedStatement stmt = null;
            try {
                stmt = con.prepareStatement(_sql);
                stmt.setObject(1, _criteria);
                final ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    final long id = rs.getLong(1);
                    final String uuid = rs.getString(2);
                    final String name = rs.getString(3);
                    AccessSet.LOG.debug("read AccessSet '{}' (id = {}, uuid ={})", name, id, uuid);
                    accessSet = new AccessSet(id, uuid, name);
                }
                ret = true;
                rs.close();
            } finally {
                if (stmt != null) {
                    stmt.close();
                }
            }
            con.commit();
            if (accessSet != null) {
                accessSet.readLinks2AccessTypes();
                accessSet.readLinks2DMTypes();
                accessSet.readLinks2Status();
                accessSet.readLinks2Person();
                // needed due to cluster serialization that does not update automatically
                AccessSet.cacheAccessSet(accessSet);
            }
        } catch (final SQLException e) {
            throw new CacheReloadException("could not read roles", e);
        } catch (final EFapsException e) {
            throw new CacheReloadException("could not read roles", e);
        } finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (final SQLException e) {
                throw new CacheReloadException("could not read child type ids", e);
            }
        }
        return ret;
    }
637802
private OpResultInfo invokeOp(final String name, final int index, final String[] args) 
      throws PrivilegedActionException
   {
      return AccessController.doPrivileged(new PrivilegedExceptionAction<OpResultInfo>()
      {
         public OpResultInfo run() throws Exception
         {
            return Server.invokeOp(name, index, args);
         }
      });
   }
808311
@Override
    public void visit(final int version, final int access, final String name,
            final String signature, final String superName,
            final String[] interfaces) {
        super.visit(Opcodes.V1_2, access, name, null, superName, interfaces);
        int index = name.lastIndexOf('/');
        if (index > 0) {
            pkgName = name.substring(0, index);
        } else {
            pkgName = "";
        }
        clsName = name;
        isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
    }
277232
public Operation addAccessConfig(
      String networkInterface, AccessConfig accessConfig, OperationOption... options) {
    return compute.addAccessConfig(getInstanceId(), networkInterface, accessConfig, options);
  }