def main():
    nrx=3
    # Create a tx
    ntx=3
    ta = None
    #ta = SampleRate()
    transmitter = Transmitter(ntx,ta)
    # Create a channel
    
    chan = TraceChan()
    num_chans=1
    length = chan.create_chan(transmitter.Ntx,nrx)

    #ta = OracleRA(chan)
    #transmitter.set_transmit_ra(ta)
    #receiver = Receiver(MaxTputRA(),nrx)
    #receiver = Receiver(MinEngRA(),nrx)
    receiver = Receiver(EngTputRA(),nrx)
    #receiver = Receiver(EffSnrRA(),nrx)
    #receiver = Receiver(RxSampleRate(),nrx)
    #receiver = Receiver(RxOracle(),nrx)

    #length =10
    for num in range(0,length):
        pkt = transmitter.transmit_pkt()
        chan.apply_channel(pkt)
        #print chan.curr_chan
        #print pkt
        
        # Create receiver
        receiver.receive_pkt(pkt)
        ack_pkt = receiver.get_feedback_pkt()
        
        transmitter.process_ack(ack_pkt)

def main():
    # TODO: parse configuration file to retreive
    # sender's and receiver's ip addresses
    config_dict = parse_config()
    if not config_dict:
        print 'no config params'
        return
    sender_name = config_dict['IP'] + '_sender'
    recv_name = config_dict['IP'] + '_receiver'
    print 'sender name: ' + sender_name
    print 'receiver name: ' + recv_name
    s_obj = Sender()
    r_obj = Receiver()
    s_obj.ip_address = config_dict['IP']
    r_obj.ip_address = config_dict['IP']
    s_obj.multicast_address = config_dict['multicast']
    r_obj.multicast_address = config_dict['multicast']
    Pyro4.Daemon.serveSimple(
        {
            s_obj: sender_name,
            r_obj: recv_name
        },
        ns=False,
        port=45000,
        host=config_dict["IP"]
    )

def ncd_loop(doInit, dlThreadNum):
	ndutil.setTimezone()

#read config
	cnfManager = CnfManager()
	cnfManager.load('./ndc.cnf')
	cnfData = cnfManager.getCnfData()

#check dirs
	ndutil.enableDir(cnfData['dirWorking'])
	ndutil.enableDir(cnfData['dirStore'])

#ndlcom
	logger = Logger('nDroid-Crawler', cnfData['ndlComHost'], cnfData['ndlComPort'])
	logger.logger('Initiating')

	dbManager = DbManager(cnfData['dbHost'], cnfData['dbUser'], cnfData['dbPass'], cnfData['dbName'])
	if doInit:
		dbManager.create_table()
		os.system('rm -f %s/*' % cnfData['dirWorking'])
		os.system('rm -f %s/*' % cnfData['dirStore'])

	#logger.logger('Customizing Spiders')
	#spiderGenerator = SpiderGenerator('template', 'spider/spiders')
	#for spider in cnfData['spiders']:
	#	spiderGenerator.gen_spider(spider, cnfData[spider]['startPage'], cnfData[spider]['stopPage'])

	rpQueue = Queue()
	pdQueue = Queue()
	dpQueue = Queue()
	pdLock = threading.Lock()

	rpcMonitor = RpcMonitor(logger, cnfData['rpcPort'], cnfData['rpcAuth'], 'RpcMonitor')
	rpcMonitor.setGlobalInfo(ndutil.getCurrentTimeStr(), 'Standalone', dlThreadNum)
	rpcMonitor.setDownloadTotal(pdQueue.qsize())
	rpcMonitor.setPdQueueSize(pdQueue.qsize())
	
	botScheduler = BotScheduler(logger, rpcMonitor, cnfData['spiders'], cnfData['spiderCnfs'], 'BotScheduler')
	receiver = Receiver(logger, rpcMonitor, rpQueue, cnfData['receiverPort'], 'Receiver')
	preProcessor = PreProcessor(logger, rpcMonitor, rpQueue, pdQueue, pdLock, dbManager, 'PreProcessor')
	downloader = Downloader([logger, rpcMonitor, pdQueue, dpQueue, pdLock, dlThreadNum, cnfData['dirWorking']], 'Downloader')
	processor = Processor(logger, rpcMonitor, dpQueue, pdLock, pdQueue, dbManager, cnfData['dirWorking'], cnfData['dirStore'], 'Processor')

	logger.logger('Starting Threads')
	rpcMonitor.start()
	botScheduler.start()
	receiver.start()
	preProcessor.start()
	downloader.start()
	processor.start()
	
	processor.join()
	downloader.join()
	preProcessor.join()
	receiver.join()
	botScheduler.join()
	rpcMonitor.join()

 def start_recvers(self):
   for port in self.cl_port_list:
     addr = (self.cl_ip, port)
     recver = Receiver(in_queue = self.queue_torecvers,
                       laddr = addr,
                       proto = self.proto,
                       rx_type = self.rx_type,
                       file_url = 'rx_over_%s.dat' % port,
                       logto = self.logto )
     recver.start()
     self.recver_thread_list.append(recver)

    def run(self):
        self.done = Event()
        while not self.done.isSet():
            print('Waiting for clients')
            client_sock, client_info = self.server_sock.accept()
            r = Receiver(self, client_sock, client_info)
            r.daemon = True
            r.start()

        self.server_sock.close()
        print('The server socket has been closed')

