1z0-599 Oracle WebLogic Server 12c Essentials Questions and Answers

By default, JMS messages never expire. When applications send messages to queues or topics with durable subscribers, WebLogic must retain the message until it is consumed. This is fine in most point-to-point messaging applications because consumers are constantly consuming messages. Any message sent to a queue will typically be consumed in a relatively short period of time. If the consumers get disconnected, they will usually reconnect as soon as possible and start processing any messages that might have built up in the queue.

D: For durable subscribers to a topic, this is not necessarily true. The messaging system is forced to retain any message that has not been consumed by a durable subscriber, regardless of whether that durable subscriber will ever return. In this case, WebLogic is at the mercy of the durable subscriber to unsubscribe when it no longer wishes to receive the messages. If the durable subscriber logic is flawed in such a way that the subscribers do not unsubscribe properly, the messaging system will start to fill up with messages that may never be delivered. This calls for real caution in using durable subscribers. Fortunately, there is another way to help deal with this problem. Message expiration can be set at the connection factory level. Using a connection factory’s default time-to-live attribute, we can specify the number of milliseconds that WebLogic should retain an undelivered message after it is sent.

Note:

* In managing multiple servers, Node Manager uses multiple configuration files and outputs log files to multiple directories.

* nodemanager.domains

This file contains mappings between the names of domains managed by Node Manager and their corresponding directories.

* Node Manager in the WebLogic Server Environment

Reference; Node Manager Administrator's Guide for Oracle WebLogic Server 12c

An internal application may be configured to always use a minimum version of the same library. Applications that require no specific version can be configured to use the latest version of the library.

Note:

* Specification-Version (a manifest Attributes for Java EE Libraries)

An optional String value that defines the specification version of the shared Java EE library. Referencing applications can optionally specify a required Specification-Version for a library; if the exact specification version is not available, deployment of the referencing application fails.

The Specification-Version uses the following format:

Major/minor version format, with version and revision numbers separated by periods (such as "9.0.1.1")

Referencing applications can be configured to require either an exact version of the shared Java EE library, a minimum version, or the latest available version.

* Implementation-Version (a manifest Attributes for Java EE Libraries)

An optional String value that defines the code implementation version of the shared

Java EE library. You can provide an Implementation-Version only if you have

also defined a Specification-Version.

* Extension-Name (a manifest Attributes for Java EE Libraries)

An optional string value that identifies the name of the shared Java EE library. Referencing applications must use the exact Extension-Name value to use the library.

As a best practice, always specify an Extension-Name value for each library. If you do not specify an extension name, one is derived from the deployment name of the library. Default deployment names are different for archive and exploded archive deployments, and they can be set to arbitrary values in the deployment command.

* After a library is deployed, the extension-name, specification-version and implementation-version of the library can be found in Administration console.

A Node Manager process is not associated with a specific WebLogic domain but with a

machine. You can use the same Node Manager process to control server instances in

any WebLogic Server domain, as long as the server instances reside on the same

machine as the Node Manager process. Node Manager must run on each computer

that hosts WebLogic Server instances—whether Administration Server or Managed

Server—that you want to control with Node Manager.

Explanation;Oracle Coherence is a component of Oracle Fusion Middleware that enables organizations to predictably scale mission-critical applications by providing fast and reliable access to frequently used data.

You can configure a JDBC TLOG store to persist transaction logs to a database, which provides the following benefits:

* Leverages replication and HA characteristics of the underlying database.

* Simplifies disaster recovery by allowing the easy synchronization of the state of the database and TLOGs.

* Improved Transaction Recovery service migration as the transaction logs to do not need to be migrated (copied) to a new location.

* You can configure a JDBC TLOG store to persist transaction logs to a database, which allows you to leverage replication and HA characteristics of the underlying database, simplify disaster recovery, and improve Transaction Recovery service migration.

incorrect:

not B: Read-only, One-phase Commit Optimization requires Oracle DB 11.1.0.7.3PSU or above.

