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
