| // Copyright (C) 2010 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package com.google.gerrit.common.data; |
| |
| import static java.util.Objects.requireNonNull; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.gerrit.common.Nullable; |
| import com.google.gerrit.entities.Project; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** Portion of a {@link Project} describing access rules. */ |
| public final class AccessSection implements Comparable<AccessSection> { |
| /** Special name given to the global capabilities; not a valid reference. */ |
| public static final String GLOBAL_CAPABILITIES = "GLOBAL_CAPABILITIES"; |
| /** Pattern that matches all references in a project. */ |
| public static final String ALL = "refs/*"; |
| |
| /** Pattern that matches all branches in a project. */ |
| public static final String HEADS = "refs/heads/*"; |
| |
| /** Prefix that triggers a regular expression pattern. */ |
| public static final String REGEX_PREFIX = "^"; |
| |
| /** Name of the access section. It could be a ref pattern or something else. */ |
| private String name; |
| |
| private List<Permission> permissions; |
| |
| public AccessSection(String name) { |
| this.name = name; |
| } |
| |
| /** @return true if the name is likely to be a valid reference section name. */ |
| public static boolean isValidRefSectionName(String name) { |
| return name.startsWith("refs/") || name.startsWith("^refs/"); |
| } |
| |
| public String getName() { |
| return name; |
| } |
| |
| public ImmutableList<Permission> getPermissions() { |
| return permissions == null ? ImmutableList.of() : ImmutableList.copyOf(permissions); |
| } |
| |
| public void setPermissions(List<Permission> list) { |
| requireNonNull(list); |
| |
| Set<String> names = new HashSet<>(); |
| for (Permission p : list) { |
| if (!names.add(p.getName().toLowerCase())) { |
| throw new IllegalArgumentException(); |
| } |
| } |
| |
| permissions = new ArrayList<>(list); |
| } |
| |
| @Nullable |
| public Permission getPermission(String name) { |
| return getPermission(name, false); |
| } |
| |
| @Nullable |
| public Permission getPermission(String name, boolean create) { |
| requireNonNull(name); |
| |
| if (permissions != null) { |
| for (Permission p : permissions) { |
| if (p.getName().equalsIgnoreCase(name)) { |
| return p; |
| } |
| } |
| } |
| |
| if (create) { |
| if (permissions == null) { |
| permissions = new ArrayList<>(); |
| } |
| |
| Permission p = new Permission(name); |
| permissions.add(p); |
| return p; |
| } |
| |
| return null; |
| } |
| |
| public void addPermission(Permission permission) { |
| requireNonNull(permission); |
| |
| if (permissions == null) { |
| permissions = new ArrayList<>(); |
| } |
| |
| for (Permission p : permissions) { |
| if (p.getName().equalsIgnoreCase(permission.getName())) { |
| throw new IllegalArgumentException(); |
| } |
| } |
| |
| permissions.add(permission); |
| } |
| |
| public void remove(Permission permission) { |
| requireNonNull(permission); |
| removePermission(permission.getName()); |
| } |
| |
| public void removePermission(String name) { |
| requireNonNull(name); |
| |
| if (permissions != null) { |
| permissions.removeIf(permission -> name.equalsIgnoreCase(permission.getName())); |
| } |
| } |
| |
| public void mergeFrom(AccessSection section) { |
| requireNonNull(section); |
| |
| for (Permission src : section.getPermissions()) { |
| Permission dst = getPermission(src.getName()); |
| if (dst != null) { |
| dst.mergeFrom(src); |
| } else { |
| permissions.add(src); |
| } |
| } |
| } |
| |
| @Override |
| public int compareTo(AccessSection o) { |
| return comparePattern().compareTo(o.comparePattern()); |
| } |
| |
| private String comparePattern() { |
| if (getName().startsWith(REGEX_PREFIX)) { |
| return getName().substring(REGEX_PREFIX.length()); |
| } |
| return getName(); |
| } |
| |
| @Override |
| public String toString() { |
| return "AccessSection[" + getName() + "]"; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (!(obj instanceof AccessSection)) { |
| return false; |
| } |
| |
| AccessSection other = (AccessSection) obj; |
| if (!getName().equals(other.getName())) { |
| return false; |
| } |
| return new HashSet<>(getPermissions()) |
| .equals(new HashSet<>(((AccessSection) obj).getPermissions())); |
| } |
| |
| @Override |
| public int hashCode() { |
| int hashCode = super.hashCode(); |
| if (permissions != null) { |
| for (Permission permission : permissions) { |
| hashCode += permission.hashCode(); |
| } |
| } |
| hashCode += getName().hashCode(); |
| return hashCode; |
| } |
| } |