src/core.vala

   1 /*
   2  * app - zavai main window
   3  *
   4  * Copyright (C) 2009  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
  25 public interface Resource : Object {
  26     /**
  27      * Shut down this resource.
  28      *
  29      * Normally one does nothing here, but it is important to give resources a
  30      * chance to do cleanup when the program quits.
  31      *
  32      * This can be used for tasks like closing the tags on a GPX track,
  33      * releasing a FSO resource, restoring mixer settings and so on.
  34      */
  35     public abstract void shutdown();
  36 }
  37
  38 public abstract class Service : Object, Resource {
  39     public string name { get; construct; }
  40
  41     bool _started;
  42     public bool started {
  43         get { return _started; }
  44         set { _started = value; }
  45     }
  46
  47     public signal void toggled(bool new_state);
  48
  49     protected class Request
  50     {
  51         public string requestor;
  52         public int count;
  53         public Request(string requestor)
  54         {
  55             this.requestor = requestor;
  56             count = 1;
  57         }
  58     }
  59
  60     protected List<Request> requests;
  61
  62     construct
  63     {
  64         started = false;
  65         requests = null;
  66         zavai.registry.register(this);
  67     }
  68
  69     public void shutdown()
  70     {
  71         stop();
  72     }
  73
  74     /// Activate the service
  75     protected virtual void start()
  76     {
  77         if (!started)
  78         {
  79             zavai.log.info("Service " + name + " started\n");
  80             started = true;
  81             toggled(started);
  82         }
  83     }
  84
  85     /// Deactivate the service
  86     protected virtual void stop()
  87     {
  88         if (started)
  89         {
  90             zavai.log.info("Service " + name + " stopped\n");
  91             started = false;
  92             toggled(started);
  93         }
  94     }
  95
  96     /**
  97       Request a resource using the given ID.
  98      *
  99      * If it is the first time the resource is requested, start it and
 100      * return true. Else, take note of the request and return false.
 101      *
 102      * If a resource is requested multiple times with the same ID, it will
 103      * need to be released multiple times with that ID.
 104      */
 105     public bool request(string id)
 106     {
 107         bool res = (requests == null);
 108         bool got = false;
 109         for (weak List<Request> i = requests; i != null; i = i.next)
 110             if (i.data.requestor == id)
 111             {
 112                 ++i.data.count;
 113                 got = true;
 114                 break;
 115             }
 116         if (!got)
 117             requests.prepend(new Request(id));
 118         if (res) start();
 119         return res;
 120     }
 121
 122     /**
 123      * Release a resource using the given ID.
 124      *
 125      * If after the call nothing is requesting the resource, stop it and
 126      * return true. Else, take note of the release and return false.
 127      *
 128      * If a resource is requested multiple times with the same ID, it will
 129      * need to be released multiple times with that ID.
 130      */
 131     public bool release(string id)
 132     {
 133         weak List<Request> el = null;
 134         for (weak List<Request> i = requests; i != null; i = i.next)
 135             if (i.data.requestor == id)
 136             {
 137                 el = i;
 138                 break;
 139             }
 140
 141         if (el == null)
 142             return false;
 143
 144         ++el.data.count;
 145         if (el.data.count == 0)
 146             requests.delete_link(el);
 147
 148         if (requests != null)
 149             return false;
 150
 151         stop();
 152         return true;
 153     }
 154 }
 155
 156 public abstract class ScriptService : Service
 157 {
 158     protected string script;
 159
 160     protected bool script_start()
 161     {
 162         try {
 163             zavai.config.find_and_run_script(name, "start");
 164             return true;
 165         } catch (Error e) {
 166             zavai.log.error("Running " + name + " start: " + e.message);
 167             return false;
 168         }
 169     }
 170
 171     protected bool script_stop()
 172     {
 173         try {
 174             zavai.config.find_and_run_script(name, "stop");
 175             return true;
 176         } catch (Error e) {
 177             zavai.log.error("Running " + name + " stop: " + e.message);
 178             return false;
 179         }
 180     }
 181
 182     protected bool script_status()
 183     {
 184         string std_out;
 185         string std_err;
 186         string script = zavai.config.find_script(name);
 187         if (script == null)
 188         {
 189             zavai.log.error("Hook " + name + " does not exist");
 190             return false;
 191         }
 192         string command = script + " status";
 193         try {
 194             int res = zavai.config.run_script_sync(command, out std_out, out std_err);
 195             if (res != 0)
 196             {
 197                 zavai.log.error("Running " + command + ": " + std_err);
 198                 return false;
 199             }
 200         } catch (SpawnError e) {
 201             zavai.log.error("Running " + command + ": " + e.message);
 202             return false;
 203         }
 204
 205         std_out._strip();
 206
 207         return (std_out == "on");
 208     }
 209 }
 210
 211 public abstract class ScriptMonitorService : Service
 212 {
 213     protected Pid child_pid;
 214     protected int child_watch_id;
 215
 216     ScriptMonitorService()
 217     {
 218         child_pid = 0;
 219         child_watch_id = 0;
 220     }
 221
 222     protected bool script_start()
 223     {
 224         string script = zavai.config.find_script(name);
 225         zavai.log.info("Run program: " + script + " pre");
 226         try {
 227             // Then run our own script
 228             zavai.config.run_script(script + " pre");
 229         } catch (Error e) {
 230             zavai.log.error("Running " + script + " pre: " + e.message);
 231             return false;
 232         }
 233
 234         zavai.log.info("Run program: " + script + " run");
 235         string[] args = { script, "run" };
 236         try {
 237             Process.spawn_async(
 238                 Environment.get_home_dir(),
 239                 args,
 240                 null,
 241                 SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
 242                 null,
 243                 out child_pid);
 244         } catch (SpawnError e) {
 245             zavai.log.error("Running " + script + " run: " + e.message);
 246             return false;
 247         }
 248
 249         // Add a child watch source to know when it ends
 250         ChildWatch.add(child_pid, on_child);
 251
 252         return true;
 253     }
 254
 255     protected bool script_stop()
 256     {
 257         Posix.kill((Posix.pid_t)child_pid, Posix.SIGTERM);
 258         return true;
 259     }
 260
 261     protected void on_child(Pid pid, int status)
 262     {
 263         zavai.log.info("Exited");
 264 stderr.printf("STATUS %d\n", status);
 265         Process.close_pid(pid);
 266
 267         try {
 268             // Then run our own script
 269             zavai.config.find_and_run_script(name, "post");
 270         } catch (Error e) {
 271             zavai.log.error("Running " + name + " post: " + e.message);
 272             return;
 273         }
 274
 275         cleanup_after_script_stop();
 276
 277         base.stop();
 278     }
 279
 280     protected virtual void cleanup_after_script_stop()
 281     {
 282     }
 283
 284     /*
 285     protected bool script_status()
 286     {
 287     }
 288     */
 289 }
 290
 291 }