congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
KeyValue
Code IndexAdd Tabnine to your IDE (free)

How to use
KeyValue
in
org.apache.sentry.policy.common

Best Java code snippets using org.apache.sentry.policy.common.KeyValue (Showing top 20 results out of 315)

origin: apache/incubator-sentry

private List<? extends Authorizable> toAuthorizables(String privilegeStr) {
 List<Authorizable> authorizables = Lists.newArrayList();
 if (privilegeStr == null) {
  return authorizables;
 }
 for (String authorizable : PolicyConstants.AUTHORIZABLE_SPLITTER.split(privilegeStr)) {
  KeyValue tempKV = new KeyValue(authorizable);
  final String key = tempKV.getKey();
  final String value = tempKV.getValue();
  authorizables.add(new Authorizable() {
   @Override
   public String getTypeName() {
    return key;
   }
   @Override
   public String getName() {
    return value;
   }
  });
 }
 return authorizables;
}
origin: apache/incubator-sentry

private boolean impliesKeyValue(KeyValue policyPart, KeyValue requestPart) {
 Preconditions.checkState(policyPart.getKey().equalsIgnoreCase(requestPart.getKey()),
   "Please report, this method should not be called with two different keys");
 if(policyPart.getValue().equals(IndexerConstants.ALL) || policyPart.equals(requestPart)) {
  return true;
 } else if (!PolicyConstants.PRIVILEGE_NAME.equalsIgnoreCase(policyPart.getKey())
   && IndexerConstants.ALL.equalsIgnoreCase(requestPart.getValue())) {
  /* privilege request is to match with any object of given type */
  return true;
 }
 return false;
}
origin: apache/incubator-sentry

 @Override
 public String toString() {
  StringBuilder sb = new StringBuilder();
  for(KeyValue kv: this.parts) {
   sb.append(kv.getKey() + "=" + kv.getValue() + "->");
  }
  return sb.toString();
 }
}
origin: co.cask.cdap/cdap-sentry-policy

/**
 * Gets a {@link Authorizable} from the given key and value
 *
 * @param key the {@link AuthorizableType type} of the authorizable
 * @param value the {@link Authorizable name} of the authorizable
 * @return the created {@link Authorizable} with the given name if {@link AuthorizableType} given was valid
 * @throws NoSuchElementException if the given {@link AuthorizableType} was not valid
 */
public static Authorizable from(String key, String value) {
 return from(new KeyValue(key, value));
}
origin: apache/incubator-sentry

private boolean hasHostWidCard(KeyValue policyPart) {
 if (policyPart.getKey().equalsIgnoreCase(KafkaAuthorizable.AuthorizableType.HOST.toString()) &&
   policyPart.getValue().equalsIgnoreCase(ALL_HOSTS)) {
  return true;
 }
 return false;
}
origin: co.cask.cdap/cdap-sentry-policy

/**
 * Gets a {@link Authorizable} from the given {@link KeyValue}
 *
 * @param keyValue {@link KeyValue} containing the {@link AuthorizableType} and name of the {@link Authorizable}
 * to be crearted
 * @return the created {@link Authorizable} with the given name if {@link AuthorizableType} given was valid
 * @throws NoSuchElementException if the given {@link AuthorizableType} was not valid
 */
static Authorizable from(String keyValue) {
 return from(new KeyValue(keyValue));
}
origin: co.cask.cdap/cdap-sentry-policy

private static Authorizable from(KeyValue keyValue) {
 String prefix = keyValue.getKey().toLowerCase();
 String name = keyValue.getValue();
 for (Authorizable.AuthorizableType type : AuthorizableType.values()) {
  if (prefix.equalsIgnoreCase(type.name())) {
   return from(type, name);
  }
 }
 throw new NoSuchElementException(String.format("Given AuthorizableType %s does not exists.", prefix));
}
origin: apache/incubator-sentry

private boolean impliesKeyValue(KeyValue policyPart, KeyValue requestPart) {
 Preconditions.checkState(policyPart.getKey().equalsIgnoreCase(requestPart.getKey()),
   "Please report, this method should not be called with two different keys");
 if(policyPart.getValue().equals(SearchConstants.ALL) || policyPart.equals(requestPart)) {
  return true;
 } else if (!PolicyConstants.PRIVILEGE_NAME.equalsIgnoreCase(policyPart.getKey())
   && SearchConstants.ALL.equalsIgnoreCase(requestPart.getValue())) {
  /* privilege request is to match with any object of given type */
  return true;
 }
 return false;
}
origin: apache/incubator-sentry

