1 20 21 22 package org.snmp4j.agent.io; 23 24 import org.snmp4j.smi.OctetString; 25 import java.io.IOException ; 26 import org.snmp4j.agent.DefaultMOServer; 27 import java.util.LinkedHashMap ; 28 import org.snmp4j.agent.ManagedObject; 29 import java.util.Iterator ; 30 import org.snmp4j.agent.SerializableManagedObject; 31 import java.util.HashMap ; 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 buildCache() { 50 HashMap serializableMO = new HashMap (server.getContexts().length); 51 synchronized (server.getRegistry()) { 52 serializableMO.clear(); 53 for (Iterator 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 objects = (LinkedHashMap ) serializableMO.get(context); 64 if (objects == null) { 65 objects = new LinkedHashMap (); 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 { 76 HashMap serializableMO = buildCache(); 77 LinkedHashMap mos = (LinkedHashMap ) 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 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 ) 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 mos) 114 throws IOException 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 { 136 HashMap serializableMO = buildCache(); 137 LinkedHashMap mos = (LinkedHashMap ) 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 ) 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 mos) 166 throws IOException 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 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 |