Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

apache-shiro/src/main/java/com/baeldung/Main.java

@@ -0,0 +1,85 @@
+package com.baeldung;
+
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.*;
+import org.apache.shiro.mgt.DefaultSecurityManager;
+import org.apache.shiro.mgt.SecurityManager;
+import org.apache.shiro.realm.Realm;
+import org.apache.shiro.realm.text.IniRealm;
+import org.apache.shiro.session.Session;
+import org.apache.shiro.subject.Subject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Main {
+
+    private static final transient Logger log = LoggerFactory.getLogger(Main.class);
+
+    public static void main(String[] args) {
+
+        Realm realm = new MyCustomRealm();
+        SecurityManager securityManager = new DefaultSecurityManager(realm);
+
+        SecurityUtils.setSecurityManager(securityManager);
+        Subject currentUser = SecurityUtils.getSubject();
+
+        if (!currentUser.isAuthenticated()) {
+          UsernamePasswordToken token 
+            = new UsernamePasswordToken("user", "password");
+          token.setRememberMe(true);
+          try {
+              currentUser.login(token);
+          } catch (UnknownAccountException uae) {
+              log.error("Username Not Found!", uae);
+          } catch (IncorrectCredentialsException ice) {
+              log.error("Invalid Credentials!", ice);
+          } catch (LockedAccountException lae) {
+              log.error("Your Account is Locked!", lae);
+          } catch (AuthenticationException ae) {
+              log.error("Unexpected Error!", ae);
+          }
+        }
+
+        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");
+
+        if (currentUser.hasRole("admin")) {
+            log.info("Welcome Admin");
+        } else if(currentUser.hasRole("editor")) {
+            log.info("Welcome, Editor!");
+        } else if(currentUser.hasRole("author")) {
+            log.info("Welcome, Author");
+        } else {
+            log.info("Welcome, Guest");
+        }
+
+        if(currentUser.isPermitted("articles:compose")) {
+            log.info("You can compose an article");
+        } else {
+            log.info("You are not permitted to compose an article!");
+        }
+
+        if(currentUser.isPermitted("articles:save")) {
+            log.info("You can save articles");
+        } else {
+            log.info("You can not save articles");
+        }
+
+        if(currentUser.isPermitted("articles:publish")) {
+            log.info("You can publish articles");
+        } else {
+            log.info("You can not publish articles");
+        }
+
+        Session session = currentUser.getSession();
+        session.setAttribute("key", "value");
+        String value = (String) session.getAttribute("key");
+        if (value.equals("value")) {
+            log.info("Retrieved the correct value! [" + value + "]");
+        }
+
+        currentUser.logout();
+
+        System.exit(0);
+    }
+
+}

apache-shiro/src/main/java/com/baeldung/MyCustomRealm.java

