← Back to branch summary

~ubuntu-branches/ubuntu/raring/libjboss-remoting-java/raring

« back to all changes in this revision

Viewing changes to src/main/org/jboss/remoting/callback/CallbackStoreWrapper.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: package-import@ubuntu.com-20110909140103-o8ucrolqt5g25k57
Tags: upstream-2.5.3.SP1
Import upstream version 2.5.3.SP1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/org/jboss/remoting/callback/CallbackStoreWrapper.java
 
1
 
 
2
/*
 
3
* JBoss, Home of Professional Open Source
 
4
* Copyright 2005, JBoss Inc., and individual contributors as indicated
 
5
* by the @authors tag. See the copyright.txt in the distribution for a
 
6
* full listing of individual contributors.
 
7
*
 
8
* This is free software; you can redistribute it and/or modify it
 
9
* under the terms of the GNU Lesser General Public License as
 
10
* published by the Free Software Foundation; either version 2.1 of
 
11
* the License, or (at your option) any later version.
 
12
*
 
13
* This software is distributed in the hope that it will be useful,
 
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
16
* Lesser General Public License for more details.
 
17
*
 
18
* You should have received a copy of the GNU Lesser General Public
 
19
* License along with this software; if not, write to the Free
 
20
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
21
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
22
*/
 
23
package org.jboss.remoting.callback;
 
24
 
 
25
import java.io.IOException;
 
26
import java.io.Serializable;
 
27
import java.security.AccessController;
 
28
import java.security.PrivilegedAction;
 
29
import java.security.PrivilegedActionException;
 
30
import java.security.PrivilegedExceptionAction;
 
31
import java.util.Map;
 
32
 
 
33
import org.jboss.remoting.SerializableStore;
 
34
import org.jboss.remoting.util.SecurityUtility;
 
35
 
 
36
/**
 
37
 * A CallbackStoreWrapper is used to wrap an MBean proxy that implements
 
38
 * org.jboss.remoting.SerializableStore.  If necessary, each call will go 
 
39
 * through an AccessController.doPrivileged() call.
 
40
 * 
 
41
 * @author <a href="ron.sigal@jboss.com">Ron Sigal</a>
 
42
 * @version $Revision: 1.1 $
 
43
 * <p>
 
44
 * Copyright May 5, 2008
 
45
 * </p>
 
46
 */
 
47
public class CallbackStoreWrapper implements SerializableStore
 
