What is session affinity?

What is session affinity in weblogic?

Session Affinity....Means the request coming from the same client should always be intertained by the Same WLS Server instance where that clients request was processed earlier....And if that server is not able to process the request then only the request will be processed by another available Cluster Node .
Example:
By default WLS server's Session affinity is ON. It means suppose if i have one application deployed on a Cluster (which contains 2-ManagedServers)...
In this Case if even if the Cluster follows Round-Robin algorithm to serve the incoming requests..first client (Client-A) request comes then it will be served by MS1 managed Server (Prmary Session will be created here)...and the replicated Session (Secondary Session) will be created on MS2.
If the Same Client (Client-A) sends a second request...so in that case Ideally the request should be processed by MS2 server...but because Session Affinity which is Enable by default...WLS Cluster will first check where the Primary Session is created for this client...then It will try to redirect the request to MS1 only...because primary session was created here for that client.
If MS1 is not able to process the request then only the request will be sent to MS2 for processing...
Thanks
Jay SenSharma
http://jaysensharma.wordpress.com (WebLogic Wonders Are Here)

Similar Messages

WL Clustering - session affinity not working

Hello,
I have a cluster setup in WL 9.2 with two nodes. Our requirement is to a session when establishes the session with Node1 in the cluster should always stay connected to it. It should not point to Node2 through its life.
In otherwords i want to have session affinity established.
What parameter I should change to make that I aceive this.
WL 9.2 is on solaris 10 and the webserver used are iplanet.

hi
Enable Default Load Algorithm: round robin Affinity in Admin console->cluster-->general tab.try this...let me know wat happen....Thank You

OHS Routing to JVM responsible for creating HttpSession (Session Affinity)

Hello,
I am using OAS 10.1.3.1 and have a plan in place to create an HttpSession for a just authenticated end user in an OC4J instance/JVM of the my application's choosing. What I then would like to happen is for every subsequent HTTP request initiated by that end user, until such a time as they logout or their session times out, that OHS route their requests to that single OC4J instance/JVM that initially created an HttpSession on their behalf. This is simply Session Affinity.
What I am wondering is do I simply get this behavior by default if I specify no select method (e.g. random, round robin, etc.) in mod_oc4j.conf? Are their combinations of select method (e.g. roundrobin:local) or other mod_oc4j directives that could result in different behavior than this simple Session Affinity I seek?
Thanks,
Doug

Hello
Within 10.1.3 OC4Js announce their mount-point(s) in the notifications they send out and mod_oc4j dynamically adjusts its routing table using this information. This eliminates the need for static mount point configuration and enables mod_oc4j to update its mount point configuration dynamically. So. routing is handled by opmn to OHS.
regards
Michel

Stateless with Session Affinity and set jbo.ampool.maxpoolsize = 1

