System and method for enabling atomic class loading in an application server environment

• US 6,845,503 B1
• Filed: 05/01/2000
• Issued: 01/18/2005
• Est. Priority Date: 08/13/1999
• Status: Expired due to Term

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Carlson, Bjorn, Soong, Milton, Hasani, Santosh
• Primary Examiner(s): Chaki, Kakali
• Assistant Examiner(s): Vu, Tuan A
• Application Number:
  US09/562,424
• Time in Patent Office: 1,723 Days
• Field of Search: 717/103, 717120-122, 717162-167, 717168-172, 707/1, 707/10, 707/101, 707/103, 713/156, 709/202, 709/315, 345/619, 719/315, 719/332, 718102-107
• US Class Current: 717/166
• CPC Class Codes: G06F 8/65 Updates security arrangements therefor G06F21/57
• CPC Class Codes: G06F 9/44505 Configuring for program initiating, e.g. using registry, configuration files
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/505 considering the load
• CPC Class Codes: H04L 67/10 in which an application is distributed across nodes in the network software deployment G06F8/60; multiprogramming arrangements G06F9/46
• CPC Class Codes: H04L 67/34 involving the movement of software or configuration parameters network booting or remote initial program loading [RIPL] G06F9/4416
• CPC Class Codes: H04L 69/329 in the application layer [OSI layer 7]
• CPC Class Codes: H04L 9/40 Network security protocols

Abstract

Disclosed is a system and method for enabling dynamic class reloading in the application server environment. Users may specify class versionability by specifying a list of explicitly versionable classes; and the application server(s) may execute a background task which operates periodically to check modified versionable classes, and cause the classes to be reloaded.

Administrators may specify a set of class files to be treated as a “bundle”. When the bundle is deployed, a deployer manager may obtain a lock, e.g. a semaphore, referred to as the “dirtyClassListLock”. Once this lock is obtained, the deployer manager may copy all the class files in the bundle from a deployment environment to their appropriate runtime locations. After the runtime locations have been updated, the deployer manager may release the dirtyClassListLock. According to this method, the background task that checks for and reloads modified classes may also have to obtain the dirtyClassListLock in order to run. Thus, the background task will discover and reload class files in the bundle atomically.

Claims

1. A method for atomically reloading class files in an application server environment, the method comprising:

receiving information specifying a set of class files to be treated as a bundle;

a deployer manager deploying the set of class files, wherein said deploying comprises;

obtaining a programmatic lock;

copying each class file in the set to an appropriate runtime location;

releasing the programmatic lock;

a background task discovering and reloading each of the class files copied by the deployer manager.

2. The method of claim 1,

wherein the background task is required to obtain the lock in order to perform said discovering and reloading each of the class files copied by the deployer manager.

3. The method of claim 1,

wherein said receiving information specifying a set of class files to be treated as a bundle results from an administrator utilizing a user interface to specify the set of class files.

4. The method of claim 1,

wherein said deployer manager deploying the set of class files is performed in response to an administrator utilizing a user interface to request deployment of the set of class files.

5. The method of claim 1,

wherein the background task is a thread operable to periodically wake up at intervals and check for modified classes that should be dynamically reloaded.

6. The method of claim 5,

wherein said thread checking for modified classes that should be dynamically reloaded comprises the thread determining a list of versionable classes, wherein the list of versionable classes comprises a list of classes that should be dynamically reloaded when modified.

7. The method of claim 6, further comprising:

the thread obtaining information specifying a list of explicitly versionable classes, wherein the list of explicitly versionable classes comprises names of classes that should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes listed in the list of explicitly versionable classes.

8. The method of claim 6, further comprising:

the thread obtaining information specifying a list of superclasses, wherein the list of superclasses comprises names of classes whose subclasses should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that extend the classes listed in the list of superclasses.

9. The method of claim 6, further comprising:

the thread obtaining information specifying a list of interfaces, wherein the list of interfaces comprises names of interfaces whose implementing classes should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that implement the interfaces listed in the list of interfaces.

10. A system comprising:

