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:%S%z"));
  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 bool acked;
  94     public List<LogEntry> entries;
  95     public List<TrackEntry> track;
  96
  97     public Log(string tag, string title, bool acked=false)
  98     {
  99         this.tag = tag;
 100         this.title = title;
 101         this.acked = acked;
 102         entries = null;
 103         track = null;
 104     }
 105
 106     public void add(string msg)
 107     {
 108         var entry = new LogEntry();
 109         entry.msg = msg;
 110         entries.append(entry);
 111     }
 112
 113     public void add_trackpoint()
 114     {
 115         track.append(new TrackEntry());
 116     }
 117
 118     public void save()
 119     {
 120         if (entries == null) return;
 121
 122         // Directory where we save the log
 123         string dir;
 124         if (acked)
 125             dir = config.homedir + "/archive";
 126         else
 127             dir = config.homedir + "/log";
 128         DirUtils.create(dir, 0777);
 129
 130         // First try with a plain name
 131         var t = Time.local(entries.data.ts);
 132         string basename = dir + "/" + t.format("%Y%m%d-%H%M%S") + "-" + tag;
 133
 134         string pathname = basename + ".gpx";
 135
 136         // Find a pathname that does not exist already
 137         for (int i = 1; FileUtils.test(pathname, FileTest.EXISTS); ++i)
 138             pathname = "%s-%d.gpx".printf(basename, i);
 139
 140         // Write out
 141         var outfd = FileStream.open(pathname, "w");
 142         if (outfd == null)
 143         {
 144             zavai.log.error("opening " + pathname + ": " + strerror(errno));
 145             return;
 146         }
 147
 148         write(outfd);
 149         outfd.flush();
 150     }
 151
 152     public void dump()
 153     {
 154         write(stderr);
 155     }
 156
 157     protected void writeTrack(FileStream outfd)
 158     {
 159         outfd.puts("   <trk>\n");
 160         outfd.puts("     <trkseg>\n");
 161         for (weak List<TrackEntry> i = track; i != null; i = i.next)
 162             i.data.write(outfd);
 163         outfd.puts("     </trkseg>\n");
 164         outfd.puts("   </trk>\n");
 165     }
 166
 167     protected void writeEntries(FileStream outfd)
 168     {
 169         for (weak List<LogEntry> i = entries; i != null; i = i.next)
 170             i.data.write(outfd);
 171     }
 172
 173     protected void write(FileStream outfd)
 174     {
 175         outfd.puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 176         outfd.puts("<gpx version=\"1.0\"\n");
 177         outfd.printf("     creator=\"zavai %s\"\n", zavai.config.version);
 178         outfd.puts("     xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
 179         outfd.puts("     xmlns=\"http://www.topografix.com/GPX/1/0\"\n");
 180         outfd.puts("     xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">\n");
 181         outfd.puts("  <metadata>\n");
 182         outfd.printf("    <name>%s</name>\n", Markup.escape_text(title));
 183         outfd.puts("  </metadata>\n");
 184         if (track != null) writeTrack(outfd);
 185         if (entries != null) writeEntries(outfd);
 186         outfd.puts(" </gpx>\n");
 187     }
 188 }
 189
 190 enum LogParserState {
 191     NONE,
 192     METADATA,
 193     TRACK,
 194     WPT,
 195 }
 196
 197 class LogParser: Object
 198 {
 199     const MarkupParser parser = { // It's a structure, not an object
 200         start,// when an element opens
 201         end,  // when an element closes
 202         text, // when text is found
 203         null, // when comments are found
 204         null  // when errors occur
 205     };
 206
 207     MarkupParseContext context = null;
 208     public Log result = null;
 209     LogParserState state = LogParserState.NONE;
 210     string cur_text = "";
 211     LogEntry cur_logentry = null;
 212     TrackEntry cur_trackentry = null;
 213
 214     construct
 215     {
 216         context = new MarkupParseContext(
 217             parser, // the structure with the callbacks
 218             0,      // MarkupParseFlags
 219             this,   // extra argument for the callbacks, methods in this case
 220             destroy // when the parsing ends
 221         );
 222     }
 223
 224     void destroy()
 225     {
 226         cur_text = "";
 227         cur_logentry = null;
 228         cur_trackentry = null;
 229     }
 230
 231     public bool parse(string content, ssize_t len = -1) throws MarkupError
 232     {
 233         string oldtz = Environment.get_variable("TZ");
 234         Environment.set_variable("TZ", "UTC", true);
 235         bool res = context.parse(content, len);
 236         if (oldtz == null)
 237             Environment.unset_variable("TZ");
 238         else
 239             Environment.set_variable("TZ", oldtz, true);
 240         return res;
 241     }
 242
 243     void parse_attrs(Waypoint w, string[] attr_names, string[] attr_values)
 244     {
 245         w.lat = 1000;
 246         w.lon = 1000;
 247         for (int i = 0; attr_names[i] != null; ++i)
 248         {
 249             if (attr_names[i] == "lat")
 250                 w.lat = attr_values[i].to_double();
 251             else if (attr_names[i] == "lon")
 252                 w.lon = attr_values[i].to_double();
 253         }
 254     }
 255
 256     void start (MarkupParseContext context, string name,
 257                 string[] attr_names, string[] attr_values) throws MarkupError
 258     {
 259         if (name == "gpx")
 260         {
 261             state = LogParserState.NONE;
 262             result = new Log("TODO:TAG", "TODO:TITLE");
 263         } else if (name == "metadata") {
 264             state = LogParserState.METADATA;
 265         } else if (name == "wpt") {
 266             cur_logentry = new LogEntry();
 267             parse_attrs(cur_logentry, attr_names, attr_values);
 268             result.entries.append(cur_logentry);
 269             state = LogParserState.WPT;
 270         } else if (name == "trkpt") {
 271             cur_trackentry = new TrackEntry();
 272             parse_attrs(cur_trackentry, attr_names, attr_values);
 273             result.track.append(cur_trackentry);
 274             state = LogParserState.TRACK;
 275         }
 276         cur_text = "";
 277     }
 278
 279     void end (MarkupParseContext context, string name) throws MarkupError
 280     {
 281         if (name == "name")
 282         {
 283             switch (state)
 284             {
 285                 case LogParserState.METADATA:
 286                     result.title = cur_text;
 287                     break;
 288                 case LogParserState.WPT:
 289                     cur_logentry.msg = cur_text;
 290                     break;
 291             }
 292         }
 293         else if (name == "time")
 294         {
 295             Time t = Time();
 296             t.strptime(cur_text, "%Y-%m-%dT%H:%M:%S%z");
 297             if (state == LogParserState.WPT)
 298                 cur_logentry.ts = t.mktime();
 299             else if (state == LogParserState.TRACK)
 300                 cur_trackentry.ts = t.mktime();
 301         }
 302     }
 303
 304     void text (MarkupParseContext context,
 305                string text, size_t text_len) throws MarkupError
 306     {
 307         cur_text += text;
 308     }
 309 }
 310
 311 public class Logger : Resource, Object
 312 {
 313     protected List<Log> logs;
 314
 315     public Logger()
 316     {
 317         logs = null;
 318         zavai.registry.register(this);
 319     }
 320
 321     protected void start_trace()
 322     {
 323         gps.gps.pos_changed += on_pos_changed;
 324     }
 325
 326     protected void end_trace()
 327     {
 328         gps.gps.pos_changed -= on_pos_changed;
 329     }
 330
 331     protected void on_pos_changed()
 332     {
 333         for (weak List<Log> i = logs; i != null; i = i.next)
 334             i.data.add_trackpoint();
 335     }
 336
 337     protected void pop(Log log)
 338     {
 339         for (weak List<Log> i = logs; i != null; i = i.next)
 340             if (i.data == log)
 341                 logs.delete_link(i);
 342     }
 343
 344     public Log start(string tag, string title)
 345     {
 346         bool was_empty = (logs == null);
 347         Log res = new Log(tag, title);
 348         logs.append(res);
 349         if (was_empty) start_trace();
 350         return res;
 351     }
 352
 353     public void end(Log log)
 354     {
 355         pop(log);
 356         log.save();
 357         if (logs == null) end_trace();
 358     }
 359
 360     public Log load(string fname)
 361     {
 362         string contents;
 363         size_t length;
 364         FileUtils.get_contents(fname, out contents, out length);
 365         LogParser parser = new LogParser();
 366         parser.parse(contents, (ssize_t)length);
 367         return parser.result;
 368     }
 369
 370     protected size_t list_dir(string dir, ref List<string> res)
 371     {
 372         size_t count = 0;
 373         var d = File.new_for_path(dir);
 374         var enumerator = d.enumerate_children(FILE_ATTRIBUTE_STANDARD_NAME, 0, null);
 375         FileInfo file_info;
 376         while ((file_info = enumerator.next_file(null)) != null)
 377         {
 378             if (!file_info.get_name().has_suffix(".gpx")) continue;
 379             res.append(file_info.get_name());
 380             ++count;
 381         }
 382         return count;
 383     }
 384
 385     public string[] list_entries(bool only_unacked=true)
 386     {
 387         size_t count = 0;
 388         List<string> entries = new List<string>();
 389         if (!only_unacked)
 390             count += list_dir(config.homedir + "/archive", ref entries);
 391         count += list_dir(config.homedir + "/log", ref entries);
 392         string[] res = new string[count+1];
 393         size_t cur = 0;
 394         for (weak List<string> i = entries; i != null; i = i.next)
 395             res[cur++] = i.data;
 396         res[cur] = null;
 397         return res;
 398     }
 399
 400     public void instant(string tag, string msg)
 401     {
 402         var log = new Log(tag, msg);
 403         log.add(msg);
 404         log.save();
 405     }
 406
 407     public void shutdown()
 408     {
 409         bool had_logs = (logs != null);
 410         while (logs != null)
 411         {
 412             logs.data.save();
 413             logs.delete_link(logs);
 414         }
 415         if (had_logs) end_trace();
 416     }
 417 }
 418
 419 public void error(string s)
 420 {
 421         stderr.printf("%s\n", s);
 422 }
 423 public void warning(string s)
 424 {
 425         stderr.printf("%s\n", s);
 426 }
 427 public void info(string s)
 428 {
 429         stderr.printf("%s\n", s);
 430 }
 431 public void debug(string s)
 432 {
 433         stderr.printf("%s\n", s);
 434 }
 435
 436 Logger log = null;
 437
 438 public void init()
 439 {
 440     log = new Logger();
 441 }
 442
 443 }
 444 }