Hi,
I would like to know more about "Stateless with Session Affinity".
If I set
jbo.ampool.maxpoolsize = 1
jbo.ampool.minavailablesize = 1
jbo.ampool.maxavailablesize = 1
in application module configuration
and have two browser clients at different computers.
If I update some values and post changed data to database without commit
at one browser
some updates using jdbc prepared statements through database connection
with following code snippet in application module
Implementation:
private Connection getCurrentConnection() throws SQLException {
PreparedStatement st = getDBTransaction().createPreparedStatement("commit",1);
Connection conn = st.getConnection();
st.close();
return conn;
, will the other web client see these post changed data with the only one
application module through the only one database connection (ignores PS_TXN connection)?
If the answer is "no", can someone explain why bc4j can do this?

Hi,
It's not clear to me from your post what you are trying to test. Generally speaking, every HttpSession (~browser) is assocated with a pooled AM that is associated with a single transaction context that is associated with a single "application" JDBC connection.
HttpSession->AM->Txn->Connection
The session affinity features of the BC4J framework maintain this logical dependency for you without necessarily having to tie up the physical resources at each layer.
Now, if one session posts but does not commit then the other sessions will not "see" those changes (different AMx, Txns, Connections). Once a session does commit then those changes will be visible to other sessions. However, if those other sessions have already queried/cached the modified data then those sessions will not "see" it until their caches are refreshed. Please see the documentation for a description of BC4J caching and refreshing caches. The standard technique to refresh a VO cache is to invoke executeQuery.
Hope this helps,
JR

What is Session in oracle

Hello
I want to know what is session in oracle and how it is active and inactive.
thanks

Read the concepts guide

What is session facade

what is session facade and what is its use in session beans

SessionFacade shows how to partition business logic in the system to help minimize dependencies between client and server, while forcing use cases to execute in one network call and in one transaction. It avoids inefficient remote client access of Entity Beans by wrapping them with a Session Bean.
The Session Fa�ade design pattern is useful in situations where client objects need to interact with a set of EJBs to perform tasks in a workflow. Take the case of an on-line trading system where customers submit orders to buy and sell stocks, the orders are verified and executed, and results are returned. Here the client need to make numerous remote calls to get the work done.
A session fa�ade solves such problems by presenting client objects with a unified interface to the underlying EJBs. Client objects interact only with the fa�ade, which resides on the server and invokes the appropriate EJB methods. As a result, dependencies and communication between clients and EJBs is reduced.

Please Advice what is Session ID? is it to Hide MAIN URL?

Please Advice what is Session ID.
Is it to Hide MAIN URL? and put them in Codes or such..
Await your soonest response

> Please Advice what is Session ID.
A variable that is stored for the time period that a person
is using the
site. It can be stored server side or client side.
> Is it to Hide MAIN URL?
No, it's to pass data from page to page during the user
session.
-Darrel

What about session memory when using BEA Weblogic connection pooling?

Hi,
consider a web application, allowing database connections via a BEA Weblogic 8.1 application server. The app-server is pooling the oracle connections. The oracle database is running in dedicated server mode.
How are the database requests from the web app served by the connection pool from BEA?
1) Does one oracle session serve more than one request simultanously?
2) Does BEA serialize the requests, which means, that a session from the pool is always serving only one request at a time?
If (1) is true, than what about the session memory of Oracle sessions? I understand, that things like package global variables are beeing stored in this session private memory. If (1) is true, the PL/SQL programmer has the same situation, as with programming an Oracle databas in "shared server" mode, that is, he should not use package global variables etc.
Thankful for any ideas...
Message was edited by:
Xenofon

Xenofon Grigoriadis wrote:
Hi,
consider a web application, using BEA between client and an Oracle Database (v9i). BEA is pooling the oracle connections. The oracle database is running in dedicated server mode.
How are the database requests from the web app beeing served by the connection pool from BEA?
1) Does one oracle session serve more than one request simultanously?no.
2) Or does BEA serialize the requests, which means, that a session from the pool is always serving only one request at a time?
Reading "Configuring and Using WebLogic JDBC" from weblogic8.1 documentation, I read:
"... Your application "borrows" a connection from the pool, uses it, then returns it to the pool by closing it...."
What do you mean by returning the connection by closing it? Tbe server will either return the connection to the pool or close it...When application code does typical jdbc code, it obtains
a connection via a WebLogic DataSource, which reserves an
unused pooled connection and passes it (transparently wrapped)
to the application. The application uses it, and then closes
it. WebLogic intercepts the close() call via the wrapper, and
puts the DBMS connection back into the WebLogic pool.
The reason, why I as an Oracle programmer ask this is, because every session (=connection)
in Oracle has its own dedicate, private memory for things like global PL/SQL variables.
Now I want to figure out, if you have to careful in programming your databases, when
one Oracle session (=connection) is serving many weblogic requests.It is serving many requests, but always serially. Do note however, that we
also transparently cache/pool prepared and callable statements with the
connection so repeat uses of the connection will be able to get already-made
statements when they call prepareStatement() and prepareCall(). These
long-lived statements will each require a DBMS-side cursor.
>
Thankful for any ideas or practical experience...
Message was edited by:
mk637Joe

What are Session Components in ATG OOTB