def main():

    if len(sys.argv) == 5:
       filename = sys.argv[1]
       card_type = sys.argv[2]
       energy_constraint = sys.argv[3]
       chan_pred = eval(sys.argv[4])
       increment = 1
       print "filename: "+str(filename)
    elif len(sys.argv) == 6:
       filename = sys.argv[1]
       card_type = sys.argv[2]
       energy_constraint = sys.argv[3]
       chan_pred = eval(sys.argv[4])
       increment = eval(sys.argv[5])
       print "filename: "+str(filename)
    else:
        print "Correct usage: python simulate_maxtput.py trace_file card_type tx/rx pred(True/False) chan_increment"
        sys.exit(1) 

    nrx=3
    # Create a tx
    ntx=3
    ta = None
    transmitter = Transmitter(ntx,ta)
    # Create a channel
    
    chan = TraceChan(filename, increment)
    length = chan.create_chan(transmitter.Ntx,nrx)

    extname=filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)+"_inc"+str(increment)

    print extname
    receiver = Receiver(MaxTputRA(card_type,energy_constraint,chan_pred),nrx,extname)

    #length =22
   
    if length > 10000: length = 10000

    for num in range(0,length):
        itr_tic = time.clock() 
        pkt = transmitter.transmit_pkt()
        chan.apply_channel(pkt)
        #print chan.curr_chan
        #print pkt
        
        # Create receiver
        receiver.receive_pkt(pkt)
        ack_pkt = receiver.get_feedback_pkt()
        
        transmitter.process_ack(ack_pkt)
        itr_toc = time.clock() 
        print "one itr: "+str(itr_toc - itr_tic)

def main():
  users = Users()
  receiver = Receiver()
  sender = Sender()
  while True:
    receiver.read_emails(users)
    for user in users.users_map.values():
      if user.modified:
        sender.send_news(user.email, list(user.topics_set))
        user.modified = False
    print ('Sleeping')
    sleep(10)
    print ('Waking up')

def main():

    if len(sys.argv) == 5:
       filename = sys.argv[1]
       card_type = sys.argv[2]
       energy_constraint = sys.argv[3]
       chan_pred = eval(sys.argv[4])
       increment = 1
       print "filename: "+str(filename)
    elif len(sys.argv) == 6:
       filename = sys.argv[1]
       card_type = sys.argv[2]
       energy_constraint = sys.argv[3]
       chan_pred = False
       increment = eval(sys.argv[5])
       print "filename: "+str(filename)
    else:
        print "Correct usage: python simulate_effsnr.py trace_file card_type tx/rx pred(True/False)"
        sys.exit(1)

    nrx=3
    # Create a tx
    ntx=3
    ta = None
    transmitter = Transmitter(ntx,ta)
    # Create a channel
    
    chan = TraceChan(filename, increment)
    num_chans=1
    length = chan.create_chan(transmitter.Ntx,nrx)
 
    ta = OracleEffSnrRA(card_type,energy_constraint,chan)
    transmitter.set_transmit_ra(ta)
    extname=ta.name+"_"+filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)+"_inc"+str(increment)
    receiver = Receiver(RxOracle(card_type,energy_constraint),nrx,extname)

    if length > 10000: length = 10000
    #length =10
    for num in range(0,length):
        pkt = transmitter.transmit_pkt()
        chan.apply_channel(pkt)
        #print chan.curr_chan
        #print pkt
        
        # Create receiver
        receiver.receive_pkt(pkt)
        ack_pkt = receiver.get_feedback_pkt()
        
        transmitter.process_ack(ack_pkt)

