def __init__(self):
super(GENIv3Delegate, self).__init__()
self._resource_manager = rm_adaptor
self._allowed_peers = AllowedPeers.get_peers()
self._mro_enabled =\
ast.literal_eval(ConfParser("ro.conf").get("master_ro").
get("mro_enabled"))
self._interdomain_available_to_user =\
ast.literal_eval(ConfParser("ro.conf").get("resources").
get("interdomain_available_to_user"))
def __init__(self):
super(GENIv3Handler, self).__init__(logger)
self._delegate = None
self._verify_users =\
ast.literal_eval(ConfParser("auth.conf").get("certificates").
get("verify_users"))
self.__credential_manager = GCFCredentialManager()
def __init__(self):
"""Constructor for the server wrapper."""
#self._app = Flask(__name__) # imports the named package, in this case this file
# Imports the named module (package includes "." and this is not nice with PyMongo)
self.config = ConfParser("flask.conf")
self.general_section = self.config.get("general")
self.template_folder = self.general_section.get("template_folder")
self.fcgi_section = self.config.get("fcgi")
self.certificates_section = self.config.get("certificates")
self._app = Flask(__name__.split(".")[-1],
template_folder=self.template_folder)
self._mongo = PyMongo(self._app)
# Added in order to be able to execute "before_request" method
app = self._app
# Setup debugging for app
cDebug = self.general_section.get("debug")
if cDebug: # log all actions on the XML-RPC interface
def log_request(sender, **extra):
logger.info(">>> REQUEST %s:\n%s" %
(request.path, request.data))
request_started.connect(log_request, self._app)
def log_response(sender, response, **extra):
logger.info(">>> RESPONSE %s:\n%s" %
(response.status, response.data))
request_finished.connect(log_response, self._app)
@app.before_request
def before_request():
# "Attach" objects within the "g" object. This is passed to each view method
g.mongo = self._mongo
def __init__(self, path=None):
super(GENIv3Delegate, self).__init__()
self.SEResources = SEConfigurator.seConfigurator()
self.SESlices = seSlicesWithSlivers()
self._verify_users =\
ast.literal_eval(ConfParser("geniv3.conf").get("certificates").get("verify_users"))
def __init__(self):
self.__abs_path = dirname(dirname(dirname(abspath(__file__))))
self.__trusted_certs =\
abspath(join(self.__abs_path, ast.literal_eval(ConfParser("auth.conf").\
get("certificates").get("cert_root"))))
self.__root_cert = join(dirname(self.__trusted_certs), "server.crt")
self.__root_cert = open(self.__root_cert, "r").read()
self.__auth = CredentialVerifier(self.__trusted_certs)
self.__define_config_object()
self.__auth = CredentialVerifier(self.__config.TRUSTED_ROOTS_DIR)
self.SFA_CREDENTIAL_TYPE = "geni_sfa"
def __init__(self):
super(SliceMonitoring, self).__init__()
ms = ConfParser("ro.conf").get("monitoring")
self.__ms_url = "%s://%s:%s%s" %\
(ms.get("protocol"), ms.get("address"),
ms.get("port"), ms.get("endpoint"))
self.__topologies = etree.Element("topology_list")
self.__stored = {}
self.__mapping_c_interface = {}
#self.__sdn_links = []
self.__se_links = []
self.__tn_links = []
self.__hybrid_links = []
def __init__(self):
super(BaseMonitoring, self).__init__()
self.peers = [p for p in db_sync_manager.get_configured_peers()]
self.peers_info = [p for p in db_sync_manager.get_info_peers()]
self.domain_urn = ""
self.domain_last_update = ""
self.topology_list = etree.Element("topology_list")
self.topology = etree.SubElement(self.topology_list, "topology")
## Operation mode
self.config = ConfParser("ro.conf")
master_ro = self.config.get("master_ro")
self.mro_enabled = ast.literal_eval(master_ro.get("mro_enabled"))
self.software_stacks = {
"ofelia": "ocf",
"felix": "fms",
}
self.urn_type_resources = {
"crm": "vtam",
"sdnrm": "openflow",
"serm": "se",
"tnrm": "tn",
}
self.urn_type_resources_variations = {
"crm": ["vtam"],
"sdnrm": ["openflow", "ofam"],
"serm": ["se"],
"tnrm": ["tn", "NSI"],
}
self.management_type_resources = {
"crm": "server",
"sdnrm": "switch",
"serm": "se",
}
self.monitoring_expected_nodes = {
"crm": "",
"sdnrm": "switch",
"serm": "se",
"tnrm": "tn",
}
self.peers_by_domain = {}
self.__group_peers_by_domain()
## Configurations
# CRM config
self.config_crm = core.config.JSONParser("crm.json")
self.crm_mgmt_info = self.config_crm.get("device_management_info")
# SDNRM config
self.config_sdnrm = core.config.JSONParser("sdnrm.json")
self.sdnrm_mgmt_info = self.config_sdnrm.get("device_management_info")
# SERM config
self.config_serm = core.config.JSONParser("serm.json")
self.serm_mgmt_info = self.config_serm.get("device_management_info")
def __init__(self):
GenericCommand.__init__(self)
self.type_ = None
self.addr_ = None
self.port_ = None
self.protocol_ = None
self.endpoint_ = None
self.user_ = None
self.password_ = None
self.am_type_ = None
self.am_version_ = None
self.config = ConfParser("ro.conf")
self.master_ro = self.config.get("master_ro")
self.mro_enabled = ast.literal_eval(self.master_ro.get("mro_enabled"))
def __init__(self):
super(MonitoringManager, self).__init__("monitoring")
self.config = ConfParser("ro.conf")
self.monitoring_section = self.config.get("monitoring")
self.protocol = self.monitoring_section.get("protocol")
self.address = self.monitoring_section.get("address")
self.port = self.monitoring_section.get("port")
self.endpoint = self.monitoring_section.get("endpoint")
self.monitoring_server = {
"protocol": self.protocol,
"address": self.address,
"port": self.port,
"endpoint": self.endpoint,
}
def __init__(self):
"""
Constructor of the service.
"""
self.config = ConfParser("ro.conf")
self.scheduler = self.config.get("scheduler")
interval = int(self.scheduler.get("frequency"))
master_ro = self.config.get("master_ro")
mro_enabled = ast.literal_eval(master_ro.get("mro_enabled"))
db_name = "felix_ro"
if mro_enabled:
db_name = "felix_mro"
global ro_scheduler
ro_scheduler = BackgroundScheduler()
ro_scheduler.add_jobstore(
MongoDBJobStore(database=db_name, collection="scheduler.jobs"))
ro_scheduler.start()
super(ROSchedulerService, self).__init__(
"ROSchedulerService", interval)
self.first_time = True
def __init__(self):
"""
Constructor of the service.
"""
self.config = ConfParser("ro.conf")
master_ro = self.config.get("master_ro")
self.mro_enabled = ast.literal_eval(master_ro.get("mro_enabled"))
self.TABLES = {
"domain.routing": self.__get_table("domain.routing"),
"resource.com.node": self.__get_table("resource.com.node"),
"resource.com.link": self.__get_table("resource.com.link"),
"resource.of.node": self.__get_table("resource.of.node"),
"resource.of.link": self.__get_table("resource.of.link"),
"resource.se.link": self.__get_table("resource.se.link"),
"resource.se.node": self.__get_table("resource.se.node"),
"resource.tn.link": self.__get_table("resource.tn.link"),
"resource.tn.node": self.__get_table("resource.tn.node"),
"topology.slice": self.__get_table("topology.slice"),
"topology.slice.sdn": self.__get_table("topology.slice.sdn"),
"scheduler.jobs": self.__get_table("scheduler.jobs"),
"domain.info": self.__get_table("domain.info"),
"topology.physical": self.__get_table("topology.physical"),
}
def __init__(self):
super(GENIv3DelegateBase, self).__init__()
self.config = ConfParser("geniv3.conf")
self.general_section = self.config.get("general")
self.certificates_section = self.config.get("certificates")
def __init__(self):
super(TNUtils, self).__init__()
w_ = ConfParser("ro.conf").get("tnrm")
self.__workaround_split_allocation =\
ast.literal_eval(w_.get("split_workaround"))
def __init__(self):
self.__mutex = threading.Lock()
self.config = ConfParser("ro.conf")
master_ro = self.config.get("master_ro")
self.mro_enabled = ast.literal_eval(master_ro.get("mro_enabled"))
