org.apache.hadoop.hive.metastore.api.PrivilegeBag Java Examples

@Test
public void grant_revoke_privileges() throws TException {
  HiveObjectRef hiveObjectRef = new HiveObjectRef();
  hiveObjectRef.setDbName(DB_P);
  HiveObjectPrivilege hiveObjectPrivilege = new HiveObjectPrivilege();
  hiveObjectPrivilege.setHiveObject(hiveObjectRef);
  PrivilegeBag privileges = new PrivilegeBag(Collections.singletonList((hiveObjectPrivilege)));

  GrantRevokeType grantRevokeType = GrantRevokeType.GRANT;

  GrantRevokePrivilegeRequest request = new GrantRevokePrivilegeRequest(grantRevokeType, privileges);
  GrantRevokePrivilegeRequest inboundRequest = new GrantRevokePrivilegeRequest();
  GrantRevokePrivilegeResponse expected = new GrantRevokePrivilegeResponse();
  when(primaryMapping.transformInboundGrantRevokePrivilegesRequest(request)).thenReturn(inboundRequest);
  when(primaryClient.grant_revoke_privileges(inboundRequest)).thenReturn(expected);
  GrantRevokePrivilegeResponse response = handler.grant_revoke_privileges(request);
  assertThat(response, is(expected));
  verify(primaryMapping).checkWritePermissions(DB_P);
}
 

private PrivilegeBag buildPrivilegeBag(
        String databaseName,
        String tableName,
        HivePrincipal grantee,
        Set<PrivilegeGrantInfo> privilegeGrantInfos)
{
    ImmutableList.Builder<HiveObjectPrivilege> privilegeBagBuilder = ImmutableList.builder();
    for (PrivilegeGrantInfo privilegeGrantInfo : privilegeGrantInfos) {
        privilegeBagBuilder.add(
                new HiveObjectPrivilege(
                        new HiveObjectRef(TABLE, databaseName, tableName, null, null),
                        grantee.getName(),
                        fromPrestoPrincipalType(grantee.getType()),
                        privilegeGrantInfo));
    }
    return new PrivilegeBag(privilegeBagBuilder.build());
}
 

