@Override public boolean equals(Object object) { if ((object == null) || !(object instanceof PrincipalSid)) { return false; } // Delegate to getPrincipal() to perform actual comparison (both should be // identical) return ((PrincipalSid) object).getPrincipal().equals(this.getPrincipal()); }
@Override public int hashCode() { return this.getPrincipal().hashCode(); }
private Set<String> getUsersInPrj(List<Sid> allSids) throws IOException { Set<String> allUsers = new TreeSet<>(); for (Sid sid : allSids) { if (sid instanceof PrincipalSid) { allUsers.add(((PrincipalSid) sid).getPrincipal()); } } return allUsers; }
private static String getName(Sid sid) { if (sid instanceof PrincipalSid) { return ((PrincipalSid) sid).getPrincipal(); } else { return ((GrantedAuthoritySid) sid).getGrantedAuthority(); } }
public SidInfo(Sid sid) { if (sid instanceof PrincipalSid) { this.sid = ((PrincipalSid) sid).getPrincipal(); this.isPrincipal = true; } else if (sid instanceof GrantedAuthoritySid) { this.sid = ((GrantedAuthoritySid) sid).getGrantedAuthority(); this.isPrincipal = false; } else throw new IllegalStateException(); }
/** * Retrieves the primary key from acl_sid, creating a new row if needed and the * allowCreate property is true. * * @param sid to find or create * @param allowCreate true if creation is permitted if not found * * @return the primary key or null if not found * * @throws IllegalArgumentException if the <tt>Sid</tt> is not a recognized * implementation. */ protected Long createOrRetrieveSidPrimaryKey(Sid sid, boolean allowCreate) { Assert.notNull(sid, "Sid required"); String sidName; boolean sidIsPrincipal = true; if (sid instanceof PrincipalSid) { sidName = ((PrincipalSid) sid).getPrincipal(); } else if (sid instanceof GrantedAuthoritySid) { sidName = ((GrantedAuthoritySid) sid).getGrantedAuthority(); sidIsPrincipal = false; } else { throw new IllegalArgumentException("Unsupported implementation of Sid"); } return createOrRetrieveSidPrimaryKey(sidName, sidIsPrincipal, allowCreate); }
public List<String> getAllAclSids(Acl acl, String type) { if (null == acl) { return Collections.emptyList(); } List<String> result = new ArrayList<>(); for (AccessControlEntry ace : acl.getEntries()) { String name = null; if (type.equalsIgnoreCase(MetadataConstants.TYPE_USER) && ace.getSid() instanceof PrincipalSid) { name = ((PrincipalSid) ace.getSid()).getPrincipal(); } if (type.equalsIgnoreCase(MetadataConstants.TYPE_GROUP) && ace.getSid() instanceof GrantedAuthoritySid) { name = ((GrantedAuthoritySid) ace.getSid()).getGrantedAuthority(); } if (!StringUtils.isBlank(name)) { result.add(name); } } return result; }
@Test public void testGetters() throws Exception { Authentication authentication = new TestingAuthenticationToken("johndoe", "password"); PrincipalSid principalSid = new PrincipalSid(authentication); GrantedAuthority ga = new SimpleGrantedAuthority("ROLE_TEST"); GrantedAuthoritySid gaSid = new GrantedAuthoritySid(ga); assertThat("johndoe".equals(principalSid.getPrincipal())).isTrue(); assertThat("scott".equals(principalSid.getPrincipal())).isFalse(); assertThat("ROLE_TEST".equals(gaSid.getGrantedAuthority())).isTrue(); assertThat("ROLE_TEST2".equals(gaSid.getGrantedAuthority())).isFalse(); } }
@Test public void testCreatePrincipalSid() { Sid result = strategy.createSid(true, "sid"); assertThat(result.getClass()).isEqualTo(PrincipalSid.class); assertThat(((PrincipalSid) result).getPrincipal()).isEqualTo("sid"); }
@Test public void correctSidsAreRetrieved() throws Exception { SidRetrievalStrategy retrStrategy = new SidRetrievalStrategyImpl(); List<Sid> sids = retrStrategy.getSids(authentication); assertThat(sids).isNotNull(); assertThat(sids).hasSize(4); assertThat(sids.get(0)).isNotNull(); assertThat(sids.get(0) instanceof PrincipalSid).isTrue(); for (int i = 1; i < sids.size(); i++) { assertThat(sids.get(i) instanceof GrantedAuthoritySid).isTrue(); } assertThat(((PrincipalSid) sids.get(0)).getPrincipal()).isEqualTo("scott"); assertThat(((GrantedAuthoritySid) sids.get(1)).getGrantedAuthority()).isEqualTo("A"); assertThat(((GrantedAuthoritySid) sids.get(2)).getGrantedAuthority()).isEqualTo("B"); assertThat(((GrantedAuthoritySid) sids.get(3)).getGrantedAuthority()).isEqualTo("C"); }
@Override protected Long createOrRetrieveSidPrimaryKey(Sid sid, boolean allowCreate) { String sidName; boolean isPrincipal = false; if (sid instanceof CustomSid) { sidName = ((CustomSid) sid).getSid(); } else if (sid instanceof GrantedAuthoritySid) { sidName = ((GrantedAuthoritySid) sid).getGrantedAuthority(); } else { sidName = ((PrincipalSid) sid).getPrincipal(); isPrincipal = true; } return createOrRetrieveSidPrimaryKey(sidName, isPrincipal, allowCreate); } }
private Map<String, Integer> getProjectPermission(String project) { Map<String, Integer> SidWithPermission = new HashMap<>(); String uuid = ProjectManager.getInstance(KylinConfig.getInstanceFromEnv()).getProject(project).getUuid(); AclEntity ae = getAclEntity(AclEntityType.PROJECT_INSTANCE, uuid); Acl acl = getAcl(ae); if (acl != null && acl.getEntries() != null) { List<AccessControlEntry> aces = acl.getEntries(); for (AccessControlEntry ace : aces) { Sid sid = ace.getSid(); if (sid instanceof PrincipalSid) { String principal = ((PrincipalSid) sid).getPrincipal(); SidWithPermission.put(principal, ace.getPermission().getMask()); } if (sid instanceof GrantedAuthoritySid) { String grantedAuthority = ((GrantedAuthoritySid) sid).getGrantedAuthority(); SidWithPermission.put(grantedAuthority, ace.getPermission().getMask()); } } } return SidWithPermission; }
@Override public boolean equals(Object object) { if ((object == null) || !(object instanceof PrincipalSid)) { return false; } // Delegate to getPrincipal() to perform actual comparison (both should be // identical) return ((PrincipalSid) object).getPrincipal().equals(this.getPrincipal()); }
private static boolean isPrincipal(Sid sid, String username) { return sid instanceof PrincipalSid && username.equals(((PrincipalSid) sid).getPrincipal()); } }
@Override public int hashCode() { return this.getPrincipal().hashCode(); }
private String getSidName(Sid sid) { if (sid instanceof PrincipalSid) { return ((PrincipalSid) sid).getPrincipal(); } else if (sid instanceof GrantedAuthoritySid) { return ((GrantedAuthoritySid) sid).getGrantedAuthority(); } else { throw new IllegalArgumentException("Unsupported implementation of Sid"); } }
protected String toString(Sid p) { if (p instanceof GrantedAuthoritySid) { return ((GrantedAuthoritySid) p).getGrantedAuthority(); } if (p instanceof PrincipalSid) { return ((PrincipalSid) p).getPrincipal(); } if (p == EVERYONE) { return "role_everyone"; } // hmm... return p.toString(); }
/** * {@inheritDoc} */ @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || !(o instanceof PrincipalSid)) { return false; } PrincipalSid that = (PrincipalSid) o; if (!getPrincipal().equals(that.getPrincipal())) { return false; } return true; }
private Function<Sid, Object> adaptObjectForSidResolver( Function<Sid, Object> objectForSidResolver, EntityConfiguration<Object> entityConfiguration ) { if ( objectForSidResolver == null ) { if ( !SecurityPrincipal.class.isAssignableFrom( entityConfiguration.getEntityType() ) ) { throw new IllegalStateException( "No ObjectForSidResolver set and entity type does not implement SecurityPrincipal - unable to create one automatically" ); } return sid -> { if ( sid instanceof PrincipalSid ) { return securityPrincipalService.getPrincipalByName( ( (PrincipalSid) sid ).getPrincipal() ); } return null; }; } return objectForSidResolver; }
public static TenantPrincipalSid from(PrincipalSid sid) { return new TenantPrincipalSid(sid.getPrincipal(), MultiTenancySupport.getTenant(sid)); } }