You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@shiro.apache.org by "Les Hazlewood (JIRA)" <ji...@apache.org> on 2010/02/19 18:52:27 UTC
[jira] Created: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Add a subject-aware ExecutorService implementation to support Subject execution on other threads
------------------------------------------------------------------------------------------------
Key: SHIRO-140
URL: https://issues.apache.org/jira/browse/SHIRO-140
Project: Shiro
Issue Type: New Feature
Components: Subject
Reporter: Les Hazlewood
Assignee: Les Hazlewood
Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
1) Looks up the currently executing Subject
2) calls subject.associateWith* methods on the callable/runnable argument
3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Work logged: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Posted by "Les Hazlewood (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/SHIRO-140?page=com.atlassian.jira.plugin.system.issuetabpanels:worklog-tabpanel#action_11008 ]
Les Hazlewood logged work on SHIRO-140:
---------------------------------------
Author: Les Hazlewood
Created on: 19/Feb/10 11:03 PM
Start Date: 19/Feb/10 11:02 PM
Worklog Time Spent: 2h
Work Description: tests and documentation should round out this issue in order to close it
Issue Time Tracking
-------------------
Time Spent: 2h
Remaining Estimate: 0h
> Add a subject-aware ExecutorService implementation to support Subject execution on other threads
> ------------------------------------------------------------------------------------------------
>
> Key: SHIRO-140
> URL: https://issues.apache.org/jira/browse/SHIRO-140
> Project: Shiro
> Issue Type: New Feature
> Components: Subject
> Reporter: Les Hazlewood
> Assignee: Les Hazlewood
> Time Spent: 2h
> Remaining Estimate: 0h
>
> Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
> It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
> 1) Looks up the currently executing Subject
> 2) calls subject.associateWith* methods on the callable/runnable argument
> 3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
> It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Resolved: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Posted by "Les Hazlewood (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/SHIRO-140?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Les Hazlewood resolved SHIRO-140.
---------------------------------
Resolution: Fixed
Sanity tests committed
> Add a subject-aware ExecutorService implementation to support Subject execution on other threads
> ------------------------------------------------------------------------------------------------
>
> Key: SHIRO-140
> URL: https://issues.apache.org/jira/browse/SHIRO-140
> Project: Shiro
> Issue Type: New Feature
> Components: Subject
> Affects Versions: 1.0.0
> Reporter: Les Hazlewood
> Assignee: Les Hazlewood
> Fix For: 1.0.0
>
> Time Spent: 2h
> Remaining Estimate: 0h
>
> Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
> It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
> 1) Looks up the currently executing Subject
> 2) calls subject.associateWith* methods on the callable/runnable argument
> 3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
> It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Posted by "Les Hazlewood (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/SHIRO-140?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Les Hazlewood updated SHIRO-140:
--------------------------------
Affects Version/s: 1.0.0
> Add a subject-aware ExecutorService implementation to support Subject execution on other threads
> ------------------------------------------------------------------------------------------------
>
> Key: SHIRO-140
> URL: https://issues.apache.org/jira/browse/SHIRO-140
> Project: Shiro
> Issue Type: New Feature
> Components: Subject
> Affects Versions: 1.0.0
> Reporter: Les Hazlewood
> Assignee: Les Hazlewood
> Fix For: 1.0.0
>
> Time Spent: 2h
> Remaining Estimate: 0h
>
> Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
> It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
> 1) Looks up the currently executing Subject
> 2) calls subject.associateWith* methods on the callable/runnable argument
> 3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
> It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Posted by "Les Hazlewood (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/SHIRO-140?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12849980#action_12849980 ]
Les Hazlewood commented on SHIRO-140:
-------------------------------------
The implementation for this is finished, but test cases still need to be written for it. I'll hold of on resolving this until then.
> Add a subject-aware ExecutorService implementation to support Subject execution on other threads
> ------------------------------------------------------------------------------------------------
>
> Key: SHIRO-140
> URL: https://issues.apache.org/jira/browse/SHIRO-140
> Project: Shiro
> Issue Type: New Feature
> Components: Subject
> Affects Versions: 1.0.0
> Reporter: Les Hazlewood
> Assignee: Les Hazlewood
> Fix For: 1.0.0
>
> Time Spent: 2h
> Remaining Estimate: 0h
>
> Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
> It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
> 1) Looks up the currently executing Subject
> 2) calls subject.associateWith* methods on the callable/runnable argument
> 3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
> It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (SHIRO-140) Add a subject-aware ExecutorService
implementation to support Subject execution on other threads
Posted by "Les Hazlewood (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/SHIRO-140?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Les Hazlewood updated SHIRO-140:
--------------------------------
Fix Version/s: 1.0.0
> Add a subject-aware ExecutorService implementation to support Subject execution on other threads
> ------------------------------------------------------------------------------------------------
>
> Key: SHIRO-140
> URL: https://issues.apache.org/jira/browse/SHIRO-140
> Project: Shiro
> Issue Type: New Feature
> Components: Subject
> Affects Versions: 1.0.0
> Reporter: Les Hazlewood
> Assignee: Les Hazlewood
> Fix For: 1.0.0
>
> Time Spent: 2h
> Remaining Estimate: 0h
>
> Currently the Subject.associateWith* methods return objects that are associated with the Subject. Then the caller is expected to dispatch the callable/runnable to some thread mechanism as they see fit.
> It might be nice to simplify this even further for anyone relying on the ExecutorService API, say by creating a SubjectExecutorService implementation that:
> 1) Looks up the currently executing Subject
> 2) calls subject.associateWith* methods on the callable/runnable argument
> 3) dispatches the associated callable/runnable to the underlying 'real' ExecutorService instance.
> It reduces Shiro-user code complexity in that they don't need to call the subject.execute* or subject.associateWith* methods any time they need to dispatch to another thread.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.