bundles/org.simantics.db.impl/src/org/simantics/db/impl/graph/WriteLogger.java

   1 package org.simantics.db.impl.graph;
   2
   3 import gnu.trove.set.hash.TIntHashSet;
   4
   5 import java.io.File;
   6 import java.io.FileInputStream;
   7 import java.io.FileNotFoundException;
   8 import java.io.IOException;
   9 import java.io.RandomAccessFile;
  10 import java.util.HashMap;
  11
  12 import org.simantics.databoard.Bindings;
  13 import org.simantics.databoard.binding.error.BindingException;
  14 import org.simantics.databoard.parser.repository.DataValueRepository;
  15 import org.simantics.db.ReadGraph;
  16 import org.simantics.db.Resource;
  17 import org.simantics.db.VirtualGraph;
  18 import org.simantics.db.WriteGraph;
  19 import org.simantics.db.exception.DatabaseException;
  20 import org.simantics.db.impl.ResourceImpl;
  21 import org.simantics.db.service.TransferableGraphSupport;
  22 import org.simantics.db.service.VirtualGraphSupport;
  23 import org.simantics.utils.Development;
  24 import org.simantics.utils.FileUtils;
  25
  26 public class WriteLogger {
  27
  28     //final public static String LOG = "WriteLogger.log";
  29
  30     public static File logFile;
  31     public static RandomAccessFile raf;
  32     public static boolean enable = false;
  33     public static TIntHashSet created;
  34
  35     static {
  36         if(Development.DEVELOPMENT) {
  37                 created = new TIntHashSet();
  38                 logFile = new File("write.log");
  39                 try {
  40                         raf = new RandomAccessFile(logFile, "rw");
  41                         } catch (FileNotFoundException e) {
  42                                 e.printStackTrace();
  43                         }
  44         }
  45     }
  46
  47     private static String resourceLog(ReadGraph graph, Resource resource) throws DatabaseException {
  48         if(!enable) return null;
  49         if(resource == null) return "N";
  50         ResourceImpl impl = (ResourceImpl)resource;
  51         int id = impl.id;
  52         if(created.contains(id)) return "I" + impl.id;
  53         else {
  54                 String uri = graph.getPossibleURI(resource);
  55                 if(uri != null) return "U" + uri;
  56                 else return "N";
  57         }
  58     }
  59
  60     private static String virtualGraphLog(ReadGraph graph) {
  61         WriteGraphImpl impl = (WriteGraphImpl)graph;
  62         VirtualGraph vg = impl.getProvider();
  63         if(vg == null) return "N";
  64         else {
  65                 if(VirtualGraph.Persistency.MEMORY == vg.getPersistency()) return "M" + vg.getIdentifier();
  66                 else return "W" + vg.getIdentifier();
  67         }
  68     }
  69
  70     private static void logLine(String line) {
  71         if(!enable) return;
  72         try {
  73                 byte[] data = line.getBytes();
  74                 raf.write(data);
  75         } catch (IOException e) {
  76
  77         }
  78     }
  79
  80     public static void logClaim(ReadGraph graph, Resource subject, Resource predicate, Resource inverse, Resource object) throws DatabaseException {
  81         logLine("C\t" + virtualGraphLog(graph) + "\t" + resourceLog(graph, subject) + "\t" + resourceLog(graph, predicate) + "\t" + resourceLog(graph, inverse) + "\t" + resourceLog(graph, object) + "\n");
  82     }
  83
  84     public static void logDeny(ReadGraph graph, Resource subject, Resource predicate, Resource inverse, Resource object) throws DatabaseException {
  85         logLine("D\t" + virtualGraphLog(graph) + "\t" + resourceLog(graph, subject) + "\t" + resourceLog(graph, predicate) + "\t" + resourceLog(graph, inverse) + "\t" + resourceLog(graph, object) + "\n");
  86     }
  87
  88     public static void logNewResource(ReadGraph graph, Resource subject) throws DatabaseException {
  89         if(!enable) return;
  90         ResourceImpl impl = (ResourceImpl)subject;
  91         created.add(impl.id);
  92         logLine("R\t" + virtualGraphLog(graph) + "\t" + resourceLog(graph, subject) + "\n");
  93     }
  94
  95     public static void logValue(ReadGraph graph, Resource subject, byte[] value) throws DatabaseException {
  96         if(!enable) return;
  97         try {
  98                         logLine("V\t" + virtualGraphLog(graph) + "\t" + resourceLog(graph, subject) + "\t" + Bindings.BYTE_ARRAY.toString(value) + "\n");
  99                 } catch (BindingException e) {
 100                         e.printStackTrace();
 101                 }
 102     }
 103
 104     private static Resource readResource(WriteGraph graph, String id, HashMap<String, Resource> ids) throws DatabaseException {
 105         if(id.startsWith("I")) {
 106                 Resource result = ids.get(id);
 107                 if(result == null) {
 108                         System.err.println("undeclared id='" + id + "'");
 109                 }
 110                 return result;
 111         } else if (id.startsWith("U")) {
 112                 return graph.getPossibleResource(id.substring(1));
 113         } else {
 114                 return null;
 115         }
 116     }
 117
 118         private static VirtualGraph vg = null;
 119
 120         private static VirtualGraph getVirtualGraph(WriteGraphImpl graph, String id) {
 121
 122                 if("N".equals(id)) return null;
 123                 VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 124                 if (id.startsWith("M")) {
 125                         return vgs.getMemoryPersistent(id.substring(1));
 126                 } else {
 127                         return vgs.getWorkspacePersistent(id.substring(1));
 128                 }
 129
 130         }
 131
 132         private static WriteGraphImpl applyVirtualGraph(WriteGraphImpl graph, String id) {
 133                 VirtualGraph target = getVirtualGraph(graph, id);
 134                 if(target != vg) {
 135                         vg = target;
 136                         return (WriteGraphImpl)graph.newSync(target);
 137                 } else {
 138                         return graph;
 139                 }
 140         }
 141
 142
 143     public static void read(WriteGraph _graph) throws Exception {
 144         vg = null;
 145         WriteGraphImpl graph = (WriteGraphImpl)_graph;
 146         String data = FileUtils.getContents(new FileInputStream(logFile)).replace("\r", "");
 147         HashMap<String, Resource> ids = new HashMap<String, Resource>();
 148         for(String line : data.split("\n")) {
 149                 String[] parts = line.split("\t");
 150                 if("C".equals(parts[0])) {
 151                         graph = applyVirtualGraph(graph, parts[1]);
 152                         Resource subject = readResource(graph, parts[2], ids);
 153                         Resource predicate = readResource(graph, parts[3], ids);
 154                         Resource inverse = readResource(graph, parts[4], ids);
 155                         Resource object = readResource(graph, parts[5], ids);
 156                         if(subject == null || predicate == null || object == null) {
 157                                 System.err.println("skipped statement");
 158                         } else {
 159                                 graph.claim(subject, predicate, inverse, object);
 160                         }
 161                 } else if("D".equals(parts[0])) {
 162                         graph = applyVirtualGraph(graph, parts[1]);
 163                         Resource subject = readResource(graph, parts[2], ids);
 164                         Resource predicate = readResource(graph, parts[3], ids);
 165                         Resource inverse = readResource(graph, parts[4], ids);
 166                         Resource object = readResource(graph, parts[5], ids);
 167                         if(subject == null || predicate == null || object == null) {
 168                                 System.err.println("skipped statement");
 169                         } else {
 170                                 graph.deny(subject, predicate, inverse, object);
 171                         }
 172                 } else if ("R".equals(parts[0])) {
 173                         graph = applyVirtualGraph(graph, parts[1]);
 174                         Resource resource = graph.newResource();
 175                         ids.put(parts[2], resource);
 176                 } else if ("V".equals(parts[0])) {
 177                         graph = applyVirtualGraph(graph, parts[1]);
 178                         Resource subject = readResource(graph, parts[2], ids);
 179                         // This is an error
 180                         if(subject == null) continue;
 181                         byte[] value = (byte[])Bindings.BYTE_ARRAY.parseValue(parts[3], new DataValueRepository());
 182                         TransferableGraphSupport tgSupport =
 183                                         graph.getService(TransferableGraphSupport.class);
 184                         tgSupport.setValue(graph, subject, vg, value);
 185
 186                 }
 187         }
 188     }
 189
 190 }