Java UnauthorizedException类代码示例

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException
{
    AuthenticatedUser user = state.getUser();

    boolean isSuper = user.isSuper();

    if (superuser != null && user.getName().equals(username))
        throw new UnauthorizedException("You aren't allowed to alter your own superuser status");

    if (superuser != null && !isSuper)
        throw new UnauthorizedException("Only superusers are allowed to alter superuser status");

    if (!user.isSuper() && !user.getName().equals(username))
        throw new UnauthorizedException("You aren't allowed to alter this user");

    if (!isSuper)
    {
        for (IAuthenticator.Option option : opts.getOptions().keySet())
        {
            if (!DatabaseDescriptor.getAuthenticator().alterableOptions().contains(option))
                throw new UnauthorizedException(String.format("You aren't allowed to alter %s option", option));
        }
    }
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public List<IMutation> prepareRowMutations(String keyspace, ThriftClientState clientState, Long timestamp, List<ByteBuffer> variables)
throws InvalidRequestException, UnauthorizedException
{
    CFMetaData metadata = validateColumnFamily(keyspace, columnFamily);

    clientState.hasColumnFamilyAccess(keyspace, columnFamily, Permission.MODIFY);
    AbstractType<?> keyType = Schema.instance.getCFMetaData(keyspace, columnFamily).getKeyValidator();

    List<IMutation> rowMutations = new ArrayList<IMutation>(keys.size());

    for (Term key : keys)
    {
        rowMutations.add(mutationForKey(key.getByteBuffer(keyType, variables), keyspace, timestamp, clientState, variables, metadata));
    }

    return rowMutations;
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException, InvalidRequestException
{
    Function function = findFunction();
    if (function == null)
    {
        if (!ifExists)
            throw new InvalidRequestException(String.format("Unconfigured function %s.%s(%s)",
                                                            functionName.keyspace,
                                                            functionName.name,
                                                            Joiner.on(",").join(argRawTypes)));
    }
    else
    {
        state.ensureHasPermission(Permission.DROP, FunctionResource.function(function.name().keyspace,
                                                                             function.name().name,
                                                                             function.argTypes()));
    }
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
private void preventSystemKSSchemaModification(String keyspace, DataResource resource, Permission perm) throws UnauthorizedException
{
    // we only care about schema modification.
    if (!((perm == Permission.ALTER) || (perm == Permission.DROP) || (perm == Permission.CREATE)))
        return;

    // prevent system keyspace modification
    if (Schema.isSystemKeyspace(keyspace))
        throw new UnauthorizedException(keyspace + " keyspace is not user-modifiable.");

    // allow users with sufficient privileges to alter KS level options on AUTH_KS and
    // TRACING_KS, and also to drop legacy tables (users, credentials, permissions) from
    // AUTH_KS
    if (ALTERABLE_SYSTEM_KEYSPACES.contains(resource.getKeyspace().toLowerCase())
       && ((perm == Permission.ALTER && !resource.isKeyspaceLevel())
           || (perm == Permission.DROP && !DROPPABLE_SYSTEM_TABLES.contains(resource))))
    {
        throw new UnauthorizedException(String.format("Cannot %s %s", perm, resource));
    }
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException, InvalidRequestException
{
    try
    {
        state.hasColumnFamilyAccess(keyspace(), columnFamily(), Permission.DROP);
    }
    catch (InvalidRequestException e)
    {
        if (!ifExists)
            throw e;
    }
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException
{
    // check that the user has AUTHORIZE permission on the resource or its parents, otherwise reject GRANT/REVOKE.
    state.ensureHasPermission(Permission.AUTHORIZE, resource);
    // check that the user has [a single permission or all in case of ALL] on the resource or its parents.
    for (Permission p : permissions)
        state.ensureHasPermission(p, resource);
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
/** {@inheritDoc} */
public List<IMutation> prepareRowMutations(String keyspace, ThriftClientState clientState, Long timestamp, List<ByteBuffer> variables)
throws InvalidRequestException, UnauthorizedException
{
    boolean hasCommutativeOperation = false;

    for (Map.Entry<Term, Operation> column : getColumns().entrySet())
    {
        if (!column.getValue().isUnary())
            hasCommutativeOperation = true;

        if (hasCommutativeOperation && column.getValue().isUnary())
            throw new InvalidRequestException("Mix of commutative and non-commutative operations is not allowed.");
    }

    CFMetaData metadata = validateColumnFamily(keyspace, columnFamily, hasCommutativeOperation);
    if (hasCommutativeOperation)
        getConsistencyLevel().validateCounterForWrite(metadata);

    QueryProcessor.validateKeyAlias(metadata, keyName);

    clientState.hasColumnFamilyAccess(keyspace, columnFamily, Permission.MODIFY);

    List<IMutation> mutations = new LinkedList<>();

    for (Term key: keys)
        mutations.add(mutationForKey(keyspace, key.getByteBuffer(getKeyType(keyspace),variables), metadata, timestamp, clientState, variables));

    return mutations;
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public List<IMutation> getMutations(String keyspace, ThriftClientState clientState, List<ByteBuffer> variables)
throws InvalidRequestException, UnauthorizedException
{
    List<IMutation> batch = new LinkedList<IMutation>();

    for (AbstractModification statement : statements) {
        batch.addAll(statement.prepareRowMutations(keyspace, clientState, timestamp, variables));
    }

    return batch;
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public List<IMutation> prepareRowMutations(String keyspace, ThriftClientState clientState, Long timestamp, List<ByteBuffer> variables)
throws InvalidRequestException, UnauthorizedException
{
    CFMetaData metadata = validateColumnFamily(keyspace, columnFamily);

    clientState.hasColumnFamilyAccess(keyspace, columnFamily, Permission.MODIFY);
    AbstractType<?> keyType = Schema.instance.getCFMetaData(keyspace, columnFamily).getKeyValidator();

    List<IMutation> mutations = new ArrayList<IMutation>(keys.size());

    for (Term key : keys)
        mutations.add(mutationForKey(key.getByteBuffer(keyType, variables), keyspace, timestamp, clientState, variables, metadata));

    return mutations;
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void hasAllKeyspacesAccess(Permission perm) throws UnauthorizedException
{
    if (isInternal)
        return;
    validateLogin();
    ensureHasPermission(perm, DataResource.root());
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
private void hasAccess(String keyspace, Permission perm, DataResource resource)
throws UnauthorizedException, InvalidRequestException
{
    validateKeyspace(keyspace);
    if (isInternal)
        return;
    validateLogin();
    preventSystemKSSchemaModification(keyspace, resource, perm);
    if (perm.equals(Permission.SELECT) && READABLE_SYSTEM_RESOURCES.contains(resource))
        return;
    if (PROTECTED_AUTH_RESOURCES.contains(resource))
        if (perm.equals(Permission.CREATE) || perm.equals(Permission.ALTER) || perm.equals(Permission.DROP))
            throw new UnauthorizedException(String.format("%s schema is protected", resource));
    ensureHasPermission(perm, resource);
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
public void ensureHasPermission(Permission perm, IResource resource) throws UnauthorizedException
{
    for (IResource r : Resources.chain(resource))
        if (authorize(r).contains(perm))
            return;

    throw new UnauthorizedException(String.format("User %s has no %s permission on %s or any of its parents",
                                                  user.getName(),
                                                  perm,
                                                  resource));
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
private void preventSystemKSSchemaModification(String keyspace, DataResource resource, Permission perm) throws UnauthorizedException
{
    // we only care about schema modification.
    if (!(perm.equals(Permission.ALTER) || perm.equals(Permission.DROP) || perm.equals(Permission.CREATE)))
        return;

    // prevent system keyspace modification
    if (Keyspace.SYSTEM_KS.equalsIgnoreCase(keyspace))
        throw new UnauthorizedException(keyspace + " keyspace is not user-modifiable.");

    // we want to allow altering AUTH_KS and TRACING_KS.
    Set<String> allowAlter = Sets.newHashSet(Auth.AUTH_KS, Tracing.TRACE_KS);
    if (allowAlter.contains(keyspace.toLowerCase()) && !(resource.isKeyspaceLevel() && perm.equals(Permission.ALTER)))
        throw new UnauthorizedException(String.format("Cannot %s %s", perm, resource));
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
/** {@inheritDoc} */
public List<IMutation> prepareRowMutations(String keyspace, ThriftClientState clientState, Long timestamp, List<ByteBuffer> variables)
throws InvalidRequestException, UnauthorizedException
{
    boolean hasCommutativeOperation = false;

    for (Map.Entry<Term, Operation> column : getColumns().entrySet())
    {
        if (!column.getValue().isUnary())
            hasCommutativeOperation = true;

        if (hasCommutativeOperation && column.getValue().isUnary())
            throw new InvalidRequestException("Mix of commutative and non-commutative operations is not allowed.");
    }

    CFMetaData metadata = validateColumnFamily(keyspace, columnFamily, hasCommutativeOperation);
    if (hasCommutativeOperation)
        getConsistencyLevel().validateCounterForWrite(metadata);

    QueryProcessor.validateKeyAlias(metadata, keyName);

    clientState.hasColumnFamilyAccess(keyspace, columnFamily, Permission.MODIFY);

    List<IMutation> rowMutations = new LinkedList<IMutation>();

    for (Term key: keys)
    {
        rowMutations.add(mutationForKey(keyspace, key.getByteBuffer(getKeyType(keyspace),variables), metadata, timestamp, clientState, variables));
    }

    return rowMutations;
}
 

import org.apache.cassandra.exceptions.UnauthorizedException; //导入依赖的package包/类
private void preventSystemKSSchemaModification(String keyspace, DataResource resource, Permission perm) throws UnauthorizedException
{
    // we only care about schema modification.
    if (!(perm.equals(Permission.ALTER) || perm.equals(Permission.DROP) || perm.equals(Permission.CREATE)))
        return;

    if (Schema.systemKeyspaceNames.contains(keyspace.toLowerCase()))
        throw new UnauthorizedException(keyspace + " keyspace is not user-modifiable.");

    // we want to allow altering AUTH_KS itself.
    if (keyspace.equals(Auth.AUTH_KS) && !(resource.isKeyspaceLevel() && perm.equals(Permission.ALTER)))
        throw new UnauthorizedException(String.format("Cannot %s %s", perm, resource));
}