def _check_prereqs(self): is_livecd = True try: open(constants.LIVECD_MARKER_FILE, 'rb').close() except: is_livecd = False is_lowmem = True try: open(constants.LOWMEM_MARKER_FILE, 'rb').close() except: is_lowmem = False n_ether = 0 try: ifaces = interfacehelper.get_interfaces() for i in ifaces.get_interface_list(): if i.is_ethernet_device(): n_ether += 1 except: pass print 'livecd prerequisites: is_livecd=%s, is_lowmem=%s, n_ether=%s' % (is_livecd, is_lowmem, n_ether) if (not is_livecd) or (is_lowmem) or (n_ether < 1): return False return True
def _check_prereqs(self): is_livecd = True try: open(constants.LIVECD_MARKER_FILE, 'rb').close() except: is_livecd = False is_lowmem = True try: open(constants.LOWMEM_MARKER_FILE, 'rb').close() except: is_lowmem = False ifaces = interfacehelper.get_interfaces() n_ether = 0 for i in ifaces.get_interface_list(): if i.is_ethernet_device(): n_ether += 1 print 'livecd prerequisites: is_livecd=%s, is_lowmem=%s, n_ether=%s' % ( is_livecd, is_lowmem, n_ether) if (not is_livecd) or (is_lowmem) or (n_ether < 1): return False return True
def render_link_maybe(self, ctx, data): from codebay.l2tpserver import interfacehelper from nevow.flat.ten import flatten have_network_connection = False try: ifname = 'eth0' # XXX: hardcoded in livecd ifaces = interfacehelper.get_interfaces() iface = ifaces.get_interface_by_name(ifname) if iface is not None: addr = iface.get_current_ipv4_address_info() if addr is not None: have_network_connection = True except: _log.exception( 'livecd cannot determine whether we have a network connection or not' ) if have_network_connection: return ctx.tag else: # XXX: ugly hack, but without this markup would need heavier elements txt = flatten(ctx.tag.children) return T.strong(_class='cb-strong')[txt]
def _interface_stats(): try: up_ifaces = interfacehelper.get_interfaces().get_interface_list() all_ifaces = interfacehelper.get_all_interfaces().get_interface_list() [rv, raw_table, err] = run_command([constants.CMD_IPTABLES_SAVE, '-t', 'raw'], retval=runcommand.FAIL) [rv, mangle_table, err] = run_command([constants.CMD_IPTABLES_SAVE, '-t', 'mangle'], retval=runcommand.FAIL) [rv, nat_table, err] = run_command([constants.CMD_IPTABLES_SAVE, '-t', 'nat'], retval=runcommand.FAIL) [rv, filter_table, err] = run_command([constants.CMD_IPTABLES_SAVE, '-t', 'filter'], retval=runcommand.FAIL) raw_len = len(raw_table.split('\n')) mangle_len = len(mangle_table.split('\n')) nat_len = len(nat_table.split('\n')) filter_len = len(filter_table.split('\n')) _log.info('NETWORKINFO: ' \ 'all interfaces: %d, ' \ 'up interfaces: %d, ' \ 'iptables size: %d (raw: %d, mangle: %d, nat: %d, filter: %d)', len(all_ifaces), len(up_ifaces), raw_len + mangle_len + nat_len + filter_len, raw_len, mangle_len, nat_len, filter_len) except: _log.exception('failed to get network stats')
def render_link_maybe(self, ctx, data): from codebay.l2tpserver import interfacehelper from nevow.flat.ten import flatten have_network_connection = False try: ifname = 'eth0' # XXX: hardcoded in livecd ifaces = interfacehelper.get_interfaces() iface = ifaces.get_interface_by_name(ifname) if iface is not None: addr = iface.get_current_ipv4_address_info() if addr is not None: have_network_connection = True except: _log.exception('livecd cannot determine whether we have a network connection or not') if have_network_connection: return ctx.tag else: # XXX: ugly hack, but without this markup would need heavier elements txt = flatten(ctx.tag.children) return T.strong(_class='cb-strong')[txt]
def reconcile_system_and_rdf_state(self, first_time=False): """Reconcile system and RDF states. Checks system device list and compares it against RDF device information. Extra PPP devices without RDF book-keeping information are terminated. Devices present in RDF but not in the system are also removed from RDF. After calling this function, the system and RDF should be reasonably synchronized. This function also detects and updates the 'liveness' of each PPP device. Devices which are not live are not taken into account in license computations, thus making their detection important. The function also updates global public/private interface rx/tx counters, rates, etc. This function should be periodically, with an interval of 1-10 minutes or so. """ # # XXX: If status is incomplete for some reason, this will now # spout exceptions. The code should check whether checking and # updating e.g. public interface status is useful at this point. # (pub_if, pub_if_name), (priv_if, priv_if_name) = helpers.get_ifaces(helpers.get_config()) # start timestamp now = datetime.datetime.utcnow() # get device info from system (ip command) _log.debug('reconcile: getting system info') ifaces = interfacehelper.get_interfaces() # build devname->node dict _log.debug('reconcile: build devname->rdf dev dict') rdfdevs = helpers.get_ppp_devices() rdfdevmap = self._build_rdf_devmap(rdfdevs) # reconcile devices, pass 1: system vs rdf [collect sysdevs dict at the same time] _log.debug('reconcile: pass 1, system vs rdf') sysdevs, pub_di, priv_di = self._reconcile_system_vs_rdf(rdfdevmap, ifaces, pub_if_name, priv_if_name) # do sysnukes for devices exceeding threshold for k in self._sysnuke_failures.keys(): if self._sysnuke_failures[k] >= SYSNUKE_FAILURE_LIMIT: try: _log.warning('sysnuke failure count for device %s too high, nuking' % k) self._nuke_system_device(k) del self._sysnuke_failures[k] except: _log.exception('sysnuke failed') # reconcile devices, pass 2: rdf vs system _log.debug('reconcile: pass 2, rdf vs system') self._reconcile_rdf_vs_system(rdfdevs, sysdevs) # do rdfnukes for devices exceeding threshold for k in self._rdfnuke_failures.keys(): # key = rdf node of type PppDevice if self._rdfnuke_failures[k] >= RDFNUKE_FAILURE_LIMIT: try: if k.hasS(ns.deviceName): devname = k.getS(ns.deviceName, rdf.String) else: devname = '<unknown devname>' _log.warning('rdfnuke failure count for device %s (%s) too high, nuking' % (k, devname)) self._nuke_rdf_device(k) del self._rdfnuke_failures[k] except: _log.exception('failed during reconcile, skipping device') # NB: device will be left in _rdfnuke_failures, and be removed next time # update rx/tx counters, transfer rates, etc # (reget devs because we may have nuked something) _log.debug('reconcile: updating rx/tx counters') rdfdevs = helpers.get_ppp_devices() self._update_rxtx_etc(now, rdfdevs, sysdevs) # update device liveness status _log.debug('reconcile: updating liveness status') rdfdevs = helpers.get_ppp_devices() self._update_liveness_status(now, rdfdevs) # update public/private interface status _log.debug('reconcile: updating public and/or private interface status') self._update_public_private_ifaces(now, ifaces, pub_di, priv_di, first_time)
def reconcile_system_and_rdf_state(self, first_time=False): """Reconcile system and RDF states. Checks system device list and compares it against RDF device information. Extra PPP devices without RDF book-keeping information are terminated. Devices present in RDF but not in the system are also removed from RDF. After calling this function, the system and RDF should be reasonably synchronized. This function also detects and updates the 'liveness' of each PPP device. Devices which are not live are not taken into account in license computations, thus making their detection important. The function also updates global public/private interface rx/tx counters, rates, etc. This function should be periodically, with an interval of 1-10 minutes or so. """ # # XXX: If status is incomplete for some reason, this will now # spout exceptions. The code should check whether checking and # updating e.g. public interface status is useful at this point. # (pub_if, pub_if_name), (priv_if, priv_if_name) = helpers.get_ifaces( helpers.get_config()) # start timestamp now = datetime.datetime.utcnow() # get device info from system (ip command) _log.debug('reconcile: getting system info') ifaces = interfacehelper.get_interfaces() # build devname->node dict _log.debug('reconcile: build devname->rdf dev dict') rdfdevs = helpers.get_ppp_devices() rdfdevmap = self._build_rdf_devmap(rdfdevs) # reconcile devices, pass 1: system vs rdf [collect sysdevs dict at the same time] _log.debug('reconcile: pass 1, system vs rdf') sysdevs, pub_di, priv_di = self._reconcile_system_vs_rdf( rdfdevmap, ifaces, pub_if_name, priv_if_name) # do sysnukes for devices exceeding threshold for k in self._sysnuke_failures.keys(): if self._sysnuke_failures[k] >= SYSNUKE_FAILURE_LIMIT: try: _log.warning( 'sysnuke failure count for device %s too high, nuking' % k) self._nuke_system_device(k) del self._sysnuke_failures[k] except: _log.exception('sysnuke failed') # reconcile devices, pass 2: rdf vs system _log.debug('reconcile: pass 2, rdf vs system') self._reconcile_rdf_vs_system(rdfdevs, sysdevs) # do rdfnukes for devices exceeding threshold for k in self._rdfnuke_failures.keys( ): # key = rdf node of type PppDevice if self._rdfnuke_failures[k] >= RDFNUKE_FAILURE_LIMIT: try: if k.hasS(ns.deviceName): devname = k.getS(ns.deviceName, rdf.String) else: devname = '<unknown devname>' _log.warning( 'rdfnuke failure count for device %s (%s) too high, nuking' % (k, devname)) self._nuke_rdf_device(k) del self._rdfnuke_failures[k] except: _log.exception('failed during reconcile, skipping device') # NB: device will be left in _rdfnuke_failures, and be removed next time # update rx/tx counters, transfer rates, etc # (reget devs because we may have nuked something) _log.debug('reconcile: updating rx/tx counters') rdfdevs = helpers.get_ppp_devices() self._update_rxtx_etc(now, rdfdevs, sysdevs) # update device liveness status _log.debug('reconcile: updating liveness status') rdfdevs = helpers.get_ppp_devices() self._update_liveness_status(now, rdfdevs) # update public/private interface status _log.debug( 'reconcile: updating public and/or private interface status') self._update_public_private_ifaces(now, ifaces, pub_di, priv_di, first_time)