Ejemplo n.º 1
0
    def on_restart(self, process, config, **kwargs):
        self.process = process
        inst_objs, _ = process.container.resource_registry.find_resources(restype=RT.Instrument, id_only=False)
        active_agents = []
        for inst in inst_objs:
            if len(inst.agent_state) >= 1:
                active_agents.append(inst._id)

        if not active_agents:
            return

        log.info("Restarting %s agents: %s", len(active_agents), active_agents)

        svc_client = ScionManagementProcessClient(process=process)
        for inst_id in active_agents:
            try:
                svc_client.start_agent(inst_id)
            except Exception as ex:
                log.exception("Cannot restart agent for %s" % inst_id)
                if "Agent already active" in ex.message:
                    try:
                        svc_client.stop_agent(inst_id)
                    except Exception:
                        pass
                    try:
                        svc_client.start_agent(inst_id)
                    except Exception:
                        log.warn("Agent stop/start for %s unsuccessful" % inst_id)
Ejemplo n.º 2
0
    def on_init(self):
        self.process = getattr(self, "process", None) or self

        self.rr = self.container.resource_registry
        self.idm_client = IdentityManagementServiceProcessClient(process=self.process)
        self.org_client = OrgManagementServiceProcessClient(process=self.process)
        self.scion_client = ScionManagementProcessClient(process=self.process)

        self.op = self.CFG.get("op", "load")

        if self.op == "auto":
            self.do_auto_preload()
        elif self.op == "init":
            pass  # Initialization only for explicit call
        elif self.op == "load":
            preload_master = CFG.get_safe("scion.preload.default_master")
            if preload_master:
                self.do_preload_master(preload_master)
        else:
            raise BadRequest("Unknown command")