@@ -0,0 +1,102 @@
+package com.baeldung;
+
+import org.apache.shiro.authc.*;
+import org.apache.shiro.authz.AuthorizationInfo;
+import org.apache.shiro.authz.SimpleAuthorizationInfo;
+import org.apache.shiro.realm.jdbc.JdbcRealm;
+import org.apache.shiro.subject.PrincipalCollection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.*;
+
+public class MyCustomRealm extends JdbcRealm {
+
+    private Map<String, String> credentials = new HashMap<>();
+    private Map<String, Set<String>> roles = new HashMap<>();
+    private Map<String, Set<String>> perm = new HashMap<>();
+
+    {
+      credentials.put("user", "password");
+      credentials.put("user2", "password2");
+      credentials.put("user3", "password3");
+
+      roles.put("user", new HashSet<>(Arrays.asList("admin")));
+      roles.put("user2", new HashSet<>(Arrays.asList("editor")));
+      roles.put("user3", new HashSet<>(Arrays.asList("author")));
+
+      perm.put("admin", new HashSet<>(Arrays.asList("*")));
+      perm.put("editor", new HashSet<>(Arrays.asList("articles:*")));
+      perm.put("author",
+        new HashSet<>(Arrays.asList("articles:compose",
+          "articles:save")));
+
+    }
+
+    @Override
+    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
+      throws AuthenticationException {
+
+        UsernamePasswordToken uToken = (UsernamePasswordToken) token;
+
+        if(uToken.getUsername() == null
+          || uToken.getUsername().isEmpty()
+          || !credentials.containsKey(uToken.getUsername())
+          ) {
+            throw new UnknownAccountException("username not found!");
+        }
+
+
+        return new SimpleAuthenticationInfo(
+          uToken.getUsername(), credentials.get(uToken.getUsername()),
+          getName());
+    }
+
+    @Override
+    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
+        Set<String> roleNames = new HashSet<>();
+        Set<String> permissions = new HashSet<>();
+
+        principals.forEach(p -> {
+            try {
+                Set<String> roles = getRoleNamesForUser(null, (String) p);
+                roleNames.addAll(roles);
+                permissions.addAll(getPermissions(null, null,roles));
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
+
+        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
+        info.setStringPermissions(permissions);
+        return info;
+    }
+
+    @Override
+    protected Set<String> getRoleNamesForUser(Connection conn, String username) throws SQLException {
+        if(!roles.containsKey(username)) {
+            throw new SQLException("username not found!");
+        }
+
+       return roles.get(username);
+    }
+
+    @Override
+    protected Set<String> getPermissions(Connection conn, String username, Collection<String> roleNames) throws SQLException {
+        for (String role : roleNames) {
+            if (!perm.containsKey(role)) {
+                throw new SQLException("role not found!");
+            }
+        }
+
+        Set<String> finalSet = new HashSet<>();
+        for (String role : roleNames) {
+            finalSet.addAll(perm.get(role));
+        }
+
+        return finalSet;
+    }
+
+}

apache-shiro/src/main/java/com/baeldung/ShiroSpringApplication.java

@@ -0,0 +1,45 @@
+package com.baeldung;
+
+import org.apache.shiro.realm.Realm;
+import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
+import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Created by smatt on 21/08/2017.
+ */
+@SpringBootApplication
+public class ShiroSpringApplication {
+
+    private static final transient Logger log = LoggerFactory.getLogger(ShiroSpringApplication.class);
+
+    public static void main(String... args) {
+        SpringApplication.run(ShiroSpringApplication.class, args);
+    }
+
+
+    @Bean
+    public Realm realm() {
+        return new MyCustomRealm();
+    }
+
+
+    @Bean
+    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
+        DefaultShiroFilterChainDefinition filter
+          = new DefaultShiroFilterChainDefinition();
+
+        filter.addPathDefinition("/secure", "authc");
+        filter.addPathDefinition("/**", "anon");
+
+        return filter;
+    }
+
+
+
+
+}

apache-shiro/src/main/java/com/baeldung/controllers/ShiroSpringController.java

@@ -0,0 +1,100 @@
+package com.baeldung.controllers;
+
+import com.baeldung.models.UserCredentials;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.apache.shiro.subject.Subject;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+
+@Controller
+public class ShiroSpringController {
+
+    @GetMapping("/")
+    public String index() {
+       return "index";
+    }
+
+    @RequestMapping( value = "/login", method = {RequestMethod.GET, RequestMethod.POST})
+    public String login(HttpServletRequest req, UserCredentials cred, RedirectAttributes attr) {
+
+      if(req.getMethod().equals(RequestMethod.GET.toString())) {
+        return "login";
+      } else {
+        Subject subject = SecurityUtils.getSubject();
+
+        if(!subject.isAuthenticated()) {
+          UsernamePasswordToken token = new UsernamePasswordToken(
+            cred.getUsername(), cred.getPassword(), cred.isRememberMe());
+          try {
+            subject.login(token);
+          } catch (AuthenticationException ae) {
+              ae.printStackTrace();
+              attr.addFlashAttribute("error", "Invalid Credentials");
+              return "redirect:/login";
+          }
+        }
+
+        return "redirect:/secure";
+      }
+    }
+
+
+    @GetMapping("/secure")
+    public String secure(ModelMap modelMap) {
+
+        Subject currentUser = SecurityUtils.getSubject();
+        String role = "", permission = "";
+
+        if(currentUser.hasRole("admin")) {
+            role = role  + "You are an Admin";
+        }
+        else if(currentUser.hasRole("editor")) {
+            role = role + "You are an Editor";
+        }
+        else if(currentUser.hasRole("author")) {
+            role = role + "You are an Author";
+        }
+
+        if(currentUser.isPermitted("articles:compose")) {
+            permission = permission + "You can compose an article, ";
+        } else {
+            permission = permission + "You are not permitted to compose an article!, ";
+        }
+
+        if(currentUser.isPermitted("articles:save")) {
+            permission = permission + "You can save articles, ";
+        } else {
+            permission = permission + "\nYou can not save articles, ";
+        }
+
+        if(currentUser.isPermitted("articles:publish")) {
+            permission = permission  + "\nYou can publish articles";
+        } else {
+            permission = permission + "\nYou can not publish articles";
+        }
+
+        modelMap.addAttribute("username", currentUser.getPrincipal());
+        modelMap.addAttribute("permission", permission);
+        modelMap.addAttribute("role", role);
+
+        return "secure";
+    }
+
+
+    @PostMapping("/logout")
+    public String logout() {
+       Subject subject = SecurityUtils.getSubject();
+       subject.logout();
+       return "redirect:/";
+    }
+
+}

apache-shiro/src/main/java/com/baeldung/models/UserCredentials.java

@@ -0,0 +1,40 @@
+package com.baeldung.models;
+
+public class UserCredentials {
+
+    private String username;
+    private String password;
+    private boolean rememberMe = false;
+
+    public UserCredentials() {}
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public boolean isRememberMe() {
+        return rememberMe;
+    }
+
+    public void setRememberMe(boolean rememberMe) {
+        this.rememberMe = rememberMe;
+    }
+
+    @Override
+    public String toString() {
+        return "username = " + getUsername()
+                + "\nrememberMe = " + isRememberMe();
+    }
+}

apache-shiro/src/main/java/com/baeldung/shiro/permissions/custom/Main.java

@@ -0,0 +1,68 @@
+package com.baeldung.shiro.permissions.custom;
+
+import com.baeldung.MyCustomRealm;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.*;
+import org.apache.shiro.config.Ini;
+import org.apache.shiro.mgt.DefaultSecurityManager;
+import org.apache.shiro.mgt.SecurityManager;
+import org.apache.shiro.realm.Realm;
+import org.apache.shiro.realm.text.IniRealm;
+import org.apache.shiro.session.Session;
+import org.apache.shiro.subject.Subject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Main {
+
+    private static final transient Logger log = LoggerFactory.getLogger(Main.class);
+
+    public static void main(String[] args) {
+
+        IniRealm realm = new IniRealm();
+        Ini ini = Ini.fromResourcePath(Main.class.getResource("/com/baeldung/shiro/permissions/custom/shiro.ini").getPath());
+        realm.setIni(ini);
+        realm.setPermissionResolver(new PathPermissionResolver());
+        realm.init();
+        SecurityManager securityManager = new DefaultSecurityManager(realm);
+
+        SecurityUtils.setSecurityManager(securityManager);
+        Subject currentUser = SecurityUtils.getSubject();
+
+        if (!currentUser.isAuthenticated()) {
+          UsernamePasswordToken token = new UsernamePasswordToken("paul.reader", "password4");
+          token.setRememberMe(true);
+          try {
+              currentUser.login(token);
+          } catch (UnknownAccountException uae) {
+              log.error("Username Not Found!", uae);
+          } catch (IncorrectCredentialsException ice) {
+              log.error("Invalid Credentials!", ice);
+          } catch (LockedAccountException lae) {
+              log.error("Your Account is Locked!", lae);
+          } catch (AuthenticationException ae) {
+              log.error("Unexpected Error!", ae);
+          }
+        }
+
+        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");
+
+        if (currentUser.hasRole("admin")) {
+            log.info("Welcome Admin");
+        } else if(currentUser.hasRole("editor")) {
+            log.info("Welcome, Editor!");
+        } else if(currentUser.hasRole("author")) {
+            log.info("Welcome, Author");
+        } else {
+            log.info("Welcome, Guest");
+        }
+
+        if(currentUser.isPermitted("/articles/drafts/new-article")) {
+            log.info("You can access articles");
+        } else {
+            log.info("You cannot access articles!");
+        }
+        currentUser.logout();
+    }
+
+}

apache-shiro/src/main/java/com/baeldung/shiro/permissions/custom/PathPermission.java

@@ -0,0 +1,22 @@
+package com.baeldung.shiro.permissions.custom;
+
+import org.apache.shiro.authz.Permission;
+
+import java.nio.file.Path;
+
+public class PathPermission implements Permission {
+
+    private final Path path;
+
+    public PathPermission(Path path) {
+        this.path = path;
+    }
+
+    @Override
+    public boolean implies(Permission p) {
+        if(p instanceof PathPermission) {
+            return ((PathPermission) p).path.startsWith(path);
+        }
+        return false;
+    }
+}

apache-shiro/src/main/java/com/baeldung/shiro/permissions/custom/PathPermissionResolver.java

@@ -0,0 +1,13 @@
+package com.baeldung.shiro.permissions.custom;
+
+import org.apache.shiro.authz.Permission;
+import org.apache.shiro.authz.permission.PermissionResolver;
+
+import java.nio.file.Paths;
+
+public class PathPermissionResolver implements PermissionResolver {
+    @Override
+    public Permission resolvePermission(String permissionString) {
+        return new PathPermission(Paths.get(permissionString));
+    }
+}