Hi,
What are the Session components in ATG OOTB, as far i know Profile and ShoppingCart are the Session components.
Please mention if any other Session components are there. we need to create the same using other framework.

There are a lot of session scoped components. Here are just the ones found in the DAS,DPS,DSS and DCS modules
DAS
===
./config/config/atg/dynamo/admin/context/SessionAdminContextHolder.properties:$scope=session
./config/config/atg/dynamo/admin/CreateWebServiceProperties.properties:$scope=session
./config/config/atg/dynamo/security/FormLoginSession.properties:$scope=session
./config/config/atg/dynamo/security/IdentityManager.properties:$scope=session
./config/config/atg/dynamo/security/User.properties:$scope=session
./config/config/atg/dynamo/security/UserFailService.properties:$scope=session
./config/config/atg/dynamo/service/fluoroscope/listener/SessionCachingListener.properties:$scope=session
./config/config/atg/dynamo/service/fluoroscope/SensorSessionData.properties:$scope=session
./config/config/atg/dynamo/service/transfer/xls/AssetXLSFileImportOperation.properties:$scope=session
./config/config/atg/dynamo/servlet/RequestLocale.properties:$scope=session
./config/config/atg/dynamo/servlet/sessiontracking/GlobalSessionEnumPropertyValues.properties:$scope=session
./config/config/atg/dynamo/servlet/sessiontracking/SessionSaver.properties:$scope=session
./config/config/atg/dynamo/servlet/windowscope/WindowScopeContextStorage.properties:$scope=session
./config/config/atg/multisite/RealmSessionTracker.properties:$scope=session
./config/config/atg/multisite/SiteSessionManager.properties:$scope=session
./config/config/atg/repository/SessionPropertyDescriptorData.properties:$scope=session
./config/config/atg/servlet/http/CookieBuffer.properties:$scope=session
./config/config/SessionConfirmationNumberHolder.properties:$scope=session
DPS
===
./config/targeting/atg/devtools/RepositoryAgent.properties:$scope=session
./config/targeting/atg/devtools/SensorAgent.properties:$scope=session
./config/targeting/atg/devtools/TargeterAgent.properties:$scope=session
./config/targeting/atg/targeting/ConflictFilter.properties:$scope=session
./config/userprofiling/atg/devtools/UserDirectoryAgent.properties:$scope=session
./config/userprofiling/atg/dynamo/droplet/PasswordExpiresSoon.properties:$scope=session
./config/userprofiling/atg/dynamo/security/IdentityManager.properties:$scope=session
./config/userprofiling/atg/reporting/datacollection/userprofiling/SiteVisitRequest.properties:$scope=session
./config/userprofiling/atg/userprofiling/Profile.properties:$scope=session
./config/userprofiling/atg/userprofiling/ProfileFailService.properties:$scope=session
./config/userprofiling/atg/userprofiling/sso/Passport.properties:$scope=session
DSS
===
./config/atg/devtools/ScenarioAgent.properties:$scope=session
DCS
===
./config/atg/commerce/catalog/AdvProductSearch.properties:$scope=session
./config/atg/commerce/catalog/CatalogNavHistory.properties:$scope=session
./config/atg/commerce/catalog/CatalogSearch.properties:$scope=session
./config/atg/commerce/catalog/CategorySearch.properties:$scope=session
./config/atg/commerce/catalog/CompareSkusFormHandler.properties:$scope=session
./config/atg/commerce/catalog/comparison/ProductList.properties:$scope=session
./config/atg/commerce/catalog/comparison/TableInfo.properties:$scope=session
./config/atg/commerce/catalog/ProductSearch.properties:$scope=session
./config/atg/commerce/catalog/ProductTextSearch.properties:$scope=session
./config/atg/commerce/gifts/GiftlistFormHandler.properties:$scope=session
./config/atg/commerce/gifts/GiftlistSearch.properties:$scope=session
./config/atg/commerce/order/purchase/CostCenterContainerService.properties:$scope=session
./config/atg/commerce/order/purchase/PaymentGroupContainerService.properties:$scope=session
./config/atg/commerce/order/purchase/PurchaseProcessConfiguration.properties:$scope=session
./config/atg/commerce/order/purchase/ShippingGroupContainerService.properties:$scope=session
./config/atg/commerce/order/scheduled/ScheduledOrderFormHandler.properties:$scope=session
./config/atg/commerce/order/ShoppingCartModifierConfiguration.properties:$scope=session
./config/atg/commerce/pricing/CleanBeforePricingSlot.properties:$scope=session
./config/atg/commerce/pricing/NoCleanBeforePricingSlot.properties:$scope=session
./config/atg/commerce/pricing/UserPricingModels.properties:$scope=session
./config/atg/commerce/promotion/PromotionAnalysisModelHolder.properties:$scope=session
./config/atg/commerce/ShoppingCart.properties:$scope=session
./config/atg/commerce/util/RepeatingRequestMonitor.properties:$scope=session
./config/atg/devtools/CommerceAgent.properties:$scope=session
./config/atg/registry/Slots/RelatedItemsOfCart.properties:$scope=session
./config/atg/userprofiling/ProfileFailService.properties:$scope=session