Ejemplo n.º 3
0
class ScionLoader(ImmediateProcess, Preloader):

    def on_init(self):
        self.process = getattr(self, "process", None) or self

        self.rr = self.container.resource_registry
        self.idm_client = IdentityManagementServiceProcessClient(process=self.process)
        self.org_client = OrgManagementServiceProcessClient(process=self.process)
        self.scion_client = ScionManagementProcessClient(process=self.process)

        self.op = self.CFG.get("op", "load")

        if self.op == "auto":
            self.do_auto_preload()
        elif self.op == "init":
            pass  # Initialization only for explicit call
        elif self.op == "load":
            preload_master = CFG.get_safe("scion.preload.default_master")
            if preload_master:
                self.do_preload_master(preload_master)
        else:
            raise BadRequest("Unknown command")

    def do_preload_core(self):
        client_obj = IonObject(RT.ActorIdentity, name="SciON UI Client",
                               details=IonObject(OT.OAuthClientIdentityDetails, default_scopes="scion"))
        client_actor_id = self.idm_client.create_actor_identity(client_obj)
        client_id = "client:scion_ui"
        self.idm_client.set_actor_credentials(client_actor_id, client_id, "client_secret")
        return True

    def do_auto_preload(self):
        """ Load configured preload scenarios and remembers in directory which ones
        have been loaded. """
        log.info("Executing auto preload")
        preload_entries = self.process.container.directory.lookup("/System/Preload")
        preload_changed = False
        if preload_entries is None:
            preload_entries = dict(scenarios={})
            preload_changed = True

        # "HACK" Preload core to get app specifics in
        if "core" not in preload_entries["scenarios"]:
            preload_entries["scenarios"]["core"] = self._get_dir_entry("core")
            self.do_preload_core()
            preload_changed = True

        preload_scenarios = CFG.get_safe("scion.preload.scenarios") or []
        preload_scope = CFG.get_safe("scion.preload.scope")
        for scenario_info in preload_scenarios:
            scope, scenario = scenario_info
            if scope == "all" or scope == preload_scope:
                if scenario not in preload_entries["scenarios"]:
                    preload_entries["scenarios"][scenario] = self._get_dir_entry(scenario)
                    changed = self.do_preload_master(scenario)
                    preload_changed = preload_changed or changed

        if preload_changed:
            self.process.container.directory.register("/System", "Preload", scenarios=preload_entries["scenarios"])

    def _get_dir_entry(self, scenario):
        return dict(ts=get_ion_ts(), name=scenario, sys_name=get_sys_name())

    def do_preload_master(self, master):
        if CFG.get_safe("scion.preload.enabled", False) is not True:
            return False
        log.info("############## PRELOAD SCION RESOURCES (%s) ##############", master)

        skip_steps = CFG.get_safe("skipsteps")
        if skip_steps:
            skip_steps = skip_steps.split(",")
        self.initialize_preloader(self.process, {})

        if os.path.isdir("res/preload/{}".format(master)):
            self.preload_master("res/preload/{}/actions.yml".format(master), skip_steps=skip_steps)
        elif os.path.exists("res/preload/{}".format(master)):
            self.preload_master("res/preload/{}".format(master), skip_steps=skip_steps)
        else:
            raise BadRequest("Cannot find preload master")

        log.info("############## END PRELOAD ##############")
        return True


    # -------------------------------------------------------------------------
    # Action callbacks

    def _load_preload_CommitBulk(self, action_cfg):
        self.commit_bulk()

    def _load_resource_CORE_CreateRole(self, action_cfg):
        org_name = action_cfg["org"]
        role_name = action_cfg["role"]
        org_obj = self.org_client.find_org(org_name)
        role_obj = IonObject(RT.UserRole, name=role_name, governance_name=role_name,
                             description="Role %s.%s" % (org_name, role_name))

        self.org_client.add_org_role(org_obj._id, role_obj, headers=self._get_system_actor_headers())

    def _load_resource_APP_ScionUser(self, action_cfg):
        actor_obj = self.create_object_from_cfg(action_cfg, RT.ActorIdentity)
        username, password = action_cfg["username"], action_cfg.get("password", None)
        user_alias = action_cfg[KEY_ID]
        if user_alias in self.resource_ids:
            log.info("Skipping existing user '%s', alias=%s", username, user_alias)
            return
        log.debug("Preload user '%s', alias=%s", username, user_alias)

        actor_id = self.scion_client.define_user(
                first_name=actor_obj.details.contact.individual_names_given,
                last_name=actor_obj.details.contact.individual_name_family,
                username=username, password=password, email=actor_obj.details.contact.email,
                attributes=actor_obj.details.profile)
        self.scion_client.update_user_contact(actor_id, actor_obj.details.contact)

        res_obj = self.container.resource_registry.read(actor_id)
        res_obj.alt_ids += ['PRE:'+action_cfg[KEY_ID]]
        self.container.resource_registry.update(res_obj)
        self._register_id(action_cfg[KEY_ID], actor_id, res_obj)

        # Roles
        roles = action_cfg.get("roles", [])
        for role in roles:
            org_name, role_name = role.split(".", 1)
            org_obj = self.org_client.find_org(org_name)
            self.org_client.grant_role(org_obj._id, actor_id, role_name, headers=self._get_system_actor_headers())

    def _load_resource_Instrument(self, action_cfg):
        if action_cfg[KEY_ID] in self.resource_ids:
            return
        res_id = self.basic_resource_create(action_cfg, RT.Instrument, "resource_registry", "create", support_bulk=True)
        self.basic_associations_create(action_cfg, action_cfg[KEY_ID], support_bulk=True)

    def _load_resource_Dataset(self, action_cfg):
        if action_cfg[KEY_ID] in self.resource_ids:
            return
        schema_def = {}
        if "schema_def" in action_cfg:
            schema_def = DataSchemaParser.parse_schema_ref(action_cfg["schema_def"])
        if "schema_override" in action_cfg:
            dict_merge(schema_def, action_cfg["schema_override"], inplace=True)
        res_id = self.basic_resource_create(action_cfg, RT.Dataset, "resource_registry", "create", support_bulk=True,
                                            set_attributes=dict(schema_definition=schema_def))
        self.basic_associations_create(action_cfg, action_cfg[KEY_ID], support_bulk=True)

    def _load_action_StartAgent(self, action_cfg):
        asset_id = action_cfg["asset_id"]
        agent_res_id = self.resource_ids[asset_id]
        self.scion_client.start_agent(agent_res_id)

    def _load_action_StopAgent(self, action_cfg):
        asset_id = action_cfg["asset_id"]
        agent_res_id = self.resource_ids[asset_id]
        self.scion_client.stop_agent(agent_res_id)
Ejemplo n.º 4
0
 def __init__(self, app, adminui):
     log.info("Initialized AdminUI extension for SciON")
     self.app = app
     self.adminui = adminui
     self.rr = Container.instance.resource_registry
     self.scion_client = ScionManagementProcessClient(process=self.adminui)
