org.apache.sentry.provider.db.service.model.MSentryPrivilege.getAction java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ArrayList a =new ArrayList<String>()
new ArrayList()
new ArrayList<Object>()
Smart code suggestions by Tabnine
}

private static Map<TPrivilegePrincipal, String> addPrivilegeEntry(MSentryPrivilege mPriv, TPrivilegePrincipalType tEntityType,
 String principal, Map<TPrivilegePrincipal, String> update) {
 TPrivilegePrincipal tPrivilegePrincipal = new TPrivilegePrincipal(tEntityType, principal);
 String existingPriv = update.get(tPrivilegePrincipal);
 String action = mPriv.getAction().toUpperCase();
 String newAction = mPriv.getAction().toUpperCase();
 if(action.equals(AccessConstants.OWNER)) {
  // Translate owner privilege to actual privilege.
  newAction = AccessConstants.ACTION_ALL;
 }
 if (existingPriv == null) {
  update.put(tPrivilegePrincipal, newAction);
 } else {
  update.put(tPrivilegePrincipal, existingPriv + "," + newAction);
 }
 return update;
}

@VisibleForTesting
static String toAuthorizable(MSentryPrivilege privilege) {
 List<String> authorizable = new ArrayList<String>(4);
 authorizable.add(KV_JOINER.join(AuthorizableType.Server.name().toLowerCase(),
   privilege.getServerName()));
 if (isNULL(privilege.getURI())) {
  if (!isNULL(privilege.getDbName())) {
   authorizable.add(KV_JOINER.join(AuthorizableType.Db.name().toLowerCase(),
     privilege.getDbName()));
   if (!isNULL(privilege.getTableName())) {
    authorizable.add(KV_JOINER.join(AuthorizableType.Table.name().toLowerCase(),
      privilege.getTableName()));
    if (!isNULL(privilege.getColumnName())) {
     authorizable.add(KV_JOINER.join(AuthorizableType.Column.name().toLowerCase(),
       privilege.getColumnName()));
    }
   }
  }
 } else {
  authorizable.add(KV_JOINER.join(AuthorizableType.URI.name().toLowerCase(),
    privilege.getURI()));
 }
 if (!isNULL(privilege.getAction())
   && !privilege.getAction().equalsIgnoreCase(AccessConstants.ALL)) {
  authorizable
  .add(KV_JOINER.join(PolicyConstants.PRIVILEGE_NAME.toLowerCase(),
    privilege.getAction()));
 }
 return AUTHORIZABLE_JOINER.join(authorizable);
}

   privilege.getURI()));