What is session tracking in servlets?

Hi ,
I'm studying servlets I don't have the clear idea about session tracking and Why and where we need to use it. Can any one say about this.....
Thanks in advance,
Maheshwaran Devaraj

Well Mheshpmr session tracking in servlets is very important...There are a number of problems that arise from the fact that HTTP is a "stateless" protocol. In particular, when you are doing on-line shopping, it is a real annoyance that the Web server can't easily remember previous transactions. This makes applications like shopping carts very problematic: when you add an entry to your cart, how does the server know what's already in your cart? Even if servers did retain contextual information, you'd still have problems with e-commerce. When you move from the page where you specify what you want to buy (hosted on the regular Web server) to the page that takes your credit card number and shipping address (hosted on the secure server that uses SSL), now let me tell you, how does the server remember what you were buying?
Well There are three typical solutions to this problem.
1. Cookies. You can use HTTP cookies to store information about a shopping session, and each subsequent connection can look up the current session and then extract information about that session from some location on the server machine. This is an excellent alternative, and is the most widely used approach. However, even though servlets have a high-level and easy-to-use interface to cookies, there are still a number of relatively tedious details that need to be handled:
* Extracting the cookie that stores the session identifier from the other cookies (there may be many, after all),
* Setting an appropriate expiration time for the cookie (sessions interrupted by 24 hours probably should be reset), and
* Associating information on the server with the session identifier (there may be far too much information to actually store it in the cookie, plus sensitive data like credit card numbers should never go in cookies).
2. URL Rewriting. You can append some extra data on the end of each URL that identifies the session, and the server can associate that session identifier with data it has stored about that session. This is also an excellent solution, and even has the advantage that it works with browsers that don't support cookies or where the user has disabled cookies. However, it has most of the same problems as cookies, namely that the server-side program has a lot of straightforward but tedious processing to do. In addition, you have to be very careful that every URL returned to the user (even via indirect means like Location fields in server redirects) has the extra information appended. And, if the user leaves the session and comes back via a bookmark or link, the session information can be lost.
3. Hidden form fields. HTML forms have an entry that looks like the following: <INPUT TYPE="HIDDEN" NAME="session" VALUE="...">. This means that, when the form is submitted, the specified name and value are included in the GET or POST data. This can be used to store information about the session. However, it has the major disadvantage that it only works if every page is dynamically generated, since the whole point is that each session has a unique identifier.
Servlets provide an outstanding technical solution: the HttpSession API. This is a high-level interface built on top of cookies or URL-rewriting. In fact, on many servers, they use cookies if the browser supports them, but automatically revert to URL-rewriting when cookies are unsupported or explicitly disabled. But the servlet author doesn't need to bother with many of the details, doesn't have to explicitly manipulate cookies or information appended to the URL, and is automatically given a convenient place to store data that is associated with each session.

HT1701 what does session no longer exsit mean

i try to sync my ipone 4s and it wont becuse the session no loner exist what should i do

