Hi, There has been many requests for a standard ConversationManager API that could be used by other frameworks (SE, GraniteDS, Seam Remoting etc) so there was a short brainstorming session and we came up with the following proposal on which I now request your feedback. public interface ConversationManager { /** * Activates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already active */ public abstract ConversationManager activateContext(); /** * Deactivates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already deactivated */ public abstract ConversationManager deactivateContext(); /** * Checks the state of the conversation context * * @return true if the conversation context is active, false otherwise */ public abstract boolean isContextActive(); /** * Starts a new, transient conversation * * @return The conversation manager * @throws IllegalStateException if there is already an active conversation or if the conversation context is not active */ public abstract ConversationManager createTransientConversation(); /** * Ends the current transient conversation * * @return The conversation manager * @throws IllegalStateException if the current transaction is not transient or if the conversation context is not active */ public abstract ConversationManager endTransientConversation(); /** * Restores a long-running conversation. * * @param cid The id of the conversation to restore * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if there already an active conversation or if the conversation context is not active */ public abstract ConversationManager restoreConversation(String cid); /** * Marks a long-running conversation transient * * @param cid The id of the conversation to make transient * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endConversation(String cid); /** * Marks all long-running conversations as transient and destroys them * * @return The conversation manager * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endAllConversations(); /** * Returns the long-running conversation IDs * * @return The long-running conversations IDs * @throws IllegalStateException if the conversation context is not active */ public abstract Set<String> getConversations(); /** * Returns a new, unused conversation ID * * @return A new, unused conversation ID * @throws IllegalStateException if the conversation context is not active */ public abstract String getNewConversationId(); /** * Checks if a conversation ID is in use for any other conversation than the current one * * @return True if the conversation ID is in use, false otherwise * @throws IllegalStateException if the conversation context is not active */ public abstract boolean isConversationIdInUse(String id); } Does it do the job? Needs more ? Needs less? Violates the specification in any point (from JSF perspective)? --- Nik _______________________________________________ weld-dev mailing list weld-dev(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/weld-dev

These are already available on CDI's Conversation interface. On 29 Jan 2010, at 14:27, Arbi Sookazian wrote: > How about begin() and end()? > > reference: http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/Conversation.... > > On Thu, Jan 28, 2010 at 11:56 PM, Nicklas Karlsson <nickarls(a)gmail.com&gt; wrote: > Hi, > > There has been many requests for a standard ConversationManager > API that could be used by other frameworks (SE, GraniteDS, Seam > Remoting etc) so there was a short brainstorming session and we came > up with the following proposal on which I now request your feedback. > > public interface ConversationManager > { > /** > * Activates the conversation context > * > * @return The conversation manager > * @throws IllegalStateException if the context is already active > */ > public abstract ConversationManager activateContext(); > > /** > * Deactivates the conversation context > * > * @return The conversation manager > * @throws IllegalStateException if the context is already deactivated > */ > public abstract ConversationManager deactivateContext(); > > /** > * Checks the state of the conversation context > * > * @return true if the conversation context is active, false otherwise > */ > public abstract boolean isContextActive(); > > /** > * Starts a new, transient conversation > * > * @return The conversation manager > * @throws IllegalStateException if there is already an active > conversation or if the conversation context is not active > */ > public abstract ConversationManager createTransientConversation(); > > /** > * Ends the current transient conversation > * > * @return The conversation manager > * @throws IllegalStateException if the current transaction is not > transient or if the conversation context is not active > */ > public abstract ConversationManager endTransientConversation(); > > /** > * Restores a long-running conversation. > * > * @param cid The id of the conversation to restore > * @return The conversation manager > * @throws NonexistentConversationException if the conversation id > is null or not a known long-running conversation > * @throws IllegalStateException if there already an active > conversation or if the conversation context is not active > */ > public abstract ConversationManager restoreConversation(String cid); > > /** > * Marks a long-running conversation transient > * > * @param cid The id of the conversation to make transient > * @return The conversation manager > * @throws NonexistentConversationException if the conversation id > is null or not a known long-running conversation > * @throws IllegalStateException if the conversation context is not active > */ > public abstract ConversationManager endConversation(String cid); > > /** > * Marks all long-running conversations as transient and destroys them > * > * @return The conversation manager > * @throws IllegalStateException if the conversation context is not active > */ > public abstract ConversationManager endAllConversations(); > > /** > * Returns the long-running conversation IDs > * > * @return The long-running conversations IDs > * @throws IllegalStateException if the conversation context is not active > */ > public abstract Set<String> getConversations(); > > /** > * Returns a new, unused conversation ID > * > * @return A new, unused conversation ID > * @throws IllegalStateException if the conversation context is not active > */ > public abstract String getNewConversationId(); > > > /** > * Checks if a conversation ID is in use for any other conversation > than the current one > * > * @return True if the conversation ID is in use, false otherwise > * @throws IllegalStateException if the conversation context is not active > */ > public abstract boolean isConversationIdInUse(String id); > > } > > Does it do the job? Needs more ? Needs less? Violates the > specification in any point (from JSF perspective)? > > --- > Nik > _______________________________________________ > weld-dev mailing list > weld-dev(a)lists.jboss.org > https://lists.jboss.org/mailman/listinfo/weld-dev > > _______________________________________________ > weld-dev mailing list > weld-dev(a)lists.jboss.org > https://lists.jboss.org/mailman/listinfo/weld-dev

> then NKarlsson's ConversationManager interface has more methods than the CDI version above, no?  So what do you mean by "These are already available on CDI's Conversation interface."?  I think that ConversationManager is a better name for a manager component than simply Conversation. These API are for different purposes, Conversation is for user control of the conversation, ConversationManager is an SPI that frameworks which integrate with Weld can use to control the built in conversation context.

>  What if I wanted to getTimeout() of a non-current conversation in the case there are multiple concurrent conversations in the current session? In that case, we need to know the use case. This can easily be solved by changing getConversations to return a Map.

So a sample use case is a hotel or airplane booking (or even eBay) app where the user has multiple tabs (and therefore multiple LRCs) running simultaneously inside the same session. If I could getTimeout() of a non-current conversation then I could display to a user x seconds prior to the LRC timing out a warning stating that "your work on tab Y is going to be lost in 30 secs". That way they know which conversations are going to timeout when and won't lose work in important conversations. In practical cases, I'm not sure how many apps actually need or use the workspace switcher concept (org.jboss.seam.core.conversationEntries) that is demonstrated in the hotel booking Seam example. I have yet to use the conversation switcher (conversationEntries and conversationList) in a real-world Seam app. What about the rest of the API related to conversations from the Seam core? *Conversation<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/Conversation.html> * Allows the conversation timeout to be set per-conversation, and the conversation description and switchable outcome to be set when the application requires workspace management functionality. * ConversationalInterceptor<http://docs.jboss.org/seam/2.2.0.GA/api/org/... * Check that a conversational bean is not being invoked outside the scope of a long-running conversation. *ConversationEntries<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationEntries.html> * Manages a map of conversation id to ConversationEntry in the session context. *ConversationEntry<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationEntry.html> * Metadata about an active conversation. *ConversationIdGenerator<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationIdGenerator.html> * *ConversationInterceptor<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationInterceptor.html> * Implements annotation-based conversation demarcation. *ConversationList<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationList.html> * Factory for the conversation list *ConversationPropagation<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationPropagation.html> * Overrideable component for extracting the conversation id from a request. *ConversationStack<http://docs.jboss.org/seam/2.2.0.GA/api/org/jboss/seam/core/ConversationStack.html> * Factory for the "breadcrumbs", a stack with all parent conversations of the current conversation. Are they going to be dismissed in the CDI API or slated for PE implementations like in Seam 3? Currently all I see in CDI API that is conversation-related is Conversation interface and ConversationScoped annotation. And also, have you guys thought about using an abstract class rather than an interface (or perhaps in addition to an interface) for some of the conversation-related API? So have the basic methods in the interface and the "bonus" ones in an abstract class. On Sat, Jan 30, 2010 at 11:22 AM, Nicklas Karlsson <nickarls(a)gmail.com&gt;wrote: > >> then NKarlsson's ConversationManager interface has more methods than > the CDI version above, no? So what do you mean by "These are already > available on CDI's Conversation interface."? I think that > ConversationManager is a better name for a manager component than simply > Conversation. > > > > These API are for different purposes, Conversation is for user control > of the conversation, ConversationManager is an SPI that frameworks which > integrate with Weld can use to control the built in conversation context. > > Yes, a Conversation is pretty much a plain parameter object that is > tossed around and evaluated at the end of the request by the CM. > > > > >> What if I wanted to getTimeout() of a non-current conversation in the > case there are multiple concurrent conversations in the current session? > > > > In that case, we need to know the use case. > > > > This can easily be solved by changing getConversations to return a Map. > > Hmm, I'm not that big of a fan of returning anything with a > Conversation in it since the implementation is a request scoped bean > and therfore proxied if stuck in a Map so it needs some "dehydration" > anyway to a normal object with similar attributes (well, actually only > the cid and the timout are interesting from a CM point of view) > > But do hit me with a usecase. > --- > Nik >

>> then NKarlsson's ConversationManager interface has more methods than the CDI version above, no? So what do you mean by "These are already available on CDI's Conversation interface."? I think that ConversationManager is a better name for a manager component than simply Conversation. > > These API are for different purposes, Conversation is for user control of the conversation, ConversationManager is an SPI that frameworks which integrate with Weld can use to control the built in conversation context. Yes, a Conversation is pretty much a plain parameter object that is tossed around and evaluated at the end of the request by the CM. > >> What if I wanted to getTimeout() of a non-current conversation in the case there are multiple concurrent conversations in the current session? > > In that case, we need to know the use case. > > This can easily be solved by changing getConversations to return a Map. Hmm, I'm not that big of a fan of returning anything with a Conversation in it since the implementation is a request scoped bean and therfore proxied if stuck in a Map so it needs some "dehydration" anyway to a normal object with similar attributes (well, actually only the cid and the timout are interesting from a CM point of view)

Hi, There has been many requests for a standard ConversationManager API that could be used by other frameworks (SE, GraniteDS, Seam Remoting etc) so there was a short brainstorming session and we came up with the following proposal on which I now request your feedback. public interface ConversationManager { /** * Activates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already active */ public abstract ConversationManager activateContext(); /** * Deactivates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already deactivated */ public abstract ConversationManager deactivateContext(); /** * Checks the state of the conversation context * * @return true if the conversation context is active, false otherwise */ public abstract boolean isContextActive(); /** * Starts a new, transient conversation * * @return The conversation manager * @throws IllegalStateException if there is already an active conversation or if the conversation context is not active */ public abstract ConversationManager createTransientConversation(); /** * Ends the current transient conversation * * @return The conversation manager * @throws IllegalStateException if the current transaction is not transient or if the conversation context is not active */ public abstract ConversationManager endTransientConversation(); /** * Restores a long-running conversation. * * @param cid The id of the conversation to restore * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if there already an active conversation or if the conversation context is not active */ public abstract ConversationManager restoreConversation(String cid); /** * Marks a long-running conversation transient * * @param cid The id of the conversation to make transient * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endConversation(String cid); /** * Marks all long-running conversations as transient and destroys them * * @return The conversation manager * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endAllConversations(); /** * Returns the long-running conversation IDs * * @return The long-running conversations IDs * @throws IllegalStateException if the conversation context is not active */ public abstract Set<String> getConversations(); /** * Returns a new, unused conversation ID * * @return A new, unused conversation ID * @throws IllegalStateException if the conversation context is not active */ public abstract String getNewConversationId(); /** * Checks if a conversation ID is in use for any other conversation than the current one * * @return True if the conversation ID is in use, false otherwise * @throws IllegalStateException if the conversation context is not active */ public abstract boolean isConversationIdInUse(String id); } Does it do the job? Needs more ? Needs less? Violates the specification in any point (from JSF perspective)? --- Nik _______________________________________________ weld-dev mailing list weld-dev(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/weld-dev

Hi, There has been many requests for a standard ConversationManager API that could be used by other frameworks (SE, GraniteDS, Seam Remoting etc) so there was a short brainstorming session and we came up with the following proposal on which I now request your feedback. public interface ConversationManager { /** * Activates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already active */ public abstract ConversationManager activateContext(); /** * Deactivates the conversation context * * @return The conversation manager * @throws IllegalStateException if the context is already deactivated */ public abstract ConversationManager deactivateContext(); /** * Checks the state of the conversation context * * @return true if the conversation context is active, false otherwise */ public abstract boolean isContextActive(); /** * Starts a new, transient conversation * * @return The conversation manager * @throws IllegalStateException if there is already an active conversation or if the conversation context is not active */ public abstract ConversationManager createTransientConversation(); /** * Ends the current transient conversation * * @return The conversation manager * @throws IllegalStateException if the current transaction is not transient or if the conversation context is not active */ public abstract ConversationManager endTransientConversation();

/** * Restores a long-running conversation. * * @param cid The id of the conversation to restore * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if there already an active conversation or if the conversation context is not active */ public abstract ConversationManager restoreConversation(String cid); /** * Marks a long-running conversation transient * * @param cid The id of the conversation to make transient * @return The conversation manager * @throws NonexistentConversationException if the conversation id is null or not a known long-running conversation * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endConversation(String cid);

/** * Marks all long-running conversations as transient and destroys them * * @return The conversation manager * @throws IllegalStateException if the conversation context is not active */ public abstract ConversationManager endAllConversations();

/** * Returns the long-running conversation IDs * * @return The long-running conversations IDs * @throws IllegalStateException if the conversation context is not active */ public abstract Set<String> getConversations();

/** * Returns a new, unused conversation ID * * @return A new, unused conversation ID * @throws IllegalStateException if the conversation context is not active */ public abstract String getNewConversationId();

/** * Checks if a conversation ID is in use for any other conversation than the current one * * @return True if the conversation ID is in use, false otherwise * @throws IllegalStateException if the conversation context is not active */ public abstract boolean isConversationIdInUse(String id);

>> public abstract ConversationManager endTransientConversation(); > > I wonder if this should be destroy, not end to preserve the semantics of end as demoting a conversation Why not. In general, this method is a bit questionable. What is the current conversation after this call?

>> public abstract ConversationManager endConversation(String cid); > > I wonder if this is needed, as you can achieve it by restoring the conversation and then calling Conversation.end()... Do you see this as a particularly common use case? Hmm. Perhaps some sort of "destroy other than current"-loops?

>> public abstract ConversationManager endAllConversations(); > > Whats the use case for this? Nothing that couldn't be achived by iterating endConversation(String) over getLRCs().

>> public abstract Set<String> getConversations(); > > This in the current session right? If so the javadoc should say that :-) The spec already says conversations don't cross session boundaries ;-) OK, OK...

>> public abstract String getNewConversationId(); > > What is the use case for this? A conversation can inject a CM and call this on Conversation.begin(). OTOH. The CM could get this itself if we defer it to the end of the request. It's probably even closer to the spec since it says that the cid should be constant over the request. That would of course mean that C.begin(String) should store the value in some cidSuggestion field

> IMO this should just check if the conversation id is in use regardless of the current conversation. This is a much simpler contract to understand. This would also be for C -> CM integration where C.begin(String) would check for cid collisions.

But as in the previous case. If the cid is checked at the end of the request this could be skipped and handled by the CM. But I recall you wanted real-time action in the conversation at one point ;-)

-- --- Nik

Hi all, First sorry if this message was received twice, I'm not sure my first response was taken in account as I was not subscribed to the list I just have a few remarks for now : 1. I don't understand the need for createTransientConversation and endTransientConversation if there is activateContext and deactivateContext. Why not something like setupConversation() / cleanupConversation() that always create a transient conversation that can be later promoted to long-running by restoreConversation / beginConversation. 2. It would be useful to be able to force a new conversationId defined by the client with beginConversation(cid) 3. This is not directly linked to the ConversationManager interface, but it would also be useful to be able to observe the same events than Seam 2 dispatches : BeginConversationEvent, EndConversationEvent, ConversationTimeoutEvent and ConversationDestroyedEvent (although I'm not sure the last one makes sense with CDI) William Hi, > > There has been many requests for a standard ConversationManager > API that could be used by other frameworks (SE, GraniteDS, Seam > Remoting etc) so there was a short brainstorming session and we came > up with the following proposal on which I now request your feedback. > > public interface ConversationManager > { > /** > * Activates the conversation context > * > * @return The conversation manager > * @throws IllegalStateException if the context is already active > */ > public abstract ConversationManager activateContext(); > > /** > * Deactivates the conversation context > * > * @return The conversation manager > * @throws IllegalStateException if the context is already deactivated > */ > public abstract ConversationManager deactivateContext(); > > /** > * Checks the state of the conversation context > * > * @return true if the conversation context is active, false otherwise > */ > public abstract boolean isContextActive(); > > /** > * Starts a new, transient conversation > * > * @return The conversation manager > * @throws IllegalStateException if there is already an active > conversation or if the conversation context is not active > */ > public abstract ConversationManager createTransientConversation(); > > /** > * Ends the current transient conversation > * > * @return The conversation manager > * @throws IllegalStateException if the current transaction is not > transient or if the conversation context is not active > */ > public abstract ConversationManager endTransientConversation(); > > /** > * Restores a long-running conversation. > * > * @param cid The id of the conversation to restore > * @return The conversation manager > * @throws NonexistentConversationException if the conversation id > is null or not a known long-running conversation > * @throws IllegalStateException if there already an active > conversation or if the conversation context is not active > */ > public abstract ConversationManager restoreConversation(String cid); > > /** > * Marks a long-running conversation transient > * > * @param cid The id of the conversation to make transient > * @return The conversation manager > * @throws NonexistentConversationException if the conversation id > is null or not a known long-running conversation > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract ConversationManager endConversation(String cid); > > /** > * Marks all long-running conversations as transient and destroys them > * > * @return The conversation manager > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract ConversationManager endAllConversations(); > > /** > * Returns the long-running conversation IDs > * > * @return The long-running conversations IDs > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract Set<String> getConversations(); > > /** > * Returns a new, unused conversation ID > * > * @return A new, unused conversation ID > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract String getNewConversationId(); > > > /** > * Checks if a conversation ID is in use for any other conversation > than the current one > * > * @return True if the conversation ID is in use, false otherwise > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract boolean isConversationIdInUse(String id); > > } > > Does it do the job? Needs more ? Needs less? Violates the > specification in any point (from JSF perspective)? > > --- > Nik > _______________________________________________ weld-dev mailing list weld-dev(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/weld-dev

Hi all, First sorry if this message was received twice, I'm not sure my first response was taken in account as I was not subscribed to the list

I just have a few remarks for now : 1. I don't understand the need for createTransientConversation and endTransientConversation if there is activateContext and deactivateContext. Why not something like setupConversation() / cleanupConversation() that always create a transient conversation that can be later promoted to long-running by restoreConversation / beginConversation.

2. It would be useful to be able to force a new conversationId defined by the client with beginConversation(cid)

3. This is not directly linked to the ConversationManager interface, but it would also be useful to be able to observe the same events than Seam 2 dispatches : BeginConversationEvent, EndConversationEvent, ConversationTimeoutEvent and ConversationDestroyedEvent (although I'm not sure the last one makes sense with CDI)

>> 1. I don't understand the need for createTransientConversation and endTransientConversation if there is activateContext and deactivateContext. Why not something like setupConversation() / cleanupConversation() that always create a transient conversation that can be later promoted to long-running by restoreConversation / beginConversation. > > Yes, this is a reasonable proposal I guess, Nik, did we already iterate through this and discard? Well, this is what the entire thread is about, finding the right granularity ;-) Should we have lots of fine-grain methods that would allow non-JSF frameworks to do pretty much anything or should we have more coarse-grained stuff. We actually already have a weld-specific ConversationManger API that looks pretty much like beginOrRestoreConversation(String cid) and cleanupConversation(). This was too coarse for some uses. So the balance is what we are looking for, freedom of usage but we don't want unnecessary methods without real usecases. I agree that the current proposal might be a bit method-heavy. > >> 2. It would be useful to be able to force a new conversationId defined by the client with beginConversation(cid) > > Well this exists, with Convesation.begin(id), so I don't understand the request. This does raise the question of why there is an endConversation() method on ConversationManager tho... That would be for ending background non-transient conversations.

From: Nicklas Karlsson <nickarls(a)gmail.com&gt; Subject: Re: [weld-dev] A ConversationManager API To: "Weld-Dev" <weld-dev(a)lists.jboss.org&gt;, william.drai(a)graniteds.org, henrichen(a)zkoss.org Date: Monday, February 1, 2010, 8:35 AM Let's try it the other way around. I toss you the minimal JSF-centric API and the framework reps of ZK, GraniteDS, SE and Remoting can speak up on what they need more control of along with their usecase then Pete can comment and I just act as a secretary ;-) That way we don't end up with too many "nice to haves" in the API that could be worked around more or less easy. public interface ConversationManager {   /**    * Checks the state of the conversation context    *    * @return true if the conversation context is active, false otherwise    */   public abstract boolean isContextActive();   // usecase: the conversation checks for active context before running methods     /**    * Activates the conversation context    *    * @return The conversation manager    *    * @throws IllegalStateException if the context is already active    */     public abstract ConversationManager activateContext(); // usecase: any non-JSF framework will want to run this themselves     /**    * Deactivates the conversation context    *    * @return The conversation manager    *    * @throws IllegalStateException if the context is already deactive    */     public abstract ConversationManager deactivateContext(); // usecase: any non-JSF framework will want to run this themselves   /**    * Resumes a long running conversation. If the cid is null, nothing is done and the current    * transient conversation is resumed    *    *    * @param cid The conversation id to restore    * @return The conversation manager    * @throws NonexistentConversationException If the non-transient conversation is not known    * @throws BusyConversationException If the conversation is locked and not released while waiting    * @throws IllegalStateException if the conversation context is not active    */   public abstract ConversationManager beginOrRestoreConversation(String cid); // usecase: start of the conversation lifecycle.     /**    * Destroys the current conversation if it's transient. Stores it for conversation    * propagation if it's non-transient    *    * @return    * @throws IllegalStateException if the conversation context is not active    */   public abstract ConversationManager cleanupConversation(); // usecase: end of the conversation lifecycle.     /**    * Gets the current non-transient conversations    *    * @return The conversations mapped by id    * @throws IllegalStateException if the conversation context is not active    */   public abstract Map<String, Conversation> getConversations(); // usecase: Conversation checks if begin(String) was called with a known cid (no need for a isCidInUse, actually)   /**    * Returns a new, session-unique conversation ID    *    * @return The conversation id    * @throws IllegalStateException if the conversation context is not active    */     public abstract String generateConversationId(); // usecase: Conversation gets a cid for begin()   Notice that the begin and end of lifecycle are big chunks. Speak up where you need more granularity. Also speak up if you want fancy switching stuff etc ;-) Re-submit any wishes/suggestions you've done in the past in this thread (method signature + usecase) so we can keep stuff together. --- Nik -----Inline Attachment Follows----- _______________________________________________ weld-dev mailing list weld-dev(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/weld-dev

I think these APIs are good enough for me. One thing needs clarification though. The ConversationManager itself is SessionScoped, right? So the getConversations() method returns all long running conversion in this Session? Henri Chen The ZK Team http://www.zkoss.org Nicklas Karlsson wrote: > Let's try it the other way around. I toss you the minimal JSF-centric API > and the *framework reps of ZK, GraniteDS, SE and Remoting can speak up on > what they need more control of along with their usecase* then Pete can > comment and I just act as a secretary ;-) That way we don't end up with too > many "nice to haves" in the API that could be worked around more or less > easy. > > public interface ConversationManager > { > /** > * Checks the state of the conversation context > * > * @return true if the conversation context is active, false otherwise > */ > public abstract boolean isContextActive(); // usecase: the conversation > checks for active context before running methods > /** > * Activates the conversation context > * > * @return The conversation manager > * > * @throws IllegalStateException if the context is already active > */ public abstract ConversationManager activateContext(); > // usecase: any non-JSF framework will want to run this themselves > /** > * Deactivates the conversation context > * > * @return The conversation manager > * > * @throws IllegalStateException if the context is already deactive > */ public abstract ConversationManager deactivateContext(); > // usecase: any non-JSF framework will want to run this themselves > > /** > * Resumes a long running conversation. If the cid is null, nothing is > done and the current > * transient conversation is resumed > * > * > * @param cid The conversation id to restore > * @return The conversation manager > * @throws NonexistentConversationException If the non-transient > conversation is not known > * @throws BusyConversationException If the conversation is locked and > not released while waiting > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract ConversationManager beginOrRestoreConversation(String > cid); > // usecase: start of the conversation lifecycle. > /** > * Destroys the current conversation if it's transient. Stores it for > conversation > * propagation if it's non-transient > * > * @return > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract ConversationManager cleanupConversation(); > // usecase: end of the conversation lifecycle. > /** > * Gets the current non-transient conversations > * > * @return The conversations mapped by id > * @throws IllegalStateException if the conversation context is not > active > */ > public abstract Map<String, Conversation> getConversations(); > // usecase: Conversation checks if begin(String) was called with a known > cid (no need for a isCidInUse, actually) > > /** > * Returns a new, session-unique conversation ID > * > * @return The conversation id > * @throws IllegalStateException if the conversation context is not > active > */ public abstract String generateConversationId(); > // usecase: Conversation gets a cid for begin() > Notice that the begin and end of lifecycle are big chunks. Speak up where > you need more granularity. Also speak up if you want fancy switching stuff > etc ;-) *Re-submit any wishes/suggestions you've done in the past* in this > thread (method signature + usecase) so we can keep stuff together. > > --- > Nik > >

Right for the ConversationManager.beginConversation, there is already Conversation.begin. I've been mistaken by the ConversationManager.endConversation of Niklas' proposal. I can maybe explain how we use the currently existing API, and in fact we are relatively happy with what exists today, except for one thing : start() { ConversatonManager manager = { get from BeanManager }; manager.beginOrRestoreConversation(cid); Conversation conversation = { get from BeanManager }; // Beginning of the ugly part !! String cid = ((ConversationImpl)conversation).getUnderlyingId(); ConversationContext ctx = Container.instance().deploymentServices().get(ContextLifecycle.class).getConversationContext(); ctx.setBeanStore(new ConversationBeanStore(httpSession, cid)); ctx.setActive(true); // End of the ugly part if (cid != null && conversation.isTransient()) // Don't remember why I need this, beginOrRestore should be enough conversation.begin(cid); } end() { ConversationManager manager = { get from BeanManager }; manager.cleanupConversation(); } The main thing is that I would prefer not having to mess with bean stores and contexts, so the manager.activateContext() looks fine. Ideally here what I would like to do (I know, I'm too lazy :-)) : start() { ConversatonManager manager = { get from BeanManager }; manager.startupConversation(); if (cid != null && conversation.isTransient()) conversation.beginOrRestoreConversation(cid); } end() { ConversationManager manager = { get from BeanManager }; manager.cleanupConversation(); } From Flex, there is no need to switch the conversation in a particular request, but getting the list of the currently existing conversations with ConversationManager.getCurrentConversationIds() can be useful.

Finally I really think it's necessary to be able to share a conversation instance between different UIs and use the same ConversationContext implementation for all. We could obviously ship a FlexConversationContext with GraniteDS/CDI but we want to make possible to build applications where a part of the UI uses JSF, another part uses Flex and why not another uses ZK or the iPhone SDK.