The WebLogic Server Management Pack EE greatly improves application

performance by providing unique functionality to automatically detect performance

bottlenecks; quickly diagnose these performance problems, and identify their root

cause. Key application performance management features of the pack include the

following:

* (A) Manage multiple farms and WebLogic Domains centrally

* Monitor Oracle Coherence Cluster – including all nodes within a cluster, all

caches, services, connection managers and connections

* Monitor middleware availability and performance out-of-box; track such data

historically, and receive notifications of potential problems

* Obtain real-time, in-depth JVM diagnostics without instrumentation overhead

* Trace transactions across containers as well as to the database

* (E) Analyze call paths and dependencies via graphical, architecture views

* (E) Automatically discover and model dependencies between Java components,

frameworks, and web services

Note:

* It is recommended that you shutdown WebLogic Server instances through the Administration Console.

* If automatic server migration is enabled, the servers are required to contact the cluster leader and renew their leases periodically. Servers will shut themselves down if they are unable to renew their leases. The failed servers will then be automatically migrated to the machines in the majority partition.

To manage work in your applications, you define one or more of the following Work Manager components:

Fair Share Request Class:

Response Time Request Class:

Min Threads Constraint:

Max Threads Constraint:

Capacity Constraint

Context Request Class:

Note:

* max-threads-constraint—This constraint limits the number of concurrent threads executing requests from the constrained work set. The default is unlimited. For example, consider a constraint defined with maximum threads of 10 and shared by 3 entry points. The scheduling logic ensures that not more than 10 threads are executing requests from the three entry points combined.

A max-threads-constraint can be defined in terms of a the availability of resource that requests depend upon, such as a connection pool.

A max-threads-constraint might, but does not necessarily, prevent a request class from taking its fair share of threads or meeting its response time goal. Once the constraint is reached the server does not schedule requests of this type until the number of concurrent executions falls below the limit. The server then schedules work based on the fair share or response time goal.

* WebLogic Server prioritizes work and allocates threads based on an execution model that takes into account administrator-defined parameters and actual run-time performance and throughput.

Administrators can configure a set of scheduling guidelines and associate them with one or more applications, or with particular application components.

* WebLogic Server uses a single thread pool, in which all types of work are executed. WebLogic Server prioritizes work based on rules you define, and run-time metrics, including the actual time it takes to execute a request and the rate at which requests are entering and leaving the pool.

The common thread pool changes its size automatically to maximize throughput. The queue monitors throughput over time and based on history, determines whether to adjust the thread count. For example, if historical throughput statistics indicate that a higher thread count increased throughput, WebLogic increases the thread count. Similarly, if statistics indicate that fewer threads did not reduce throughput, WebLogic decreases the thread count. This new strategy makes it easier for administrators to allocate processing resources and manage performance, avoiding the effort and complexity involved in configuring, monitoring, and tuning custom executes queues.

Comparing File Stores and JDBC-accessible Stores

The following are some similarities and differences between file stores and JDBC-accessible stores:

* (A) JDBC stores may make it easier to handle failure recovery since the JDBC interface can access the database from any machine on the same network. With the file store, the disk must be shared or migrated.

* The default persistent store can only be a file store. Therefore, a JDBC store cannot be used as a default persistent store.

* Both have the same transaction semantics and guarantees. As with JDBC store writes, file store writes are guaranteed to be persisted to disk and are not simply left in an intermediate (that is, unsafe) cache.

* Both have the same application interface (no difference in application code).

* (not B, not E) All things being equal, file stores generally offer better throughput than a JDBC store.

/ If a database is running on high-end hardware with very fast disks, and WebLogic Server is running on slower hardware or with slower disks, then you may get better performance from the JDBC store.

* File stores are generally easier to configure and administer, and do not require that WebLogic subsystems depend on any external component.

* File stores generate no network traffic; whereas, JDBC stores generate network traffic if the database is on a different machine from WebLogic Server.