def api_scripts(self, request, id): o = self.get_object_or_404(ManagedObject, id=id) if not o.has_access(request.user): return self.response_forbidden("Access denied") r = [] for s in o.scripts: sn = o.profile.name + "." + s script = script_loader.get_script(sn) if not script: self.logger.error("Failed to load script: %s", sn) continue interface = script.interface() ss = { "name": s, "has_input": any(interface.gen_parameters()), "require_input": interface.has_required_params, "form": interface.get_form(), "preview": interface.preview or "NOC.sa.managedobject.scripts.JSONPreview", } r += [ss] return r
def handle_run(self, path, storage, script, pretty=False, yaml=False, access_preference="SC", arguments=None, *args, **options): from noc.core.script.loader import loader st = self.get_storage(storage, beef=True) beef = self.get_beef(st, path) # Build credentials credentials = { "address": beef.uuid, "cli_protocol": "beef", "beef_storage_url": st.url, "beef_path": path, "access_preference": access_preference, "snmp_ro": "public", } # Get capabilities caps = {} # Parse arguments script_args = self.get_script_args(arguments or []) # Run script service = ServiceStub(pool="default") for s_name in script: if "." not in script: s_name = "%s.%s" % (beef.box.profile, s_name) scls = loader.get_script(s_name) if not scls: self.die("Failed to load script '%s'" % script) scr = scls( service=service, credentials=credentials, capabilities=caps, version={ "vendor": beef.box.vendor, "platform": beef.box.platform, "version": beef.box.version, }, timeout=3600, name=s_name, args=script_args, ) result = scr.run() if pretty: import pprint pprint.pprint(result) elif yaml: import yaml import sys yaml.dump(result, sys.stdout, indent=2) else: self.stdout.write("%s\n" % result)
def test_script_name(sa_script): script = loader.get_script(sa_script) assert getattr(script, "name"), "Script should has name" req_name = script.__module__ if req_name.startswith("noc.sa.profiles."): req_name = req_name[16:] assert script.name == req_name
def __call__(self, **kwargs): script_name = "%s.%s" % (self.object.profile.name, self.name) scls = loader.get_script(script_name) # Build credentials credentials = { "address": self.object.address, "cli_protocol": "beef", "beef_storage_url": self.object._beef_storage, "beef_path": self.object._beef_path, "access-preference": "CS", "snmp_ro": "public", } # Build version if self.object.vendor and self.object.platform and self.object.version: version = { "vendor": self.object.vendor.code, "platform": self.object.platform.name, "version": self.object.version.version, } if self.object.software_image: version["image"] = self.object.software_image else: version = None # scr = scls( service=get_service(self.object.pool.name), credentials=credentials, capabilities=ObjectCapabilities.get_capabilities(self.object.id), version=version, timeout=3600, name=script_name, args=kwargs, ) return scr.run()
def handle(self, script, object_name, arguments, pretty, yaml, use_snmp, access_preference, update_spec, *args, **options): # Get object obj = self.get_object(object_name[0]) # Build credentials credentials = self.get_credentials(obj) # Parse arguments args = self.get_script_args(arguments) # Load script script = script[0] if "." not in script: script = "%s.%s" % (obj.profile.name, script) script_class = loader.get_script(script) if not script_class: self.die("Failed to load script %s" % script_class) # Get capabilities caps = obj.get_caps() # if not use_snmp: if "snmp_ro" in credentials: del credentials["snmp_ro"] if "SNMP" in caps: del caps["SNMP"] if access_preference: credentials["access_preference"] = access_preference # Get version info if obj.version: version = { "vendor": obj.vendor.name if obj.vendor else None, "platform": obj.platform.name if obj.platform else None, "version": obj.version.version if obj.version else None } else: version = None # Run script service = ServiceStub(pool=obj.pool.name) scr = script_class(service=service, credentials=credentials, capabilities=caps, args=args, version=version, timeout=3600, name=script) span_sample = 1 if update_spec else 0 with Span(sample=span_sample): result = scr.run() if pretty: pprint.pprint(result) elif yaml: import yaml import sys yaml.dump(result, sys.stdout) else: self.stdout.write("%s\n" % result) if update_spec: self.update_spec(update_spec, scr)
def script( self, name, credentials, capabilities=None, version=None, args=None, timeout=None, session=None, session_idle_timeout=None, ): """ Execute SA script :param name: Script name (with profile) :param credentials: Dict containing following fields * cli_protocol - CLI protocol (telnet, ssh) * address - IP address * cli_port (optional) - Non-standard CLI port * user (optional) - Login as user * password (optional) - User password * super_password (optional) - Enable password * snmp_version (optional) - Use SNMP version (None, v2c) * snmp_ro (optional) - Use SNMP R/O community * path (optional) - unstructured path * snmp_rate_limit (optional) - limit of outgoing snmp requests (float, in requests per second) :param capabilities: Dict of discovered capabilities :param version: Dict of discovered version :param timeout: Script timeout, in seconds :param session: Unique session id to share CLI stream :param session_idle_timeout: Hold CLI stream up to session_idle_timeout seconds after script completion """ script_class = loader.get_script(name) if not script_class: metrics["error", ("type", "invalid_script")] += 1 raise APIError("Invalid script: %s" % name) script = script_class( service=self.service, credentials=credentials, args=args, capabilities=capabilities, version=version, timeout=timeout, name=name, session=session, session_idle_timeout=session_idle_timeout, ) try: result = script.run() except script.ScriptError as e: metrics["error", ("type", "script_error")] += 1 raise APIError("Script error: %s" % e.__doc__) return result
def test_beef(beef_test): fs, path = beef_test test = ujson.loads(bz2.decompress(fs.getbytes(path))) service = ServiceStub(pool="default") # Load script script = test["script"] scls = loader.get_script(script) assert scls # Build credentials # @todo: Input scr = scls(service=service, credentials=test["credentials"], capabilities=test["capabilities"], version=test["version"], timeout=3600, name=script) result = scr.run() assert result == test["result"]
def handle_build_test_case(self, test_storage, test_path, cfg=None, *args, **options): import bz2 from noc.core.script.loader import loader if isinstance(test_storage, str): test_st = self.get_storage(test_storage, beef_test=True) else: test_st = test_storage if not cfg: # Get config with test_st.open_fs() as fs: data = fs.readbytes( smart_text(os.path.join(test_path, "test-config.yml"))) cfg = yaml.safe_load(data) # Get beef beef_path = os.path.join(test_path, "beef.json.bz2") beef = self.get_beef(test_st, beef_path) # Get capabilities caps = {} # Run tests tests = cfg.get("tests", []) service = ServiceStub(pool="default") for n, test in enumerate(tests): # Load script script = "%s.%s" % (beef.box.profile, test["script"]) scls = loader.get_script(script) if not scls: self.die("Failed to load script '%s'" % script) # Build credentials credentials = { "address": beef.uuid, "cli_protocol": "beef", "beef_storage_url": test_st.url, "beef_path": beef_path, "access_preference": test.get("access_preference", "SC"), } # Build version version = { "vendor": beef.box.vendor, "platform": beef.box.platform, "version": beef.box.version, } # @todo: Input scr = scls( service=service, credentials=credentials, capabilities=caps, version=version, timeout=3600, name=script, ) self.print("[%04d] Running %s" % (n, test["script"])) result = scr.run() tc = { "script": script, "capabilities": caps, "credentials": credentials, "version": version, "input": {}, "result": result, } data = bz2.compress(orjson.dumps(tc)) # rn = os.path.join(test_path, "%04d.%s.json.bz2" % (n, test["script"])) self.print("[%04d] Writing %s" % (n, rn)) with test_st.open_fs() as fs: fs.writebytes(smart_text(rn), data)
def handle(self, script, object_name, arguments, pretty, yaml_o, use_snmp, access_preference, update_spec, beef_output, *args, **options): # Get object obj = self.get_object(object_name[0]) # Build credentials credentials = self.get_credentials(obj) # Parse arguments args = self.get_script_args(arguments) # Load script script = script[0] if "." not in script: script = "%s.%s" % (obj.profile.name, script) script_class = loader.get_script(script) if not script_class: self.die("Failed to load script %s" % script_class) # Get capabilities caps = obj.get_caps() # if not use_snmp: if "snmp_ro" in credentials: del credentials["snmp_ro"] if "SNMP" in caps: del caps["SNMP"] if access_preference: credentials["access_preference"] = access_preference # Get version info if obj.version: version = { "vendor": obj.vendor.name if obj.vendor else None, "platform": obj.platform.name if obj.platform else None, "version": obj.version.version if obj.version else None, "image": obj.software_image if obj.software_image else None, } else: version = None # Run script service = ServiceStub(pool=obj.pool.name) scr = script_class( service=service, credentials=credentials, capabilities=caps, args=args, version=version, timeout=3600, name=script, ) span_sample = 1 if update_spec or beef_output else 0 with Span(sample=span_sample): result = scr.run() if pretty: pprint.pprint(result) elif yaml_o: import sys yaml.dump(result, sys.stdout) else: self.stdout.write("%s\n" % result) if update_spec: self.update_spec(update_spec, scr) if beef_output: spec = self.update_spec(update_spec, scr, save=False) bef_script_class = loader.get_script( "%s.%s" % (obj.profile.name, "get_beef")) beef_scr = bef_script_class( service=service, credentials=credentials, capabilities=caps, args={"spec": spec.get_spec_request()}, version=version, timeout=3600, name="%s.%s" % (obj.profile.name, "get_beef"), ) bdata = beef_scr.run() beef = Beef.from_json(bdata) storage = StorageStub("osfs:///") sdata = beef.get_data(decode=True) with storage.open_fs() as fs: fs.writebytes(beef_output, bytes(yaml.dump(sdata)))
def test_script_interface(sa_script): script = loader.get_script(sa_script) assert getattr(script, "interface", None) is not None, "Script should has 'interface' attribute" assert issubclass(script.interface, BaseInterface)
def test_script_type(sa_script): script = loader.get_script(sa_script) assert issubclass(script, BaseScript)
def test_script_loading(sa_script): script = loader.get_script(sa_script) assert script is not None