Feat: IP white list

hugegraph-api/src/main/java/org/apache/hugegraph/api/filter/AuthenticationFilter.java

@@ -122,16 +122,16 @@
         }
 
         if (Objects.equals(whiteIpStatus, STRING_ENABLE) && request != null) {
             peer = request.getRemoteAddr() + ":" + request.getRemotePort();
             path = request.getRequestURI();
 
             String remoteIp = request.getRemoteAddr();
-            List<String> whiteIpList = manager.authManager().listWhiteIp();
+            List<String> whiteIpList = manager.authManager().listWhiteIPs();
             boolean whiteIpEnabled = manager.authManager().getWhiteIpStatus();
             if (!path.contains(STRING_WHITE_IP_LIST) && whiteIpEnabled &&
                 !whiteIpList.contains(remoteIp)) {
                 throw new ForbiddenException(
                         String.format("Remote ip '%s' is not permitted",
                                       remoteIp));
             }
         }

hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpAPI.java → hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/WhiteIpListAPI.java

@@ -50,19 +50,19 @@
 
 @Path("whiteiplist")
 @Singleton
-public class WhiteIpAPI extends API {
+public class WhiteIpListAPI extends API {
 
     private static final Logger LOG = Log.logger(RestServer.class);
 
     @GET
     @Timed
     @Produces(APPLICATION_JSON_WITH_CHARSET)
     @RolesAllowed("admin")
     public Map<String, Object> list(@Context GraphManager manager) {
         LOG.debug("List white ips");
         AuthManager authManager = manager.authManager();
-        List<String> whiteIpList = authManager.listWhiteIp();
+        List<String> whiteIpList = authManager.listWhiteIPs();
         return ImmutableMap.of("whiteIpList", whiteIpList);
     }
 
     @POST
@@ -71,87 +71,87 @@
     @Consumes(APPLICATION_JSON)
     @Produces(APPLICATION_JSON_WITH_CHARSET)
     @RolesAllowed("admin")
-    public Map<String, Object> batch(@Context GraphManager manager,
+    public Map<String, Object> updateWhiteIPs(@Context GraphManager manager,
                                      Map<String, Object> actionMap) {
         E.checkArgument(actionMap != null,
                         "Missing argument: actionMap");
-        List<String> whiteIpList = manager.authManager().listWhiteIp();
-        Object ips = actionMap.get("ips");
-        E.checkArgument(ips instanceof List,
-                        "Invalid ips type '%s', must be list", ips.getClass());
-        List<String> ipList = (List<String>) ips;
-        Object value = actionMap.get("action");
-        E.checkArgument(value != null,
+        List<String> whiteIpList = manager.authManager().listWhiteIPs();
+        Object ipListRaw = actionMap.get("ips");
+        E.checkArgument(ipListRaw instanceof List,
+                        "Invalid ips type '%s', must be list", ipListRaw.getClass());
+        List<String> ipList = (List<String>) ipListRaw;
+        Object actionRaw = actionMap.get("action");
+        E.checkArgument(actionRaw != null,
                         "Missing argument: action");
-        E.checkArgument(value instanceof String,
+        E.checkArgument(actionRaw instanceof String,
                         "Invalid action type '%s', must be string",
-                        value.getClass());
-        String action = (String) value;
+                        actionRaw.getClass());
+        String action = (String) actionRaw;
         E.checkArgument(StringUtils.isNotEmpty(action),
                         "Missing argument: action");
-        List<String> existed = new ArrayList<>();
-        List<String> loaded = new ArrayList<>();
-        List<String> illegalIps = new ArrayList<>();
+        List<String> existedIPs = new ArrayList<>();
+        List<String> loadedIPs = new ArrayList<>();
+        List<String> illegalIPs = new ArrayList<>();
         Map<String, Object> result = new HashMap<>();
         for (String ip : ipList) {
             if (whiteIpList.contains(ip)) {
-                existed.add(ip);
+                existedIPs.add(ip);
                 continue;
             }
             if ("load".equals(action)) {
-                boolean rightIp = checkIp(ip) ? loaded.add(ip) : illegalIps.add(ip);
+                boolean rightIp = checkIp(ip) ? loadedIPs.add(ip) : illegalIPs.add(ip);
             }
         }
         switch (action) {
             case "load":
                 LOG.debug("Load to white ip list");
-                result.put("existed", existed);
-                result.put("loaded", loaded);
-                if (!illegalIps.isEmpty()) {
-                    result.put("illegalIps", illegalIps);
+                result.put("existed_ips", existedIPs);
+                result.put("loaded_ips", loadedIPs);
+                if (!illegalIPs.isEmpty()) {
+                    result.put("illegal_ips", illegalIPs);
                 }
-                whiteIpList.addAll(loaded);
+                whiteIpList.addAll(loadedIPs);
                 break;
             case "remove":
                 LOG.debug("Remove from white ip list");
-                result.put("removed", existed);
-                result.put("nonexistent", loaded);
-                whiteIpList.removeAll(existed);
+                result.put("removed", existedIPs);
+                result.put("nonexistent", loadedIPs);
+                whiteIpList.removeAll(existedIPs);
                 break;
             default:
                 throw new AssertionError(String.format("Invalid action '%s', " +
                                                        "supported action is " +
                                                        "'load' or 'remove'",
                                                        action));
         }
-        manager.authManager().setWhiteIpList(whiteIpList);
+        manager.authManager().setWhiteIPs(whiteIpList);
         return result;
     }
 
     @PUT
     @Timed
     @Produces(APPLICATION_JSON_WITH_CHARSET)
     @RolesAllowed("admin")
-    public Map<String, Object> update(@Context GraphManager manager,
+    public Map<String, Object> updateStatus(@Context GraphManager manager,
                                       @QueryParam("status") String status) {
         LOG.debug("Enable or disable white ip list");
         E.checkArgument("true".equals(status) ||
                         "false".equals(status),
                         "Invalid status, valid status is 'true' or 'false'");
         boolean open = Boolean.parseBoolean(status);
-        manager.authManager().setWhiteIpStatus(open);
+        manager.authManager().enabledWhiteIpList(open);
         Map<String, Object> map = new HashMap<>();
         map.put("WhiteIpListOpen", open);
         return map;
     }
 
     private boolean checkIp(String ipStr) {
         String ip = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
                     + "(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
                     + "(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
                     + "(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
         Pattern pattern = Pattern.compile(ip);
         Matcher matcher = pattern.matcher(ipStr);
         return matcher.matches();
     }
 }

hugegraph-api/src/main/java/org/apache/hugegraph/auth/HugeGraphAuthProxy.java

@@ -1569,24 +1569,24 @@
         }
 
         @Override
-        public List<String> listWhiteIp() {
-            return this.authManager.listWhiteIp();
+        public List<String> listWhiteIPs() {
+            return this.authManager.listWhiteIPs();
         }
 
         @Override
-        public void setWhiteIpList(List<String> whiteIpList) {
-            this.authManager.setWhiteIpList(whiteIpList);
+        public void setWhiteIPs(List<String> whiteIpList) {
+            this.authManager.setWhiteIPs(whiteIpList);
         }
 
         @Override
         public boolean getWhiteIpStatus() {
             return this.authManager.getWhiteIpStatus();
         }
 
         @Override
-        public void setWhiteIpStatus(boolean status) {
-            this.authManager.setWhiteIpStatus(status);
+        public void enabledWhiteIpList(boolean status) {
+            this.authManager.enabledWhiteIpList(status);
         }
 
         @Override
         public String loginUser(String username, String password) {

hugegraph-core/src/main/java/org/apache/hugegraph/auth/AuthManager.java

@@ -127,11 +127,11 @@ public interface AuthManager {
 
     UserWithRole validateUser(String token);
 
-    List<String> listWhiteIp();
+    List<String> listWhiteIPs();
 
-    void setWhiteIpList(List<String> whiteIpList);
+    void setWhiteIPs(List<String> whiteIpList);
 
     boolean getWhiteIpStatus();
 
-    void setWhiteIpStatus(boolean status);
+    void enabledWhiteIpList(boolean status);
 }

hugegraph-core/src/main/java/org/apache/hugegraph/auth/StandardAuthManager.java

@@ -78,7 +78,7 @@
 
     private List<String> ipWhiteList;
 
-    private Boolean whiteIpStatus;
+    private Boolean ipWhiteListEnabled;
 
     public StandardAuthManager(HugeGraphParams graph) {
         E.checkNotNull(graph, "graph");
@@ -110,7 +110,7 @@
 
         this.ipWhiteList = new ArrayList<>();
 
-        this.whiteIpStatus = false;
+        this.ipWhiteListEnabled = false;
     }
 
     private <V> Cache<Id, V> cache(String prefix, long capacity,
@@ -697,24 +697,24 @@
     }
 
     @Override
-    public List<String> listWhiteIp() {
+    public List<String> listWhiteIPs() {
         return ipWhiteList;
     }
 
     @Override
-    public void setWhiteIpList(List<String> ipWhiteList) {
+    public void setWhiteIPs(List<String> ipWhiteList) {
         this.ipWhiteList = ipWhiteList;
     }
 
     @Override
     public boolean getWhiteIpStatus() {
-        return this.whiteIpStatus;
+        return this.ipWhiteListEnabled;
     }
 
     @Override
-    public void setWhiteIpStatus(boolean status) {
-        this.whiteIpStatus = status;
+    public void enabledWhiteIpList(boolean status) {
+        this.ipWhiteListEnabled = status;
     }
 
     /**
      * Maybe can define an proxy class to choose forward or call local