I actually stole this from one of Kappy's earlier posts but you could create a bootable thumb drive for an earlier operating system still using Rosetta.
Drive Preparation and Installation
1. Boot from the Snow Leopard Installer Disc. After the installer loads select your language and click on the Continue button. When the menu bar appears select Disk Utility from the Utilities menu.
2. After DU loads select the USB flash drive (this is the entry with the mfgr.'s ID and size) from the left side list. Click on the Partition tab in the DU main window.
3. Under the Volume Scheme heading set the number of partitions from the drop down menu to one. Click on the Options button, set the partition scheme to GUID then click on the OK button. Set the format type to Mac OS Extended (Journaled.) Click on the Partition button and wait until the process has completed.
4. Select the volume you just created (this is the sub-entry under the drive entry) from the left side list. Click on the Erase tab in the DU main window.
5. Set the format type to Mac OS Extended (Journaled.) Click on the Securitybutton, check the button for Zero Data and click on OK to return to the Erase window.
6. Click on the Erase button. The format process can take up to several hours depending upon the drive size.
7. After formatting is complete quit DU and return to the installer. Install Snow Leopard being careful to select the USB flash drive as the target (the installer defaults to your startup volume.)
8. Boot the computer using the USB flash drive to test that it works.
9. Download and install the Mac OS X 10.6.8 Update Combo v1.1 update to bring the Snow Leopard system to 10.6.8.
10. Again boot the computer using the USB flash drive to test that it works.
You can now use the USB flash drive to boot your computer. Then clone the USB flash drive system to the external drive you wish to use on your computer. Put the flash drive safely away in case you have to use it again.

WHAT V$SESSION contains

Hi
Can anyone let me know what exactly columns : PROCESS , STATUS mean in V$SESSION dictionary table ?
Thanks,
Ravikanth K.

please have a look at this
hope it helps
http://www.stanford.edu/dept/itss/docs/oracle/10g/server.101/b10755/dynviews_2073.htm
Regards
SL

What is session variables in BSP

Hi
I am using using IC Webclient. can anyone help me to findout the details about session varibales ?
Best Regards
Bhavishya

hi,
Session variables is a handy way to define a persistent variable.The standard variables used in ColdFusion can be only transferred or sent to the next page before it is necessary to restate the variable. In some situations, you may want to define a variable that will apply to all the pages during a single session of the user. An example is when the pages a user sees are personalized to his or her specific needs. In such a case, session variables are defined and used.
Session variable persistent
A session variable is one of several types of variables that persist across multiple templates:
>Server variables - Accessible by all clients and applications on a single
>Application variables - Tied to a single application and accessible by multiple clients
>Client variables - Tied to a single client over multiple sessions
>Session variables - Exist for one client or browser during a single session
>Cookie variables
Session variables are designed to hold information that you seldom write but are read often.
Defining session variables
Session variables are normally defined in the Application template, but can be also defined on all applicable pages.
Application template
The standard method of using session variables is to define them in the application.cfm template, which is a special ColdFusion page that is processed before the other pages in a session. It usually should be in the session root directory.
CFAPPLICATION tag
To enable the use of session variables, as well as client and application management, you should use the CFAPPLICATION tag in the Application template. A typical tag would be:
<CFAPPLICATION NAME="Name"
SESSIONMANAGEMENT="Yes"
SESSIONTIMEOUT="#CreateTimeSpan(0, 0, 20, 0)#">
where:
>NAME is required to avoid problems if you have session variables tied to separate applications.
>SESSIONMANAGEMENT is required to enable the session variables.
>SESSIONTIMEOUT is optional and limits the time the variables will stay in memory (20 minutes in the example) Note that the default is 20 minutes, so you really may not need this unless you want to change that number.
Setting variables
After the CFAPPLICATION tag, you can set your session variables, using the CFSET tag. You must always refer to session variables with the prefix session. Thus, you could define a session variable, such as:
<CFSET session.name="#form.othername#">
Should lock variables
You should lock the session variables to avoid problems when several people are using the system at the same time. An example of this is:
<CFLOCK TIMEOUT="30" NAME="#session.sessionID#" TYPE="Exclusive">
<CFSET session.name="#form.othername#">
</CFLOCK>
Defined on applicable pages
A problem in using the Application.cfm template is that it is often difficult to change your session variables, once they have been set. An alternative is to use the CFAPPLICATION tag in each applicable page:
<CFAPPLICATION NAME="Name"
SESSIONMANAGEMENT="Yes">
You then can define the session variable in the first page, accessed:
<CFOUTPUT QUERY="return">
<CFSET session.ID="#ID#">
</CFOUTPUT>
This is a compromise between the standard method and defining the variable on each page.
Example of use
Suppose a user logged in to the site. His name could be sent through a form and entered in Application.cfm. Then the session will constantly refer to him by name.
Application.cfm
<CFAPPLICATION NAME="Name"
SESSIONMANAGEMENT="Yes">
<CFSET session.name="#form.othername#">
Start.cfm
<CFOUTPUT>
<H1>Hello #session.name#</H1>
</CFOUTPUT>

Session Affinity WLS8.1

Our setup includes .NET client communicating (via a .NET-to-J2EE bridge) with a session facade. Now, as long as the .NET client retains the client-side proxy (of the session facade), all requests are routed to the original node -- regardless of load.
For our purposes, this is desirable behavior. The problem is, I'm having a hard time explaining why this is so, especially in high load situations when one node is idle while the other is being hammered. Is it a config issue i.e. can it be turned off/on.
Also, were would I find tracing/logging information on the session cookies -- or whatever means is used to route the the request to the appropriate server.
Thanks...and pardon the lenghty post.

          try to use url-rewriting
          and check if you enabled cookies with your browser.
          fear
          Mark Swanson <[email protected]> wrote:
          >Hello,
          >
          >I have a Session used between several JSP pages and it works fine. However,
          >when I submit the results of a form to a servlet the Session becomes
          >null.
          >I've spent hours on this and haven't been able to find out why this is.
          >
          >JSP Code:
          >System.out.println("*** jsp sessionID:" + session.getId()); // works
          >
          >JSP calls servlet using this path:
          >(/webapp/servlet/ZZZServlet)
          >request.getContextPath() + "/servlet/ZZZServlet";
          >
          >Servlet calls this:
          >
          >HttpSession session = request.getSession(false);
          > if (session == null)
          > Logger.info(LID + "ZZZServlet HTTPSESSION FAILED")
          >
          >The session is always null. It's a 10-line JSP and a 20-line servlet.
          >
          >Does anyone see anything wrong? Any suggestions?
          >
          >Thanks.
          >

What does session management guarantee?

Hi guys,
I am a newbie to Sun ONE Message Queue.
I am trying to use a business object delegate inside Axis to pass informaiton through JMS (Developers Edition) to an other remote jave process which extracts information from a receiver queue, processes the request and sends back to the business object delegate residing inside axis. the result is then passed back to the GUI.
If multiple GUI clients place a request over HTTP using SOAP and SOAP server delegates the request to a remote java process by creating new JMS object everytime to send the request, does JMS session guarantee that the information will be returned back to the appropriate GUI client who initiated the request?
I appreciate your time.
Thanks,
Phoenix

>
If multiple GUI clients place a request over HTTP
using SOAP and SOAP server delegates the request to a
remote java process by creating new JMS object
everytime to send the request, does JMS session
guarantee that the information will be returned back
to the appropriate GUI client who initiated the
request?
JMS guarentees the reliability which the message was
sent with ...
For example, if you send a persistent message to a queue
JMS guarentees that that message will remain in the system
until it is delivered to and acknowledged by a receiver
who is interested in the message
If you send a persistent message to a topic, it guarentees
that the message will be delivered to all active subscribers
and all durable subscribers (active or note)
If you send a non-persistent message, you have the same
guarentees as above however the message will be lost if
there is a provider failure.
In addition, messages produced (sent) in a single session
are guarenteed to be received by consumers in the same
order (unless something else in your system, like message
priority changes the order)

What is session affinity?

Similar Messages

Maybe you are looking for