48
{
 
49
   private SerializableStore proxy;
 
50
 
 
51
 
 
52
   public CallbackStoreWrapper(SerializableStore proxy)
 
53
   {
 
54
      this.proxy = proxy;
 
55
   }
 
56
   
 
57
   public void add(final Serializable object) throws IOException
 
58
   {
 
59
      if (SecurityUtility.skipAccessControl())
 
60
      {
 
61
         proxy.add(object);
 
62
         return;
 
63
      }
 
64
      
 
65
      try
 
66
      {
 
67
         AccessController.doPrivileged( new PrivilegedExceptionAction()
 
68
         {
 
69
            public Object run() throws IOException
 
70
            {
 
71
               proxy.add(object);
 
72
               return null;
 
73
            }
 
74
         });
 
75
      }
 
76
      catch (PrivilegedActionException e)
 
77
      {
 
78
         throw (IOException) e.getCause();
 
79
      }
 
80
   }
 
81
 
 
82
   public void create() throws Exception
 
83
   {
 
84
      if (SecurityUtility.skipAccessControl())
 
85
      {
 
86
         proxy.create();
 
87
         return;
 
88
      }
 
89
      
 
90
      try
 
91
      {
 
92
         AccessController.doPrivileged( new PrivilegedExceptionAction()
 
93
         {
 
94
            public Object run() throws Exception
 
95
            {
 
96
               proxy.create();
 
97
               return null;
 
98
            }
 
99
         });
 
100
      }
 
101
      catch (PrivilegedActionException e)
 
102
      {
 
103
         throw (Exception) e.getCause();
 
104
      }
 
105
   }
 
106
 
 
107
   public void destroy()
 
108
   {
 
109
      if (SecurityUtility.skipAccessControl())
 
110
      {
 
111
          proxy.destroy();
 
112
          return;
 
113
      }
 
114
 
 
115
      AccessController.doPrivileged( new PrivilegedAction()
 
116
      {
 
117
         public Object run()
 
118
         {
 
119
            proxy.destroy();
 
120
            return null;
 
121
         }
 
122
      });
 
123
   }
 
124
 
 
125
   public Object getNext() throws IOException
 
126
   {
 
127
      if (SecurityUtility.skipAccessControl())
 
128
      {
 
129
         return proxy.getNext();
 
130
      }
 
131
      
 
132
      try
 
133
      {
 
134
         return AccessController.doPrivileged( new PrivilegedExceptionAction()
 
135
         {
 
136
            public Object run() throws IOException
 
137
            {
 
138
               return proxy.getNext();
 
139
            }
 
140
         });
 
141
      }
 
142
      catch (PrivilegedActionException e)
 
143
      {
 
144
         throw (IOException) e.getCause();
 
145
      }
 
146
   }
 
147
 
 
148
   public boolean getPurgeOnShutdown()
 
149
   {
 
150
      if (SecurityUtility.skipAccessControl())
 
151
      {
 
152
          return proxy.getPurgeOnShutdown();
 
153
      }
 
154
 
 
155
      return ((Boolean) AccessController.doPrivileged( new PrivilegedAction()
 
156
      {
 
157
         public Object run()
 
158
         {
 
159
            return new Boolean(proxy.getPurgeOnShutdown());
 
160
         }
 
161
      })).booleanValue();
 
162
   }
 
163
 
 
164
   public void purgeFiles()
 
165
   {
 
166
      if (SecurityUtility.skipAccessControl())
 
167
      {
 
168
          proxy.purgeFiles();
 
169
          return;
 
170
      }
 
171
 
 
172
      AccessController.doPrivileged( new PrivilegedAction()
 
173
      {
 
174
         public Object run()
 
175
         {
 
176
            proxy.purgeFiles();
 
177
            return null;
 
178
         }
 
179
      });
 
180
   }
 
181
 
 
182
   public void setConfig(final Map config)
 
183
   {
 
184
      if (SecurityUtility.skipAccessControl())
 
185
      {
 
186
          proxy.setConfig(config);
 
187
          return;
 
188
      }
 
189
 
 
190
      AccessController.doPrivileged( new PrivilegedAction()
 
191
      {
 
192
         public Object run()
 
193
         {
 
194
            proxy.setConfig(config);
 
195
            return null;
 
196
         }
 
197
      });
 
198
   }
 
199
 
 
200
   public void setPurgeOnShutdown(final boolean purgeOnShutdown)
 
201
   {
 
202
      if (SecurityUtility.skipAccessControl())
 
203
      {
 
204
          proxy.setPurgeOnShutdown(purgeOnShutdown);
 
205
          return;
 
206
      }
 
207
 
 
208
      AccessController.doPrivileged( new PrivilegedAction()
 
209
      {
 
210
         public Object run()
 
211
         {
 
212
            proxy.setPurgeOnShutdown(purgeOnShutdown);
 
213
            return null;
 
214
         }
 
215
      });
 
216
   }
 
217
 
 
218
   public int size()
 
219
   {
 
220
      if (SecurityUtility.skipAccessControl())
 
221
      {
 
222
          return proxy.size();
 
223
      }
 
224
 
 
225
      return ((Integer) AccessController.doPrivileged( new PrivilegedAction()
 
226
      {
 
227
         public Object run()
 
228
         {
 
229
            return new Integer(proxy.size());
 
230
         }
 
231
      })).intValue();
 
232
   }
 
233
 
 
234
   public void start() throws Exception
 
235
   {
 
236
      if (SecurityUtility.skipAccessControl())
 
237
      {
 
238
          proxy.start();
 
239
          return;
 
240
      }
 
241
 
 
242
      try
 
243
      {
 
244
         AccessController.doPrivileged( new PrivilegedExceptionAction()
 
245
         {
 
246
            public Object run() throws Exception
 
247
            {
 
248
               proxy.start();
 
249
               return null;
 
250
            }
 
251
         });
 
252
      }
 
253
      catch (PrivilegedActionException e)
 
254
      {
 
255
         throw (Exception) e.getCause();
 
256
      }
 
257
   }
 
258
 
 
259
   public void stop()
 
260
   {
 
261
      if (SecurityUtility.skipAccessControl())
 
262
      {
 
263
          proxy.stop();
 
264
          return;
 
265
      }
 
266
 
 
267
      AccessController.doPrivileged( new PrivilegedAction()
 
268
      {
 
269
         public Object run()
 
270
         {
 
271
            proxy.stop();
 
272
            return null;
 
273
         }
 
274
      });
 
275
   }
 
276
}
 
 
b'\\ No newline at end of file'