def lldp_loop(self):
        """
        This function is how the topology is kept up to date.
        It will send out LLDP packets at every interval to
        update the topology.
        """
        while self.is_active:
	    self.lldp_event.clear()
            now = time.time()
            timeout = None
            ports_now = []
            ports = []
            for (key, data) in self.ports.items():
                if data.timestamp is None:
                    ports_now.append(key)
                    continue

                expire = data.timestamp + self.LLDP_SEND_PERIOD_PER_PORT
                if expire <= now:
                    ports.append(key)
                    continue

                timeout = expire - now
                break

            for port in ports_now:
                self.send_lldp_packet(port)
            for port in ports:
                self.send_lldp_packet(port)
                hub.sleep(self.LLDP_SEND_GUARD)      # don't burst
            if timeout is not None and ports:
                timeout = 0     # We have already slept
            # LOG.debug('lldp sleep %s', timeout)
            self.draw_graph(1, draw=True)
            self.lldp_event.wait(timeout=timeout)

	def _port_stats_requester(self):                           #Defining a function to send port stat request every 10 seconds 
            while True:
                for dp in self.switchports.keys():
                    switch = self.switches[dp]                         #Getting datapath from dpid
                    msg = parser13.OFPPortDescStatsRequest(switch)
                    switch.send_msg(msg)
                hub.sleep(5)                                      # Sleeping for five seconds

 def _topoThread(self):
     linkNode = self.zkConf['root'] + self.zkConf['topo'] + self.ip
     if self.zk.exists(linkNode):
         self.zk.set(linkNode, json.dumps(self.links))
     else:
         self.zk.create(linkNode, json.dumps(self.links))
     hub.sleep(self.interval)

 def _monitor(self):
     while True:
         tm_log = open("./ryu/app/AdaptiveIDS/tmlogs.txt", "w")
         tm_log.close()
         for dp in self.datapaths.values():
             self._request_stats(dp.datapath)
         hub.sleep(IDSCfgParams.FLOW_STATS_INTERVAL)

    def _discover(self):###periodically get topology information

	self.debugfile.write("child processing start"+"\n")
	self.debugfile.flush()
        i = 0
	is_fist_time = True	
        while True:
            self.show_topology()###show topology(topo link,link port,access host)

	    if(is_fist_time and i == 1):###we first get the topology information after the child processing start SLEEP_PERIOD time
		self.get_topology(None)	
		self.set_nodelink()
		is_fist_time = False
	   
            if i == 2:
                self.get_topology(None)	###we reflash the topology data and nodelink per 2*SLEEP_PERIOD

		self.set_nodelink()###set self.nodelink	
                i = 0	  	
	    
            hub.sleep(SLEEP_PERIOD)
            i = i + 1

	self.debugfile.write("child processing over"+"\n")
	self.debugfile.flush()	

    def pause(self, seconds=0):
        """Relinquishes hub for given number of seconds.

        In other words is puts to sleep to give other greenthread a chance to
        run.
        """
        hub.sleep(seconds)