public static TSentryPrivilege convertToTSentryPrivilege(String privilegeStr) {
 TSentryPrivilege tSentryPrivilege = new TSentryPrivilege();
 for (String authorizable : PolicyConstants.AUTHORIZABLE_SPLITTER.split(privilegeStr)) {
  KeyValue tempKV = new KeyValue(authorizable);
  String key = tempKV.getKey();
  String value = tempKV.getValue();
  if (PolicyFileConstants.PRIVILEGE_SERVER_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setServerName(value);
  } else if (PolicyFileConstants.PRIVILEGE_DATABASE_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setDbName(value);
  } else if (PolicyFileConstants.PRIVILEGE_TABLE_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setTableName(value);
  } else if (PolicyFileConstants.PRIVILEGE_COLUMN_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setColumnName(value);
  } else if (PolicyFileConstants.PRIVILEGE_URI_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setURI(value);
  } else if (PolicyFileConstants.PRIVILEGE_ACTION_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setAction(value);
  } else if (PolicyFileConstants.PRIVILEGE_GRANT_OPTION_NAME.equalsIgnoreCase(key)) {
   TSentryGrantOption grantOption = "true".equalsIgnoreCase(value) ? TSentryGrantOption.TRUE
     : TSentryGrantOption.FALSE;
   tSentryPrivilege.setGrantOption(grantOption);
  }
 }
 tSentryPrivilege.setPrivilegeScope(getPrivilegeScope(tSentryPrivilege));
 return tSentryPrivilege;
}
origin: co.cask.cdap/cdap-sentry-policy

public WildcardPrivilege(String permission) {
 if (Strings.isNullOrEmpty(permission)) {
  throw new IllegalArgumentException("Permission string cannot be null or empty.");
 }
 List<KeyValue> parts = new ArrayList<>();
 for (String authorizable : PolicyConstants.AUTHORIZABLE_SPLITTER.trimResults().split(permission)) {
  if (authorizable.isEmpty()) {
   throw new IllegalArgumentException("Privilege '" + permission + "' has an empty section");
  }
  parts.add(new KeyValue(authorizable));
 }
 Preconditions.checkState(!parts.isEmpty(), "Failed to split the permission string %s into a list of Authorizables" +
  " separated by %s", permission, PolicyConstants.AUTHORIZABLE_SPLITTER);
 this.privilegeParts = Collections.unmodifiableList(parts);
}
origin: apache/incubator-sentry

public static SearchModelAuthorizable from(KeyValue keyValue) {
 String prefix = keyValue.getKey().toLowerCase();
 String name = keyValue.getValue().toLowerCase();
 for(AuthorizableType type : AuthorizableType.values()) {
  if(prefix.equalsIgnoreCase(type.name())) {
   return from(type, name);
  }
 }
 return null;
}
public static SearchModelAuthorizable from(String s) {
origin: apache/incubator-sentry

 private boolean impliesKeyValue(KeyValue policyPart, KeyValue requestPart) {
  Preconditions.checkState(policyPart.getKey().equalsIgnoreCase(requestPart.getKey()),
    "Please report, this method should not be called with two different keys");
  if(policyPart.getValue().equalsIgnoreCase(SqoopActionConstant.ALL) ||
    policyPart.getValue().equalsIgnoreCase(SqoopActionConstant.ALL_NAME) ||
    policyPart.equals(requestPart)) {
   return true;
  } else if (!SqoopActionConstant.NAME.equalsIgnoreCase(policyPart.getKey())
    && SqoopActionConstant.ALL.equalsIgnoreCase(requestPart.getValue())) {
   /* privilege request is to match with any object of given type */
   return true;
  }
  return false;

 }
}
origin: apache/incubator-sentry

public static TSentryPrivilege convertToTSentryPrivilege(String privilegeStr) throws Exception {
 TSentryPrivilege tSentryPrivilege = new TSentryPrivilege();
 for (String authorizable : PolicyConstants.AUTHORIZABLE_SPLITTER.split(privilegeStr)) {
  KeyValue tempKV = new KeyValue(authorizable);
  String key = tempKV.getKey();
  String value = tempKV.getValue();
  if (PolicyFileConstants.PRIVILEGE_SERVER_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setServerName(value);
  } else if (PolicyFileConstants.PRIVILEGE_DATABASE_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setDbName(value);
  } else if (PolicyFileConstants.PRIVILEGE_TABLE_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setTableName(value);
  } else if (PolicyFileConstants.PRIVILEGE_COLUMN_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setColumnName(value);
  } else if (PolicyFileConstants.PRIVILEGE_URI_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setURI(value);
  } else if (PolicyFileConstants.PRIVILEGE_ACTION_NAME.equalsIgnoreCase(key)) {
   tSentryPrivilege.setAction(value);
  } else if (PolicyFileConstants.PRIVILEGE_GRANT_OPTION_NAME.equalsIgnoreCase(key)) {
   TSentryGrantOption grantOption = "true".equalsIgnoreCase(value) ? TSentryGrantOption.TRUE
       : TSentryGrantOption.FALSE;
   tSentryPrivilege.setGrantOption(grantOption);
  }
 }
 tSentryPrivilege.setPrivilegeScope(getPrivilegeScope(tSentryPrivilege));
 validatePrivilegeHierarchy(tSentryPrivilege);
 return tSentryPrivilege;
}
origin: apache/incubator-sentry

