KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > snmp4j > agent > io > MOServerPersistence


1 /*_############################################################################
2   _##
3   _## SNMP4J-Agent - MOServerPersistence.java
4   _##
5   _## Copyright (C) 2005-2007 Frank Fock (SNMP4J.org)
6   _##
7   _## Licensed under the Apache License, Version 2.0 (the "License");
8   _## you may not use this file except in compliance with the License.
9   _## You may obtain a copy of the License at
10   _##
11   _## http://www.apache.org/licenses/LICENSE-2.0
12   _##
13   _## Unless required by applicable law or agreed to in writing, software
14   _## distributed under the License is distributed on an "AS IS" BASIS,
15   _## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   _## See the License for the specific language governing permissions and
17   _## limitations under the License.
18   _##
19   _##########################################################################*/

20
21
22 package org.snmp4j.agent.io;
23
24 import org.snmp4j.smi.OctetString;
25 import java.io.IOException JavaDoc;
26 import org.snmp4j.agent.DefaultMOServer;
27 import java.util.LinkedHashMap JavaDoc;
28 import org.snmp4j.agent.ManagedObject;
29 import java.util.Iterator JavaDoc;
30 import org.snmp4j.agent.SerializableManagedObject;
31 import java.util.HashMap JavaDoc;
32 import java.util.Map.Entry;
33 import org.snmp4j.agent.MOScope;
34 import org.snmp4j.agent.MOContextScope;
35 import org.snmp4j.log.LogFactory;
36 import org.snmp4j.log.LogAdapter;
37
38 public class MOServerPersistence {
39
40   private static final LogAdapter logger =
41       LogFactory.getLogger(MOServerPersistence.class);
42
43   private DefaultMOServer server;
44
45   public MOServerPersistence(DefaultMOServer server) {
46     this.server = server;
47   }
48
49   private HashMap JavaDoc buildCache() {
50     HashMap JavaDoc serializableMO = new HashMap JavaDoc(server.getContexts().length);
51     synchronized (server.getRegistry()) {
52       serializableMO.clear();
53       for (Iterator JavaDoc it = server.getRegistry().entrySet().iterator(); it.hasNext(); ) {
54         Entry entry = (Entry) it.next();
55         MOScope scope = (MOScope) entry.getKey();
56         ManagedObject value = (ManagedObject) entry.getValue();
57         if ((value instanceof SerializableManagedObject) &&
58             (!((SerializableManagedObject)value).isVolatile())) {
59           OctetString context = null;
60           if (scope instanceof MOContextScope) {
61             context = ((MOContextScope) scope).getContext();
62           }
63           LinkedHashMap JavaDoc objects = (LinkedHashMap JavaDoc) serializableMO.get(context);
64           if (objects == null) {
65             objects = new LinkedHashMap JavaDoc();
66             serializableMO.put(context, objects);
67           }
68           objects.put(((SerializableManagedObject) value).getID(), value);
69         }
70       }
71     }
72     return serializableMO;
73   }
74
75   public synchronized void loadData(MOInput input) throws IOException JavaDoc {
76     HashMap JavaDoc serializableMO = buildCache();
77     // load context independent data
78
LinkedHashMap JavaDoc mos = (LinkedHashMap JavaDoc) serializableMO.get(null);
79     if (mos != null) {
80       readData(input, mos);
81     }
82     else {
83       Sequence seq = input.readSequence();
84       for (int i=0; i<seq.getSize(); i++) {
85         MOInfo mo = input.readManagedObject();
86         input.skipManagedObject(mo);
87       }
88     }
89     // load contexts
90
Sequence contextSequence = input.readSequence();
91     for (int i=0; i<contextSequence.getSize(); i++) {
92       Context context = input.readContext();
93       boolean skip = !server.isContextSupported(context.getContext());
94       if (skip) {
95         logger.warn("Context '"+context.getContext()+
96                     "' is no longer supported by agent");
97         input.skipContext(context);
98         continue;
99       }
100       if (logger.isDebugEnabled()) {
101         logger.debug("Loading data for context '"+context.getContext()+"'");
102       }
103       mos = (LinkedHashMap JavaDoc) serializableMO.get(context.getContext());
104       if (mos == null) {
105         input.skipContext(context);
106         continue;
107       }
108       readData(input, mos);
109       input.skipContext(context);
110     }
111   }
112
113   private static void readData(MOInput input, LinkedHashMap JavaDoc mos)
114       throws IOException JavaDoc
115   {
116     Sequence moGroup = input.readSequence();
117     for (int j=0; j<moGroup.getSize(); j++) {
118       MOInfo moid = input.readManagedObject();
119       if (logger.isDebugEnabled()) {
120         logger.debug("Looking up object "+moid.getOID());
121       }
122       SerializableManagedObject mo =
123           (SerializableManagedObject) mos.get(moid.getOID());
124       if (mo != null) {
125         if (logger.isDebugEnabled()) {
126           logger.debug("Loading data for object "+moid.getOID());
127         }
128         mo.load(input);
129       }
130       input.skipManagedObject(moid);
131     }
132   }
133
134
135   public synchronized void saveData(MOOutput output) throws IOException JavaDoc {
136     HashMap JavaDoc serializableMO = buildCache();
137     // write context independent data
138
LinkedHashMap JavaDoc mos = (LinkedHashMap JavaDoc) serializableMO.get(null);
139     if (logger.isDebugEnabled()) {
140       logger.debug("Trying to write MIB data for all contexts");
141     }
142     if (mos != null) {
143       writeData(output, null, mos);
144     }
145     else {
146       output.writeSequence(new Sequence(0));
147     }
148     OctetString[] contexts = server.getContexts();
149     output.writeSequence(new Sequence(contexts.length));
150     for (int i=0; i<contexts.length; i++) {
151       Context c = new Context(contexts[i]);
152       output.writeContextBegin(c);
153       if (logger.isDebugEnabled()) {
154         logger.debug("Trying to write MIB data for context '"+
155                      c.getContext()+"'");
156       }
157       mos = (LinkedHashMap JavaDoc) serializableMO.get(c.getContext());
158       if (mos != null) {
159         writeData(output, c, mos);
160       }
161       output.writeContextEnd(c);
162     }
163   }
164
165   private static void writeData(MOOutput output, Context c, LinkedHashMap JavaDoc mos)
166       throws IOException JavaDoc
167   {
168     if (logger.isDebugEnabled()) {
169       if (c == null) {
170         logger.debug("Writing " + mos.size() +
171                      " context independent managed objects");
172       }
173       else {
174         logger.debug("Writing " + mos.size() +
175                      " managed objects for context '" +
176                      c.getContext() + "'");
177       }
178     }
179     output.writeSequence(new Sequence(mos.size()));
180     for (Iterator JavaDoc it = mos.values().iterator(); it.hasNext(); ) {
181       SerializableManagedObject mo = (SerializableManagedObject) it.next();
182       MOInfo moInfo = new MOInfo(mo.getID());
183       output.writeManagedObjectBegin(moInfo);
184       mo.save(output);
185       output.writeManagedObjectEnd(moInfo);
186     }
187   }
188 }
189
Popular Tags