def transact_block(request, connection):
    """Emulate jsonrpc.Connection.transact_block without blocking eventlet.
    """
    error = connection.send(request)
    reply = None

    if error:
        return error, reply

    ovs_poller = poller.Poller()
    while not error:
        ovs_poller.immediate_wake()
        error, reply = connection.recv()

        if error != errno.EAGAIN:
            break

        if (reply and
            reply.id == request.id and
            reply.type in (jsonrpc.Message.T_REPLY,
                           jsonrpc.Message.T_ERROR)):
            break

        connection.run()
        connection.wait(ovs_poller)
        connection.recv_wait(ovs_poller)
        ovs_poller.block()

        hub.sleep(0)

    return error, reply

 def barrier_reply_handler(cls, msg):
     datapath = msg.datapath
     if cls._SENDER != None and\
         datapath.id == cls._SENDER.get_dpid():
         while not isinstance(cls._WAITER, hub.Event):
             hub.sleep(1)
         cls._WAITER.set()

    def send_mldquey_regularly(self):
        self.logger.debug("")
        mc_service_info_list = []
        for line in open(self.MULTICAST_SERVICE_INFO, "r"):
            if line[0] == "#":
                continue
            else:
                # multicast_addr, srcip_addr
                column = list(line[:-1].split(","))
                mc_service_info_list.append(column)
        self.logger.debug(
            "send address(multicast_addr, srcip_addr) : %s",
            str(mc_service_info_list))

        while True:
            for mc_service_info in mc_service_info_list:
                ip_addr_list = []
                if not mc_service_info[1] == "":
                    ip_addr_list.append(mc_service_info[1])
                mld = self.create_mldquery(
                    mc_service_info[0], ip_addr_list)
                sendpkt = self.create_packet(
                    self.addressinfo[0], self.addressinfo[1],
                    self.addressinfo[2], self.addressinfo[3], mld)
                self.send_packet_to_sw(sendpkt)
                hub.sleep(self.WAIT_TIME)

    def _transmit_tc_bpdu(self):
        """ Set send_tc_flg to send Topology Change BPDU. """
        timer = self.port_times.max_age + self.port_times.forward_delay

        self.send_tc_flg = True
        hub.sleep(timer)
        self.send_tc_flg = False

    def network_monitor(self):
        ''' Monitors network RTT and Congestion '''

        self.logger.info('Starting monitoring sub-routine')
        # First, we get an estimation of the link benchmark_network_capacity
        # in a state where the network will be idle.
        self.benchmark_network_capacity()

        # Then we start the periodic measurement of RTT times and port
        # utilization

        counter = 0
        while True:
            if not self.topo_shape.is_empty():
                self.logger.info('Requesting port stats to '
                                 'measure utilization')
                for dpid, s in self.topo_shape.dpid_to_switch.iteritems():

                    s.port_stats_request_time = time.time()

                    # Requesting portstats to calculate controller
                    # to switch delay and congeston
                    self._request_port_stats(s)

                    # Calculating peering switches RTT (once every 10 portstats
                    # so ~10 secs)
                    if counter % 10 == 0:
                        self.send_latency_probe_packet(s)
                counter += 1

            hub.sleep(1)

 def _monitor(self):
     while True:
         # Send the states requests to the state tables
         for dp in self.datapaths.values():
             self._request_stats(dp)
         hub.sleep(timewindow)  # Wait X seconds
         self.replies = 0

    def _send_packet_thread(self, arg):
        """ Send several packets continuously. """
        if self.ingress_event is None or self.ingress_event._cond:
            return

        # display dots to express progress of sending packets
        if not arg['thread_counter'] % arg['dot_span']:
            sys.stdout.write(".")
            sys.stdout.flush()

        arg['thread_counter'] += 1

        # pile up float values and
        # use integer portion as the number of packets this thread sends
        arg['packet_counter'] += arg['packet_counter_inc']
        count = int(arg['packet_counter'])
        arg['packet_counter'] -= count

        hub.sleep(CONTINUOUS_THREAD_INTVL)

        tid = hub.spawn(self._send_packet_thread, arg)
        self.ingress_threads.append(tid)
        hub.sleep(0)
        for _ in range(count):
            try:
                self.tester_sw.send_packet_out(arg['pkt_data'])
            except Exception as err:
                self.thread_msg = err
                self.ingress_event.set()
                break

 def _balance_loop(self):
      while 1:
          self.logger.debug("Balancing")
          #--- tell the system to rebalance
          self.api.run_balancers()
          #--- sleep
          hub.sleep(self.balanceInterval)

    def _update(self):
        
        while True:
            for dp in self.datapaths.values():
                parser = dp.ofproto_parser
                ofproto = dp.ofproto
                self.logger.info("dpid="+str(dp.id));
                if dp.id == 161 :
                    
                    self.logger.info("Check SQL Database")
                    db = database()
                    list = db.db_getList()
                    for data in list:
                        print data["id"],"(",type(data["id"]),")"," ",data["address"],"(",type(data["address"]),")"," ",data["access"],"(",type(data["access"]),")"
                        if data["access"] == 1:
                             
                            self.logger.info("DENY "+str(data["address"]))
                            match = parser.OFPMatch(eth_type=0x0800, ipv4_src=str(data["address"]))
                            actions = {}
                            self.add_flow(dp, data["id"]+10, match, actions)

                        if data["access"] == 0:
                            self.logger.info("ALLOW "+str(data["address"]))
                            match = parser.OFPMatch(eth_type=0x0800, ipv4_src=str(data["address"]))
                            mod = parser.OFPFlowMod(dp, command=ofproto.OFPFC_DELETE, out_port=ofproto.OFPP_ANY, out_group=ofproto.OFPG_ANY, match=match)
                            dp.send_msg(mod)



            hub.sleep(10)

 def _send_echo_request(self):
     for datapath in self.datapaths.values():
         parser = datapath.ofproto_parser
         echo_req = parser.OFPEchoRequest(datapath,
                                          data="%.12f" % time.time())
         datapath.send_msg(echo_req)
         hub.sleep(random.randint(0,10))

 def _measurement(self):
     while True:
         print 'ActiveFlows: ', self.active_flows
         print 'FlowRate: ', self.flow_rate
         print 'Graph: ', json.dumps(json_graph.node_link_data(self.graph))
         self._send_measure_request()
         hub.sleep(1)

    def _change_status(self, new_state, thread_switch=True):
        if new_state is not PORT_STATE_DISABLE:
            self.ofctl.set_port_status(self.ofport, new_state)

        if(new_state is PORT_STATE_FORWARD or
                (self.state is PORT_STATE_FORWARD and
                    (new_state is PORT_STATE_DISABLE or
                     new_state is PORT_STATE_BLOCK))):
            self.topology_change_notify(new_state)

        if (new_state is PORT_STATE_DISABLE
                or new_state is PORT_STATE_BLOCK):
            self.send_tc_flg = False
            self.send_tc_timer = None
            self.send_tcn_flg = False
            self.send_bpdu_thread.stop()
        elif new_state is PORT_STATE_LISTEN:
            self.send_bpdu_thread.start()

        self.state = new_state
        self.send_event(EventPortStateChange(self.dp, self))

        if self.state_event is not None:
            self.state_event.set()
            self.state_event = None
        if thread_switch:
            hub.sleep(0)  # For thread switching.

    def _routing(self):
        print('system is ready')
        while True:
            if Config.forwarding == 'IP':
                Collector.path = DFS.findAllPairsPath(Collector.topo)
                hub.sleep(5)

            elif Config.forwarding == 'MPLS':
                # localtime = time.asctime(time.localtime(time.time()))
                # print(localtime, 'find Paths is started')
                # start = time.time()
                # create topo
                topo = {}
                for src in Collector.topo:
                    topo[src] = {}
                    for dst in Collector.topo[src]:
                        topo[src][dst] = Collector.topo[src][dst].get_cost()

                Collector.path = AllPairsSP.main(topo)

                path = Collector.path
                datapaths = Collector.datapaths
                topo = Collector.topo
                route = Config.route
                MPLSSetup.main(path, datapaths, topo, route)
                # done = time.time()
                # print('routing calc: ', done - start)
                hub.sleep(60)

 def _update_wait_bpdu_timer(self):
     if self.wait_timer_event is not None:
         self.wait_timer_event.set()
         self.wait_timer_event = None
         self.logger.debug('[port=%d] Wait BPDU timer is updated.',
                           self.ofport.port_no, extra=self.dpid_str)
     hub.sleep(0)  # For thread switching.