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         requests.delete_link(el);
 145
 146         if (requests != null)
 147             return false;
 148
 149         stop();
 150         return true;
 151     }
 152 }
 153
 154 public abstract class ScriptService : Service
 155 {
 156     protected string script;
 157
 158     protected bool script_start()
 159     {
 160         try {
 161             zavai.config.find_and_run_script(name, "start");
 162             return true;
 163         } catch (Error e) {
 164             zavai.log.error("Running " + name + " start: " + e.message);
 165             return false;
 166         }
 167     }
 168
 169     protected bool script_stop()
 170     {
 171         try {
 172             zavai.config.find_and_run_script(name, "stop");
 173             return true;
 174         } catch (Error e) {
 175             zavai.log.error("Running " + name + " stop: " + e.message);
 176             return false;
 177         }
 178     }
 179
 180     protected bool script_status()
 181     {
 182         string std_out;
 183         string std_err;
 184         string script = zavai.config.find_script(name);
 185         if (script == null)
 186         {
 187             zavai.log.error("Hook " + name + " does not exist");
 188             return false;
 189         }
 190         string command = script + " status";
 191         try {
 192             int res = zavai.config.run_script_sync(command, out std_out, out std_err);
 193             if (res != 0)
 194             {
 195                 zavai.log.error("Running " + command + ": " + std_err);
 196                 return false;
 197             }
 198         } catch (SpawnError e) {
 199             zavai.log.error("Running " + command + ": " + e.message);
 200             return false;
 201         }
 202
 203         std_out._strip();
 204
 205         return (std_out == "on");
 206     }
 207 }
 208
 209 public abstract class ScriptMonitorService : Service
 210 {
 211     protected Pid child_pid;
 212     protected int child_watch_id;
 213
 214     ScriptMonitorService()
 215     {
 216         child_pid = 0;
 217         child_watch_id = 0;
 218     }
 219
 220     protected bool script_start()
 221     {
 222         string command = zavai.config.homedir + "/" + name + " pre";
 223         try {
 224             // Then run our own script
 225             zavai.config.run_script(command);
 226         } catch (Error e) {
 227             zavai.log.error("Running " + command + ": " + e.message);
 228             return false;
 229         }
 230
 231         command = zavai.config.homedir + "/" + name + " run";
 232         zavai.log.info("Run program: " + command);
 233         string[] args = command.split(" ");
 234         try {
 235             Process.spawn_async(
 236                 Environment.get_home_dir(),
 237                 args,
 238                 null,
 239                 SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,
 240                 null,
 241                 out child_pid);
 242         } catch (SpawnError e) {
 243             zavai.log.error("Running " + command + ": " + e.message);
 244             return false;
 245         }
 246
 247         // Add a child watch source to know when it ends
 248         ChildWatch.add(child_pid, on_child);
 249
 250         return true;
 251     }
 252
 253     protected bool script_stop()
 254     {
 255         Posix.kill((Posix.pid_t)child_pid, Posix.SIGTERM);
 256         return true;
 257     }
 258
 259     protected void on_child(Pid pid, int status)
 260     {
 261         zavai.log.info("Exited");
 262 stderr.printf("STATUS %d\n", status);
 263         Process.close_pid(pid);
 264
 265         string command = zavai.config.homedir + "/" + name + " post";
 266         try {
 267             // Then run our own script
 268             zavai.config.run_script(command);
 269         } catch (Error e) {
 270             zavai.log.error("Running " + command + ": " + e.message);
 271             return;
 272         }
 273
 274         cleanup_after_script_stop();
 275
 276         base.stop();
 277     }
 278
 279     protected virtual void cleanup_after_script_stop()
 280     {
 281     }
 282
 283     /*
 284     protected bool script_status()
 285     {
 286     }
 287     */
 288 }
 289
 290 }