class Broadcaster(object):

    def __init__(self):
        self._receiver = None

    def register(self, receiver):
        self._receiver = Receiver(receiver)

    def has_receivers(self):
        if self._receiver:
            return True
        else:
            return False

    def broadcast(self):
        self._receiver.notify()

def main():
    global indexer, uploader, sender, receiver, downloader
    setup_signals()
    logging.info("Asink client started at %s" %
                 (time.strftime("%a, %d %b %Y %X GMT", time.gmtime())))

    #create all threads which will be used to process events
    indexer = Indexer()
    uploader = Uploader()
    sender = Sender()
    receiver = Receiver()
    downloader = Downloader()

    #create and set up queues which are used to pass events between threads
    uploader_queue = Queue()
    indexer.uploader_queue = uploader_queue
    uploader.queue = uploader_queue
    #set on watcher when initialized

    sender_queue = Queue()
    uploader.sender_queue = sender_queue
    sender.queue = sender_queue

    downloader_queue = Queue()
    receiver.downloader_queue = downloader_queue
    downloader.queue = downloader_queue

    #setup storage provider
    storage = setup_storage()
    uploader.storage = storage.clone()
    downloader.storage = storage

    #start all threads
    watcher.start_watching(uploader_queue)
    indexer.start()
    uploader.start()
    sender.start()
    receiver.start()
    downloader.start()

    #sleep until signaled, which will call sig_handler
    while True:
        time.sleep(86400) #= 24 hours just for fun

    def __init__(self, packet_sender):
        print 'Init Connection'

        self.ee = EventEmitter()

        self._sender = Sender(packet_sender)
        self._receiver = Receiver(packet_sender)

        @self._receiver.ee.on('data')
        def on_data(data):
            self.ee.emit('data', data)

 def welcome_s(self, data_):
   sch_req_id = data_['sch_req_id']
   stpdst = data_['tp_dst']
   qtorecver = Queue.Queue(0)
   qfromrecver = Queue.Queue(0)
   laddr = (self.cl_ip, int(stpdst))
   recver = Receiver(in_queue = qtorecver,
                     out_queue = qfromrecver,
                     laddr = laddr,
                     proto = self.proto,
                     rx_type = 'kstardata',
                     file_url = 'kstardata_%s.dat' % stpdst,
                     logto = self.logto )
   recver.start()
   #
   self.sinfo_dict[sch_req_id] = {'tp_dst': stpdst,
                                  'qtorecver': qtorecver,
                                  'qfromrecver': qfromrecver }
   logging.info('welcome_s:: welcome sinfo=\n%s', pprint.pformat(self.sinfo_dict[sch_req_id]))
   threading.Thread(target = self.waitfor_couplingtoend,
                    kwargs = {'sch_req_id': sch_req_id} ).start()

def handle_block(new_block_size, E, K):
    # Simulator.simulate returns the number of bit errors in each block
    bit_errors = Simulator.simulate(new_block_size, E)

    Statistics.update(Statistics.total_transmitions)
    if (bit_errors != 0):
        Statistics.update(Statistics.block_errors)
    try:
        Receiver.receive(bit_errors)
        Statistics.update(Statistics.no_error)
        Statistics.update(Statistics.correctly_received_blocks)
        return 0
    except OneBitError:
        Statistics.update(Statistics.one_bit_error)
        if (K != 0):
            Statistics.update(Statistics.correctly_received_blocks)
            # Assume: Fixing the error requires 0 trials_time units
            return 0
        return bit_errors
    except MultipleBitErrors:
        Statistics.update(Statistics.multiple_bit_errors)
        return bit_errors

def main():
	sender = Sender('localhost')
	sender.connect()
	sender.create_queue('inbox')
	sender.send_message('inbox', 'hello')
	sender.disconnect()

	receiver = Receiver('localhost')
	receiver.connect()
	receiver.receive('inbox')
	receiver.disconnect()