Ejemplo n.º 5
0
class AdminUIExtension(object):
    def __init__(self, app, adminui):
        log.info("Initialized AdminUI extension for SciON")
        self.app = app
        self.adminui = adminui
        self.rr = Container.instance.resource_registry
        self.scion_client = ScionManagementProcessClient(process=self.adminui)

    def system_commands(self, fragments):
        fragments.append(
            build_command("Reload access policy", "/cmd/sys_reload_policy"))
        fragments.append(
            build_command("Run preload scenario", "/cmd/sys_run_preload"))
        fragments.append(build_command("Create user", "/cmd/sys_create_user"))

    def resource_commands(self, resource_id, restype, fragments):
        if restype == "Instrument":
            fragments.append(
                build_command("Start agent",
                              "/cmd/start_agent?rid=%s" % resource_id))
            fragments.append(
                build_command("Stop agent",
                              "/cmd/stop_agent?rid=%s" % resource_id))

    # -------------------------------------------------------------------------

    def _process_cmd_start_agent(self, resource_id, res_obj=None):
        msg_lines = []
        res = self.scion_client.start_agent(resource_id)

        msg_text = "<br>".join(msg_lines) + "<br><br>"

        return "%sOK. Started agent for %s '%s'<br><br>" % (
            msg_text, res_obj.type_, resource_id)

    def _process_cmd_stop_agent(self, resource_id, res_obj=None):
        msg_lines = []
        res = self.scion_client.stop_agent(resource_id)

        msg_text = "<br>".join(msg_lines) + "<br><br>"

        return "%sOK. Stopped agent for %s '%s'<br><br>" % (
            msg_text, res_obj.type_, resource_id)

    # -------------------------------------------------------------------------

    def _process_cmd_sys_reload_policy(self, resource_id, res_obj=None):
        policy_ids, _ = self.rr.find_resources(RT.Policy, id_only=True)
        for pol_id in policy_ids:
            self.rr.delete(pol_id)

        from ion.process.bootstrap.load_system_policy import LoadSystemPolicy
        LoadSystemPolicy.op_load_system_policies(self.adminui)

        new_policy_ids, _ = self.rr.find_resources(RT.Policy, id_only=True)

        msg_text = "Deleted %s policies.<br>Added %s new policies.<br><br>OK." % (
            len(policy_ids), len(new_policy_ids))

        return msg_text

    def _process_cmd_sys_run_preload(self, resource_id, res_obj=None):
        fragments = []
        if get_arg("scenario"):
            scenario = get_arg("scenario")
            if scenario:
                from scion.process.preload.preloader import ScionLoader
                preloader = ScionLoader()
                preloader.container = Container.instance
                preloader.process = self.adminui
                preloader.CFG = dict(op="init")
                preloader.on_init()

                preloader.do_preload_master(scenario)
                fragments.append("Preload scenario '%s' executed.<br>OK" %
                                 scenario)
            else:
                fragments.append("Invalid arguments for scenario.")

        else:
            fragments.append("</pre><h2>Run Preload Scenario</h2>")
            fragments.append(
                "<form id='form_run_preload' action='%s' method='post'>" %
                _link('/cmd/sys_run_preload'))
            fragments.append("Scenario: <input name='scenario'><br>")
            fragments.append(
                "<input name='submit' type='submit' value='Run'><br>")
            fragments.append("</form>")
            fragments.append("<pre>")

        msg_text = "".join(fragments)
        return msg_text

    def _process_cmd_sys_create_user(self, resource_id, res_obj=None):
        fragments = []
        if get_arg("email"):
            first, last, email, password = get_arg("first_name"), get_arg(
                "last_name"), get_arg("email"), get_arg("password")
            if first and last and email and password:
                sys_headers = get_system_actor_header()
                self.scion_client.define_user(None,
                                              first,
                                              last,
                                              email,
                                              password,
                                              email=email,
                                              headers=sys_headers)
                fragments.append("User '%s' created.<br>OK" % email)
            else:
                fragments.append("Invalid arguments to create user.")

        else:
            fragments.append("</pre><h2>Create User</h2>")
            fragments.append(
                "<form id='form_user_create' action='%s' method='post'>" %
                _link('/cmd/sys_create_user'))
            fragments.append("First name: <input name='first_name'><br>")
            fragments.append("Last name: <input name='last_name'><br>")
            fragments.append("Email: <input name='email' type='email'><br>")
            fragments.append(
                "Password: <input name='password' type='password'><br><br>")
            fragments.append(
                "<input name='submit' type='submit' value='Create'><br>")
            fragments.append("</form>")
            fragments.append("<pre>")

        msg_text = "".join(fragments)
        return msg_text
Ejemplo n.º 6
0
 def __init__(self, app, adminui):
     log.info("Initialized AdminUI extension for SciON")
     self.app = app
     self.adminui = adminui
     self.rr = Container.instance.resource_registry
     self.scion_client = ScionManagementProcessClient(process=self.adminui)
