public override bool CheckAccess(UserGroupInformation callerUGI, QueueACL acl, string
queueName)
{
lock (this)
{
return(acl != QueueACL.AdministerQueue);
}
}
public override bool CheckAccess(UserGroupInformation callerUGI, QueueACL acl, string
queueName)
{
lock (this)
{
return(DefaultQueue.HasAccess(acl, callerUGI));
}
}
public virtual bool CheckAccess(UserGroupInformation callerUGI, QueueACL acl, string
queueName)
{
if (!isACLsEnable)
{
return(true);
}
return(scheduler.CheckAccess(callerUGI, acl, queueName));
}
public virtual AccessControlList GetAcl(string queue, QueueACL acl)
{
string queuePrefix = GetQueuePrefix(queue);
// The root queue defaults to all access if not defined
// Sub queues inherit access if not defined
string defaultAcl = queue.Equals(Root) ? AllAcl : NoneAcl;
string aclString = Get(queuePrefix + GetAclKey(acl), defaultAcl);
return(new AccessControlList(aclString));
}
public IList <QueueUserACLInfo> GetQueueUserAclInfo(UserGroupInformation unused)
{
QueueUserACLInfo queueUserAclInfo = Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Scheduler.Fifo.FifoScheduler
.recordFactory.NewRecordInstance <QueueUserACLInfo>();
queueUserAclInfo.SetQueueName(Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Scheduler.Fifo.FifoScheduler
.DefaultQueueName);
queueUserAclInfo.SetUserAcls(Arrays.AsList(QueueACL.Values()));
return(Sharpen.Collections.SingletonList(queueUserAclInfo));
}
public IDictionary <QueueACL, AccessControlList> GetQueueAcls()
{
IDictionary <QueueACL, AccessControlList> acls = new Dictionary <QueueACL, AccessControlList
>();
foreach (QueueACL acl in QueueACL.Values())
{
acls[acl] = new AccessControlList("*");
}
return(acls);
}
public virtual IDictionary <AccessType, AccessControlList> GetAcls(string queue)
{
IDictionary <AccessType, AccessControlList> acls = new Dictionary <AccessType, AccessControlList
>();
foreach (QueueACL acl in QueueACL.Values())
{
acls[SchedulerUtils.ToAccessType(acl)] = GetAcl(queue, acl);
}
return(acls);
}
/// <summary>Get the ACLs associated with this queue.</summary>
/// <remarks>
/// Get the ACLs associated with this queue. If a given ACL is not explicitly
/// configured, include the default value for that ACL. The default for the
/// root queue is everybody ("*") and the default for all other queues is
/// nobody ("")
/// </remarks>
public virtual AccessControlList GetQueueAcl(string queue, QueueACL operation)
{
IDictionary <QueueACL, AccessControlList> queueAcls = this.queueAcls[queue];
if (queueAcls != null)
{
AccessControlList operationAcl = queueAcls[operation];
if (operationAcl != null)
{
return(operationAcl);
}
}
return((queue.Equals("root")) ? EverybodyAcl : NobodyAcl);
}
public virtual bool HasQueueACL(IList <QueueUserACLInfo> aclInfos, QueueACL acl, string
qName)
{
foreach (QueueUserACLInfo aclInfo in aclInfos)
{
if (aclInfo.GetQueueName().Equals(qName))
{
if (aclInfo.GetUserAcls().Contains(acl))
{
return(true);
}
}
}
return(false);
}
public static AccessType ToAccessType(QueueACL acl)
{
switch (acl)
{
case QueueACL.AdministerQueue:
{
return(AccessType.AdministerQueue);
}
case QueueACL.SubmitApplications:
{
return(AccessType.SubmitApp);
}
}
return(null);
}
public virtual bool HasAccess(string queueName, QueueACL acl, UserGroupInformation
user)
{
int lastPeriodIndex = queueName.Length;
while (lastPeriodIndex != -1)
{
string queue = Sharpen.Runtime.Substring(queueName, 0, lastPeriodIndex);
if (GetQueueAcl(queue, acl).IsUserAllowed(user))
{
return(true);
}
lastPeriodIndex = queueName.LastIndexOf('.', lastPeriodIndex - 1);
}
return(false);
}
public override IList <QueueUserACLInfo> GetQueueUserAclInfo(UserGroupInformation
user)
{
QueueUserACLInfo userAclInfo = recordFactory.NewRecordInstance <QueueUserACLInfo>(
);
IList <QueueACL> operations = new AList <QueueACL>();
foreach (QueueACL operation in QueueACL.Values())
{
if (HasAccess(operation, user))
{
operations.AddItem(operation);
}
}
userAclInfo.SetQueueName(GetQueueName());
userAclInfo.SetUserAcls(operations);
return(Sharpen.Collections.SingletonList(userAclInfo));
}
private QueueUserACLInfo GetUserAclInfo(UserGroupInformation user)
{
lock (this)
{
QueueUserACLInfo userAclInfo = recordFactory.NewRecordInstance <QueueUserACLInfo>(
);
IList <QueueACL> operations = new AList <QueueACL>();
foreach (QueueACL operation in QueueACL.Values())
{
if (HasAccess(operation, user))
{
operations.AddItem(operation);
}
}
userAclInfo.SetQueueName(GetQueueName());
userAclInfo.SetUserAcls(operations);
return(userAclInfo);
}
}
public virtual void SetAcl(string queue, QueueACL acl, string aclString)
{
string queuePrefix = GetQueuePrefix(queue);
Set(queuePrefix + GetAclKey(acl), aclString);
}
private static string GetAclKey(QueueACL acl)
{
return("acl_" + StringUtils.ToLowerCase(acl.ToString()));
}
public virtual bool HasAccess(QueueACL acl, UserGroupInformation user)
{
return(authorizer.CheckPermission(SchedulerUtils.ToAccessType(acl), queueEntity,
user));
}
public abstract bool CheckAccess(UserGroupInformation arg1, QueueACL arg2, string
arg3);
private YarnProtos.QueueACLProto ConvertToProtoFormat(QueueACL queueAcl)
{
return(ProtoUtils.ConvertToProtoFormat(queueAcl));
}
public bool HasAccess(QueueACL acl, UserGroupInformation user)
{
return(this.GetQueueAcls()[acl].IsUserAllowed(user));
}
/*
* QueueACL
*/
public static YarnProtos.QueueACLProto ConvertToProtoFormat(QueueACL e)
{
return(YarnProtos.QueueACLProto.ValueOf(QueueAclPrefix + e.ToString()));
}
public virtual bool HasAccess(QueueACL acl, UserGroupInformation user)
{
return(scheduler.GetAllocationConfiguration().HasAccess(name, acl, user));
}
public static QueueACL ConvertFromProtoFormat(YarnProtos.QueueACLProto e)
{
return(QueueACL.ValueOf(e.ToString().Replace(QueueAclPrefix, string.Empty)));
}