def main():
    if len(sys.argv) == 6:
       filename = sys.argv[1]
       card_type = sys.argv[2]
       energy_constraint = sys.argv[3]
       chan_pred = eval(sys.argv[4])
       threshold = eval(sys.argv[5])
       print "filename: "+str(filename)
    else:
        print "Correct usage: python simulate_engtput.py trace_file card_type tx/rx pred(True/False)"
        sys.exit(1) 

    nrx=3
    # Create a tx
    ntx=3
    ta = None
    transmitter = Transmitter(ntx,ta)
    # Create a channel
    
    chan = TraceChan(filename)
    num_chans=1
    length = chan.create_chan(transmitter.Ntx,nrx)
 
    extname=filename.split('/')[-1].split('.')[0]+"_"+card_type+"_"+energy_constraint+"_pred"+str(chan_pred)+"th"+str(threshold)
    receiver = Receiver(EffSnrRAEngTput(card_type,energy_constraint,chan_pred,threshold),nrx,extname)

    for num in range(0,length):
        pkt = transmitter.transmit_pkt()
        chan.apply_channel(pkt)
        #print chan.curr_chan
        #print pkt
        
        # Create receiver
        receiver.receive_pkt(pkt)
        ack_pkt = receiver.get_feedback_pkt()
        
        transmitter.process_ack(ack_pkt)

    def __init__(self, UPLOAD=True, USE_GUI=True, USE_FILESTREAM=False):
        self._socket_address = 'src/client/data_stream.sock'
        self._receiver = Receiver(self._socket_address)
        self._geo_listen = Geometry()
        self._frequency = 15

        if USE_FILESTREAM:
            self._stream = FileStream(
                "gen_data/downtown-east2_only_turn_sigs_speed_lims.json",
                self._socket_address)

        self._send_frequency = 1
        self._speed_limit = None
        self._speed_time = None

        self._gui = None

        self._forgot_signals_event = threading.Event()
        self._speeding_event = threading.Event()
        self._aggressive_event = threading.Event()
        self._green_event = threading.Event()
        self._green_event.direction = None
        self._speeding_event.speed_limit = None
        self._last_turn_forget = None
        self._turn_analyzer = TurnSignalAnalyzer(self._forgot_signals_event)
        self._speeding_analyzer = SpeedingAnalyzer(self._speeding_event)
        self._green = Green(1, self._green_event)
        self._aggressive_analyze = AggressiveAnalyzer(self._aggressive_event)
        self._evaluatebox_last_time = None

        if USE_GUI:
            self._gui = GUI(self._receiver.is_alive)

            t = threading.Thread(target=self._mainloop, daemon=True)
            t.daemon = True
            t.start()

        if UPLOAD:
            self._distributor = Distributor(
                '/src/client/upload_stream.sock', self._send_frequency)
            s = threading.Thread(target=self._sender, daemon=True)
            s.start()

        if USE_GUI:
            self._gui.mainloop()
        else:
            self._receiver.join()  # keep main from exiting

        shutil.rmtree(filename, True)
    logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
                    datefmt="%Y-%m-%d %H:%M:%S",
                    filename=filename,
                    filemode="w")
    console = logging.StreamHandler()
    console.setLevel(logging.NOTSET)
    formatter = logging.Formatter("%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s")
    console.setFormatter(formatter)
    logging.getLogger('').addHandler(console)

if __name__ == '__main__':
    InitLogging()
    handler = Handler()
    receiver = Receiver()
    transmitter = Transmitter()
    receiver.connect()

    td1 = threading.Thread(target=handler.run)
    td2 = threading.Thread(target=receiver.run)
    td3 = threading.Thread(target=transmitter.run)
    td1.start()
    td2.start()
    td3.start()

    # main loop
    while True:
        if handler.is_runing() and receiver.is_runing() and transmitter.is_runing():
            msg = receiver.fetch()
            while msg != None:

        channel = bch.BypassChannel(opt.noise, opt.lag, h)
    else:
        channel = ach.AudioChannel(opt.samplerate, opt.chunksize, opt.prefill)

    # transmit the samples, and retrieve samples back from the channel
    try:
        samples_rx = channel.xmit_and_recv(mod_samples)
    except ZeroDivisionError:
        # should only happen for audio channel
        print "I didn't get any samples; is your microphone or speaker OFF?"
        sys.exit(1)