an application server including a CPU, memory, and file system;

a deployer manager stored in the memory of the application server, wherein the deployer manager is executable to deploy a set of class files, wherein said deploying comprises;

obtaining a programmatic lock;

copying each class file in the set to an appropriate runtime location in the file system of the application server;

releasing the programmatic lock;

a background task stored in the memory of the application server, wherein the background task is operable to discover and reload each of the class files copied by the deployer manager.

11. The system of claim 10, further comprising:

a program stored in the memory of the application server;

wherein the program is operable to display a user interface;

wherein the user interface enables an administrator to specify a set of class files to be treated as a bundle;

wherein the program is operable to inform the deployer manager of the set of class files to be treated as a bundle.

12. The system of claim 11,

wherein the user interface enables the administrator to request that the set of class files be deployed;

wherein said program informing the deployer manager of the set of class files to be treated as a bundle is performed in response to the administrator utilizing the user interface to request deployment of the set of class files.

13. The system of claim 10,

wherein the background task is required to obtain the lock in order to perform said discovering and reloading each of the class files copied by the deployer manager.

14. The system of claim 10,

wherein the background task is a thread operable to periodically wake up at intervals and check for modified classes that should be dynamically reloaded.

15. The system of claim 14,

wherein said thread checking for modified classes that should be dynamically reloaded comprises the thread determining a list of versionable classes, wherein the list of versionable classes comprises a list of classes that should be dynamically reloaded when modified.

16. The system of claim 15,

wherein the thread is executable to obtain information specifying a list of explicitly versionable classes, wherein the list of explicitly versionable classes comprises names of classes that should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes listed in the list of explicitly versionable classes.

17. The system of claim 15,

wherein the thread is executable to obtain information specifying a list of superclasses, wherein the list of superclasses comprises names of classes whose subclasses should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that extend the classes listed in the list of superclasses.

18. The system of claim 15,

wherein the thread is executable to obtain information specifying a list of interfaces, wherein the list of interfaces comprises names of interfaces whose implementing classes should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that implement the interfaces listed in the list of interfaces.

19. A memory medium comprising program instructions operable to implement:

receiving information specifying a set of class files to be treated as a bundle;

a deployer manager deploying the set of class files, wherein said deploying comprises;

obtaining a programmatic lock;

copying each class file in the set to an appropriate runtime location in an application server file system;

releasing the programmatic lock;

a background task discovering and reloading each of the class files copied by the deployer manager.

20. The memory medium of claim 19,

wherein the background task is required to obtain the lock in order to perform said discovering and reloading each of the class files copied by the deployer manager.

21. The memory medium of claim 19,

wherein said receiving information specifying a set of class files to be treated as a bundle results from an administrator utilizing a user interface to specify the set of class files.

22. The memory medium of claim 19,

wherein said deployer manager deploying the set of class files is performed in response to an administrator utilizing a user interface to request deployment of the set of class files.

23. The memory medium of claim 19,

wherein the background task is a thread operable to periodically wake up at intervals and check for modified classes that should be dynamically reloaded.

24. The memory medium of claim 23,

wherein said thread checking for modified classes that should be dynamically reloaded comprises the thread determining a list of versionable classes, wherein the list of versionable classes comprises a list of classes that should be dynamically reloaded when modified.

25. The memory medium of claim 24, further comprising program instructions operable to implement:

the thread obtaining information specifying a list of explicitly versionable classes, wherein the list of explicitly versionable classes comprises names of classes that should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes listed in the list of explicitly versionable classes.

26. The memory medium of claim 24, further comprising program instructions operable to implement:

the thread obtaining information specifying a list of superclasses, wherein the list of superclasses comprises names of classes whose subclasses should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that extend the classes listed in the list of superclasses.

27. The memory medium of claim 24, further comprising program instructions operable to implement:

the thread obtaining information specifying a list of interfaces, wherein the list of interfaces comprises names of interfaces whose implementing classes should be dynamically reloaded when modified;

wherein the list of versionable classes comprises classes that implement the interfaces listed in the list of interfaces.