src/log.vala

   1 /*
   2  * log - logging functions
   3  *
   4  * Copyright (C) 2009--2010  Enrico Zini <enrico@enricozini.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 using GLib;
  22
  23 namespace zavai {
  24 namespace log {
  25
  26 public class Waypoint : Object
  27 {
  28     public time_t ts;
  29     public double lat;
  30     public double lon;
  31
  32     public Waypoint()
  33     {
  34         if (gps.gps.fix_status() != libgps.STATUS_NO_FIX)
  35         {
  36             lat = gps.gps.info().fix.latitude;
  37             lon = gps.gps.info().fix.longitude;
  38             ts = (time_t)gps.gps.info().fix.time;
  39         } else {
  40             // Use 1000 as missing values
  41             lat = 1000;
  42             lon = 1000;
  43             ts = time_t();
  44         }
  45     }
  46
  47     public void writeInside(FileStream outfd)
  48     {
  49         var t = Time.gm(ts);
  50         outfd.printf("   <time>%s</time>\n", t.format("%Y-%m-%dT%H:%M:%SZ"));
  51     }
  52 }
  53
  54
  55 public class LogEntry : Waypoint
  56 {
  57     public string msg;
  58
  59     public LogEntry()
  60     {
  61         base();
  62     }
  63
  64     public void write(FileStream outfd)
  65     {
  66         outfd.printf("   <wpt lat=\"%f\" lon=\"%f\">\n", lat, lon);
  67         writeInside(outfd);
  68         outfd.printf("   <name>%s</name>\n", Markup.escape_text(msg));
  69         outfd.puts("   </wpt>\n");
  70     }
  71 }
  72
  73 public class TrackEntry : Waypoint
  74 {
  75     public TrackEntry()
  76     {
  77         base();
  78     }
  79
  80     public void write(FileStream outfd)
  81     {
  82         outfd.printf("   <trkpt lat=\"%f\" lon=\"%f\">\n", lat, lon);
  83         writeInside(outfd);
  84         outfd.puts("   </trkpt>\n");
  85     }
  86 }
  87
  88
  89 public class Log : Object
  90 {
  91     public string tag;
  92     public string title;
  93     public List<LogEntry> entries;
  94     public List<TrackEntry> track;
  95
  96     public Log(string tag, string title)
  97     {
  98         this.tag = tag;
  99         this.title = title;
 100         entries = null;
 101         track = null;
 102     }
 103
 104     public void add(string msg)
 105     {
 106         var entry = new LogEntry();
 107         entry.msg = msg;
 108         entries.append(entry);
 109     }
 110
 111     public void add_trackpoint()
 112     {
 113         track.append(new TrackEntry());
 114     }
 115
 116     public void save()
 117     {
 118         if (entries == null) return;
 119
 120         // Directory where we save the log
 121         string dir = config.homedir + "/log-" + tag;
 122         DirUtils.create(dir, 0777);
 123
 124         // First try with a plain name
 125         var t = Time.local(entries.data.ts);
 126         string basename = dir + "/" + t.format("%Y%m%d-%H%M%S");
 127
 128         string pathname = basename + ".gpx";
 129
 130         // Find a pathname that does not exist already
 131         for (int i = 1; FileUtils.test(pathname, FileTest.EXISTS); ++i)
 132             pathname = "%s-%d.gpx".printf(basename, i);
 133
 134         // Write out
 135         var outfd = FileStream.open(pathname, "w");
 136         if (outfd == null)
 137         {
 138             zavai.log.error("opening " + pathname + ": " + strerror(errno));
 139             return;
 140         }
 141
 142         write(outfd);
 143         outfd.flush();
 144     }
 145
 146     protected void writeTrack(FileStream outfd)
 147     {
 148         outfd.puts("   <trk>\n");
 149         outfd.puts("     <trkseg>\n");
 150         for (weak List<TrackEntry> i = track; i != null; i = i.next)
 151             i.data.write(outfd);
 152         outfd.puts("     </trkseg>\n");
 153         outfd.puts("   </trk>\n");
 154     }
 155
 156     protected void writeEntries(FileStream outfd)
 157     {
 158         outfd.puts("   <wpt>\n");
 159         for (weak List<LogEntry> i = entries; i != null; i = i.next)
 160             i.data.write(outfd);
 161         outfd.puts("   </wpt>\n");
 162     }
 163
 164     protected void write(FileStream outfd)
 165     {
 166         outfd.puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 167         outfd.puts("<gpx version=\"1.0\"\n");
 168         outfd.printf("     creator=\"zavai %s\"\n", zavai.config.version);
 169         outfd.puts("     xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
 170         outfd.puts("     xmlns=\"http://www.topografix.com/GPX/1/0\"\n");
 171         outfd.puts("     xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">\n");
 172         outfd.puts("  <metadata>\n");
 173         outfd.printf("    <name>%s</name>\n", Markup.escape_text(title));
 174         outfd.puts("  </metadata>\n");
 175         if (track != null) writeTrack(outfd);
 176         if (entries != null) writeEntries(outfd);
 177         outfd.puts(" </gpx>\n");
 178     }
 179 }
 180
 181 enum LogParserState {
 182     NONE,
 183     METADATA,
 184     TRACK,
 185     WPT,
 186 }
 187
 188 class LogParser: Object
 189 {
 190     const MarkupParser parser = { // It's a structure, not an object
 191         start,// when an element opens
 192         end,  // when an element closes
 193         text, // when text is found
 194         null, // when comments are found
 195         null  // when errors occur
 196     };
 197
 198     MarkupParseContext context = null;
 199     public Log result = null;
 200     LogParserState state = LogParserState.NONE;
 201     string cur_text = "";
 202
 203     construct
 204     {
 205         context = new MarkupParseContext(
 206             parser, // the structure with the callbacks
 207             0,      // MarkupParseFlags
 208             this,   // extra argument for the callbacks, methods in this case
 209             destroy // when the parsing ends
 210         );
 211     }
 212
 213     void destroy()
 214     {
 215         cur_text = "";
 216     }
 217
 218     public bool parse(string content, ssize_t len = -1) throws MarkupError
 219     {
 220         return context.parse(content, len);
 221     }
 222
 223
 224         /*
 225         outfd.puts("  <metadata>\n");
 226         outfd.printf("    <name>%s</name>\n", Markup.escape_text(title));
 227         outfd.puts("  </metadata>\n");
 228         if (track != null) writeTrack(outfd);
 229         if (entries != null) writeEntries(outfd);
 230         outfd.puts(" </gpx>\n");
 231         */
 232
 233
 234     void start (MarkupParseContext context, string name,
 235                 string[] attr_names, string[] attr_values) throws MarkupError
 236     {
 237         if (name == "gpx")
 238         {
 239             state = LogParserState.NONE;
 240             result = new Log("TODO:TAG", "TODO:TITLE");
 241         } else if (name == "metadata") {
 242             state = LogParserState.METADATA;
 243         } else if (name == "wpt") {
 244             state = LogParserState.WPT;
 245         } else if (name == "trkseg") {
 246             state = LogParserState.TRACK;
 247         }
 248         cur_text = "";
 249     }
 250
 251     void end (MarkupParseContext context, string name) throws MarkupError
 252     {
 253         if (name == "state")
 254             if (state == LogParserState.METADATA)
 255                 result.title = cur_text;
 256     }
 257
 258     void text (MarkupParseContext context,
 259                string text, size_t text_len) throws MarkupError
 260     {
 261         cur_text += text;
 262     }
 263 }
 264
 265 public class Logger : Resource, Object
 266 {
 267     protected List<Log> logs;
 268
 269     public Logger()
 270     {
 271         logs = null;
 272         zavai.registry.register(this);
 273     }
 274
 275     protected void start_trace()
 276     {
 277         gps.gps.pos_changed += on_pos_changed;
 278     }
 279
 280     protected void end_trace()
 281     {
 282         gps.gps.pos_changed -= on_pos_changed;
 283     }
 284
 285     protected void on_pos_changed()
 286     {
 287         for (weak List<Log> i = logs; i != null; i = i.next)
 288             i.data.add_trackpoint();
 289     }
 290
 291     protected void pop(Log log)
 292     {
 293         for (weak List<Log> i = logs; i != null; i = i.next)
 294             if (i.data == log)
 295                 logs.delete_link(i);
 296     }
 297
 298     public Log start(string tag, string title)
 299     {
 300         bool was_empty = (logs == null);
 301         Log res = new Log(tag, title);
 302         logs.append(res);
 303         if (was_empty) start_trace();
 304         return res;
 305     }
 306
 307     public void end(Log log)
 308     {
 309         pop(log);
 310         log.save();
 311         if (logs == null) end_trace();
 312     }
 313
 314     public Log load(string fname)
 315     {
 316         string contents;
 317         size_t length;
 318         FileUtils.get_contents(fname, out contents, out length);
 319         LogParser parser = new LogParser();
 320         parser.parse(contents, (ssize_t)length);
 321         return parser.result;
 322     }
 323
 324     public void instant(string tag, string msg)
 325     {
 326         var log = new Log(tag, msg);
 327         log.add(msg);
 328         log.save();
 329     }
 330
 331     public void shutdown()
 332     {
 333         bool had_logs = (logs != null);
 334         while (logs != null)
 335         {
 336             logs.data.save();
 337             logs.delete_link(logs);
 338         }
 339         if (had_logs) end_trace();
 340     }
 341 }
 342
 343 public void error(string s)
 344 {
 345         stderr.printf("%s\n", s);
 346 }
 347 public void warning(string s)
 348 {
 349         stderr.printf("%s\n", s);
 350 }
 351 public void info(string s)
 352 {
 353         stderr.printf("%s\n", s);
 354 }
 355 public void debug(string s)
 356 {
 357         stderr.printf("%s\n", s);
 358 }
 359
 360 Logger log = null;
 361
 362 public void init()
 363 {
 364     log = new Logger();
 365 }
 366
 367 }
 368 }