#################################

    # process the received samples
    # make receiver
    r = Receiver(fc, opt.samplerate, opt.spb)
    demod_samples = r.demodulate(samples_rx)
    one, zero, thresh = r.detect_threshold(demod_samples)
    barker_start = r.detect_preamble(demod_samples, thresh, one)
    rcdbits = r.demap_and_check(demod_samples, barker_start)
    decoded_bits = r.decode(rcdbits)

    # push into sink
    sink = Sink()
    rcd_payload = sink.process(decoded_bits)

    if len(rcd_payload) > 0:
        hd, err = common_srcsink.hamming(decoded_bits, databits)
        print 'Hamming distance for payload at frequency', fc,'Hz:', hd, 'BER:', err
    else:
        print 'Could not recover transmission.'

    def run(self):
        sleep_time = 0
        while True:
            if (os.getppid() != self.ppid):
                logger.info('parent exited. aborting.')
                break
            try:
                self.rep_ip = self._replication_interface()
                break
            except:
                time.sleep(1)
                sleep_time = sleep_time + 1
                if (sleep_time % 30 == 0):
                    msg = ('Failed to get replication interface for last %d'
                           ' seconds' % sleep_time)
                    logger.info('failed to get replication interface')

        ctx = zmq.Context()
        #fs diffs are sent via this publisher.
        rep_pub = ctx.socket(zmq.PUB)
        rep_pub.bind('tcp://%s:%d' % (self.rep_ip, self.data_port))

        #synchronization messages are received in this pull socket
        meta_pull = ctx.socket(zmq.PULL)
        meta_pull.RCVTIMEO = 100
        meta_pull.bind('tcp://%s:%d' % (self.rep_ip, self.meta_port))

        total_sleep = 0
        while True:
            if (os.getppid() != self.ppid):
                logger.info('parent exited. aborting.')
                break

            while(not self.pubq.empty()):
                msg = self.pubq.get()
                rep_pub.send(msg)

            #check for any recv's coming
            try:
                self.recv_meta = meta_pull.recv_json()
                snap_id = self.recv_meta['id']
                if (self.recv_meta['msg'] == 'begin'):
                    logger.info('begin received. meta: %s' % self.recv_meta)
                    rw = Receiver(self.recv_meta, Queue())
                    self.receivers[snap_id] = rw
                    rw.start()
                elif (self.recv_meta['msg'] == 'begin_ok'):
                    self.senders[snap_id].q.put('send')
                elif (self.recv_meta['msg'] == 'receive_ok' or
                      self.recv_meta['msg'] == 'receive_error'):
                    self.senders[snap_id].q.put(self.recv_meta['msg'])
            except zmq.error.Again:
                pass

            self._prune_workers((self.receivers, self.senders))

            if (total_sleep >= 60 and len(self.senders) < 50):
                logger.info('scanning for replicas')
                for r in Replica.objects.filter(enabled=True):
                    rt = ReplicaTrail.objects.filter(replica=r).order_by('-snapshot_created')
                    now = datetime.utcnow().replace(second=0,
                                                    microsecond=0,
                                                    tzinfo=utc)
                    sw = None
                    snap_name = ('%s_replica_snap' % r.share)
                    if (len(rt) == 0):
                        snap_name = ('%s_1' % snap_name)
                        sw = Sender(r, self.rep_ip, self.pubq, Queue(),
                                    snap_name)
                    elif (rt[0].status == 'succeeded' and
                          (now - rt[0].end_ts).total_seconds() >
                          r.frequency):
                        snap_name = ('%s_%d' % (snap_name, rt[0].id + 1))
                        sw = Sender(r, self.rep_ip, self.pubq, Queue(),
                                    snap_name, rt[0])
                    else:
                        continue
                    snap_id = ('%s_%s_%s_%s' %
                               (self.rep_ip, r.pool, r.share, snap_name))
                    self.senders[snap_id] = sw
                    sw.daemon = True
                    sw.start()
                total_sleep = 0

            time.sleep(1)
            total_sleep = total_sleep + 1

 def bind(self, client_socket):
     self.debug_continue.disabled = self.debug
     self.sender = Sender(client_socket, self.send_queue, self)
     self.receiver = Receiver(client_socket, self.receive_queue, self)
     self.sender.start()
     self.receiver.start()