← Back to branch summary

~ubuntu-branches/ubuntu/precise/classpath/precise

« back to all changes in this revision

Viewing changes to gnu/java/rmi/server/ActivatableServerRef.java

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2006-05-27 16:11:15 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060527161115-h6e39eposdt5snb6
Tags: 2:0.91-3
http://bugs.debian.org/368172
* Install header files to /usr/include/classpath.
* debian/control: classpath: Conflict with jamvm < 1.4.3 and
  cacao < 0.96 (Closes: #368172).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnu/java/rmi/server/ActivatableServerRef.java
 
1
/* ActivatableServerRef.java -- The activatable server reference
 
2
   Copyright (C) 2006 Free Software Foundation, Inc.
 
3
 
 
4
This file is part of GNU Classpath.
 
5
 
 
6
GNU Classpath is free software; you can redistribute it and/or modify
 
7
it under the terms of the GNU General Public License as published by
 
8
the Free Software Foundation; either version 2, or (at your option)
 
9
any later version.
 
10
 
 
11
GNU Classpath is distributed in the hope that it will be useful, but
 
12
WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
General Public License for more details.
 
15
 
 
16
You should have received a copy of the GNU General Public License
 
17
along with GNU Classpath; see the file COPYING.  If not, write to the
 
18
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
19
02110-1301 USA.
 
20
 
 
21
Linking this library statically or dynamically with other modules is
 
22
making a combined work based on this library.  Thus, the terms and
 
23
conditions of the GNU General Public License cover the whole
 
24
combination.
 
25
 
 
26
As a special exception, the copyright holders of this library give you
 
27
permission to link this library with independent modules to produce an
 
28
executable, regardless of the license terms of these independent
 
29
modules, and to copy and distribute the resulting executable under
 
30
terms of your choice, provided that you also meet, for each linked
 
31
independent module, the terms and conditions of the license of that
 
32
module.  An independent module is a module which is not derived from
 
33
or based on this library.  If you modify this library, you may extend
 
34
this exception to your version of the library, but you are not
 
35
obligated to do so.  If you do not wish to do so, delete this
 
36
exception statement from your version. */
 
37
 
 
38
 
 
39
package gnu.java.rmi.server;
 
40
 
 
41
import java.io.IOException;
 
42
import java.io.ObjectInput;
 
43
import java.io.ObjectOutput;
 
44
import java.rmi.Remote;
 
45
import java.rmi.RemoteException;
 
46
import java.rmi.activation.ActivationID;
 
47
import java.rmi.server.ObjID;
 
48
import java.rmi.server.RMIServerSocketFactory;
 
49
import java.rmi.server.RemoteStub;
 
50
import java.rmi.server.Skeleton;
 
51
 
 
52
/**
 
53
 * The activatable server reference works like UnicastServerReference, but it
 
54
 * additionally activates the associated object on demand, during the first
 
55
 * incoming call. When UnicastServerReference takes the working reference,
 
56
 * the ActivatableServerRef takes the activation id instead.
 
57
 * 
 
58
 * @author Audrius Meskauskas (Audriusa@Bioinformatics.org)
 
59
 */
 
60
public class ActivatableServerRef extends UnicastServerRef
 
61
{
 
62
  /**
 
63
   * Use SVUID for interoperability
 
64
   */
 
65
  private static final long serialVersionUID = 1;
 
66
  
 
67
  /**
 
68
   * The object activation id.
 
69
   */
 
70
  public ActivationID actId;
 
71
 
 
72
  /**
 
73
   * Used by serialization only
 
74
   */
 
75
  public ActivatableServerRef()
 
76
  {
 
77
    super();
 
78
  }
 
79
  
 
80
  /**
 
81
   * Create the new activatable server reference that will activate object on
 
82
   * the first call using the given activation id.
 
83
   */
 
84
  public ActivatableServerRef(ObjID id, ActivationID anId, int aPort,
 
85
                              RMIServerSocketFactory ssFactory)
 
86
      throws RemoteException
 
87
  {
 
88
    super(id, aPort, ssFactory);
 
89
    actId = anId;
 
90
    
 
91
    // The object ID will be placed in the object map and should deliver
 
92
    // incoming call to {@link #incommingMessageCall}. The object itself
 
93
    // is currently null.
 
94
    UnicastServer.exportActivatableObject(this);
 
95
  }
 
96
  
 
97
  /**
 
98
   * Inactivate the object (stop the server).
 
99
   */
 
100
  public void inactivate()
 
101
  {
 
102
    manager.stopServer();
 
103
  }
 
104
  
 
105
  /**
 
106
   * Activate the object (normally during the first call).
 
107
   */
 
108
  protected void activate() throws RemoteException
 
109
  {
 
110
    try
 
111
      {
 
112
        Remote self = actId.activate(false);
 
113
        
 
114
        // This will call UnicastServer.exportObject, replacing null by
 
115
        // the activated object (self) in the object map.
 
116
        exportObject(self);
 
117
      }
 
118
    catch (RemoteException rex)
 
119
      {
 
120
        throw rex;
 
121
      }
 
122
    catch (Exception exc)
 
123
      {
 
124
        RemoteException rx = new RemoteException("Activation failed.");
 
125
        rx.detail = exc;
 
126
        throw rx;
 
127
      }
 
128
  }
 
129
 
 
130
  /**
 
131
   * If the object is not active, activate it first.
 
132
   */
 
133
  public Object incomingMessageCall(UnicastConnection conn, int method,
 
134
                                    long hash) throws Exception
 
135
  {
 
136
    if (myself == null)
 
137
      activate();
 
138
    return super.incomingMessageCall(conn, method, hash);
 
139
  }
 
140
 
 
141
  /**
 
142
   * Export object and ensure it is present in the server activation table 
 
143
   * as well.
 
144
   */
 
145
  public Remote exportObject(Remote obj) throws RemoteException
 
146
  {
 
147
    Remote r = super.exportObject(obj);
 
148
    UnicastServer.registerActivatable(this);
 
149
    return r;
 
150
  }
 
151
  
 
152
  /**
 
153
   * Export object and ensure it is present in the server activation table as
 
154
   * well.
 
155
   * 
 
156
   * @param aClass the class being exported, must implement Remote.
 
157
   */
 
158
  public Remote exportClass(Class aClass) throws RemoteException
 
159
  {
 
160
    if (!Remote.class.isAssignableFrom(aClass))
 
161
      throw new InternalError(aClass.getName()+" must implement Remote");
 
162
 
 
163
        String ignoreStubs;
 
164
        
 
165
        ClassLoader loader =aClass.getClassLoader(); 
 
166
        
 
167
        // Stubs are always searched for the bootstrap classes that may have
 
168
        // obsolete pattern and may still need also skeletons.
 
169
        if (loader==null)
 
170
          ignoreStubs = "false";
 
171
        else
 
172
          ignoreStubs = System.getProperty("java.rmi.server.ignoreStubClasses", 
 
173
                                           "false");
 
174
        
 
175
        if (! ignoreStubs.equals("true"))
 
176
          {
 
177
            // Find and install the stub
 
178
            Class cls = aClass;
 
179
 
 
180
            // where ist the _Stub? (check superclasses also)
 
181
            Class expCls = expCls = findStubSkelClass(cls);
 
182
 
 
183
            if (expCls != null)
 
184
              {
 
185
                stub = (RemoteStub) getHelperClass(expCls, "_Stub");
 
186
                // Find and install the skeleton (if there is one)
 
187
                skel = (Skeleton) getHelperClass(expCls, "_Skel");
 
188
              }
 
189
          }
 
190
 
 
191
        if (stub == null)
 
192
          stub = createProxyStub(aClass, this);
 
193
 
 
194
        // Build hash of methods which may be called.
 
195
        buildMethodHash(aClass, true);
 
196
 
 
197
    UnicastServer.registerActivatable(this);
 
198
    return stub;
 
199
  }
 
200
 
 
201
  /**
 
202
   * Get the referencing class.
 
203
   */
 
204
  public String getRefClass(ObjectOutput out)
 
205
  {
 
206
    return "ActivatableRef";
 
207
  }
 
208
 
 
209
  /**
 
210
   * Read the content from the input stream.
 
211
   */
 
212
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
 
213
  {
 
214
    super.readExternal(in);
 
215
    actId = (ActivationID) in.readObject();
 
216
  }
 
217
 
 
218
  /**
 
219
   * Write the content to the output stream.
 
220
   */
 
221
  public void writeExternal(ObjectOutput out) throws IOException
 
222
  {
 
223
    super.writeExternal(out);
 
224
    out.writeObject(actId);
 
225
  }
 
226
  
 
227
}