Example #1
0
 def __init__(self, component_name, *args, **kargs):
     ComponentBase.__init__(self, component_name, *args, **kargs)
     self.run_type = kargs.get("run_type", Foreground.RUN_TYPE)
     self.tracereader = TraceReader(self.tracedir, IN_TRACE)
     self.tracewriter = TraceWriter(self.tracedir, START_TRACE)
     self.starttracereader = TraceReader(self.tracedir, START_TRACE)
     self.check_installed_pkgs = kargs.get("check_installed_pkgs", True)
Example #2
0
 def __init__(self, component_name, *args, **kargs):
     ComponentBase.__init__(self, component_name, *args, **kargs)
     self.run_type = kargs.get("run_type", Foreground.RUN_TYPE)
     self.tracereader = TraceReader(self.tracedir, IN_TRACE)
     self.tracewriter = TraceWriter(self.tracedir, START_TRACE)
     self.starttracereader = TraceReader(self.tracedir, START_TRACE)
     self.check_installed_pkgs = kargs.get("check_installed_pkgs", True)
Example #3
0
class RabbitRuntime(ComponentBase, RuntimeComponent):
    def __init__(self, *args, **kargs):
        ComponentBase.__init__(self, TYPE, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def start(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if (len(pkgsinstalled) == 0):
            msg = "Can not start %s since it was not installed" % (TYPE)
            raise StartException(msg)
        if (self.status().find('start') == -1):
            self._run_cmd(START_CMD)
        return None

    def status(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if (len(pkgsinstalled) == 0):
            msg = "Can not check the status of %s since it was not installed" % (
                TYPE)
            raise StatusException(msg)
        (sysout, stderr) = execute(*STATUS_CMD, run_as_root=True)
        return sysout.strip().lower()

    def _run_cmd(self, cmd):
        if (self.distro == UBUNTU11):
            with TemporaryFile() as f:
                execute(*cmd, run_as_root=True, stdout_fh=f, stderr_fh=f)
        else:
            execute(*cmd, run_as_root=True)

    def restart(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if (len(pkgsinstalled) == 0):
            msg = "Can not check the status of %s since it was not installed" % (
                TYPE)
            raise RestartException(msg)
        self._run_cmd(RESTART_CMD)
        return None

    def stop(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if (len(pkgsinstalled) == 0):
            msg = "Can not stop %s since it was not installed" % (TYPE)
            raise StopException(msg)
        if (self.status().find('stop') == -1):
            self._run_cmd(STOP_CMD)
        return None
Example #4
0
class RabbitRuntime(ComponentBase, RuntimeComponent):
    def __init__(self, *args, **kargs):
        ComponentBase.__init__(self, TYPE, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def start(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if(len(pkgsinstalled) == 0):
            msg = "Can not start %s since it was not installed" % (TYPE)
            raise StartException(msg)
        if(self.status().find('start') == -1):
            self._run_cmd(START_CMD)
        return None

    def status(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if(len(pkgsinstalled) == 0):
            msg = "Can not check the status of %s since it was not installed" % (TYPE)
            raise StatusException(msg)
        (sysout, stderr) = execute(*STATUS_CMD, run_as_root=True)
        return sysout.strip().lower()

    def _run_cmd(self, cmd):
        if(self.distro == UBUNTU11):
            with TemporaryFile() as f:
                execute(*cmd, run_as_root=True,
                            stdout_fh=f, stderr_fh=f)
        else:
            execute(*cmd, run_as_root=True)    

    def restart(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if(len(pkgsinstalled) == 0):
            msg = "Can not check the status of %s since it was not installed" % (TYPE)
            raise RestartException(msg)
        self._run_cmd(RESTART_CMD)
        return None

    def stop(self):
        pkgsinstalled = self.tracereader.packages_installed()
        if(len(pkgsinstalled) == 0):
            msg = "Can not stop %s since it was not installed" % (TYPE)
            raise StopException(msg)
        if(self.status().find('stop') == -1):
            self._run_cmd(STOP_CMD)
        return None
Example #5
0
class PkgUninstallComponent(ComponentBase, UninstallComponent):
    def __init__(self, component_name, *args, **kargs):
        ComponentBase.__init__(self, component_name, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def unconfigure(self):
        self._unconfigure_files()

    def _unconfigure_files(self):
        cfgfiles = self.tracereader.files_configured()
        if (len(cfgfiles)):
            LOG.info("Removing %s configuration files" % (len(cfgfiles)))
            for fn in cfgfiles:
                if (len(fn)):
                    unlink(fn)
                    LOG.info("Removed %s" % (fn))

    def uninstall(self):
        self._uninstall_pkgs()
        self._uninstall_touched_files()
        self._uninstall_dirs()

    def _uninstall_pkgs(self):
        pkgsfull = self.tracereader.packages_installed()
        if (len(pkgsfull)):
            LOG.info("Potentially removing %s packages" % (len(pkgsfull)))
            self.packager.remove_batch(pkgsfull)

    def _uninstall_touched_files(self):
        filestouched = self.tracereader.files_touched()
        if (len(filestouched)):
            LOG.info("Removing %s touched files" % (len(filestouched)))
            for fn in filestouched:
                if (len(fn)):
                    unlink(fn)
                    LOG.info("Removed %s" % (fn))

    def _uninstall_dirs(self):
        dirsmade = self.tracereader.dirs_made()
        if (len(dirsmade)):
            LOG.info("Removing %s created directories" % (len(dirsmade)))
            for dirname in dirsmade:
                deldir(dirname)
                LOG.info("Removed %s" % (dirname))
Example #6
0
class PkgUninstallComponent(ComponentBase, UninstallComponent):
    def __init__(self, component_name, *args, **kargs):
        ComponentBase.__init__(self, component_name, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def unconfigure(self):
        self._unconfigure_files()

    def _unconfigure_files(self):
        cfgfiles = self.tracereader.files_configured()
        if(len(cfgfiles)):
            LOG.info("Removing %s configuration files" % (len(cfgfiles)))
            for fn in cfgfiles:
                if(len(fn)):
                    unlink(fn)
                    LOG.info("Removed %s" % (fn))

    def uninstall(self):
        self._uninstall_pkgs()
        self._uninstall_touched_files()
        self._uninstall_dirs()

    def _uninstall_pkgs(self):
        pkgsfull = self.tracereader.packages_installed()
        if(len(pkgsfull)):
            LOG.info("Potentially removing %s packages" % (len(pkgsfull)))
            self.packager.remove_batch(pkgsfull)

    def _uninstall_touched_files(self):
        filestouched = self.tracereader.files_touched()
        if(len(filestouched)):
            LOG.info("Removing %s touched files" % (len(filestouched)))
            for fn in filestouched:
                if(len(fn)):
                    unlink(fn)
                    LOG.info("Removed %s" % (fn))

    def _uninstall_dirs(self):
        dirsmade = self.tracereader.dirs_made()
        if(len(dirsmade)):
            LOG.info("Removing %s created directories" % (len(dirsmade)))
            for dirname in dirsmade:
                deldir(dirname)
                LOG.info("Removed %s" % (dirname))
Example #7
0
class DBRuntime(ComponentBase, RuntimeComponent):
    def __init__(self, *args, **kargs):
        ComponentBase.__init__(self, TYPE, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def _gettypeactions(self, act, exception_cls):
        pkgsinstalled = self.tracereader.packages_installed()
        if(len(pkgsinstalled) == 0):
            msg = "Can not %s %s since it was not installed" % (act, TYPE)
            raise exception_cls(msg)
        #figure out how to do it
        dbtype = self.cfg.get("db", "type")
        typeactions = DB_ACTIONS.get(dbtype)
        if(typeactions == None or not typeactions.get(act)):
            msg = BASE_ERROR % (act, dbtype)
            raise NotImplementedError(msg)
        return typeactions.get(act)

    def start(self):
        if(self.status().find('start') == -1):
            startcmd = self._gettypeactions('start', StartException)
            execute(*startcmd, run_as_root=True)
        return None

    def stop(self):
        if(self.status().find('stop') == -1):
            stopcmd = self._gettypeactions('stop', StopException)
            execute(*stopcmd, run_as_root=True)
        return None

    def restart(self):
        restartcmd = self._gettypeactions('restart', RestartException)
        execute(*restartcmd, run_as_root=True)
        return None

    def status(self):
        statuscmd = self._gettypeactions('status', StatusException)
        (sysout, stderr) = execute(*statuscmd, run_as_root=True)
        return sysout.strip()
Example #8
0
class DBRuntime(ComponentBase, RuntimeComponent):
    def __init__(self, *args, **kargs):
        ComponentBase.__init__(self, TYPE, *args, **kargs)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)

    def _gettypeactions(self, act, exception_cls):
        pkgsinstalled = self.tracereader.packages_installed()
        if (len(pkgsinstalled) == 0):
            msg = "Can not %s %s since it was not installed" % (act, TYPE)
            raise exception_cls(msg)
        #figure out how to do it
        dbtype = self.cfg.get("db", "type")
        typeactions = DB_ACTIONS.get(dbtype)
        if (typeactions == None or not typeactions.get(act)):
            msg = BASE_ERROR % (act, dbtype)
            raise NotImplementedError(msg)
        return typeactions.get(act)

    def start(self):
        if (self.status().find('start') == -1):
            startcmd = self._gettypeactions('start', StartException)
            execute(*startcmd, run_as_root=True)
        return None

    def stop(self):
        if (self.status().find('stop') == -1):
            stopcmd = self._gettypeactions('stop', StopException)
            execute(*stopcmd, run_as_root=True)
        return None

    def restart(self):
        restartcmd = self._gettypeactions('restart', RestartException)
        execute(*restartcmd, run_as_root=True)
        return None

    def status(self):
        statuscmd = self._gettypeactions('status', StatusException)
        (sysout, stderr) = execute(*statuscmd, run_as_root=True)
        return sysout.strip()
Example #9
0
class ProgramRuntime(ComponentBase, RuntimeComponent):
    #this here determines how we start and stop and
    #what classes handle different running/stopping types
    STARTER_CLS_MAPPING = {
        Foreground.RUN_TYPE: ForegroundRunner,
        Screen.RUN_TYPE: ScreenRunner,
    }
    STOPPER_CLS_MAPPING = {
        Foreground.RUN_TYPE: ForegroundRunner,
        Screen.RUN_TYPE: ScreenRunner,
    }

    def __init__(self, component_name, *args, **kargs):
        ComponentBase.__init__(self, component_name, *args, **kargs)
        self.run_type = kargs.get("run_type", Foreground.RUN_TYPE)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)
        self.tracewriter = TraceWriter(self.tracedir, START_TRACE)
        self.starttracereader = TraceReader(self.tracedir, START_TRACE)
        self.check_installed_pkgs = kargs.get("check_installed_pkgs", True)

    def _getstartercls(self, start_mode):
        if (start_mode not in ProgramRuntime.STARTER_CLS_MAPPING):
            raise NotImplementedError("Can not yet start %s mode" %
                                      (start_mode))
        return ProgramRuntime.STARTER_CLS_MAPPING.get(start_mode)

    def _getstoppercls(self, stop_mode):
        if (stop_mode not in ProgramRuntime.STOPPER_CLS_MAPPING):
            raise NotImplementedError("Can not yet stop %s mode" % (stop_mode))
        return ProgramRuntime.STOPPER_CLS_MAPPING.get(stop_mode)

    def _was_installed(self):
        if (not self.check_installed_pkgs):
            return True
        if (len(self.tracereader.packages_installed())):
            return True
        return False

    def _get_apps_to_start(self):
        raise NotImplementedError()

    def _get_app_options(self, app):
        return None

    def _get_param_map(self, app=None):
        return {
            'ROOT': self.appdir,
        }

    def start(self):
        #ensure it was installed
        if (not self._was_installed()):
            msg = "Can not start %s since it was not installed" % (
                self.component_name)
            raise StartException(msg)
        #select how we are going to start it
        startercls = self._getstartercls()
        starter = startercls()
        #start all apps
        #this fns list will have info about what was started
        fns = list()
        apps = self._get_apps_to_start()
        for app in apps:
            #adjust the program options now that we have real locations
            params = self._get_param_map(app)
            program_opts = self._get_app_options(app)
            if (params and program_opts):
                adjusted_opts = list()
                for opt in program_opts:
                    adjusted_opts.append(param_replace(opt, params))
                program_opts = adjusted_opts
            LOG.info("Starting %s with options [%s]" %
                     (app, ", ".join(program_opts)))
            #start it with the given settings
            fn = starter.start(app,
                               app,
                               *program_opts,
                               app_dir=self.appdir,
                               trace_dir=self.tracedir)
            if (fn and len(fn)):
                fns.append(fn)
                LOG.info("Started %s, details are in %s" % (app, fn))
                #this trace is used to locate details about what to stop
                self.tracewriter.started_info(app, fn)
            else:
                LOG.info("Started %s" % (app))
        return fns

    def stop(self):
        #ensure it was installed
        if (not self._was_installed()):
            msg = "Can not stop %s since it was not installed" % (
                self.component_name)
            raise StopException(msg)
        #we can only stop what has a started trace
        start_traces = self.starttracereader.apps_started()
        killedam = 0
        for mp in start_traces:
            #extract the apps name and where its trace is
            fn = mp.get('trace_fn')
            name = mp.get('name')
            #missing some key info, skip it
            if (fn == None or name == None):
                continue
            #figure out which class will stop it
            contents = parse_fn(fn)
            killcls = None
            for (cmd, action) in contents:
                if (cmd == Runner.RUN_TYPE):
                    killcls = self._getstoppercls(action)
                    break
            #did we find a class that can do it?
            if (killcls):
                #we can try to stop it
                LOG.info("Stopping %s" % (name))
                #create an instance of the killer class and attempt to stop
                killer = killcls()
                killer.stop(name, trace_dir=self.tracedir)
                killedam += 1
        #if we got rid of them all get rid of the trace
        if (killedam == len(start_traces)):
            fn = self.starttracereader.trace_fn
            LOG.info("Deleting trace file %s" % (fn))
            unlink(fn)
Example #10
0
 def __init__(self, component_name, *args, **kargs):
     ComponentBase.__init__(self, component_name, *args, **kargs)
     self.tracereader = TraceReader(self.tracedir, IN_TRACE)
Example #11
0
 def __init__(self, *args, **kargs):
     ComponentBase.__init__(self, TYPE, *args, **kargs)
     self.tracereader = TraceReader(self.tracedir, IN_TRACE)
Example #12
0
class ProgramRuntime(ComponentBase, RuntimeComponent):
    #this here determines how we start and stop and 
    #what classes handle different running/stopping types
    STARTER_CLS_MAPPING = {
        Foreground.RUN_TYPE: ForegroundRunner,
        Screen.RUN_TYPE: ScreenRunner,
    }
    STOPPER_CLS_MAPPING = {
        Foreground.RUN_TYPE: ForegroundRunner,
        Screen.RUN_TYPE: ScreenRunner,
    }
    def __init__(self, component_name, *args, **kargs):
        ComponentBase.__init__(self, component_name, *args, **kargs)
        self.run_type = kargs.get("run_type", Foreground.RUN_TYPE)
        self.tracereader = TraceReader(self.tracedir, IN_TRACE)
        self.tracewriter = TraceWriter(self.tracedir, START_TRACE)
        self.starttracereader = TraceReader(self.tracedir, START_TRACE)
        self.check_installed_pkgs = kargs.get("check_installed_pkgs", True)

    def _getstartercls(self, start_mode):
        if(start_mode not in ProgramRuntime.STARTER_CLS_MAPPING):
            raise NotImplementedError("Can not yet start %s mode" % (start_mode))
        return ProgramRuntime.STARTER_CLS_MAPPING.get(start_mode)

    def _getstoppercls(self, stop_mode):
        if(stop_mode not in ProgramRuntime.STOPPER_CLS_MAPPING):
            raise NotImplementedError("Can not yet stop %s mode" % (stop_mode))
        return ProgramRuntime.STOPPER_CLS_MAPPING.get(stop_mode)

    def _was_installed(self):
        if(not self.check_installed_pkgs):
            return True
        if(len(self.tracereader.packages_installed())):
            return True
        return False

    def _get_apps_to_start(self):
        raise NotImplementedError()

    def _get_app_options(self, app):
        return None

    def _get_param_map(self, app=None):
        return {
            'ROOT': self.appdir,
        }

    def start(self):
        #ensure it was installed
        if(not self._was_installed()):
            msg = "Can not start %s since it was not installed" % (self.component_name)
            raise StartException(msg)
        #select how we are going to start it
        startercls = self._getstartercls()
        starter = startercls()
        #start all apps
        #this fns list will have info about what was started
        fns = list()
        apps = self._get_apps_to_start()
        for app in apps:
            #adjust the program options now that we have real locations
            params = self._get_param_map(app)
            program_opts = self._get_app_options(app)
            if(params and program_opts):
                adjusted_opts = list()
                for opt in program_opts:
                    adjusted_opts.append(param_replace(opt, params))
                program_opts = adjusted_opts
            LOG.info("Starting %s with options [%s]" % (app, ", ".join(program_opts)))
            #start it with the given settings
            fn = starter.start(app, app, *program_opts, app_dir=self.appdir, trace_dir=self.tracedir)
            if(fn and len(fn)):
                fns.append(fn)
                LOG.info("Started %s, details are in %s" % (app, fn))
                #this trace is used to locate details about what to stop
                self.tracewriter.started_info(app, fn)
            else:
                LOG.info("Started %s" % (app))
        return fns

    def stop(self):
        #ensure it was installed
        if(not self._was_installed()):
            msg = "Can not stop %s since it was not installed" % (self.component_name)
            raise StopException(msg)
        #we can only stop what has a started trace
        start_traces = self.starttracereader.apps_started()
        killedam = 0
        for mp in start_traces:
            #extract the apps name and where its trace is
            fn = mp.get('trace_fn')
            name = mp.get('name')
            #missing some key info, skip it
            if(fn == None or name == None):
                continue
            #figure out which class will stop it
            contents = parse_fn(fn)
            killcls = None
            for (cmd, action) in contents:
                if(cmd == Runner.RUN_TYPE):
                    killcls = self._getstoppercls(action)
                    break
            #did we find a class that can do it?
            if(killcls):
                #we can try to stop it
                LOG.info("Stopping %s" % (name))
                #create an instance of the killer class and attempt to stop
                killer = killcls()
                killer.stop(name, trace_dir=self.tracedir)
                killedam += 1
        #if we got rid of them all get rid of the trace
        if(killedam == len(start_traces)):
            fn = self.starttracereader.trace_fn
            LOG.info("Deleting trace file %s" % (fn))
            unlink(fn)