if (!isNULL(privilege.getAction())
  && !privilege.getAction().equalsIgnoreCase(AccessConstants.ALL)) {
 authorizable
 .add(KV_JOINER.join(SentryConstants.PRIVILEGE_NAME.toLowerCase(),
   privilege.getAction()));

/**
 * Roles can be granted ALL, SELECT, and INSERT on tables. When
 * a role has ALL and SELECT or INSERT are revoked, we need to remove the ALL
 * privilege and add SELECT (INSERT was revoked) or INSERT (SELECT was revoked).
 */
private void revokePartial(PersistenceManager pm,
  TSentryPrivilege requestedPrivToRevoke, MSentryRole mRole,
  MSentryPrivilege currentPrivilege) throws SentryInvalidInputException {
 MSentryPrivilege persistedPriv = getMSentryPrivilege(convertToTSentryPrivilege(currentPrivilege), pm);
 if (persistedPriv == null) {
  persistedPriv = convertToMSentryPrivilege(convertToTSentryPrivilege(currentPrivilege));
 }
 if (requestedPrivToRevoke.getAction().equalsIgnoreCase("ALL") || requestedPrivToRevoke.getAction().equalsIgnoreCase("*")) {
  persistedPriv.removeRole(mRole);
  privCleaner.incPrivRemoval();
  pm.makePersistent(persistedPriv);
 } else if (requestedPrivToRevoke.getAction().equalsIgnoreCase(AccessConstants.SELECT)
   && !currentPrivilege.getAction().equalsIgnoreCase(AccessConstants.INSERT)) {
  revokeRolePartial(pm, mRole, currentPrivilege, persistedPriv, AccessConstants.INSERT);
 } else if (requestedPrivToRevoke.getAction().equalsIgnoreCase(AccessConstants.INSERT)
   && !currentPrivilege.getAction().equalsIgnoreCase(AccessConstants.SELECT)) {
  revokeRolePartial(pm, mRole, currentPrivilege, persistedPriv, AccessConstants.SELECT);
 }
}

/**
 * Revoke privilege from role
 */
private void revokePrivilege(PersistenceManager pm, TSentryPrivilege tPrivilege,
               PrivilegePrincipal mEntity, MSentryPrivilege mPrivilege)
 throws SentryInvalidInputException {
 if (PARTIAL_REVOKE_ACTIONS.contains(mPrivilege.getAction())) {
  // if this privilege is in partial revoke actions
  // we will do partial revoke
  revokePartial(pm, tPrivilege, mEntity, mPrivilege);
 } else {
  // otherwise,
  // we will revoke it from role directly
  MSentryPrivilege persistedPriv = getMSentryPrivilege(convertToTSentryPrivilege(mPrivilege), pm);
  if (persistedPriv != null) {
   persistedPriv.removePrincipal(mEntity);
   persistPrivilege(pm, persistedPriv);
  }
 }
}

for (String actionToAdd : PARTIAL_REVOKE_ACTIONS) {
 if( !requestedPrivToRevoke.getAction().equalsIgnoreCase(actionToAdd) &&
   !currentPrivilege.getAction().equalsIgnoreCase(actionToAdd) &&
   !AccessConstants.ALL.equalsIgnoreCase(actionToAdd) &&
   !AccessConstants.ACTION_ALL.equalsIgnoreCase(actionToAdd)) {

String existingPriv = pUpdate.get(mRole.getRoleName());
if (existingPriv == null) {
 pUpdate.put(mRole.getRoleName(), mPriv.getAction().toUpperCase());
} else {
 pUpdate.put(mRole.getRoleName(), existingPriv + ","
   + mPriv.getAction().toUpperCase());

/**
 * Revoke privilege from role
 */
private void revokePrivilegeFromRole(PersistenceManager pm, TSentryPrivilege tPrivilege,
  MSentryRole mRole, MSentryPrivilege mPrivilege) throws SentryInvalidInputException {
 if (PARTIAL_REVOKE_ACTIONS.contains(mPrivilege.getAction())) {
  // if this privilege is in {ALL,SELECT,INSERT}
  // we will do partial revoke
  revokePartial(pm, tPrivilege, mRole, mPrivilege);
 } else {
  // if this privilege is not ALL, SELECT nor INSERT,
  // we will revoke it from role directly
  MSentryPrivilege persistedPriv = getMSentryPrivilege(convertToTSentryPrivilege(mPrivilege), pm);
  if (persistedPriv != null) {
   mPrivilege.removeRole(mRole);
   privCleaner.incPrivRemoval();
   pm.makePersistent(mPrivilege);
  }
 }
}

childPriv.setAction(priv.getAction());

childPriv.setAction(priv.getAction());

private void convertToTSentryPrivilege(MSentryPrivilege mSentryPrivilege,
  TSentryPrivilege privilege) {
 privilege.setCreateTime(mSentryPrivilege.getCreateTime());
 privilege.setAction(fromNULLCol(mSentryPrivilege.getAction()));
 privilege.setPrivilegeScope(mSentryPrivilege.getPrivilegeScope());
 privilege.setServerName(fromNULLCol(mSentryPrivilege.getServerName()));
 privilege.setDbName(fromNULLCol(mSentryPrivilege.getDbName()));
 privilege.setTableName(fromNULLCol(mSentryPrivilege.getTableName()));
 privilege.setColumnName(fromNULLCol(mSentryPrivilege.getColumnName()));
 privilege.setURI(fromNULLCol(mSentryPrivilege.getURI()));
 if (mSentryPrivilege.getGrantOption() != null) {
  privilege.setGrantOption(TSentryGrantOption.valueOf(mSentryPrivilege.getGrantOption().toString().toUpperCase()));
 } else {
  privilege.setGrantOption(TSentryGrantOption.UNSET);
 }
}

private void convertToTSentryPrivilege(MSentryPrivilege mSentryPrivilege,
  TSentryPrivilege privilege) {
 privilege.setCreateTime(mSentryPrivilege.getCreateTime());
 privilege.setAction(fromNULLCol(mSentryPrivilege.getAction()));
 privilege.setPrivilegeScope(mSentryPrivilege.getPrivilegeScope());
 privilege.setServerName(fromNULLCol(mSentryPrivilege.getServerName()));
 privilege.setDbName(fromNULLCol(mSentryPrivilege.getDbName()));
 privilege.setTableName(fromNULLCol(mSentryPrivilege.getTableName()));
 privilege.setColumnName(fromNULLCol(mSentryPrivilege.getColumnName()));
 privilege.setURI(fromNULLCol(mSentryPrivilege.getURI()));
 if (mSentryPrivilege.getGrantOption() != null) {
  privilege.setGrantOption(TSentryGrantOption.valueOf(mSentryPrivilege.getGrantOption().toString().toUpperCase()));
 } else {
  privilege.setGrantOption(TSentryGrantOption.UNSET);
 }
}

assertFalse(mPrivilege.getGrantOption());
if (mPrivilege.getTableName().equals(table1)) {
 assertEquals(AccessConstants.ALL, mPrivilege.getAction());
} else if (mPrivilege.getTableName().equals(table2)) {
 assertNotSame(AccessConstants.SELECT, mPrivilege.getAction());
 assertNotSame(AccessConstants.ALL, mPrivilege.getAction());
} else {
 fail("Unexpected table name: " + mPrivilege.getTableName());
assertEquals(db, mPrivilege.getDbName());
if (table1.equals(mPrivilege.getTableName())) {
 assertNotSame(AccessConstants.INSERT, mPrivilege.getAction());
 assertNotSame(AccessConstants.ALL, mPrivilege.getAction());
} else if (table2.equals(mPrivilege.getTableName())) {
 assertNotSame(AccessConstants.INSERT, mPrivilege.getAction());
 assertNotSame(AccessConstants.SELECT, mPrivilege.getAction());
 assertNotSame(AccessConstants.ALL, mPrivilege.getAction());

assertEquals(privileges.toString(), 1 * (i+1), privileges.size());
for ( MSentryPrivilege mSentryPrivilege : privileges) {
 assertNotSame(AccessConstants.INSERT, mSentryPrivilege.getAction());
 assertNotSame(AccessConstants.ALL, mSentryPrivilege.getAction());

assertEquals(db, mPrivilege.getDbName());
assertEquals(table, mPrivilege.getTableName());
assertNotSame(AccessConstants.SELECT, mPrivilege.getAction());
assertFalse(mPrivilege.getGrantOption());

assertEquals(server, mPrivilege.getServerName());
assertEquals(db, mPrivilege.getDbName());
assertNotSame(AccessConstants.SELECT, mPrivilege.getAction());

assertEquals(db, mPrivilege.getDbName());
assertEquals(table, mPrivilege.getTableName());
assertNotSame(AccessConstants.SELECT, mPrivilege.getAction());
assertFalse(mPrivilege.getGrantOption());

assertEquals(privileges.toString(), i+1, privileges.size());
MSentryPrivilege mPrivilege = Iterables.get(privileges, 0);
assertEquals(AccessConstants.INSERT, mPrivilege.getAction());

assertEquals(db, mPrivilege.getDbName());
assertEquals(table, mPrivilege.getTableName());
assertEquals(AccessConstants.INSERT, mPrivilege.getAction());
assertFalse(mPrivilege.getGrantOption());

assertEquals(server, mPrivilege.getServerName());
assertEquals(db, mPrivilege.getDbName());
assertEquals(AccessConstants.INSERT, mPrivilege.getAction());

Popular methods of MSentryPrivilege

<init>
getColumnName
getDbName
getGrantOption
getServerName
getTableName
implies
Return true if this privilege implies other privilege Otherwise, return false
setAction
setColumnName
setDbName
setGrantOption
setPrivilegeScope

Popular in Java

Making http post requests using okhttp
scheduleAtFixedRate (Timer)
addToBackStack (FragmentTransaction)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
JCheckBox (javax.swing)
Table (org.hibernate.mapping)
A relational table
Top 17 Free Sublime Text Plugins

How to use getActionmethodin org.apache.sentry.provider.db.service.model.MSentryPrivilege

Best Java code snippets using org.apache.sentry.provider.db.service.model.MSentryPrivilege.getAction (Showing top 20 results out of 315)

How to use
getAction
method
in
org.apache.sentry.provider.db.service.model.MSentryPrivilege