public static SqoopAuthorizable from(String keyValue) {
 return from(new KeyValue(keyValue));
}
origin: apache/incubator-sentry

public static SqoopAuthorizable from(KeyValue keyValue) {
 String prefix = keyValue.getKey().toLowerCase();
 String name = keyValue.getValue().toLowerCase();
 for (AuthorizableType type : AuthorizableType.values()) {
  if(prefix.equalsIgnoreCase(type.name())) {
   return from(type, name);
  }
 }
 return null;
}
origin: apache/incubator-sentry

private boolean impliesKeyValue(KeyValue policyPart, KeyValue requestPart) {
 Preconditions.checkState(policyPart.getKey().equalsIgnoreCase(requestPart.getKey()),
   "Please report, this method should not be called with two different keys");
 // Host is a special resource, not declared as resource in Kafka. Each Kafka resource can be
 // authorized based on the host request originated from and to handle this, Sentry uses host as
 // a resource. Kafka allows using '*' as wildcard for all hosts. '*' however is not a valid
 // Kafka action.
 if (hasHostWidCard(policyPart)) {
  return true;
 }
 if (KafkaActionConstant.actionName.equalsIgnoreCase(policyPart.getKey())) { // is action
  return policyPart.getValue().equalsIgnoreCase(KafkaActionConstant.ALL) ||
    policyPart.equals(requestPart);
 } else {
  return policyPart.getValue().equals(requestPart.getValue());
 }
}
origin: apache/incubator-sentry

List<TAuthorizable> authorizables = new LinkedList<TAuthorizable>();
for (String authorizable : PolicyConstants.AUTHORIZABLE_SPLITTER.split(privilegeStr)) {
 KeyValue keyValue = new KeyValue(authorizable);
 String key = keyValue.getKey();
 String value = keyValue.getValue();
origin: apache/incubator-sentry

public static KafkaAuthorizable from(String keyValue) throws ConfigurationException {
 return from(new KeyValue(keyValue));
}
origin: apache/incubator-sentry

public static KafkaAuthorizable from(KeyValue keyValue) throws ConfigurationException {
 String prefix = keyValue.getKey().toLowerCase();
 String name = keyValue.getValue();
 for (AuthorizableType type : AuthorizableType.values()) {
  if (prefix.equalsIgnoreCase(type.name())) {
   return from(type, name);
  }
 }
 return null;
}
origin: co.cask.cdap/cdap-sentry-policy

 /**
  * For policy and request parts with the same key, ensure that the policy implies the request. In this method, the
  * keys for both #policyPart and #requestPart are expected to be the same.
  *
  * @param policyPart the policy part
  * @param requestPart the request part
  * @return true if either
  * - policy part is {@link Action#ALL}; or
  * - policy part equals request part;
  * false otherwise.
  */
 private boolean impliesKeyValue(KeyValue policyPart, KeyValue requestPart) {
  Preconditions.checkState(policyPart.getKey().equalsIgnoreCase(requestPart.getKey()),
               String.format("Privilege Key Mismatch: Key %s and %s does not match.", policyPart.getKey
                (), requestPart.getKey()));
  // if it is an action, then either the policy part must include ALL, or be the same as the request part.
  if (ActionConstant.ACTION_NAME.equalsIgnoreCase(policyPart.getKey()) &&
   policyPart.getValue().equalsIgnoreCase(ActionConstant.ALL)) {
    return true;
  }
  // if policy part is not Action#ALL, make sure that the policy and request parts match.
  return policyPart.equals(requestPart);
 }
}
org.apache.sentry.policy.commonKeyValue

Most used methods

  • <init>
  • getKey
  • getValue
  • equals

Popular in Java

  • Reactive rest calls using spring rest template
  • getContentResolver (Context)
  • requestLocationUpdates (LocationManager)
  • runOnUiThread (Activity)
  • Component (java.awt)
    A component is an object having a graphical representation that can be displayed on the screen and t
  • Window (java.awt)
    A Window object is a top-level window with no borders and no menubar. The default layout for a windo
  • System (java.lang)
    Provides access to system-related information and resources including standard input and output. Ena
  • Proxy (java.net)
    This class represents proxy server settings. A created instance of Proxy stores a type and an addres
  • Format (java.text)
    The base class for all formats. This is an abstract base class which specifies the protocol for clas
  • Enumeration (java.util)
    A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
  • Top Sublime Text plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now