001 package nl.cwi.sen1.modulemanager; 002 003 import java.io.IOException; 004 import java.util.Iterator; 005 import java.util.Map; 006 import java.util.Set; 007 008 import nl.cwi.sen1.graph.types.Graph; 009 import nl.cwi.sen1.moduleapi.Factory; 010 import nl.cwi.sen1.moduleapi.types.AttributeStore; 011 import nl.cwi.sen1.moduleapi.types.Dependency; 012 import nl.cwi.sen1.moduleapi.types.DependencyList; 013 import nl.cwi.sen1.moduleapi.types.ModuleId; 014 import nl.cwi.sen1.moduleapi.types.ModuleIdList; 015 import nl.cwi.sen1.modulemanager.model.AttributeSetListener; 016 import nl.cwi.sen1.modulemanager.model.Module; 017 import nl.cwi.sen1.modulemanager.model.ModuleGraph; 018 import aterm.ATerm; 019 import aterm.ATermList; 020 import aterm.pure.PureFactory; 021 022 public class ModuleManager implements ModuleManagerTif, AttributeSetListener { 023 private ModuleGraph moduleDB; 024 025 private PureFactory pureFactory = new PureFactory(); 026 027 private Factory factory = Factory.getInstance(pureFactory); 028 029 private ModuleManagerBridge bridge; 030 031 public ModuleManager(String[] args) { 032 moduleDB = new ModuleGraph(pureFactory, this); 033 034 bridge = new ModuleManagerBridge(pureFactory, this); 035 try { 036 bridge.init(args); 037 bridge.connect(); 038 } catch (IOException e) { 039 System.err.println("Could not establish connection to ToolBus: " 040 + e); 041 System.exit(1); 042 } 043 044 Thread thread = new Thread(new Runnable() { 045 public void run() { 046 try { 047 bridge.run(); 048 } catch (java.lang.RuntimeException e) { 049 e.printStackTrace(); 050 } 051 } 052 }); 053 thread.setName("ModuleManager"); 054 thread.start(); 055 } 056 057 public ATerm createModule() { 058 ModuleId moduleId = factory.makeModuleId_ModuleId(moduleDB 059 .getNextModuleId()); 060 moduleDB.addModule(new Module(factory), moduleId); 061 return pureFactory.make("snd-value(module-id(<term>))", moduleId 062 .toTerm()); 063 } 064 065 public ATerm getModuleIdByAttribute(ATerm namespace, ATerm key, ATerm value) { 066 ModuleId moduleId = moduleDB.getModuleIdByAttribute(namespace, key, 067 value); 068 069 if (moduleId == null) { 070 return pureFactory.parse("snd-value(no-such-module)"); 071 } 072 073 return pureFactory.make("snd-value(module-id(<term>))", moduleId 074 .toTerm()); 075 } 076 077 public ATerm getAllModules() { 078 Set<ModuleId> modules = moduleDB.getAllModules(); 079 080 return pureFactory.make("snd-value(modules(<list>))", 081 extractATermList(modules)); 082 } 083 084 public ATerm getAllAttributes(ATerm id) { 085 try { 086 ModuleId moduleId = factory.ModuleIdFromTerm(id); 087 AttributeStore attributes = moduleDB.getAllAttributes(moduleId); 088 089 return pureFactory.make("snd-value(attributes(<term>))", attributes 090 .toTerm()); 091 } catch (IllegalArgumentException e) { 092 System.err.println("warning:" + e); 093 return pureFactory.make("snd-value(no-such-module)"); 094 } 095 } 096 097 public void deleteModule(ATerm id) { 098 try { 099 ModuleId moduleId = factory.ModuleIdFromTerm(id); 100 moduleDB.removeModule(moduleId); 101 } catch (IllegalArgumentException e) { 102 System.err.println("warning:" + e); 103 } 104 } 105 106 public void addAttribute(ATerm id, ATerm namespace, ATerm key, ATerm value) { 107 try { 108 ModuleId moduleId = factory.ModuleIdFromTerm(id); 109 moduleDB.setAttribute(moduleId, namespace, key, value); 110 } catch (IllegalArgumentException e) { 111 System.err.println("warning:" + e); 112 } 113 } 114 115 public ATerm getAttribute(ATerm id, ATerm namespace, ATerm key) { 116 try { 117 ModuleId moduleId = factory.ModuleIdFromTerm(id); 118 ATerm value = moduleDB.getModuleAttribute(moduleId, namespace, key); 119 120 if (value == null) { 121 return pureFactory.parse("snd-value(no-such-key)"); 122 } 123 124 return pureFactory.make("snd-value(attribute(<term>))", value); 125 } catch (IllegalArgumentException e) { 126 System.err.println("warning:" + e); 127 return pureFactory.parse("snd-value(no-such-key)"); 128 } 129 } 130 131 public void deleteAttribute(ATerm id, ATerm namespace, ATerm key) { 132 try { 133 ModuleId moduleId = factory.ModuleIdFromTerm(id); 134 135 moduleDB.deleteModuleAttribute(moduleId, namespace, key); 136 } catch (IllegalArgumentException e) { 137 System.err.println("warning:" + e); 138 } 139 } 140 141 public void addDependency(ATerm from, ATerm to) { 142 try { 143 ModuleId moduleFromId = factory.ModuleIdFromTerm(from); 144 ModuleId moduleToId = factory.ModuleIdFromTerm(to); 145 146 moduleDB.addDependency(moduleFromId, moduleToId); 147 } catch (IllegalArgumentException e) { 148 System.err.println("warning:" + e); 149 } 150 } 151 152 public ATerm getChildrenModules(ATerm id) { 153 try { 154 ModuleId moduleId = factory.ModuleIdFromTerm(id); 155 156 Set<ModuleId> dependencies = moduleDB.getChildren(moduleId); 157 158 if (dependencies == null) { 159 return pureFactory.parse("snd-value(no-such-module)"); 160 } 161 162 return pureFactory.make("snd-value(children-modules(<list>))", 163 extractATermList(dependencies)); 164 } catch (IllegalArgumentException e) { 165 System.err.println("warning:" + e); 166 return pureFactory.make("snd-value(children-modules([]))"); 167 } 168 } 169 170 public ATerm getAllParentModules(ATerm id) { 171 try { 172 ModuleId moduleId = factory.ModuleIdFromTerm(id); 173 174 Set<ModuleId> dependencies = moduleDB.getAllParents(moduleId); 175 176 if (dependencies == null) { 177 return pureFactory.parse("snd-value(no-such-module)"); 178 } 179 180 return pureFactory.make("snd-value(all-parent-modules(<list>))", 181 extractATermList(dependencies)); 182 } catch (IllegalArgumentException e) { 183 System.err.println("warning:" + e); 184 185 return pureFactory.make("snd-value(all-parent-modules([]))"); 186 } 187 } 188 189 public ATerm getParentModules(ATerm id) { 190 try { 191 ModuleId moduleId = factory.ModuleIdFromTerm(id); 192 193 Set<ModuleId> dependencies = moduleDB.getParents(moduleId); 194 195 if (dependencies == null) { 196 return pureFactory.parse("snd-value(no-such-module)"); 197 } 198 199 return pureFactory.make("snd-value(parent-modules(<list>))", 200 extractATermList(dependencies)); 201 } catch (IllegalArgumentException e) { 202 System.err.println("warning:" + e); 203 return pureFactory.parse("snd-value(no-such-module)"); 204 } 205 } 206 207 public ATerm getAllChildrenModules(ATerm id) { 208 try { 209 ModuleId moduleId = factory.ModuleIdFromTerm(id); 210 211 Set<ModuleId> dependencies = moduleDB.getAllChildren(moduleId); 212 213 if (dependencies == null) { 214 return pureFactory.parse("snd-value(no-such-module)"); 215 } 216 217 return pureFactory.make("snd-value(all-children-modules(<list>))", 218 extractATermList(dependencies)); 219 } catch (IllegalArgumentException e) { 220 System.err.println("warning:" + e); 221 return pureFactory.parse("snd-value(no-such-module)"); 222 } 223 } 224 225 public ATerm getClosableModules(ATerm id) { 226 try { 227 ModuleId moduleId = factory.ModuleIdFromTerm(id); 228 229 Set<ModuleId> closableModules = moduleDB 230 .getClosableModules(moduleId); 231 232 return pureFactory.make("snd-value(closable-modules(<list>))", 233 extractATermList(closableModules)); 234 } catch (IllegalArgumentException e) { 235 System.err.println("warning:" + e); 236 return pureFactory.make("snd-value(closable-modules([]))"); 237 } 238 } 239 240 public ATerm getDependencies() { 241 DependencyList list = factory.makeDependencyList(); 242 Map<ModuleId, Set<ModuleId>> dependencies = moduleDB.getDependencies(); 243 244 for (Iterator<ModuleId> iter = dependencies.keySet().iterator(); iter 245 .hasNext();) { 246 ModuleId moduleId = iter.next(); 247 Set<ModuleId> deps = dependencies.get(moduleId); 248 249 ModuleIdList moduleList = factory.makeModuleIdList(); 250 for (Iterator<ModuleId> depsIter = deps.iterator(); depsIter 251 .hasNext();) { 252 moduleList = moduleList.append(depsIter.next()); 253 } 254 255 Dependency dependency = factory.makeDependency_Dependency(moduleId, 256 moduleList); 257 list = list.append(dependency); 258 } 259 return pureFactory.make("snd-value(dependencies(<term>))", list 260 .toTerm()); 261 } 262 263 private ATermList extractATermList(Set<ModuleId> dependencies) { 264 ATermList list = pureFactory.makeList(); 265 for (Iterator<ModuleId> iter = dependencies.iterator(); iter.hasNext();) { 266 list = list.append(iter.next().toTerm()); 267 } 268 return list; 269 } 270 271 public void deleteDependency(ATerm from, ATerm to) { 272 ModuleId moduleFromId = factory.ModuleIdFromTerm(from); 273 ModuleId moduleToId = factory.ModuleIdFromTerm(to); 274 275 moduleDB.deleteDependency(moduleFromId, moduleToId); 276 } 277 278 public void deleteDependencies(ATerm id) { 279 try { 280 ModuleId moduleId = factory.ModuleIdFromTerm(id); 281 moduleDB.deleteDependencies(moduleId); 282 } catch (IllegalArgumentException e) { 283 System.err.println("warning:" + e); 284 } 285 } 286 287 public ATerm getModuleGraph(ATerm namespace) { 288 Graph graph = moduleDB.getModuleGraph(namespace); 289 290 return pureFactory.make("snd-value(module-graph(<term>))", graph 291 .toTerm()); 292 } 293 294 public void recTerminate(ATerm t0) { 295 } 296 297 public static void main(String[] args) { 298 // args = new String[6]; 299 // args[0] = "-TB_HOST_NAME"; 300 // args[1] = "localhost"; 301 // args[2] = "-TB_PORT"; 302 // args[3] = "8999"; 303 // args[4] = "-TB_TOOL_NAME"; 304 // args[5] = "module-manager"; 305 306 new ModuleManager(args); 307 } 308 309 public void attributeSet(ModuleId id, ATerm namespace, ATerm key, 310 ATerm oldValue, ATerm newValue) { 311 312 if (oldValue == null) { 313 /* 314 * The old value is unknown, so we construct a pattern that may mean 315 * any term 316 */ 317 oldValue = key.getFactory().parse("undefined"); 318 } 319 320 if (newValue == null) { 321 /* 322 * The new value is unknown, so we construct a pattern that may mean 323 * any term 324 */ 325 newValue = key.getFactory().parse("undefined"); 326 } 327 328 bridge.postEvent(pureFactory.make( 329 "attribute-changed(<term>,<term>,<term>,<term>,<term>)", id 330 .toTerm(), namespace, key, oldValue, newValue)); 331 } 332 333 public void registerAttributeUpdateRule(ATerm namespace, ATerm key, 334 ATerm rule, ATerm value) { 335 moduleDB.registerAttributeUpdateRule(namespace, key, rule, value); 336 } 337 338 public void recAckEvent(ATerm t0) { 339 // intentionally empty 340 } 341 }