Ejemplo n.º 7
0
class AdminUIExtension(object):

    def __init__(self, app, adminui):
        log.info("Initialized AdminUI extension for SciON")
        self.app = app
        self.adminui = adminui
        self.rr = Container.instance.resource_registry
        self.scion_client = ScionManagementProcessClient(process=self.adminui)

    def system_commands(self, fragments):
        fragments.append(build_command("Reload access policy", "/cmd/sys_reload_policy"))
        fragments.append(build_command("Run preload scenario", "/cmd/sys_run_preload"))
        fragments.append(build_command("Create user", "/cmd/sys_create_user"))

    def resource_commands(self, resource_id, restype, fragments):
        if restype == "Instrument":
            fragments.append(build_command("Start agent", "/cmd/start_agent?rid=%s" % resource_id))
            fragments.append(build_command("Stop agent", "/cmd/stop_agent?rid=%s" % resource_id))

    # -------------------------------------------------------------------------

    def _process_cmd_start_agent(self, resource_id, res_obj=None):
        msg_lines = []
        res = self.scion_client.start_agent(resource_id)

        msg_text = "<br>".join(msg_lines) + "<br><br>"

        return "%sOK. Started agent for %s '%s'<br><br>" % (msg_text, res_obj.type_, resource_id)

    def _process_cmd_stop_agent(self, resource_id, res_obj=None):
        msg_lines = []
        res = self.scion_client.stop_agent(resource_id)

        msg_text = "<br>".join(msg_lines) + "<br><br>"

        return "%sOK. Stopped agent for %s '%s'<br><br>" % (msg_text, res_obj.type_, resource_id)

    # -------------------------------------------------------------------------

    def _process_cmd_sys_reload_policy(self, resource_id, res_obj=None):
        policy_ids, _ = self.rr.find_resources(RT.Policy, id_only=True)
        for pol_id in policy_ids:
            self.rr.delete(pol_id)

        from ion.process.bootstrap.load_system_policy import LoadSystemPolicy
        LoadSystemPolicy.op_load_system_policies(self.adminui)

        new_policy_ids, _ = self.rr.find_resources(RT.Policy, id_only=True)

        msg_text = "Deleted %s policies.<br>Added %s new policies.<br><br>OK." % (len(policy_ids), len(new_policy_ids))

        return msg_text

    def _process_cmd_sys_run_preload(self, resource_id, res_obj=None):
        fragments = []
        if get_arg("scenario"):
            scenario = get_arg("scenario")
            if scenario:
                from scion.process.preload.preloader import ScionLoader
                preloader = ScionLoader()
                preloader.container = Container.instance
                preloader.process = self.adminui
                preloader.CFG = dict(op="init")
                preloader.on_init()

                preloader.do_preload_master(scenario)
                fragments.append("Preload scenario '%s' executed.<br>OK" % scenario)
            else:
                fragments.append("Invalid arguments for scenario.")

        else:
            fragments.append("</pre><h2>Run Preload Scenario</h2>")
            fragments.append("<form id='form_run_preload' action='%s' method='post'>" % _link('/cmd/sys_run_preload'))
            fragments.append("Scenario: <input name='scenario'><br>")
            fragments.append("<input name='submit' type='submit' value='Run'><br>")
            fragments.append("</form>")
            fragments.append("<pre>")

        msg_text = "".join(fragments)
        return msg_text

    def _process_cmd_sys_create_user(self, resource_id, res_obj=None):
        fragments = []
        if get_arg("email"):
            first, last, email, password = get_arg("first_name"), get_arg("last_name"), get_arg("email"), get_arg(
                "password")
            if first and last and email and password:
                sys_headers = get_system_actor_header()
                self.scion_client.define_user(None, first, last, email, password, email=email, headers=sys_headers)
                fragments.append("User '%s' created.<br>OK" % email)
            else:
                fragments.append("Invalid arguments to create user.")

        else:
            fragments.append("</pre><h2>Create User</h2>")
            fragments.append("<form id='form_user_create' action='%s' method='post'>" % _link('/cmd/sys_create_user'))
            fragments.append("First name: <input name='first_name'><br>")
            fragments.append("Last name: <input name='last_name'><br>")
            fragments.append("Email: <input name='email' type='email'><br>")
            fragments.append("Password: <input name='password' type='password'><br><br>")
            fragments.append("<input name='submit' type='submit' value='Create'><br>")
            fragments.append("</form>")
            fragments.append("<pre>")

        msg_text = "".join(fragments)
        return msg_text