@Test
public void transformInboundGrantRevokePrivilegesRequest() throws Exception {
  GrantRevokePrivilegeRequest grantRevokePrivilegeRequest = new GrantRevokePrivilegeRequest();
  PrivilegeBag privilegeBag = new PrivilegeBag();
  privilegeBag.setPrivileges(hiveObjectPrivileges);
  grantRevokePrivilegeRequest.setPrivileges(privilegeBag);
  GrantRevokePrivilegeRequest result = databaseMapping
      .transformInboundGrantRevokePrivilegesRequest(grantRevokePrivilegeRequest);
  assertThat(result, is(sameInstance(grantRevokePrivilegeRequest)));
  PrivilegeBag resultPrivilegeBag = result.getPrivileges();
  assertThat(resultPrivilegeBag, is(sameInstance(privilegeBag)));
  assertHiveObjectPrivileges(resultPrivilegeBag.getPrivileges(), IN_DB_NAME);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public GrantRevokePrivilegeResponse grant_revoke_privileges(GrantRevokePrivilegeRequest request)
    throws MetaException, TException {
  PrivilegeBag privilegesBag = request.getPrivileges();
  if (privilegesBag.isSetPrivileges() && !privilegesBag.getPrivileges().isEmpty()) {
    DatabaseMapping mapping = checkWritePermissionsForPrivileges(privilegesBag);
    return mapping.getClient().grant_revoke_privileges(mapping.transformInboundGrantRevokePrivilegesRequest(request));
  }
  return getPrimaryClient().grant_revoke_privileges(request);
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean revoke_privileges(PrivilegeBag privileges) throws MetaException, TException {
  if (privileges.isSetPrivileges() && !privileges.getPrivileges().isEmpty()) {
    DatabaseMapping mapping = checkWritePermissionsForPrivileges(privileges);
    return mapping.getClient().revoke_privileges(mapping.transformInboundPrivilegeBag(privileges));
  }
  return false;
}
 

@Override
@Loggable(value = Loggable.DEBUG, skipResult = true, name = INVOCATION_LOG_NAME)
public boolean grant_privileges(PrivilegeBag privileges) throws MetaException, TException {
  if (privileges.isSetPrivileges() && !privileges.getPrivileges().isEmpty()) {
    DatabaseMapping mapping = checkWritePermissionsForPrivileges(privileges);
    return mapping.getClient().grant_privileges(mapping.transformInboundPrivilegeBag(privileges));
  }
  return false;
}
 

private DatabaseMapping checkWritePermissionsForPrivileges(PrivilegeBag privileges) throws NoSuchObjectException {
  DatabaseMapping mapping = databaseMappingService
      .databaseMapping(privileges.getPrivileges().get(0).getHiveObject().getDbName());
  for (HiveObjectPrivilege privilege : privileges.getPrivileges()) {
    HiveObjectRef obj = privilege.getHiveObject();
    mapping.checkWritePermissions(obj.getDbName());
    if (obj.getObjectType() == HiveObjectType.DATABASE) {
      mapping.checkWritePermissions(obj.getObjectName());
    }
  }
  return mapping;
}
 

@Override
public PrivilegeBag transformInboundPrivilegeBag(PrivilegeBag privilegeBag) {
  if (privilegeBag.isSetPrivileges()) {
    for (HiveObjectPrivilege privilege : privilegeBag.getPrivileges()) {
      privilege.setHiveObject(transformInboundHiveObjectRef(privilege.getHiveObject()));
    }
  }
  return privilegeBag;
}
 

@Test
public void transformInboundPrivilegeBag() throws Exception {
  PrivilegeBag privilegeBag = new PrivilegeBag();
  privilegeBag.setPrivileges(hiveObjectPrivileges);
  PrivilegeBag result = databaseMapping.transformInboundPrivilegeBag(privilegeBag);
  assertThat(result, is(sameInstance(privilegeBag)));
  assertHiveObjectPrivileges(result.getPrivileges(), IN_DB_NAME);
}
 

@Test
public void transformInboundPrivilegeBagPriviligesNotSet() throws Exception {
  PrivilegeBag privilegeBag = new PrivilegeBag();
  PrivilegeBag result = databaseMapping.transformInboundPrivilegeBag(privilegeBag);
  assertThat(result, is(sameInstance(privilegeBag)));
  assertFalse(result.isSetPrivileges());
}
 

@Test
public void grant_privileges() throws TException {
  HiveObjectRef hiveObjectRef = new HiveObjectRef();
  hiveObjectRef.setDbName(DB_P);
  HiveObjectPrivilege hiveObjectPrivilege = new HiveObjectPrivilege();
  hiveObjectPrivilege.setHiveObject(hiveObjectRef);
  PrivilegeBag privileges = new PrivilegeBag(Collections.singletonList((hiveObjectPrivilege)));
  PrivilegeBag inboundPrivileges = new PrivilegeBag();
  when(primaryMapping.transformInboundPrivilegeBag(privileges)).thenReturn(inboundPrivileges);
  handler.grant_privileges(privileges);
  verify(primaryMapping).checkWritePermissions(DB_P);
  verify(primaryClient).grant_privileges(inboundPrivileges);
}
 

@Test
public void revoke_privileges() throws TException {
  HiveObjectRef hiveObjectRef = new HiveObjectRef();
  hiveObjectRef.setDbName(DB_P);
  HiveObjectPrivilege hiveObjectPrivilege = new HiveObjectPrivilege();
  hiveObjectPrivilege.setHiveObject(hiveObjectRef);
  PrivilegeBag privileges = new PrivilegeBag(Collections.singletonList((hiveObjectPrivilege)));
  PrivilegeBag inboundPrivileges = new PrivilegeBag();
  when(primaryMapping.transformInboundPrivilegeBag(privileges)).thenReturn(inboundPrivileges);
  handler.revoke_privileges(privileges);
  verify(primaryMapping).checkWritePermissions(DB_P);
  verify(primaryClient).revoke_privileges(inboundPrivileges);
}
 

public void grantPublicSelect(String tableName, String grantor) {
  HiveObjectRef hiveObject = new HiveObjectRef(TABLE, databaseName, tableName, null, null);
  PrivilegeGrantInfo grantInfo = new PrivilegeGrantInfo("SELECT", 0, grantor, ROLE, false);
  HiveObjectPrivilege privilege = new HiveObjectPrivilege(hiveObject, "public", ROLE, grantInfo);
  PrivilegeBag privilegeBag = new PrivilegeBag(singletonList(privilege));
  try {
    metaStoreClient.grant_privileges(privilegeBag);
  } catch (TException e) {
    throw new MetaStoreException(e);
  }
}
 

public static PrivilegeBag getPrivilegeBag() {
  PrivilegeBag bag = new PrivilegeBag();
  HiveObjectPrivilege hivePrivilege = new HiveObjectPrivilege();
  hivePrivilege.setPrincipalName("user1");
  hivePrivilege.setPrincipalType(org.apache.hadoop.hive.metastore.api.PrincipalType.USER);
  org.apache.hadoop.hive.metastore.api.PrivilegeGrantInfo grantInfo = new org.apache.hadoop.hive.metastore.api.PrivilegeGrantInfo();
  grantInfo.setGrantor("user2");
  grantInfo.setGrantorType(org.apache.hadoop.hive.metastore.api.PrincipalType.USER);
  hivePrivilege.setGrantInfo(grantInfo);
  bag.setPrivileges(Lists.newArrayList(hivePrivilege));
  return bag;
}
 

@Test
public void grantPublicSelect() throws Exception {
  underTest.grantPublicSelect(TABLE, "grantor");

  ArgumentCaptor<PrivilegeBag> privilegeBagCaptor = ArgumentCaptor.forClass(PrivilegeBag.class);
  verify(metaStoreClient).grant_privileges(privilegeBagCaptor.capture());

  PrivilegeBag privilegeBag = privilegeBagCaptor.getValue();
  assertThat(privilegeBag.getPrivilegesSize(), is(1));
  HiveObjectPrivilege privilege = privilegeBag.getPrivileges().get(0);

  HiveObjectRef hiveObject = privilege.getHiveObject();
  assertThat(hiveObject.getObjectType(), is(HiveObjectType.TABLE));
  assertThat(hiveObject.getDbName(), is(DATABASE));
  assertThat(hiveObject.getObjectName(), is(TABLE));
  assertThat(hiveObject.getPartValues(), is(nullValue()));
  assertThat(hiveObject.getColumnName(), is(nullValue()));

  assertThat(privilege.getPrincipalName(), is("public"));
  assertThat(privilege.getPrincipalType(), is(ROLE));

  PrivilegeGrantInfo grantInfo = privilege.getGrantInfo();
  assertThat(grantInfo.getPrivilege(), is("SELECT"));
  assertThat(grantInfo.getCreateTime(), is(0));
  assertThat(grantInfo.getGrantor(), is("grantor"));
  assertThat(grantInfo.getGrantorType(), is(ROLE));
  assertThat(grantInfo.isGrantOption(), is(false));
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean revoke_privileges(final PrivilegeBag privileges) throws TException {
    throw unimplemented("revoke_privileges", new Object[]{privileges});
}
 

@Test
public void transformInboundPrivilegeBag() throws Exception {
  PrivilegeBag privilegeBag = new PrivilegeBag();
  PrivilegeBag result = databaseMapping.transformInboundPrivilegeBag(privilegeBag);
  assertThat(result, is(sameInstance(privilegeBag)));
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean grant_privileges(final PrivilegeBag privileges) throws TException {
    throw unimplemented("grant_privileges", new Object[]{privileges});
}
 

@Override
public PrivilegeBag transformInboundPrivilegeBag(PrivilegeBag privilegeBag) {
  return privilegeBag;
}
 

@Override
public boolean revokePrivileges(PrivilegeBag privilegeBag)
{
    throw new UnsupportedOperationException();
}
 

@Override
public boolean grantPrivileges(PrivilegeBag privilegeBag)
{
    throw new UnsupportedOperationException();
}
 

boolean revokePrivileges(PrivilegeBag privilegeBag)
throws TException;
 

boolean grantPrivileges(PrivilegeBag privilegeBag)
throws TException;
 

@Override
public boolean revokePrivileges(PrivilegeBag privilegeBag)
        throws TException
{
    return client.revoke_privileges(privilegeBag);
}
 

@Override
public boolean grantPrivileges(PrivilegeBag privilegeBag)
        throws TException
{
    return client.grant_privileges(privilegeBag);
}
 

@Override
public boolean revokePrivileges(PrivilegeBag privilegeBag)
        throws TException
{
    return runWithHandle(() -> delegate.revokePrivileges(privilegeBag));
}
 

@Override
public boolean grantPrivileges(PrivilegeBag privilegeBag)
        throws TException
{
    return runWithHandle(() -> delegate.grantPrivileges(privilegeBag));
}
 

PrivilegeBag transformInboundPrivilegeBag(PrivilegeBag privilegeBag);