def Main(fetcherclass, outputdir=None, argv=None): """ main() function. Parse command line arguments, fetch information from a device, parsing it into a memory structure (specified by pynt.elements) and write that to files in multiple formats """ (options, args) = GetOptions(argv) if len(args) > 0: # override hostname hostname = args[0] pynt.logger.SetLogLevel(options.verbosity) logger = logging.getLogger() if options.ip: hostname = options.ip else: hostname = "ospf" identifier = hostname.split(".")[0] errorfile = os.path.join(options.outputdir, "%s-error.log" % identifier) # log of errors serialfile = os.path.join(options.outputdir, "%s-serial.pickle" % identifier) # memory dump debugfile = os.path.join(options.outputdir, "%s-debug.txt" % identifier) # human readable memory dump ndl24file = os.path.join(options.outputdir, "%s-config.rdf" % identifier) # All information in latest NDL staticfile = os.path.join(options.outputdir, "%s-interfaces.rdf" % identifier) # Static interface configuration in NDL (no configuration info) ndl22file = os.path.join(options.outputdir, "%s-v22.rdf" % identifier) # NDL v2.2 deprecated version with all info dotfile = os.path.join(options.outputdir, "%s.dot" % identifier) # Dot output for generating a graph # iologfile = options.iologfile # file to log raw I/O communications with devices # passwdfile = options.configfile # file with usernames and passwords errorlog = pynt.logger.Logger(errorfile, verbosity=options.verbosity) try: namespaceuri = "#" identifier = hostname.split(".")[0].capitalize() fetcher = fetcherclass(hostname, nsuri=namespaceuri, identifier=identifier) if options.inputfilename: logger.log(25, "Performing simulated query on %s" % hostname) fetcher.setSourceFile(options.inputfilename, hostname=hostname) # hostname is used to set prompt elif options.ip: logger.log(25, "Performing live query on %s" % hostname) fetcher.setSourceHost(hostname, localport=options.localport, remoteport=options.remoteport) else: sys.exit("Please specify either an ip (-i) or a file (-f).") # fetches data from device and returns object structure. # The subject is something that can be passed on to BaseOutput.output(); # Typically a Device object or namespace. subject = fetcher.getSubject() subject = subject.getNamespace() if options.ip: out = pynt.output.serial.SerialOutput(serialfile) out.output(subject) out = pynt.output.debug.DebugOutput(debugfile) out.output() out = pynt.output.manualrdf.RDFOutput(ndl24file) out.output(subject) out = pynt.output.dot.DeviceGraphOutput(dotfile) out.output(subject) except: # *any* kind of exception, including user-interupts, etc. # the write functions are atomic, so those will be fine when an exception occurs errorlog.logException() (exceptionclass, exception, traceback) = sys.exc_info() logger.exception("")
def processDevice(self, hostname): try: identifier = self.devices_conf.get(hostname, "identifier") except: identifier = None if not identifier: identifier = hostname pynt.logger.SetLogLevel(self.options.verbosity) logger = logging.getLogger() errorfile = os.path.join(self.options.outputdir, "%s-error.log" % identifier) # log of errors serialfile = os.path.join(self.options.outputdir, "%s-serial.pickle" % identifier) # memory dump debugfile = os.path.join(self.options.outputdir, "%s-debug.txt" % identifier) # human readable memory dump ndl24file = os.path.join(self.options.outputdir, "%s-config.rdf" % identifier) # All information in latest NDL staticfile = os.path.join( self.options.outputdir, "%s-interfaces.rdf" % identifier ) # Static interface configuration in NDL (no configuration info) devdotfile = os.path.join( self.options.outputdir, "%s-device.dot" % identifier ) # Graph with vertices for devices ifdotfile = os.path.join( self.options.outputdir, "%s-interface.dot" % identifier ) # Graph with vertices for interfaces iologfile = self.options.iologfile # file to log raw I/O communications with devices passwdfile = self.options.configfile # file with usernames and passwords errorlog = pynt.logger.Logger(errorfile, verbosity=self.options.verbosity) inputfilename = os.path.join(self.options.inputdir, hostname) try: if self.options.simulate in ["pickle", "memory"]: if inputfilename: fetcher = pynt.input.serial.SerialInput(inputfilename) else: fetcher = pynt.input.serial.SerialInput(serialfile) else: fetcher = self.fetcherclass(hostname, identifier=identifier) if self.options.simulate in ["command"]: logger.log(25, "Performing simulated query on %s" % hostname) if inputfilename: fetcher.setSourceFile(inputfilename) else: fetcher.setSourceFile(iologfile) else: logger.log(25, "Performing live query on %s" % hostname) fetcher.setSourceHost(hostname, port=self.options.port) userpwd = pynt.input.usernames.GetLoginSettings( hostname, self.options.username, self.options.password, passwdfile ) fetcher.io.setLoginCredentials(**userpwd) if iologfile: fetcher.io.setLogFile(iologfile) # fetches data from device and returns object structure. # The subject is something that can be passed on to BaseOutput.output(); # Typically a Device object or namespace. subject = fetcher.getSubject() # if not self.options.simulate: # out = pynt.output.serial.SerialOutput(serialfile) # out.output(subject) # # out = pynt.output.debug.DebugOutput(debugfile) # out.output(subject) # # out = pynt.output.manualrdf.RDFOutput(ndl24file) # out.setMetaData("description", 'Configuration of the %s' % subject.getName()) # out.output(subject) # # out.setOutputFile(staticfile) # out.setPrintConfigured(False) # out.setMetaData("description", 'Configuration of the %s' % subject.getName()) # out.output(subject) # # out = pynt.output.dot.DeviceGraphOutput(devdotfile) # out.output(subject) # # out = pynt.output.dot.InterfaceGraphOutput(ifdotfile) # out.output(subject) except: # *any* kind of exception, including user-interupts, etc. # the write functions are atomic, so those will be fine when an exception occurs errorlog.logException() (exceptionclass, exception, traceback) = sys.exc_info() logger.exception("") # We check if an error occurred # if so, we do nothing, and keep the existing files. Those should still be valid. # However, if we previously also had errors, this is probably more fundamental. # In that case, we replace the -cache file with the -static file, effectively # removing all dynamic data from the RDF files. if errorlog.getCurErrorCount() and errorlog.getPrevErrorCount(): logger.info("Two errors in a row. Overwriting %s with %s" % (ndl24file, staticfile)) try: pynt.output.CopyFile(staticfile, ndl24file) except IOError: pass
def DeviceMain(fetcherclass, hostname, argv=None): """ main() function. Parse command line arguments, fetch information from a device, parsing it into a memory structure (specified by pynt.elements) and write that to files in multiple formats """ (options, args) = GetOptions(argv) if len(args) > 0: # override hostname hostname = args[0] pynt.logger.SetLogLevel(options.verbosity) logger = logging.getLogger() identifier = hostname.split(".")[0] errorfile = os.path.join(options.outputdir, "%s-error.log" % identifier) # log of errors serialfile = os.path.join(options.outputdir, "%s-serial.pickle" % identifier) # memory dump debugfile = os.path.join(options.outputdir, "%s-debug.txt" % identifier) # human readable memory dump ndl24file = os.path.join(options.outputdir, "%s-config.rdf" % identifier) # All information in latest NDL staticfile = os.path.join( options.outputdir, "%s-interfaces.rdf" % identifier ) # Static interface configuration in NDL (no configuration info) ndl22file = os.path.join( options.outputdir, "%s-v22.rdf" % identifier) # NDL v2.2 deprecated version with all info devdotfile = os.path.join(options.outputdir, "%s-device.dot" % identifier) # Graph with vertices for devices ifdotfile = os.path.join(options.outputdir, "%s-interface.dot" % identifier) # Graph with vertices for interfaces iologfile = options.iologfile # file to log raw I/O communications with devices passwdfile = options.configfile # file with usernames and passwords errorlog = pynt.logger.Logger(errorfile, verbosity=options.verbosity) try: if options.simulate in ["pickle", "memory"]: if options.inputfilename: fetcher = pynt.input.serial.SerialInput(options.inputfilename) else: fetcher = pynt.input.serial.SerialInput(serialfile) else: namespaceuri = "http://%s#" % hostname identifier = hostname.split(".")[0].capitalize() fetcher = fetcherclass(hostname, nsuri=namespaceuri, identifier=identifier) if options.simulate in ["command"]: logger.log(25, "Performing simulated query on %s" % hostname) if options.inputfilename: fetcher.setSourceFile( options.inputfilename, hostname=hostname) # hostname is used to set prompt else: fetcher.setSourceFile( iologfile, hostname=hostname) # hostname is used to set prompt else: logger.log(25, "Performing live query on %s" % hostname) fetcher.setSourceHost(hostname, port=options.port) userpwd = pynt.input.usernames.GetLoginSettings( hostname, options.username, options.password, passwdfile) fetcher.io.setLoginCredentials(**userpwd) if iologfile: fetcher.io.setLogFile(iologfile) # fetches data from device and returns object structure. # The subject is something that can be passed on to BaseOutput.output(); # Typically a Device object or namespace. subject = fetcher.getSubject() if not options.simulate: out = pynt.output.serial.SerialOutput(serialfile) out.output(subject) out = pynt.output.debug.DebugOutput(debugfile) out.output() out = pynt.output.manualrdf.RDFOutput(ndl24file) out.setMetaData( "description", 'Configuration of the %s switch at Netherlight. This file is semi-dynamically generated by a cron job that logs in the devices and retrieves all information. You should expect this data to be stale for about 5 minutes. If you really need real-time data, then don\'t use NDL, but another mechanism (e.g. a routing protocol).' % subject.getName()) out.setMetaData("publicationdate", '2007-01-31') out.output(subject) #out.setOutputFile(None) # set to STDOUT #out.output(force10) out.setOutputFile(staticfile) out.setPrintConfigured(False) out.setMetaData( "description", 'Configuration of the %s switch at Netherlight. This file is automatically generated by a script that logs in the devices and all static information. This file does NOT contain dynamic information.' % subject.getName()) out.setMetaData("publicationdate", '2007-01-31') out.output(subject) out = pynt.output.manualrdf.RDFv22Output(ndl22file) out.output(subject) out = pynt.output.dot.DeviceGraphOutput(devdotfile) out.output(subject) out = pynt.output.dot.InterfaceGraphOutput(ifdotfile) out.output(subject) except: # *any* kind of exception, including user-interupts, etc. # the write functions are atomic, so those will be fine when an exception occurs errorlog.logException() (exceptionclass, exception, traceback) = sys.exc_info() logger.exception("") # We check if an error occured # if so, we do nothing, and keep the existing files. Those should still be valid. # However, if we previously also had errors, this is probably more fundamental. # In that case, we replace the -cache file with the -static file, effectively # removing all dynamic data from the RDF files. if errorlog.getCurErrorCount() and errorlog.getPrevErrorCount(): logger.info("Two errors in a row. Overwriting %s with %s" % (ndl24file, staticfile)) try: pynt.output.CopyFile(staticfile, ndl24file) except IOError: pass
def Main(fetcherclass, outputdir=None, argv=None): """ main() function. Parse command line arguments, fetch information from a device, parsing it into a memory structure (specified by pynt.elements) and write that to files in multiple formats """ (options, args) = GetOptions(argv) if len(args) > 0: # override hostname hostname = args[0] pynt.logger.SetLogLevel(options.verbosity) logger = logging.getLogger() if options.ip: hostname = options.ip else: hostname = "ospf" identifier = hostname.split(".")[0] errorfile = os.path.join(options.outputdir, "%s-error.log" % identifier) # log of errors serialfile = os.path.join(options.outputdir, "%s-serial.pickle" % identifier) # memory dump debugfile = os.path.join(options.outputdir, "%s-debug.txt" % identifier) # human readable memory dump ndl24file = os.path.join(options.outputdir, "%s-config.rdf" % identifier) # All information in latest NDL staticfile = os.path.join( options.outputdir, "%s-interfaces.rdf" % identifier ) # Static interface configuration in NDL (no configuration info) ndl22file = os.path.join( options.outputdir, "%s-v22.rdf" % identifier) # NDL v2.2 deprecated version with all info dotfile = os.path.join(options.outputdir, "%s.dot" % identifier) # Dot output for generating a graph # iologfile = options.iologfile # file to log raw I/O communications with devices # passwdfile = options.configfile # file with usernames and passwords errorlog = pynt.logger.Logger(errorfile, verbosity=options.verbosity) try: namespaceuri = "#" identifier = hostname.split(".")[0].capitalize() fetcher = fetcherclass(hostname, nsuri=namespaceuri, identifier=identifier) if options.inputfilename: logger.log(25, "Performing simulated query on %s" % hostname) fetcher.setSourceFile( options.inputfilename, hostname=hostname) # hostname is used to set prompt elif options.ip: logger.log(25, "Performing live query on %s" % hostname) fetcher.setSourceHost(hostname, localport=options.localport, remoteport=options.remoteport) else: sys.exit("Please specify either an ip (-i) or a file (-f).") # fetches data from device and returns object structure. # The subject is something that can be passed on to BaseOutput.output(); # Typically a Device object or namespace. subject = fetcher.getSubject() subject = subject.getNamespace() if options.ip: out = pynt.output.serial.SerialOutput(serialfile) out.output(subject) out = pynt.output.debug.DebugOutput(debugfile) out.output() out = pynt.output.manualrdf.RDFOutput(ndl24file) out.output(subject) out = pynt.output.dot.DeviceGraphOutput(dotfile) out.output(subject) except: # *any* kind of exception, including user-interupts, etc. # the write functions are atomic, so those will be fine when an exception occurs errorlog.logException() (exceptionclass, exception, traceback) = sys.exc_info() logger.exception("")
def DeviceMain(fetcherclass, hostname, argv=None): """ main() function. Parse command line arguments, fetch information from a device, parsing it into a memory structure (specified by pynt.elements) and write that to files in multiple formats """ (options, args) = GetOptions(argv) if len(args) > 0: # override hostname hostname = args[0] pynt.logger.SetLogLevel(options.verbosity) logger = logging.getLogger() identifier = hostname.split(".")[0] errorfile = os.path.join(options.outputdir, "%s-error.log" % identifier) # log of errors serialfile = os.path.join(options.outputdir, "%s-serial.pickle" % identifier) # memory dump debugfile = os.path.join(options.outputdir, "%s-debug.txt" % identifier) # human readable memory dump ndl24file = os.path.join(options.outputdir, "%s-config.rdf" % identifier) # All information in latest NDL staticfile = os.path.join(options.outputdir, "%s-interfaces.rdf" % identifier) # Static interface configuration in NDL (no configuration info) ndl22file = os.path.join(options.outputdir, "%s-v22.rdf" % identifier) # NDL v2.2 deprecated version with all info devdotfile = os.path.join(options.outputdir, "%s-device.dot" % identifier) # Graph with vertices for devices ifdotfile = os.path.join(options.outputdir, "%s-interface.dot" % identifier) # Graph with vertices for interfaces iologfile = options.iologfile # file to log raw I/O communications with devices passwdfile = options.configfile # file with usernames and passwords errorlog = pynt.logger.Logger(errorfile, verbosity=options.verbosity) try: if options.simulate in ["pickle", "memory"]: if options.inputfilename: fetcher = pynt.input.serial.SerialInput(options.inputfilename) else: fetcher = pynt.input.serial.SerialInput(serialfile) else: namespaceuri = "http://%s#" % hostname identifier = hostname.split(".")[0].capitalize() fetcher = fetcherclass(hostname, nsuri=namespaceuri, identifier=identifier) if options.simulate in ["command"]: logger.log(25, "Performing simulated query on %s" % hostname) if options.inputfilename: fetcher.setSourceFile(options.inputfilename, hostname=hostname) # hostname is used to set prompt else: fetcher.setSourceFile(iologfile, hostname=hostname) # hostname is used to set prompt else: logger.log(25, "Performing live query on %s" % hostname) fetcher.setSourceHost(hostname, port=options.port) userpwd = pynt.input.usernames.GetLoginSettings(hostname, options.username, options.password, passwdfile) fetcher.io.setLoginCredentials(**userpwd) if iologfile: fetcher.io.setLogFile(iologfile) # fetches data from device and returns object structure. # The subject is something that can be passed on to BaseOutput.output(); # Typically a Device object or namespace. subject = fetcher.getSubject() if not options.simulate: out = pynt.output.serial.SerialOutput(serialfile) out.output(subject) out = pynt.output.debug.DebugOutput(debugfile) out.output() out = pynt.output.manualrdf.RDFOutput(ndl24file) out.setMetaData("description", 'Configuration of the %s switch at Netherlight. This file is semi-dynamically generated by a cron job that logs in the devices and retrieves all information. You should expect this data to be stale for about 5 minutes. If you really need real-time data, then don\'t use NDL, but another mechanism (e.g. a routing protocol).' % subject.getName()) out.setMetaData("publicationdate", '2007-01-31') out.output(subject) #out.setOutputFile(None) # set to STDOUT #out.output(force10) out.setOutputFile(staticfile) out.setPrintConfigured(False) out.setMetaData("description", 'Configuration of the %s switch at Netherlight. This file is automatically generated by a script that logs in the devices and all static information. This file does NOT contain dynamic information.' % subject.getName()) out.setMetaData("publicationdate", '2007-01-31') out.output(subject) out = pynt.output.manualrdf.RDFv22Output(ndl22file) out.output(subject) out = pynt.output.dot.DeviceGraphOutput(devdotfile) out.output(subject) out = pynt.output.dot.InterfaceGraphOutput(ifdotfile) out.output(subject) except: # *any* kind of exception, including user-interupts, etc. # the write functions are atomic, so those will be fine when an exception occurs errorlog.logException() (exceptionclass, exception, traceback) = sys.exc_info() logger.exception("") # We check if an error occured # if so, we do nothing, and keep the existing files. Those should still be valid. # However, if we previously also had errors, this is probably more fundamental. # In that case, we replace the -cache file with the -static file, effectively # removing all dynamic data from the RDF files. if errorlog.getCurErrorCount() and errorlog.getPrevErrorCount(): logger.info("Two errors in a row. Overwriting %s with %s" % (ndl24file, staticfile)) try: pynt.output.CopyFile(staticfile, ndl24file) except IOError: pass
def DefineNetwork(): # - Earth 1 physical interface: Ethernet # - Vogon 4 physical interface: Ethernet, SONET (3x), 1 Switch Matrix (SONET); 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - StarLight 2 physical interfaces: SONET/Ethernet, 2 Switch Matrices (SONET and Ethernet) # - MANLAN 5 physical interfaces: SONET, 1 Switch Matrix (SONET) # - NetherLight 3 physical interface: Ethernet, SONET (2x), 1 Switch Matrix; 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - Amsterdam 1 physical interface: Ethernet # Ford # | vlan 28 untagged # Earth ----------------- Vogon ----------------- Golgafrinchan # tagged | | # | tagged | # tagged | tagged | vlan 42 # Betelgeuse ------------ Haggunenons ----------- Margrathea --- Dolphins # | vlan 42 | vlan 42 # Zaphod Mice # domainNamespaces = [] # Get all namespaces, layers and adaptations. ethns = pynt.xmlns.GetNamespaceByPrefix("ethernet") ethlayer = pynt.xmlns.GetRDFObject("EthernetNetworkElement", namespace=ethns, klass=pynt.layers.Layer) ethineth = pynt.xmlns.GetRDFObject("Tagged-Ethernet", namespace=ethns, klass=pynt.layers.AdaptationFunction) logger = logging.getLogger("network") logger.log(25, "Building demo Ethernet network in memory") ieee8021qrange = pynt.rangeset.RangeSet("0-4095", itemtype=int, interval=1) vlan42 = pynt.rangeset.RangeSet("42", itemtype=int, interval=1) vlan28 = pynt.rangeset.RangeSet("28", itemtype=int, interval=1) vlanno42 = ieee8021qrange - vlan42 exns = pynt.xmlns.GetCreateNamespace("http://example.net/#") # # External # ford = pynt.xmlns.GetCreateRDFObject("Ford", namespace=exns, klass=pynt.elements.StaticInterface) ford.setLayer(ethlayer) ford.setLabel(None) zaphod = pynt.xmlns.GetCreateRDFObject("Zaphod", namespace=exns, klass=pynt.elements.StaticInterface) zaphod.setLayer(ethlayer) zaphod.setLabel(None) dolphins = pynt.xmlns.GetCreateRDFObject( "Dolphins", namespace=exns, klass=pynt.elements.StaticInterface) dolphins.setLayer(ethlayer) dolphins.setLabel(None) mice = pynt.xmlns.GetCreateRDFObject("Mice", namespace=exns, klass=pynt.elements.StaticInterface) mice.setLayer(ethlayer) mice.setLabel(None) # # Earth: # earth = pynt.elements.GetCreateDevice("Earth", namespace=exns) # ifford: Untagged, VLAN 28 ifearth_ford = pynt.xmlns.GetCreateRDFObject( "ifearth_ford", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifearth_ford.setLayer(ethlayer) ifearth_ford.setDevice(earth) ifearth_ford.setLabel(28) ifearth_ford.setInternalLabelSet(vlan28) # ifvogon: Tagged, all VLANs ifearth_vogon_tag = pynt.xmlns.GetCreateRDFObject( "ifearth_vogon_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifearth_vogon_tag.setLayer(ethlayer) ifearth_vogon_tag.setDevice(earth) ifearth_vogon_tag.setLabelSet(vlan28) ifearth_vogon_unt = pynt.xmlns.GetCreateRDFObject( "ifearth_vogon_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifearth_vogon_unt.setLayer(ethlayer) ifearth_vogon_unt.setDevice(earth) ifearth_vogon_unt.setLabel(None) ifearth_vogon_unt.addClientInterface(ifearth_vogon_tag, ethineth) # Ethernet switch matrix earthswitch = pynt.elements.GetCreateSwitchMatrix("EarthSwitch", namespace=exns) earthswitch.setLayer(ethlayer) earthswitch.setDevice(earth) earthswitch.setSwitchingCapability(True) earthswitch.setSwappingCapability(False) earthswitch.setUnicast(False) earthswitch.setBroadcast(True) earthswitch.addInterface(ifearth_ford) earthswitch.addInterface(ifearth_vogon_tag) # # Vogon: # vogon = pynt.elements.GetCreateDevice("Vogon", namespace=exns) # ifearth: Tagged, all VLANs ifvogon_earth_tag = pynt.xmlns.GetCreateRDFObject( "ifvogon_earth_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifvogon_earth_tag.setLayer(ethlayer) ifvogon_earth_tag.setDevice(vogon) ifvogon_earth_tag.setLabelSet(ieee8021qrange) ifvogon_earth_unt = pynt.xmlns.GetCreateRDFObject( "ifvogon_earth_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifvogon_earth_unt.setLayer(ethlayer) ifvogon_earth_unt.setDevice(vogon) ifvogon_earth_unt.setLabel(None) ifvogon_earth_unt.addClientInterface(ifvogon_earth_tag, ethineth) # ifhaggu: Tagged, all VLANs ifvogon_haggu_tag = pynt.xmlns.GetCreateRDFObject( "ifvogon_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifvogon_haggu_tag.setLayer(ethlayer) ifvogon_haggu_tag.setDevice(vogon) ifvogon_haggu_tag.setLabelSet(ieee8021qrange) ifvogon_haggu_unt = pynt.xmlns.GetCreateRDFObject( "ifvogon_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifvogon_haggu_unt.setLayer(ethlayer) ifvogon_haggu_unt.setDevice(vogon) ifvogon_haggu_unt.setLabel(None) ifvogon_haggu_unt.addClientInterface(ifvogon_haggu_tag, ethineth) # ifgolga: Untagged, any VLAN ifvogon_golga_unt = pynt.xmlns.GetCreateRDFObject( "ifvogon_golga_unt", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifvogon_golga_unt.setLayer(ethlayer) ifvogon_golga_unt.setDevice(vogon) ifvogon_golga_unt.setLabel(0) ifvogon_golga_unt.setLabelSet(None) ifvogon_golga_unt.setInternalLabelSet(ieee8021qrange) # Ethernet switch matrix vogonswitch = pynt.elements.GetCreateSwitchMatrix("VogonSwitch", namespace=exns) vogonswitch.setLayer(ethlayer) vogonswitch.setDevice(vogon) vogonswitch.setSwitchingCapability(True) vogonswitch.setSwappingCapability(False) vogonswitch.setUnicast(False) vogonswitch.setBroadcast(True) vogonswitch.addInterface(ifvogon_earth_tag) vogonswitch.addInterface(ifvogon_haggu_tag) vogonswitch.addInterface(ifvogon_golga_unt) # # Golgafrinchan: # golga = pynt.elements.GetCreateDevice("Golgafrinchan", namespace=exns) # ifvogon: Untagged, any VLAN ifgolga_vogon_unt = pynt.xmlns.GetCreateRDFObject( "ifgolga_vogon_unt", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifgolga_vogon_unt.setLayer(ethlayer) ifgolga_vogon_unt.setDevice(golga) ifgolga_vogon_unt.setLabel(0) ifgolga_vogon_unt.setLabelSet(None) ifgolga_vogon_unt.setInternalLabelSet(ieee8021qrange) # ifmargr: Tagged, all VLANs ifgolga_margr_tag = pynt.xmlns.GetCreateRDFObject( "ifgolga_margr_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifgolga_margr_tag.setLayer(ethlayer) ifgolga_margr_tag.setDevice(golga) ifgolga_margr_tag.setLabelSet(ieee8021qrange) ifgolga_margr_unt = pynt.xmlns.GetCreateRDFObject( "ifgolga_margr_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifgolga_margr_unt.setLayer(ethlayer) ifgolga_margr_unt.setDevice(golga) ifgolga_margr_unt.setLabel(None) ifgolga_margr_unt.addClientInterface(ifgolga_margr_tag, ethineth) # Ethernet switch matrix golgaswitch = pynt.elements.GetCreateSwitchMatrix("GolgafrinchanSwitch", namespace=exns) golgaswitch.setLayer(ethlayer) golgaswitch.setDevice(golga) golgaswitch.setSwitchingCapability(True) golgaswitch.setSwappingCapability(False) golgaswitch.setUnicast(False) golgaswitch.setBroadcast(True) golgaswitch.addInterface(ifgolga_vogon_unt) golgaswitch.addInterface(ifgolga_margr_tag) # # Margrathea: # margrathea = pynt.elements.GetCreateDevice("Margrathea", namespace=exns) # ifgolga: Tagged, all VLANs except 42 ifmargr_golga_tag = pynt.xmlns.GetCreateRDFObject( "ifmargr_golga_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifmargr_golga_tag.setLayer(ethlayer) ifmargr_golga_tag.setDevice(margrathea) ifmargr_golga_tag.setLabelSet( vlanno42 ) # TODO: test if (ieee8021qrange) work. Broadcast should remove VLAN 42. ifmargr_golga_unt = pynt.xmlns.GetCreateRDFObject( "ifmargr_golga_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_golga_unt.setLayer(ethlayer) ifmargr_golga_unt.setDevice(margrathea) ifmargr_golga_unt.setLabel(None) ifmargr_golga_unt.addClientInterface(ifmargr_golga_tag, ethineth) # ifhaggu: Tagged, all VLANs except 42 ifmargr_haggu_tag = pynt.xmlns.GetCreateRDFObject( "ifmargr_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifmargr_haggu_tag.setLayer(ethlayer) ifmargr_haggu_tag.setDevice(margrathea) ifmargr_haggu_tag.setLabelSet( vlanno42 ) # TODO: test if (ieee8021qrange) work. Broadcast should remove VLAN 42. ifmargr_haggu_unt = pynt.xmlns.GetCreateRDFObject( "ifmargr_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_haggu_unt.setLayer(ethlayer) ifmargr_haggu_unt.setDevice(margrathea) ifmargr_haggu_unt.setLabel(None) ifmargr_haggu_unt.addClientInterface(ifmargr_haggu_tag, ethineth) # ifdolphins: Untagged, VLAN 42 ifmargr_dolphins = pynt.xmlns.GetCreateRDFObject( "ifmargr_dolphins", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_dolphins.setLayer(ethlayer) ifmargr_dolphins.setDevice(margrathea) ifmargr_dolphins.setLabel(None) ifmargr_dolphins.setInternalLabel(42) # ifmice: Untagged, VLAN 42 ifmargr_mice = pynt.xmlns.GetCreateRDFObject( "ifmargr_mice", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_mice.setLayer(ethlayer) ifmargr_mice.setDevice(margrathea) ifmargr_mice.setLabel(None) ifmargr_mice.setInternalLabel(42) # Ethernet switch matrix margrswitch = pynt.elements.GetCreateSwitchMatrix("MargratheaSwitch", namespace=exns) margrswitch.setLayer(ethlayer) margrswitch.setDevice(margrathea) margrswitch.setSwitchingCapability(True) margrswitch.setSwappingCapability(False) margrswitch.setUnicast(False) margrswitch.setBroadcast(True) margrswitch.addInterface(ifmargr_golga_tag) margrswitch.addInterface(ifmargr_haggu_tag) margrswitch.addInterface(ifmargr_dolphins) margrswitch.addInterface(ifmargr_mice) # # Haggunenons: # haggunenons = pynt.elements.GetCreateDevice("Haggunenons", namespace=exns) # ifmargr: Tagged, all VLANs ifhaggu_margr_tag = pynt.xmlns.GetCreateRDFObject( "ifhaggu_margr_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_margr_tag.setLayer(ethlayer) ifhaggu_margr_tag.setDevice(haggunenons) ifhaggu_margr_tag.setLabelSet(ieee8021qrange) ifhaggu_margr_unt = pynt.xmlns.GetCreateRDFObject( "ifhaggu_margr_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_margr_unt.setLayer(ethlayer) ifhaggu_margr_unt.setDevice(haggunenons) ifhaggu_margr_unt.setLabel(None) ifhaggu_margr_unt.addClientInterface(ifhaggu_margr_tag, ethineth) # ifvogon: Tagged, all VLANs ifhaggu_vogon_tag = pynt.xmlns.GetCreateRDFObject( "ifhaggu_vogon_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_vogon_tag.setLayer(ethlayer) ifhaggu_vogon_tag.setDevice(haggunenons) ifhaggu_vogon_tag.setLabelSet(ieee8021qrange) ifhaggu_vogon_unt = pynt.xmlns.GetCreateRDFObject( "ifhaggu_vogon_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_vogon_unt.setLayer(ethlayer) ifhaggu_vogon_unt.setDevice(haggunenons) ifhaggu_vogon_unt.setLabel(None) ifhaggu_vogon_unt.addClientInterface(ifhaggu_vogon_tag, ethineth) # ifbetel: Tagged, all VLANs ifhaggu_betel_tag = pynt.xmlns.GetCreateRDFObject( "ifhaggu_betel_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_betel_tag.setLayer(ethlayer) ifhaggu_betel_tag.setDevice(haggunenons) ifhaggu_betel_tag.setLabelSet(vlan42) ifhaggu_betel_unt = pynt.xmlns.GetCreateRDFObject( "ifhaggu_betel_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_betel_unt.setLayer(ethlayer) ifhaggu_betel_unt.setDevice(haggunenons) ifhaggu_betel_unt.setLabel(None) ifhaggu_betel_unt.addClientInterface(ifhaggu_betel_tag, ethineth) # Ethernet switch matrix hagguswitch = pynt.elements.GetCreateSwitchMatrix("HaggunenonsSwitch", namespace=exns) hagguswitch.setLayer(ethlayer) hagguswitch.setDevice(haggunenons) hagguswitch.setSwitchingCapability(True) hagguswitch.setSwappingCapability(False) hagguswitch.setUnicast(False) hagguswitch.setBroadcast(True) hagguswitch.addInterface(ifhaggu_margr_tag) hagguswitch.addInterface(ifhaggu_vogon_tag) hagguswitch.addInterface(ifhaggu_betel_tag) # # Betelgeuse: # betelgeuse = pynt.elements.GetCreateDevice("Betelgeuse", namespace=exns) # ifford: Untagged, VLAN 28 ifbetel_zaphod = pynt.xmlns.GetCreateRDFObject( "ifbetel_zaphod", namespace=exns, klass=pynt.elements.StaticInterface) ifbetel_zaphod.setLayer(ethlayer) ifbetel_zaphod.setDevice(betelgeuse) ifbetel_zaphod.setLabel(None) ifbetel_zaphod.setInternalLabel(42) # ifhaggu: Tagged, all VLANs ifbetel_haggu_tag = pynt.xmlns.GetCreateRDFObject( "ifbetel_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifbetel_haggu_tag.setLayer(ethlayer) ifbetel_haggu_tag.setDevice(betelgeuse) ifbetel_haggu_tag.setLabelSet(ieee8021qrange) ifbetel_haggu_unt = pynt.xmlns.GetCreateRDFObject( "ifbetel_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifbetel_haggu_unt.setLayer(ethlayer) ifbetel_haggu_unt.setDevice(betelgeuse) ifbetel_haggu_unt.setLabel(None) ifbetel_haggu_unt.addClientInterface(ifbetel_haggu_tag, ethineth) # Ethernet switch matrix betelswitch = pynt.elements.GetCreateSwitchMatrix("BetelgeuseSwitch", namespace=exns) betelswitch.setLayer(ethlayer) betelswitch.setDevice(betelgeuse) betelswitch.setSwitchingCapability(True) betelswitch.setSwappingCapability(False) betelswitch.setUnicast(False) betelswitch.setBroadcast(True) betelswitch.addInterface(ifbetel_zaphod) betelswitch.addInterface(ifbetel_haggu_tag) # # Connections between the domains (Devices) # # Earth <--> Ford ifearth_ford.addLinkedInterface(ford) ford.addLinkedInterface(ifearth_ford) # Earth <--> Vogon ifearth_vogon_unt.addLinkedInterface(ifvogon_earth_unt) ifvogon_earth_unt.addLinkedInterface(ifearth_vogon_unt) # Vogon <--> Haggunenons ifvogon_haggu_unt.addLinkedInterface(ifhaggu_vogon_unt) ifhaggu_vogon_unt.addLinkedInterface(ifvogon_haggu_unt) # Vogon <--> Golgafrinchan ifvogon_golga_unt.addLinkedInterface(ifgolga_vogon_unt) ifgolga_vogon_unt.addLinkedInterface(ifvogon_golga_unt) # Golgafrinchan <--> Margrathea ifgolga_margr_unt.addLinkedInterface(ifmargr_golga_unt) ifmargr_golga_unt.addLinkedInterface(ifgolga_margr_unt) # Margrathea <--> Dolphins ifmargr_dolphins.addLinkedInterface(dolphins) dolphins.addLinkedInterface(ifmargr_dolphins) # Margrathea <--> Mice ifmargr_mice.addLinkedInterface(mice) mice.addLinkedInterface(ifmargr_mice) # Haggunenons <--> Margrathea ifhaggu_margr_unt.addLinkedInterface(ifmargr_haggu_unt) ifmargr_haggu_unt.addLinkedInterface(ifhaggu_margr_unt) # Betelgeuse <--> Haggunenons ifbetel_haggu_unt.addLinkedInterface(ifhaggu_betel_unt) ifhaggu_betel_unt.addLinkedInterface(ifbetel_haggu_unt) # Betelgeuse <--> Zaphod ifbetel_zaphod.addLinkedInterface(zaphod) zaphod.addLinkedInterface(ifbetel_zaphod) return [exns]
def DefineNetwork(): # - Quebec 1 physical interface: Ethernet # - CAnet 3 physical interface: Ethernet, SONET (2x), 1 Switch Matrix (SONET, switching, no swapping); 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - StarLight 2 physical interfaces: SONET/Ethernet, 2 Switch Matrices (SONET, switching and swapping and Ethernet, broadcast) # - MANLAN 4 physical interfaces: SONET, 1 Switch Matrix (SONET, switching and swapping) # - NetherLight 3 physical interface: Ethernet, SONET (2x), 1 Switch Matrix (SONET, switching, no swapping); 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - Amsterdam 1 physical interface: Ethernet domainNamespaces = [] # Get all namespaces, layers and adaptations. ethns = pynt.xmlns.GetNamespaceByPrefix("ethernet") tdmaltns = pynt.xmlns.GetNamespaceByPrefix("tdmalt") tdmns = pynt.xmlns.GetNamespaceByURI("http://www.science.uva.nl/research/sne/ndl/tdm#") wdmns = pynt.xmlns.GetNamespaceByPrefix("wdm") copperns = pynt.xmlns.GetNamespaceByPrefix("copper") ethlayer = pynt.xmlns.GetRDFObject("EthernetNetworkElement", namespace=ethns, klass=pynt.layers.Layer) vc4layer = pynt.xmlns.GetRDFObject("VC4NetworkElement", namespace=tdmaltns, klass=pynt.layers.Layer) oclayer = pynt.xmlns.GetRDFObject("OC192NetworkElement", namespace=tdmns, klass=pynt.layers.Layer) lambdalayer = pynt.xmlns.GetRDFObject("LambdaNetworkElement", namespace=wdmns, klass=pynt.layers.Layer) fiberlayer = pynt.xmlns.GetRDFObject("FiberNetworkElement", namespace=wdmns, klass=pynt.layers.Layer) utplayer = pynt.xmlns.GetRDFObject("TwistedPairNetworkElement", namespace=copperns, klass=pynt.layers.Layer) ethin7vc4 = pynt.xmlns.GetRDFObject("GiEthernet-in-7-VC4", namespace=tdmaltns, klass=pynt.layers.AdaptationFunction) ethin8vc4 = pynt.xmlns.GetRDFObject("GiEthernet-in-8-VC4", namespace=tdmaltns, klass=pynt.layers.AdaptationFunction) stsinoc = pynt.xmlns.GetRDFObject("STS-in-OC192", namespace=tdmaltns, klass=pynt.layers.AdaptationFunction) ocinlambda = pynt.xmlns.GetRDFObject("oc192-in-Lambda", namespace=wdmns, klass=pynt.layers.AdaptationFunction) lambdainfiber = pynt.xmlns.GetRDFObject("WDM", namespace=wdmns, klass=pynt.layers.AdaptationFunction) ethinutp = pynt.xmlns.GetRDFObject("base-T", namespace=copperns, klass=pynt.layers.AdaptationFunction) ethinlambda = pynt.xmlns.GetRDFObject("eth1000base-X", namespace=wdmns, klass=pynt.layers.AdaptationFunction) logger = logging.getLogger("network") logger.log(25, "Building demo GLIF network in memory") vc4range = pynt.rangeset.RangeSet("1-64", itemtype=int, interval=1) # link 1: VC-4 (fixed label: 31) link1label = 31 link1range = pynt.rangeset.RangeSet(31, itemtype=int, interval=1) # link 2: Potential VC-4 (7 free labels) # must have 42, must not have 31 link2label = 12 link2range = pynt.rangeset.RangeSet("2,12-16,42", itemtype=int, interval=1) link2sl = pynt.rangeset.RangeSet(42, itemtype=int, interval=1) assert(len(link2range) == 7) assert(len(link1range + link2range) > 0) assert(len(link1range & link2sl) == 0) # link 3: Potential VC-4 (13 free labels) link3label = 42 link3sl = pynt.rangeset.RangeSet(42, itemtype=int, interval=1) link3range = pynt.rangeset.RangeSet("3,10-14,34-39,42", itemtype=int, interval=1) assert(len(link3range) == 13) # link 4: Potential VC-4 (20 free labels) # must have 31, 42, multiple of link 2 link4label = 14 link4range = pynt.rangeset.RangeSet("14-24,31-35,41-44", itemtype=int, interval=1) assert(len(link4range) == 20) assert(len(link4range & link2range) > 1) assert(len(link4range & link1range) > 0) # link 5: Potential VC-4 (9 free labels) # must have 31, 42, multiple of link 2 #link5label = 15 #link5range = pynt.rangeset.RangeSet("15-20,31,42,55", itemtype=int, interval=1) #assert(len(link5range) == 9) #assert(len(link5range & link2range) > 1) #assert(len(link5range & link1range) > 0) # link 6: Potential VC-4 (10 free labels) link6label = 16 link6range = pynt.rangeset.RangeSet("16-19,28,41-45", itemtype=int, interval=1) assert(len(link6range) == 10) # link 7: Potential VC-4 (11 free labels) # should not have 42 link7label = 17 link7range = pynt.rangeset.RangeSet("17,24-28,53-57", itemtype=int, interval=1) assert(len(link7range) == 11) # link 8: VC-4 (fixed label: 28) link8label = 28 link8range = pynt.rangeset.RangeSet(28, itemtype=int, interval=1) # # Université de Quebec: # uqamns = pynt.xmlns.GetCreateNamespace("http://uqam.ca/#") domainNamespaces.append(uqamns) uqamdev = pynt.elements.GetCreateDevice("QuebecEthernetDevice", namespace=uqamns) uqamdev.setName("Quebec") # if1: Ethernet over UTP uqamif1utp = pynt.xmlns.CreateRDFObject("if1-utp", namespace=uqamns, klass=pynt.elements.StaticInterface) uqamif1utp.setLayer(utplayer) uqamif1utp.setDevice(uqamdev) uqamif1eth = pynt.xmlns.CreateRDFObject("if1-eth", namespace=uqamns, klass=pynt.elements.StaticInterface) uqamif1eth.setLayer(ethlayer) uqamif1eth.setDevice(uqamdev) uqamif1utp.addClientInterface(uqamif1eth, ethinutp) # no switch matrix # # CA*net: # canetns = pynt.xmlns.GetCreateNamespace("http://canarie.ca/#") domainNamespaces.append(canetns) canetdev = pynt.elements.GetCreateDevice("CANetDevice", namespace=canetns) canetdev.setName("CA*net") # if1 (a): Ethernet over UTP # if1 (b): Ethernet over (8-variant) VC-4 (fixed label: 31) # if1 (c): VC-4 canetif1aeth = pynt.xmlns.CreateRDFObject("if1a-eth", namespace=canetns, klass=pynt.elements.StaticInterface) canetif1aeth.setLayer(ethlayer) canetif1aeth.setDevice(canetdev) canetif1autp = pynt.xmlns.CreateRDFObject("if1a-utp", namespace=canetns, klass=pynt.elements.StaticInterface) canetif1autp.setLayer(utplayer) canetif1autp.setDevice(canetdev) canetif1autp.addClientInterface(canetif1aeth, ethinutp) canetif1beth = pynt.xmlns.CreateRDFObject("if1b-eth", namespace=canetns, klass=pynt.elements.StaticInterface) canetif1beth.setLayer(ethlayer) canetif1beth.setDevice(canetdev) canetif1bvc4 = pynt.xmlns.CreateRDFObject("if1b-vc4", namespace=canetns, klass=pynt.elements.ConfigurableInterface) canetif1bvc4.setLayer(vc4layer) canetif1bvc4.setDevice(canetdev) canetif1bvc4.setLabel(link1label) canetif1bvc4.setLabelSet(link1range) canetif1bvc4.addClientInterface(canetif1beth, ethin8vc4) canetif1aeth.addSwitchedInterface(canetif1beth) canetif1beth.addSwitchedInterface(canetif1aeth) canetif1cvc4 = pynt.xmlns.CreateRDFObject("if1c-vc4", namespace=canetns, klass=pynt.elements.ConfigurableInterface) canetif1cvc4.setLayer(vc4layer) canetif1cvc4.setDevice(canetdev) canetif1cvc4.setLabel(link1label) canetif1cvc4.setLabelSet(vc4range) canetif1bvc4.addLinkedInterface(canetif1cvc4) canetif1cvc4.addLinkedInterface(canetif1bvc4) # if2: Potential VC-4 (22 free labels) over OC over Lambda over Fiber canetif2vc4 = pynt.xmlns.CreateRDFObject("if2-vc4", namespace=canetns, klass=pynt.elements.PotentialMuxInterface) canetif2vc4.setLayer(vc4layer) canetif2vc4.setDevice(canetdev) #canetif2vc4.setLabel(link2label) canetif2vc4.setLabelSet(link2range) canetif2oc = pynt.xmlns.CreateRDFObject("if2-oc", namespace=canetns, klass=pynt.elements.StaticInterface) canetif2oc.setLayer(oclayer) canetif2oc.setDevice(canetdev) canetif2lambda = pynt.xmlns.CreateRDFObject("if2-lambda", namespace=canetns, klass=pynt.elements.StaticInterface) canetif2lambda.setLayer(lambdalayer) canetif2lambda.setDevice(canetdev) canetif2lambda.setLabel(1310.0) canetif2fiber = pynt.xmlns.CreateRDFObject("if2-fiber", namespace=canetns, klass=pynt.elements.StaticInterface) canetif2fiber.setLayer(fiberlayer) canetif2fiber.setDevice(canetdev) canetif2fiber.addClientInterface(canetif2lambda, lambdainfiber) canetif2lambda.addClientInterface(canetif2oc, ocinlambda) canetif2oc.addClientInterface(canetif2vc4, stsinoc) # if4: Potential VC-4 (61 free labels) over OC over Lambda over Fiber canetif4vc4 = pynt.xmlns.CreateRDFObject("if4-vc4", namespace=canetns, klass=pynt.elements.PotentialMuxInterface) canetif4vc4.setLayer(vc4layer) canetif4vc4.setDevice(canetdev) #canetif4vc4.setLabel(link4label) canetif4vc4.setLabelSet(link4range) canetif4oc = pynt.xmlns.CreateRDFObject("if4-oc", namespace=canetns, klass=pynt.elements.StaticInterface) canetif4oc.setLayer(oclayer) canetif4oc.setDevice(canetdev) canetif4lambda = pynt.xmlns.CreateRDFObject("if4-lambda", namespace=canetns, klass=pynt.elements.StaticInterface) canetif4lambda.setLayer(lambdalayer) canetif4lambda.setDevice(canetdev) canetif4lambda.setLabel(1310.0) canetif4fiber = pynt.xmlns.CreateRDFObject("if4-fiber", namespace=canetns, klass=pynt.elements.StaticInterface) canetif4fiber.setLayer(fiberlayer) canetif4fiber.setDevice(canetdev) canetif4fiber.addClientInterface(canetif4lambda, lambdainfiber) canetif4lambda.addClientInterface(canetif4oc, ocinlambda) canetif4oc.addClientInterface(canetif4vc4, stsinoc) # if5: Potential VC-4 (26 free labels) over OC over Lambda over Fiber #canetif5vc4 = pynt.xmlns.CreateRDFObject("if5-vc4", namespace=canetns, klass=pynt.elements.PotentialMuxInterface) #canetif5vc4.setLayer(vc4layer) #canetif5vc4.setDevice(canetdev) ##canetif5vc4.setLabel(link5label) #canetif5vc4.setLabelSet(link5range) #canetif5oc = pynt.xmlns.CreateRDFObject("if5-oc", namespace=canetns, klass=pynt.elements.StaticInterface) #canetif5oc.setLayer(oclayer) #canetif5oc.setDevice(canetdev) #canetif5lambda = pynt.xmlns.CreateRDFObject("if5-lambda", namespace=canetns, klass=pynt.elements.StaticInterface) #canetif5lambda.setLayer(lambdalayer) #canetif5lambda.setDevice(canetdev) #canetif5lambda.setLabel(1310.0) #canetif5fiber = pynt.xmlns.CreateRDFObject("if5-fiber", namespace=canetns, klass=pynt.elements.StaticInterface) #canetif5fiber.setLayer(fiberlayer) #canetif5fiber.setDevice(canetdev) #canetif5fiber.addClientInterface(canetif5lambda, lambdainfiber) #canetif5lambda.addClientInterface(canetif5oc, ocinlambda) #canetif5oc.addClientInterface(canetif5vc4, stsinoc) # VC-4 Switch Matrix, only switching (no swapping) canetsw = pynt.elements.GetCreateSwitchMatrix("CAnetSwitchMatrix", namespace=canetns) canetsw.setLayer(vc4layer) canetsw.setDevice(canetdev) canetsw.setSwitchingCapability(True) canetsw.setSwappingCapability(False) canetsw.setUnicast(True) canetsw.addInterface(canetif1cvc4) canetsw.addInterface(canetif2vc4) canetsw.addInterface(canetif4vc4) #canetsw.addInterface(canetif5vc4) switchmatrix = canetif1cvc4.getSwitchMatrix() # # StarLight # starlns = pynt.xmlns.GetCreateNamespace("http://starlight.org/#") domainNamespaces.append(starlns) starldev = pynt.elements.GetCreateDevice("StarLightDevice", namespace=starlns) starldev.setName("StarLight") # if2: Potential Ethernet over (either 7 or 8 variant) Potential? VC-4 (fixed label: 42) over OC over Lambda over Fiber starlif2eth7 = pynt.xmlns.CreateRDFObject("if2-eth7", namespace=starlns, klass=pynt.elements.PotentialMuxInterface) starlif2eth7.setLayer(ethlayer) starlif2eth7.setDevice(starldev) starlif2eth8 = pynt.xmlns.CreateRDFObject("if2-eth8", namespace=starlns, klass=pynt.elements.PotentialMuxInterface) starlif2eth8.setLayer(ethlayer) starlif2eth8.setDevice(starldev) starlif2vc4 = pynt.xmlns.CreateRDFObject("if2-vc4", namespace=starlns, klass=pynt.elements.ConfigurableInterface) starlif2vc4.setLayer(vc4layer) starlif2vc4.setDevice(starldev) starlif2vc4.setLabel(link2label) starlif2vc4.setLabelSet(link2range) starlif2oc = pynt.xmlns.CreateRDFObject("if2-oc", namespace=starlns, klass=pynt.elements.StaticInterface) starlif2oc.setLayer(oclayer) starlif2oc.setDevice(starldev) starlif2lambda = pynt.xmlns.CreateRDFObject("if2-lambda", namespace=starlns, klass=pynt.elements.StaticInterface) starlif2lambda.setLayer(lambdalayer) starlif2lambda.setDevice(starldev) starlif2lambda.setLabel(1310.0) starlif2fiber = pynt.xmlns.CreateRDFObject("if2-fiber", namespace=starlns, klass=pynt.elements.StaticInterface) starlif2fiber.setLayer(fiberlayer) starlif2fiber.setDevice(starldev) starlif2fiber.addClientInterface(starlif2lambda, lambdainfiber) starlif2lambda.addClientInterface(starlif2oc, ocinlambda) starlif2oc.addClientInterface(starlif2vc4, stsinoc) starlif2vc4.addClientInterface(starlif2eth7, ethin7vc4) starlif2vc4.addClientInterface(starlif2eth8, ethin8vc4) # if3: Potential Ethernet over (either 7 or 8 variant) Potential? VC-4 (fixed label: 42) over OC over Lambda over Fiber starlif3eth7 = pynt.xmlns.CreateRDFObject("if3-eth7", namespace=starlns, klass=pynt.elements.PotentialMuxInterface) starlif3eth7.setLayer(ethlayer) starlif3eth7.setDevice(starldev) starlif3eth8 = pynt.xmlns.CreateRDFObject("if3-eth8", namespace=starlns, klass=pynt.elements.PotentialMuxInterface) starlif3eth8.setLayer(ethlayer) starlif3eth8.setDevice(starldev) starlif3vc4 = pynt.xmlns.CreateRDFObject("if3-vc4", namespace=starlns, klass=pynt.elements.ConfigurableInterface) starlif3vc4.setLayer(vc4layer) starlif3vc4.setDevice(starldev) starlif3vc4.setLabel(link3label) starlif3vc4.setLabelSet(link3range) starlif3oc = pynt.xmlns.CreateRDFObject("if3-oc", namespace=starlns, klass=pynt.elements.StaticInterface) starlif3oc.setLayer(oclayer) starlif3oc.setDevice(starldev) starlif3lambda = pynt.xmlns.CreateRDFObject("if3-lambda", namespace=starlns, klass=pynt.elements.StaticInterface) starlif3lambda.setLayer(lambdalayer) starlif3lambda.setDevice(starldev) starlif3lambda.setLabel(1310.0) starlif3fiber = pynt.xmlns.CreateRDFObject("if3-fiber", namespace=starlns, klass=pynt.elements.StaticInterface) starlif3fiber.setLayer(fiberlayer) starlif3fiber.setDevice(starldev) starlif3fiber.addClientInterface(starlif3lambda, lambdainfiber) starlif3lambda.addClientInterface(starlif3oc, ocinlambda) starlif3oc.addClientInterface(starlif3vc4, stsinoc) starlif3vc4.addClientInterface(starlif3eth7, ethin7vc4) starlif3vc4.addClientInterface(starlif3eth8, ethin8vc4) # Ethernet Switch Matrix, no labels (switching only) starlethsw = pynt.elements.GetCreateSwitchMatrix("StarLightEthernetSwitchMatrix", namespace=starlns) starlethsw.setLayer(ethlayer) starlethsw.setDevice(starldev) starlethsw.setSwitchingCapability(True) starlethsw.setSwappingCapability(True) starlethsw.setUnicast(False) starlethsw.setBroadcast(True) starlethsw.addInterface(starlif2eth7) starlethsw.addInterface(starlif2eth8) starlethsw.addInterface(starlif3eth7) starlethsw.addInterface(starlif3eth8) # VC-4 Switch Matrix, switching and swapping starlvc4sw = pynt.elements.GetCreateSwitchMatrix("StarLightVC-4SwitchMatrix", namespace=starlns) starlvc4sw.setLayer(vc4layer) starlvc4sw.setDevice(starldev) starlvc4sw.setSwitchingCapability(True) starlvc4sw.setSwappingCapability(True) starlvc4sw.setUnicast(True) starlvc4sw.addInterface(starlif2vc4) starlvc4sw.addInterface(starlif3vc4) # # MAN LAN # manlanns = pynt.xmlns.GetCreateNamespace("http://manlan.internet2.edu/#") domainNamespaces.append(manlanns) manlandev = pynt.elements.GetCreateDevice("ManLanDevice", namespace=manlanns) manlandev.setName("MAN LAN") # if3: Potential VC-4 (38 free labels) over OC over Lambda over Fiber manlanif3vc4 = pynt.xmlns.CreateRDFObject("if3-vc4", namespace=manlanns, klass=pynt.elements.PotentialMuxInterface) manlanif3vc4.setLayer(vc4layer) manlanif3vc4.setDevice(manlandev) #manlanif3vc4.setLabel(link3label) manlanif3vc4.setLabelSet(link3range) manlanif3oc = pynt.xmlns.CreateRDFObject("if3-oc", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif3oc.setLayer(oclayer) manlanif3oc.setDevice(manlandev) manlanif3lambda = pynt.xmlns.CreateRDFObject("if3-lambda", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif3lambda.setLayer(lambdalayer) manlanif3lambda.setDevice(manlandev) manlanif3lambda.setLabel(1310.0) manlanif3fiber = pynt.xmlns.CreateRDFObject("if3-fiber", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif3fiber.setLayer(fiberlayer) manlanif3fiber.setDevice(manlandev) manlanif3fiber.addClientInterface(manlanif3lambda, lambdainfiber) manlanif3lambda.addClientInterface(manlanif3oc, ocinlambda) manlanif3oc.addClientInterface(manlanif3vc4, stsinoc) # if4: Potential VC-4 (61 free labels) over OC over Lambda over Fiber manlanif4vc4 = pynt.xmlns.CreateRDFObject("if4-vc4", namespace=manlanns, klass=pynt.elements.PotentialMuxInterface) manlanif4vc4.setLayer(vc4layer) manlanif4vc4.setDevice(manlandev) #manlanif4vc4.setLabel(link4label) manlanif4vc4.setLabelSet(link4range) manlanif4oc = pynt.xmlns.CreateRDFObject("if4-oc", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif4oc.setLayer(oclayer) manlanif4oc.setDevice(manlandev) manlanif4lambda = pynt.xmlns.CreateRDFObject("if4-lambda", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif4lambda.setLayer(lambdalayer) manlanif4lambda.setDevice(manlandev) manlanif4lambda.setLabel(1310.0) manlanif4fiber = pynt.xmlns.CreateRDFObject("if4-fiber", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif4fiber.setLayer(fiberlayer) manlanif4fiber.setDevice(manlandev) manlanif4fiber.addClientInterface(manlanif4lambda, lambdainfiber) manlanif4lambda.addClientInterface(manlanif4oc, ocinlambda) manlanif4oc.addClientInterface(manlanif4vc4, stsinoc) ## if5: Potential VC-4 (26 free labels) over OC over Lambda over Fiber #manlanif5vc4 = pynt.xmlns.CreateRDFObject("if5-vc4", namespace=manlanns, klass=pynt.elements.PotentialMuxInterface) #manlanif5vc4.setLayer(vc4layer) #manlanif5vc4.setDevice(manlandev) ##manlanif5vc4.setLabel(link5label) #manlanif5vc4.setLabelSet(link5range) #manlanif5oc = pynt.xmlns.CreateRDFObject("if5-oc", namespace=manlanns, klass=pynt.elements.StaticInterface) #manlanif5oc.setLayer(oclayer) #manlanif5oc.setDevice(manlandev) #manlanif5lambda = pynt.xmlns.CreateRDFObject("if5-lambda", namespace=manlanns, klass=pynt.elements.StaticInterface) #manlanif5lambda.setLayer(lambdalayer) #manlanif5lambda.setDevice(manlandev) #manlanif5lambda.setLabel(1310.0) #manlanif5fiber = pynt.xmlns.CreateRDFObject("if5-fiber", namespace=manlanns, klass=pynt.elements.StaticInterface) #manlanif5fiber.setLayer(fiberlayer) #manlanif5fiber.setDevice(manlandev) #manlanif5fiber.addClientInterface(manlanif5lambda, lambdainfiber) #manlanif5lambda.addClientInterface(manlanif5oc, ocinlambda) #manlanif5oc.addClientInterface(manlanif5vc4, stsinoc) # if6: Potential VC-4 (30 free labels) over OC over Lambda over Fiber manlanif6vc4 = pynt.xmlns.CreateRDFObject("if6-vc4", namespace=manlanns, klass=pynt.elements.PotentialMuxInterface) manlanif6vc4.setLayer(vc4layer) manlanif6vc4.setDevice(manlandev) #manlanif6vc4.setLabel(link6label) manlanif6vc4.setLabelSet(link6range) manlanif6oc = pynt.xmlns.CreateRDFObject("if6-oc", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif6oc.setLayer(oclayer) manlanif6oc.setDevice(manlandev) manlanif6lambda = pynt.xmlns.CreateRDFObject("if6-lambda", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif6lambda.setLayer(lambdalayer) manlanif6lambda.setDevice(manlandev) manlanif6lambda.setLabel(1310.0) manlanif6fiber = pynt.xmlns.CreateRDFObject("if6-fiber", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif6fiber.setLayer(fiberlayer) manlanif6fiber.setDevice(manlandev) manlanif6fiber.addClientInterface(manlanif6lambda, lambdainfiber) manlanif6lambda.addClientInterface(manlanif6oc, ocinlambda) manlanif6oc.addClientInterface(manlanif6vc4, stsinoc) # if7: Potential VC-4 (33 free labels) over OC over Lambda over Fiber manlanif7vc4 = pynt.xmlns.CreateRDFObject("if7-vc4", namespace=manlanns, klass=pynt.elements.PotentialMuxInterface) manlanif7vc4.setLayer(vc4layer) manlanif7vc4.setDevice(manlandev) #manlanif7vc4.setLabel(link7label) manlanif7vc4.setLabelSet(link7range) manlanif7oc = pynt.xmlns.CreateRDFObject("if7-oc", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif7oc.setLayer(oclayer) manlanif7oc.setDevice(manlandev) manlanif7lambda = pynt.xmlns.CreateRDFObject("if7-lambda", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif7lambda.setLayer(lambdalayer) manlanif7lambda.setDevice(manlandev) manlanif7lambda.setLabel(1310.0) manlanif7fiber = pynt.xmlns.CreateRDFObject("if7-fiber", namespace=manlanns, klass=pynt.elements.StaticInterface) manlanif7fiber.setLayer(fiberlayer) manlanif7fiber.setDevice(manlandev) manlanif7fiber.addClientInterface(manlanif7lambda, lambdainfiber) manlanif7lambda.addClientInterface(manlanif7oc, ocinlambda) manlanif7oc.addClientInterface(manlanif7vc4, stsinoc) # VC-4 Switch Matrix, switching and swapping manlansw = pynt.elements.GetCreateSwitchMatrix("ManLanSwitchMatrix", namespace=manlanns) manlansw.setLayer(vc4layer) manlansw.setDevice(manlandev) manlansw.setSwitchingCapability(True) manlansw.setSwappingCapability(True) manlansw.setUnicast(True) manlansw.addInterface(manlanif3vc4) manlansw.addInterface(manlanif4vc4) #manlansw.addInterface(manlanif5vc4) manlansw.addInterface(manlanif6vc4) manlansw.addInterface(manlanif7vc4) # # NetherLight # netherlns = pynt.xmlns.GetCreateNamespace("http://netherlight.net/#") domainNamespaces.append(netherlns) netherldev = pynt.elements.GetCreateDevice("NetherLightDevice", namespace=netherlns) netherldev.setName("NetherLight") # if6: Potential VC-4 (30 free labels) over OC over Lambda over Fiber netherl6vc4 = pynt.xmlns.CreateRDFObject("if6-vc4", namespace=netherlns, klass=pynt.elements.PotentialMuxInterface) netherl6vc4.setLayer(vc4layer) netherl6vc4.setDevice(netherldev) #netherl6vc4.setLabel(link6label) netherl6vc4.setLabelSet(link6range) netherl6oc = pynt.xmlns.CreateRDFObject("if6-oc", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl6oc.setLayer(oclayer) netherl6oc.setDevice(netherldev) netherl6lambda = pynt.xmlns.CreateRDFObject("if6-lambda", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl6lambda.setLayer(lambdalayer) netherl6lambda.setDevice(netherldev) netherl6lambda.setLabel(1310.0) netherl6fiber = pynt.xmlns.CreateRDFObject("if6-fiber", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl6fiber.setLayer(fiberlayer) netherl6fiber.setDevice(netherldev) netherl6fiber.addClientInterface(netherl6lambda, lambdainfiber) netherl6lambda.addClientInterface(netherl6oc, ocinlambda) netherl6oc.addClientInterface(netherl6vc4, stsinoc) # if7: Potential VC-4 (33 free labels) over OC over Lambda over Fiber netherl7vc4 = pynt.xmlns.CreateRDFObject("if7-vc4", namespace=netherlns, klass=pynt.elements.PotentialMuxInterface) netherl7vc4.setLayer(vc4layer) netherl7vc4.setDevice(netherldev) #netherl7vc4.setLabel(link7label) netherl7vc4.setLabelSet(link7range) netherl7oc = pynt.xmlns.CreateRDFObject("if7-oc", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl7oc.setLayer(oclayer) netherl7oc.setDevice(netherldev) netherl7lambda = pynt.xmlns.CreateRDFObject("if7-lambda", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl7lambda.setLayer(lambdalayer) netherl7lambda.setDevice(netherldev) netherl7lambda.setLabel(1310.0) netherl7fiber = pynt.xmlns.CreateRDFObject("if7-fiber", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl7fiber.setLayer(fiberlayer) netherl7fiber.setDevice(netherldev) netherl7fiber.addClientInterface(netherl7lambda, lambdainfiber) netherl7lambda.addClientInterface(netherl7oc, ocinlambda) netherl7oc.addClientInterface(netherl7vc4, stsinoc) # if8 (a): Ethernet over UTP # if8 (b): Ethernet over (7-variant) VC-4 # if8 (c): VC-4 (fixed label: 28) netherl8aeth = pynt.xmlns.CreateRDFObject("if8a-eth", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl8aeth.setLayer(ethlayer) netherl8aeth.setDevice(netherldev) netherl8autp = pynt.xmlns.CreateRDFObject("if8a-utp", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl8autp.setLayer(utplayer) netherl8autp.setDevice(netherldev) netherl8autp.addClientInterface(netherl8aeth, ethinutp) netherl8beth = pynt.xmlns.CreateRDFObject("if8b-eth", namespace=netherlns, klass=pynt.elements.StaticInterface) netherl8beth.setLayer(ethlayer) netherl8beth.setDevice(netherldev) netherl8bvc4 = pynt.xmlns.CreateRDFObject("if8b-vc4", namespace=netherlns, klass=pynt.elements.ConfigurableInterface) netherl8bvc4.setLayer(vc4layer) netherl8bvc4.setDevice(netherldev) netherl8bvc4.setLabel(link8label) netherl8bvc4.setLabelSet(link8range) netherl8bvc4.addClientInterface(netherl8beth, ethin7vc4) netherl8aeth.addSwitchedInterface(netherl8beth) netherl8beth.addSwitchedInterface(netherl8aeth) netherl8cvc4 = pynt.xmlns.CreateRDFObject("if8c-vc4", namespace=netherlns, klass=pynt.elements.ConfigurableInterface) netherl8cvc4.setLayer(vc4layer) netherl8cvc4.setDevice(netherldev) netherl8cvc4.setLabel(link8label) netherl8cvc4.setLabelSet(vc4range) netherl8bvc4.addLinkedInterface(netherl8cvc4) netherl8cvc4.addLinkedInterface(netherl8bvc4) # VC-4 Switch Matrix, only switching (no swapping) netherlsw = pynt.elements.GetCreateSwitchMatrix("NetherlightSwitchMatrix", namespace=netherlns) netherlsw.setLayer(vc4layer) netherlsw.setDevice(netherldev) netherlsw.setSwitchingCapability(True) netherlsw.setSwappingCapability(False) netherlsw.setUnicast(True) netherlsw.addInterface(netherl6vc4) netherlsw.addInterface(netherl7vc4) netherlsw.addInterface(netherl8cvc4) # # Universiteit van Amsterdam # uvans = pynt.xmlns.GetCreateNamespace("http://uva.nl/#") domainNamespaces.append(uvans) uvadev = pynt.elements.GetCreateDevice("UvADevice", namespace=uvans) uvadev.setName("Amsterdam") # if8: Ethernet over UTP uvaif8utp = pynt.xmlns.CreateRDFObject("if8-utp", namespace=uvans, klass=pynt.elements.StaticInterface) uvaif8utp.setLayer(utplayer) uvaif8utp.setDevice(uvadev) uvaif8eth = pynt.xmlns.CreateRDFObject("if8-eth", namespace=uvans, klass=pynt.elements.StaticInterface) uvaif8eth.setLayer(ethlayer) uvaif8eth.setDevice(uvadev) uvaif8utp.addClientInterface(uvaif8eth, ethinutp) # no switch matrix # # Connections between the domains (Devices) # # Quebec <--> CA*net # if1 <--> if1 (a) (UTP layer) uqamif1utp.addLinkedInterface(canetif1autp) canetif1autp.addLinkedInterface(uqamif1utp) # CA*net <--> StarLight # if2 <--> if2 (fiber layer) canetif2fiber.addLinkedInterface(starlif2fiber) starlif2fiber.addLinkedInterface(canetif2fiber) # StarLight <--> MAN LAN # if3 <--> if3 (fiber layer) starlif3fiber.addLinkedInterface(manlanif3fiber) manlanif3fiber.addLinkedInterface(starlif3fiber) # CA*net <--> MAN LAN # if4 <--> if4 (fiber layer) # if5 <--> if5 (fiber layer) canetif4fiber.addLinkedInterface(manlanif4fiber) manlanif4fiber.addLinkedInterface(canetif4fiber) #canetif5fiber.addLinkedInterface(manlanif5fiber) #manlanif5fiber.addLinkedInterface(canetif5fiber) # MAN LAN <--> NetherLight # if6 <--> if6 (fiber layer) # if7 <--> if7 (fiber layer) manlanif6fiber.addLinkedInterface(netherl6fiber) netherl6fiber.addLinkedInterface(manlanif6fiber) manlanif7fiber.addLinkedInterface(netherl7fiber) netherl7fiber.addLinkedInterface(manlanif7fiber) # NetherLight <--> Amsterdam # if8 (a) <--> if8 (UTP layer) netherl8autp.addLinkedInterface(uvaif8utp) uvaif8utp.addLinkedInterface(netherl8autp) return domainNamespaces
def DefineNetwork(): # - Earth 1 physical interface: Ethernet # - Vogon 4 physical interface: Ethernet, SONET (3x), 1 Switch Matrix (SONET); 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - StarLight 2 physical interfaces: SONET/Ethernet, 2 Switch Matrices (SONET and Ethernet) # - MANLAN 5 physical interfaces: SONET, 1 Switch Matrix (SONET) # - NetherLight 3 physical interface: Ethernet, SONET (2x), 1 Switch Matrix; 1 fixed switchedTo outside matrix (for Ethernet in SONET) # - Amsterdam 1 physical interface: Ethernet # Ford # | vlan 28 untagged # Earth ----------------- Vogon ----------------- Golgafrinchan # tagged | | # | tagged | # tagged | tagged | vlan 42 # Betelgeuse ------------ Haggunenons ----------- Margrathea --- Dolphins # | vlan 42 | vlan 42 # Zaphod Mice # domainNamespaces = [] # Get all namespaces, layers and adaptations. ethns = pynt.xmlns.GetNamespaceByPrefix("ethernet") ethlayer = pynt.xmlns.GetRDFObject("EthernetNetworkElement", namespace=ethns, klass=pynt.layers.Layer) ethineth = pynt.xmlns.GetRDFObject("Tagged-Ethernet", namespace=ethns, klass=pynt.layers.AdaptationFunction) logger = logging.getLogger("network") logger.log(25, "Building demo Ethernet network in memory") ieee8021qrange = pynt.rangeset.RangeSet("0-4095", itemtype=int, interval=1) vlan42 = pynt.rangeset.RangeSet("42", itemtype=int, interval=1) vlan28 = pynt.rangeset.RangeSet("28", itemtype=int, interval=1) vlanno42 = ieee8021qrange - vlan42 exns = pynt.xmlns.GetCreateNamespace("http://example.net/#") # # External # ford = pynt.xmlns.GetCreateRDFObject("Ford", namespace=exns, klass=pynt.elements.StaticInterface) ford.setLayer(ethlayer) ford.setLabel(None) zaphod = pynt.xmlns.GetCreateRDFObject("Zaphod", namespace=exns, klass=pynt.elements.StaticInterface) zaphod.setLayer(ethlayer) zaphod.setLabel(None) dolphins = pynt.xmlns.GetCreateRDFObject("Dolphins", namespace=exns, klass=pynt.elements.StaticInterface) dolphins.setLayer(ethlayer) dolphins.setLabel(None) mice = pynt.xmlns.GetCreateRDFObject("Mice", namespace=exns, klass=pynt.elements.StaticInterface) mice.setLayer(ethlayer) mice.setLabel(None) # # Earth: # earth = pynt.elements.GetCreateDevice("Earth", namespace=exns) # ifford: Untagged, VLAN 28 ifearth_ford = pynt.xmlns.GetCreateRDFObject("ifearth_ford", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifearth_ford.setLayer(ethlayer) ifearth_ford.setDevice(earth) ifearth_ford.setLabel(28) ifearth_ford.setInternalLabelSet(vlan28) # ifvogon: Tagged, all VLANs ifearth_vogon_tag = pynt.xmlns.GetCreateRDFObject("ifearth_vogon_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifearth_vogon_tag.setLayer(ethlayer) ifearth_vogon_tag.setDevice(earth) ifearth_vogon_tag.setLabelSet(vlan28) ifearth_vogon_unt = pynt.xmlns.GetCreateRDFObject("ifearth_vogon_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifearth_vogon_unt.setLayer(ethlayer) ifearth_vogon_unt.setDevice(earth) ifearth_vogon_unt.setLabel(None) ifearth_vogon_unt.addClientInterface(ifearth_vogon_tag, ethineth) # Ethernet switch matrix earthswitch = pynt.elements.GetCreateSwitchMatrix("EarthSwitch", namespace=exns) earthswitch.setLayer(ethlayer) earthswitch.setDevice(earth) earthswitch.setSwitchingCapability(True) earthswitch.setSwappingCapability(False) earthswitch.setUnicast(False) earthswitch.setBroadcast(True) earthswitch.addInterface(ifearth_ford) earthswitch.addInterface(ifearth_vogon_tag) # # Vogon: # vogon = pynt.elements.GetCreateDevice("Vogon", namespace=exns) # ifearth: Tagged, all VLANs ifvogon_earth_tag = pynt.xmlns.GetCreateRDFObject("ifvogon_earth_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifvogon_earth_tag.setLayer(ethlayer) ifvogon_earth_tag.setDevice(vogon) ifvogon_earth_tag.setLabelSet(ieee8021qrange) ifvogon_earth_unt = pynt.xmlns.GetCreateRDFObject("ifvogon_earth_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifvogon_earth_unt.setLayer(ethlayer) ifvogon_earth_unt.setDevice(vogon) ifvogon_earth_unt.setLabel(None) ifvogon_earth_unt.addClientInterface(ifvogon_earth_tag, ethineth) # ifhaggu: Tagged, all VLANs ifvogon_haggu_tag = pynt.xmlns.GetCreateRDFObject("ifvogon_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifvogon_haggu_tag.setLayer(ethlayer) ifvogon_haggu_tag.setDevice(vogon) ifvogon_haggu_tag.setLabelSet(ieee8021qrange) ifvogon_haggu_unt = pynt.xmlns.GetCreateRDFObject("ifvogon_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifvogon_haggu_unt.setLayer(ethlayer) ifvogon_haggu_unt.setDevice(vogon) ifvogon_haggu_unt.setLabel(None) ifvogon_haggu_unt.addClientInterface(ifvogon_haggu_tag, ethineth) # ifgolga: Untagged, any VLAN ifvogon_golga_unt = pynt.xmlns.GetCreateRDFObject("ifvogon_golga_unt", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifvogon_golga_unt.setLayer(ethlayer) ifvogon_golga_unt.setDevice(vogon) ifvogon_golga_unt.setLabel(0) ifvogon_golga_unt.setLabelSet(None) ifvogon_golga_unt.setInternalLabelSet(ieee8021qrange) # Ethernet switch matrix vogonswitch = pynt.elements.GetCreateSwitchMatrix("VogonSwitch", namespace=exns) vogonswitch.setLayer(ethlayer) vogonswitch.setDevice(vogon) vogonswitch.setSwitchingCapability(True) vogonswitch.setSwappingCapability(False) vogonswitch.setUnicast(False) vogonswitch.setBroadcast(True) vogonswitch.addInterface(ifvogon_earth_tag) vogonswitch.addInterface(ifvogon_haggu_tag) vogonswitch.addInterface(ifvogon_golga_unt) # # Golgafrinchan: # golga = pynt.elements.GetCreateDevice("Golgafrinchan", namespace=exns) # ifvogon: Untagged, any VLAN ifgolga_vogon_unt = pynt.xmlns.GetCreateRDFObject("ifgolga_vogon_unt", namespace=exns, klass=pynt.elements.ConfigurableInterface) ifgolga_vogon_unt.setLayer(ethlayer) ifgolga_vogon_unt.setDevice(golga) ifgolga_vogon_unt.setLabel(0) ifgolga_vogon_unt.setLabelSet(None) ifgolga_vogon_unt.setInternalLabelSet(ieee8021qrange) # ifmargr: Tagged, all VLANs ifgolga_margr_tag = pynt.xmlns.GetCreateRDFObject("ifgolga_margr_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifgolga_margr_tag.setLayer(ethlayer) ifgolga_margr_tag.setDevice(golga) ifgolga_margr_tag.setLabelSet(ieee8021qrange) ifgolga_margr_unt = pynt.xmlns.GetCreateRDFObject("ifgolga_margr_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifgolga_margr_unt.setLayer(ethlayer) ifgolga_margr_unt.setDevice(golga) ifgolga_margr_unt.setLabel(None) ifgolga_margr_unt.addClientInterface(ifgolga_margr_tag, ethineth) # Ethernet switch matrix golgaswitch = pynt.elements.GetCreateSwitchMatrix("GolgafrinchanSwitch", namespace=exns) golgaswitch.setLayer(ethlayer) golgaswitch.setDevice(golga) golgaswitch.setSwitchingCapability(True) golgaswitch.setSwappingCapability(False) golgaswitch.setUnicast(False) golgaswitch.setBroadcast(True) golgaswitch.addInterface(ifgolga_vogon_unt) golgaswitch.addInterface(ifgolga_margr_tag) # # Margrathea: # margrathea = pynt.elements.GetCreateDevice("Margrathea", namespace=exns) # ifgolga: Tagged, all VLANs except 42 ifmargr_golga_tag = pynt.xmlns.GetCreateRDFObject("ifmargr_golga_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifmargr_golga_tag.setLayer(ethlayer) ifmargr_golga_tag.setDevice(margrathea) ifmargr_golga_tag.setLabelSet(vlanno42) # TODO: test if (ieee8021qrange) work. Broadcast should remove VLAN 42. ifmargr_golga_unt = pynt.xmlns.GetCreateRDFObject("ifmargr_golga_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_golga_unt.setLayer(ethlayer) ifmargr_golga_unt.setDevice(margrathea) ifmargr_golga_unt.setLabel(None) ifmargr_golga_unt.addClientInterface(ifmargr_golga_tag, ethineth) # ifhaggu: Tagged, all VLANs except 42 ifmargr_haggu_tag = pynt.xmlns.GetCreateRDFObject("ifmargr_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifmargr_haggu_tag.setLayer(ethlayer) ifmargr_haggu_tag.setDevice(margrathea) ifmargr_haggu_tag.setLabelSet(vlanno42) # TODO: test if (ieee8021qrange) work. Broadcast should remove VLAN 42. ifmargr_haggu_unt = pynt.xmlns.GetCreateRDFObject("ifmargr_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_haggu_unt.setLayer(ethlayer) ifmargr_haggu_unt.setDevice(margrathea) ifmargr_haggu_unt.setLabel(None) ifmargr_haggu_unt.addClientInterface(ifmargr_haggu_tag, ethineth) # ifdolphins: Untagged, VLAN 42 ifmargr_dolphins = pynt.xmlns.GetCreateRDFObject("ifmargr_dolphins", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_dolphins.setLayer(ethlayer) ifmargr_dolphins.setDevice(margrathea) ifmargr_dolphins.setLabel(None) ifmargr_dolphins.setInternalLabel(42) # ifmice: Untagged, VLAN 42 ifmargr_mice = pynt.xmlns.GetCreateRDFObject("ifmargr_mice", namespace=exns, klass=pynt.elements.StaticInterface) ifmargr_mice.setLayer(ethlayer) ifmargr_mice.setDevice(margrathea) ifmargr_mice.setLabel(None) ifmargr_mice.setInternalLabel(42) # Ethernet switch matrix margrswitch = pynt.elements.GetCreateSwitchMatrix("MargratheaSwitch", namespace=exns) margrswitch.setLayer(ethlayer) margrswitch.setDevice(margrathea) margrswitch.setSwitchingCapability(True) margrswitch.setSwappingCapability(False) margrswitch.setUnicast(False) margrswitch.setBroadcast(True) margrswitch.addInterface(ifmargr_golga_tag) margrswitch.addInterface(ifmargr_haggu_tag) margrswitch.addInterface(ifmargr_dolphins) margrswitch.addInterface(ifmargr_mice) # # Haggunenons: # haggunenons = pynt.elements.GetCreateDevice("Haggunenons", namespace=exns) # ifmargr: Tagged, all VLANs ifhaggu_margr_tag = pynt.xmlns.GetCreateRDFObject("ifhaggu_margr_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_margr_tag.setLayer(ethlayer) ifhaggu_margr_tag.setDevice(haggunenons) ifhaggu_margr_tag.setLabelSet(ieee8021qrange) ifhaggu_margr_unt = pynt.xmlns.GetCreateRDFObject("ifhaggu_margr_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_margr_unt.setLayer(ethlayer) ifhaggu_margr_unt.setDevice(haggunenons) ifhaggu_margr_unt.setLabel(None) ifhaggu_margr_unt.addClientInterface(ifhaggu_margr_tag, ethineth) # ifvogon: Tagged, all VLANs ifhaggu_vogon_tag = pynt.xmlns.GetCreateRDFObject("ifhaggu_vogon_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_vogon_tag.setLayer(ethlayer) ifhaggu_vogon_tag.setDevice(haggunenons) ifhaggu_vogon_tag.setLabelSet(ieee8021qrange) ifhaggu_vogon_unt = pynt.xmlns.GetCreateRDFObject("ifhaggu_vogon_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_vogon_unt.setLayer(ethlayer) ifhaggu_vogon_unt.setDevice(haggunenons) ifhaggu_vogon_unt.setLabel(None) ifhaggu_vogon_unt.addClientInterface(ifhaggu_vogon_tag, ethineth) # ifbetel: Tagged, all VLANs ifhaggu_betel_tag = pynt.xmlns.GetCreateRDFObject("ifhaggu_betel_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifhaggu_betel_tag.setLayer(ethlayer) ifhaggu_betel_tag.setDevice(haggunenons) ifhaggu_betel_tag.setLabelSet(vlan42) ifhaggu_betel_unt = pynt.xmlns.GetCreateRDFObject("ifhaggu_betel_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifhaggu_betel_unt.setLayer(ethlayer) ifhaggu_betel_unt.setDevice(haggunenons) ifhaggu_betel_unt.setLabel(None) ifhaggu_betel_unt.addClientInterface(ifhaggu_betel_tag, ethineth) # Ethernet switch matrix hagguswitch = pynt.elements.GetCreateSwitchMatrix("HaggunenonsSwitch", namespace=exns) hagguswitch.setLayer(ethlayer) hagguswitch.setDevice(haggunenons) hagguswitch.setSwitchingCapability(True) hagguswitch.setSwappingCapability(False) hagguswitch.setUnicast(False) hagguswitch.setBroadcast(True) hagguswitch.addInterface(ifhaggu_margr_tag) hagguswitch.addInterface(ifhaggu_vogon_tag) hagguswitch.addInterface(ifhaggu_betel_tag) # # Betelgeuse: # betelgeuse = pynt.elements.GetCreateDevice("Betelgeuse", namespace=exns) # ifford: Untagged, VLAN 28 ifbetel_zaphod = pynt.xmlns.GetCreateRDFObject("ifbetel_zaphod", namespace=exns, klass=pynt.elements.StaticInterface) ifbetel_zaphod.setLayer(ethlayer) ifbetel_zaphod.setDevice(betelgeuse) ifbetel_zaphod.setLabel(None) ifbetel_zaphod.setInternalLabel(42) # ifhaggu: Tagged, all VLANs ifbetel_haggu_tag = pynt.xmlns.GetCreateRDFObject("ifbetel_haggu_tag", namespace=exns, klass=pynt.elements.PotentialMuxInterface) ifbetel_haggu_tag.setLayer(ethlayer) ifbetel_haggu_tag.setDevice(betelgeuse) ifbetel_haggu_tag.setLabelSet(ieee8021qrange) ifbetel_haggu_unt = pynt.xmlns.GetCreateRDFObject("ifbetel_haggu_unt", namespace=exns, klass=pynt.elements.StaticInterface) ifbetel_haggu_unt.setLayer(ethlayer) ifbetel_haggu_unt.setDevice(betelgeuse) ifbetel_haggu_unt.setLabel(None) ifbetel_haggu_unt.addClientInterface(ifbetel_haggu_tag, ethineth) # Ethernet switch matrix betelswitch = pynt.elements.GetCreateSwitchMatrix("BetelgeuseSwitch", namespace=exns) betelswitch.setLayer(ethlayer) betelswitch.setDevice(betelgeuse) betelswitch.setSwitchingCapability(True) betelswitch.setSwappingCapability(False) betelswitch.setUnicast(False) betelswitch.setBroadcast(True) betelswitch.addInterface(ifbetel_zaphod) betelswitch.addInterface(ifbetel_haggu_tag) # # Connections between the domains (Devices) # # Earth <--> Ford ifearth_ford.addLinkedInterface(ford) ford.addLinkedInterface(ifearth_ford) # Earth <--> Vogon ifearth_vogon_unt.addLinkedInterface(ifvogon_earth_unt) ifvogon_earth_unt.addLinkedInterface(ifearth_vogon_unt) # Vogon <--> Haggunenons ifvogon_haggu_unt.addLinkedInterface(ifhaggu_vogon_unt) ifhaggu_vogon_unt.addLinkedInterface(ifvogon_haggu_unt) # Vogon <--> Golgafrinchan ifvogon_golga_unt.addLinkedInterface(ifgolga_vogon_unt) ifgolga_vogon_unt.addLinkedInterface(ifvogon_golga_unt) # Golgafrinchan <--> Margrathea ifgolga_margr_unt.addLinkedInterface(ifmargr_golga_unt) ifmargr_golga_unt.addLinkedInterface(ifgolga_margr_unt) # Margrathea <--> Dolphins ifmargr_dolphins.addLinkedInterface(dolphins) dolphins.addLinkedInterface(ifmargr_dolphins) # Margrathea <--> Mice ifmargr_mice.addLinkedInterface(mice) mice.addLinkedInterface(ifmargr_mice) # Haggunenons <--> Margrathea ifhaggu_margr_unt.addLinkedInterface(ifmargr_haggu_unt) ifmargr_haggu_unt.addLinkedInterface(ifhaggu_margr_unt) # Betelgeuse <--> Haggunenons ifbetel_haggu_unt.addLinkedInterface(ifhaggu_betel_unt) ifhaggu_betel_unt.addLinkedInterface(ifbetel_haggu_unt) # Betelgeuse <--> Zaphod ifbetel_zaphod.addLinkedInterface(zaphod) zaphod.addLinkedInterface(ifbetel_zaphod) return [exns]