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 }