def main(): if len(sys.argv) < 2: print "Insufficient arguments provideed \n Code Usage- python ProduceRecords.py <config File>" exit() else: ConfigFile = open(sys.argv[1], "r") Configs = ConfigFile.readlines() inputTopicName = "Default" brokerList = ["localhost:9092"] timeInterVal = 30 for config in Configs: if "inputTopicName" in config: inputTopicName = config.split("=")[1].strip("\n") if "brokerList" in config: brokerList = config.split("=")[1].strip("\n").split(",") if "timeInterVal" in config: timeInterVal = int(config.split("=")[1].strip("\n")) print "Config Sucessfully Captured\n Details:\n1.TopicName=%s\n2.BrokerList=%s\n3.TimeInterval=%s" % ( inputTopicName, str(brokerList), timeInterVal) Producer = ProduceRecords(brokerList, inputTopicName, timeInterVal) Producer.messgaeCreator()
def __init__(self, *args, **kwargs): Producer.__init__(self, *args, **kwargs) if 'fname' in kwargs: fname = kwargs['fname'] self.log.info('Opening frame source %s', fname) self.resource = cv2.VideoCapture(fname)
def Equilibrium_Ind(self): # Obtain the output list with the correct list length # Format of output list: [C1G1 C1G2 C2G1 C2G2 C1F1 C1F2 C2F1 C2F2 P1F1 P1F2 P2F1 P2F2] output_list_length = self.c * (self.g + self.f) + self.g * self.f output_list = [] # Generate initial output list values for the optimization for i in range(output_list_length): output_list.append(random.uniform(0.3, 5)) # Solve the optimization problem # G: An instance of the social planner, who determines the welfare function and constraints G = SP(self.c, self.g, self.f, self.A, self.B, self.T, self.e1) # res: Results of optimization problem res = minimize(G.Welfare, output_list, method='SLSQP', constraints=G.Constraints_Ind(output_list)) for i in range(100): output_list = [] for i in range(output_list_length): output_list.append(random.uniform(0.3, 5)) compare = minimize(G.Welfare, output_list, method='SLSQP', constraints=G.Constraints_Ind(output_list)) if res.fun > compare.fun: res = compare P = Producer(self.c, self.g, self.f, self.e1) real = P.Production(res.x) for i in range(self.g * self.c): if i == 0 or (i % self.g == 0 and i < self.g * self.c): res.x[i:i + self.g] = real / self.c welfare = G.Welfare(res.x) return welfare
def main(): # handle user input from_date_string = str( raw_input("Please specify a Start Date with format ddmmYYYY: ")) # raw input in python2 is the same as input in python3 (returns a string instead of a python expression) to_date_string = str( raw_input("Please specify a End Date with format ddmmYYYY: ")) locale.setlocale(locale.LC_ALL, '') from_date = datetime.datetime.strptime(from_date_string, '%d%m%Y').isoformat() to_date = datetime.datetime.strptime(to_date_string, '%d%m%Y') tmp_date = to_date + datetime.timedelta(1) to_date = tmp_date.isoformat() threads = list() stopper = threading.Event() consumer = Consumer() producer = Producer(from_date=from_date, to_date=to_date) threads.append(consumer) threads.append(producer) handler = SignalHandler(stopper, threads) signal.signal(signal.SIGINT, handler) producer.start() consumer.start()
def __start_qualification(self): self.buffer = __buffer_sensor__() self.producer_qualification = Producer(self.buffer, self.sensor, self.race, 'qualification') self.consumer_qualification = Consumer(self.buffer, self.race, self.publisher, 'qualification') self.producer_qualification.start() self.consumer_qualification.start() return ''
def __start_race(self): self.buffer = __buffer_sensor__() self.producer_race = Producer(self.buffer, self.sensor, self.race, 'race') self.consumer_race = Consumer(self.buffer, self.race, self.publisher, 'race') self.producer_race.start() self.consumer_race.start() return ''
def __init__(self, name=None, symbols=None, **kwargs): Producer.__init__(self, name=name, **kwargs) self.sina = V('Sina') if symbols is None: self.symbols = self.sina.get_symbols() else: self.symbols = symbols [self.szSymbols, self.shSymbols] = util.split_symbols(self.symbols) self.szTime = datetime(1970, 1, 1) self.shTime = datetime(1970, 1, 1)
def run(self): # Setting producer. producer = Producer(self.semaphore) producer.setPort(9092) producer.setIP("10.0.0.212") producer.startConnection() #sending messages. for x in range(0, 100): print("Send message....") self.semaphore.acquire() producer.sendMessage(Point(5 * x, 10 * math.sin(5 * x + 10) + 40)) self.semaphore.release()
def run(self): roomName = input('Please enter the name of the room: \n') clientName = input('Please enter the name of the client: \n') privateKey = bytearray(123) res = self.enterRoom(roomName, clientName, privateKey) if (res): print('Entered') self.consumer = Consumer(clientName, self.channel, self.queue_name) self.consumer.start() self.producer = Producer(clientName, self.channel, roomName, privateKey) self.producer.start()
def Constraints(self,output_list): # Generate an instance of Producer P = Producer(self.c,self.g,self.f,self.e1) # Generate an instance of Total T = Total(self.c,self.g,self.f) # Construct the constraints function # First constraint: Total Production = Total Consumption # Second constraint: Total factor supplied = Total factor demanded # Third constraint: All result values are non-negative Cons = ({'type': 'eq','fun' : lambda x:(T.total_consumption(x)-P.Production(x))}, {'type': 'eq','fun' : lambda x:(T.total_factor_dd(x)-T.total_factor_ss(x))}, {'type': 'ineq','fun': lambda x:x},) return Cons
def generate_predictions(): """ Spawns a producer which reads video frames and result collector to yield results. Iterates through result collector and yields results to client as they are available Uses event-stream to keep connection open. :return: Flask response (event-stream) """ video_name = request.args.get('video_name') producer = Producer(sender_port=args.producer_send_port, video_path=f'data/{video_name}') Process(target=producer.run).start() result_collector = ResultCollector(receiver_port=args.consumer_send_port) def generate(): try: for frame_idx, img, peak_points in result_collector.run(): img_data_url = encode_img_to_data_url(img=img) peak_points = peak_points.numpy().tolist() res = json.dumps({ 'img': img_data_url, 'peak_points': peak_points, 'frame_idx': frame_idx }) yield f'data: {res}\n\n' yield 'event: done\ndata: {}\n\n' except GeneratorExit: log.debug('APP: Client closed connection') return Response(generate(), mimetype='text/event-stream')
def __init__(self, securities): self.consumer_group = [] for security in securities: self.consumer_group.append(Consumer(security, self)) self.producer = Producer(self.consumer_group, self) self.flag = AtomicNumber() self.i = 0
def createProducer(self, connect, stats, routingKey): channel = connect.channel() if self.producerTxSize > 0: channel.tx_select() if self.confirm >= 0: channel.confirm_delivery() channel.exchange_declare(self.exchangeName, self.exchangeType) return Producer(channel, self.exchangeName, self.exchangeType, routingKey, self.randomRoutingKey, self.flags, self.producerTxSize, self.producerRateLimit, self.producerMsgCount, self.timeLimit, self.minMsgSize, stats)
class TwitterStreamListener(StreamListener): def __init__(self): print "TwitterStreamListener started" self.counter = 0 self.last_sent = time.time() self.producer = Producer(host, exchange, routing_type, routing_key) #self.pos_sent_polarity = 0.0 #self.neg_sent_polarity = 0.0 def broadcast(self, message_text): #, pos, neg): if self.producer is None: print "Cannot send because self.producer is None" return False m = Message("twitter-volume", message_text) #m.add_field("pos_sent", str(pos)) #m.add_field("neg_sent", str(neg)) if self.producer.send(m.str()): print "[%d] Transmission successful" % m.get_time() else: print "[%d] Transmission failed" % m.get_time() def on_data(self, data): structured = json.loads(data) if 'text' not in structured: return True print "Received tweet with keyword (counter=%d)" % self.counter #blob = TextBlob(structured['text']) #dur_sent = blob.sentiment.polarity #if dur_sent < 0.0: # self.neg_sent_polarity += dur_sent #else: # self.pos_sent_polarity += dur_sent #if print_each: # print "[%d] %s polarity = %s" % (self.counter, structured['text'], str(dur_sent)) self.counter += 1 if time.time() - self.last_sent > diff_time: self.last_sent = time.time() self.broadcast(str(self.counter)) # self.pos_sent_polarity, self.neg_sent_polarity) #self.pos_sent_polarity = 0.0 #self.neg_sent_polarity = 0.0 self.counter = 0 return True def on_error(self, status): print status
class Client(): def __init__(self, address): self.connection = pika.BlockingConnection( pika.ConnectionParameters(address)) self.channel = self.connection.channel() def run(self): roomName = input('Please enter the name of the room: \n') clientName = input('Please enter the name of the client: \n') privateKey = bytearray(123) res = self.enterRoom(roomName, clientName, privateKey) if (res): print('Entered') self.consumer = Consumer(clientName, self.channel, self.queue_name) self.consumer.start() self.producer = Producer(clientName, self.channel, roomName, privateKey) self.producer.start() def enterRoom(self, room_name, name, privateKey): # Hash the room name and client name with private key room_name = hmac.new(privateKey, room_name.encode(), hashlib.sha256).hexdigest() name = hmac.new(privateKey, name.encode(), hashlib.sha256).hexdigest() # Generate a random unique key for the queue name unique_key = ''.join( random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(64)) # set queue names self.queue_name = room_name + ":" + name self.exchange = self.channel.exchange_declare(exchange=room_name, exchange_type='fanout') self.queue = self.channel.queue_declare(queue=self.queue_name) self.channel.queue_bind(exchange=room_name, queue=self.queue_name) return True
class ProduceRecords(): def __init__(self, brokerList, topicName, interval=30): self.keys = ["key1", "key2", "key3", "key4", "key5"] self.topicName = topicName self.Producer = Producer(brokerList) self.interval = interval def messgaeCreator(self): Status = True while Status: for key in self.keys: try: self.Producer.sendData(key, self.createValue(key), self.topicName) time.sleep(random.randint(1, 4)) except Exception, e: print "Exception Encountered" print e exit() time.sleep(int(self.interval))
def __init__(self, name=None, username=None, pwd=None, symbols=None, hq='hq_pjb', query=['quotation', 'orders', 'deal', 'info'], **kwargs): Producer.__init__(self, name=name, **kwargs) self.ip = util.get_client_ip() self.hq = hq self.query = query # 登录模块在V('Sina')中 self.sina = V('Sina') self.is_login = self.login() if not self.is_login: self.logger.error(u'登录失败,请核对账号和密码') sys.exit(-1) if symbols is None: self.symbols = self.sina.get_symbols() else: self.symbols = symbols self.websockets = dict()
def main(argv): # Default values assignment_url = 'https://raw.githubusercontent.com/rpfk/python-kafka-producer-assignment/master/assignment.json' kafka_address = '192.168.21.21:9092' # Check if the required command line arguments are given try: opts, args = getopt.getopt(argv, "", ["kafka-address=", "assignment-url="]) except getopt.GetoptError: print 'run.py --kafka-address=<kafka-address> --assignment-url=<assignment-url>' sys.exit() # Get kafka_address from the command line arguments for opt, arg in opts: if opt == "--kafka-address": kafka_address = arg elif opt == "--assignment-url": assignment_url = arg # Check if kafka address is set correctly try: kafka_address except NameError: print 'kafka address is not set correctly, check the kafka address' print 'run.py --kafka-address=<kafka-address> --assignment-url=<assignment-url>' sys.exit() # Check if assignment is set correctly try: assignment_url except NameError: print 'assignment url is not set correctly, check the assignment url' print 'run.py --kafka-address=<kafka-address> --assignment-url=<assignment-url>' sys.exit() # get the assignment from the assignment url assignment_buffer = StringIO() c = pycurl.Curl() c.setopt(c.URL, assignment_url) c.setopt(c.WRITEDATA, assignment_buffer) c.perform() c.close() assignment = assignment_buffer.getvalue() # Run the producer if everything is set correctly Producer(kafka_address, assignment)
def init(): global curTime, factoryEvents, simulator_state, credit, profit, idleProducers curTime = 0 factoryEvents = np.empty(shape=[0], dtype=FactoryEvent) simulator_state = True credit = 100 profit = 0 idleProducers = np.empty(shape=[0], dtype=int) for i in range(0, NUM_OF_PRODUCER): producers[i] = Producer() idleProducers = np.append(idleProducers, producers[i].getIndex()) print(producers[i]) for i in range(0, NUM_OF_PRODUCT): products[i] = Product(PRODUCE_TIME[i]) PRODUCT_NAME[i] = i print(products[i]) loadConsumers()
def run(self): producer = Producer() # producer.setPort(9092) # producer.setIP("52.186.81.99") producer.startConnection() self.points.producerTime = time.time() self.semaphore.acquire() for x in range(0, 100): print("PRODUCER: Sending message....") producer.sendMessage(Point(5 * x, 10 * math.sin(5 * x + 10) + 40)) if (x % 10 == 0): self.semaphore.release() time.sleep(self.delay) self.semaphore.acquire()
def addFactory(self, last_x = 0, last_y = 0): randx = random.random()-.5 signx = -1 if randx<0 else 1 randy = random.random()-.5 signy = -1 if randy<0 else 1 if 1:#random.random()>.5: x = round(randx*WINDOW_WIDTH/self.scale) y = round(randy*WINDOW_HEIGHT/self.scale) else: x = round(signx*((abs(randx)**2)*(WINDOW_WIDTH/self.scale*4)) + last_x) y = round(signy*(2+(abs(randy)**2)*(WINDOW_HEIGHT/self.scale*4)) + last_y) if (x, y) in self.filledSpaces: return self.addFactory(last_x, last_y) else: bmax = len(self.button_dict)+1 b = math.floor(random.random()*4)+1 if b > bmax: b = bmax producer = Producer(self.getType(), self, assemblerimg[int(b)-1], x, y, button=BUTTON_DICT_M[b]) self.factories.add(producer) self.filledSpaces.append((x,y)) return producer
def main(): stack = Manager().list() n = Semaphore(0) s = Semaphore(1) # Create Producer and Consumer threads producer1 = Producer(stack, n, s, 1) #producer2 = Producer(stack, n, s, 2) #producer3 = Producer(stack, n, s, 3) #producer4 = Producer(stack, n, s, 4) #producer5 = Producer(stack, n, s, 5) consumer = Consumer(stack, n, s) # Start all the threads producer1.start() #producer2.start() #producer3.start() #producer4.start() #producer5.start() consumer.start() time.sleep(2) consumer.stop() time.sleep(0.1) producer1.stop() # Wait for threads to finish producer1.join() #producer2.join() #producer3.join() #producer4.join() #producer5.join() consumer.join() print("Done.")
def MainLoop(self): self.button_dict = {} self.scale = 40000/self.x_view self.filledSpaces = [] # add coordinate tuples whenever a space if filled e.g. (x, y) self.setRhythms(self.level) # 4 rhythms, each expressed as a array of 8 ones or zeros (for each 8th note beat) self.quota = self.score+100*sum(map(lambda r: sum(r), self.rhythms))-200 # sprite groups so we can render everything all at once self.allConveyorSprites = pygame.sprite.Group() self.factories = pygame.sprite.Group() self.allSprites = pygame.sprite.Group(self.allConveyorSprites,self.factories) #Background music from the following music #http://audionautix.com/?utm_campaign=elearningindustry.com&utm_source=%2Fultimate-list-free-music-elearning-online-education&utm_medium=link myMusic.load('BigCarTheft.ogg') myMusic.play(-1) self.songTime = 0 # how far along in the song the system thinks we are in ms self.lastReportedPlayheadPosition = 0 # the last reported song position from the mixer self.beatStep = 0 self.beatProgress = 0 # number of beats that have passed self.beatPos = 0 # position inside our current beat self.renderTeddy = False self.counter= 0 self.frameCounter = 0 self.fps = 0 self.timePassed = 0 self.displayDebug = False self.beatAlternate = True self.gamestart = False while not self.gamestart: self.screen.fill((20, 20, 20)) # setting background color font ="norasi" font_size1 = 100 font_size2 = 30 k = 250 if self.health <= 0: msg1 = "Game Over" msg2 = "PRESS ENTER TO TRY AGAIN" msg3 = "Final Score: " + str(self.score) msg4 = "Final Level: " + str(self.level) msg_location1 = (120+k,100) msg_location2 = (165+k,300) msg_location3 = (270+k,370) msg_location4 = (270+k,420) self.MsgRender(self.screen, font, font_size2, msg3, msg_location3,(255,255,255)) self.MsgRender(self.screen, font, font_size2, msg4, msg_location4,(255,255,255)) elif self.level == 1: msg1 = "Manual Control" msg2 = "PRESS ENTER TO ENJOY!" msg_location1 = (40+k,100) msg_location2 = (210+k,300) else: msg1 = "Level " + str(self.level) msg2 = "PRESS ENTER TO CONTINUE!" msg_location1 = (230+k,100) msg_location2 = (170+k,300) self.MsgRender(self.screen, font, font_size1, msg1, msg_location1,(255,255,255)) self.MsgRender(self.screen, font, font_size2, msg2, msg_location2,(255,255,255)) for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: self.gamestart = True self.lastFactory = Producer('teddybear',self,assemblerimg[0],0,0) self.factories.add(self.lastFactory) self.lastBeatProgress = self.beatProgress+16 if self.health <= 0: self.score = 0 self.quota = 200 self.level = 1 self.health = 100 if event.type == pygame.QUIT: pygame.display.quit() pygame.display.flip() while self.gamestart: self.scale = 40000.0/self.x_view self.x_view += 0.125 self.y_view += 3/32 button = False if self.health <= 0: # game over print("died") self.health = -1000 self.x_view = 200 self.y_view = self.x_view * 3/4 self.MainLoop() return if self.score >= self.quota and self.health > 0: self.level += 1 self.score += self.health self.x_view = 200 self.y_view = self.x_view * 3/4 self.MainLoop() #TODO: This is actually terrible return # frameTimeDifference attribute keeps track of the time passed between this frame and the last self.frameTimeDifference = clock.tick(120) #clock.tick also is limiting the frame rate to 60fps self.checkEvents() self.checkFPS() self.trackSongPos() # smooths out accuracy of song position pygame.display.update() # updates the display to show everything that has been drawn/blit # add a factory if self.beatProgress-self.lastBeatProgress > 16: producer = self.addFactory(self.lastFactory.x, self.lastFactory.y) conveyor = Conveyor(producer, self.lastFactory, producer.x, producer.y,self) self.lastFactory = producer self.lastBeatProgress = self.beatProgress # draws sprites onto the screen self.screen.fill((20, 20, 20)) # setting background color self.allConveyorSprites.draw(self.screen) for factory in self.factories.sprites(): for conveyor in factory.conveyors: self.conveyor_render(self.screen, conveyor) self.factories.draw(self.screen) for factory in self.factories: self.factory_render(self.screen, factory) if self.onScreen(factory.x, factory.y): factory.step(pygame.key.get_pressed()[factory.button], self.beatProgress%4-2) if factory.button not in list(self.button_dict.keys()): self.button_dict[factory.button] = factory if factory in list(self.button_dict.values()): place = list(self.button_dict.values()).index(factory) self.prod_render(self.screen, factory, place) # Display score if pygame.font: font = pygame.font.Font(None, 40) text1 = font.render("Score: %s" % self.score,1,(255,255,0)) text2 = font.render("Level: %s" % self.level,1,(255,255,0)) text3 = font.render("Health: %s" % self.health,1,(255,255,0)) textpos1 = text1.get_rect(top=10, right = self.screen.get_width()-20) textpos2 = text2.get_rect(top=50, right = self.screen.get_width()-20) textpos3 = text3.get_rect(top=90, right = self.screen.get_width()-20) self.screen.blit(text1, textpos1) self.screen.blit(text2, textpos2) self.screen.blit(text3, textpos3) # displays Debug if self.displayDebug: self.renderDebug()
def __init__(self): print "TwitterStreamListener started" self.counter = 0 self.last_sent = time.time() self.producer = Producer(host, exchange, routing_type, routing_key)
def __init__(self, brokerList, topicName, interval=30): self.keys = ["key1", "key2", "key3", "key4", "key5"] self.topicName = topicName self.Producer = Producer(brokerList) self.interval = interval
def __init__(self, *args, **kwargs): Producer.__init__(self, *args, **kwargs) self.origin = self.resource self.resource = self.q.Queue(maxsize=1)
def main(): stack = [] n = Semaphore(0) s = Semaphore(1) # Create Producer and Consumer threads producer1 = Producer(stack, n, s, 1) producer2 = Producer(stack, n, s, 2) producer3 = Producer(stack, n, s, 3) producer4 = Producer(stack, n, s, 4) producer5 = Producer(stack, n, s, 5) consumer = Consumer(stack, n, s) # Start all the threads producer1.start() producer2.start() producer3.start() producer4.start() producer5.start() consumer.start() # Wait for threads to finish producer1.join() producer2.join() producer3.join() producer4.join() producer5.join() consumer.join() print("Done.")
if P < 0: print("That was not a positive integer") else: if len([s for s in Processes.Heap if s.Priority == P]) == 0: break else: print( "A process with that priority has already been added" ) #Create the process with the parameters _Process = Process(AT, BT, PID, P) #Set process value to it's arrival to be organized by the min-heap _Process.value = _Process.ArrivalTime Processes.add(_Process) os.system('cls') #Sets a sleep command to sleep for a second every iteration realTime = True if input("Simulate in real time? (y/n):") == "y" else False os.system('cls') #Create the producer with the processes _Producer = Producer(Processes) #Start passing process to the consumer based on the scheduling method _Producer.Begin(Method, realTime) #Output of stats _Producer.CPUstats() #Can repeatedly run the simulation simulate = True if input( "Would you like to simulate another set of processes? (y/n):" ) == "y" else False os.system('cls')
from Producer import Producer producer = Producer(10, 'Movie trailers', 'Enter your YouTube API key here') producer.start() print("Producer has started!") server = Server() server.start() print("Server started") def broadcast_msg(message): for conn in server.all_connected(): conn.sendMessage(message) consumer = Consumer(broadcast_msg) consumer.start() print("Consumer started")
class ServerController: sensor = None def __init__(self): ''' * Quando iniciado, o controller uma instância de subscriber para ouvir as requisições * e cria uma instância de publisher para retornar os responses das requisições. * Depois dissoverifica se já existe arquivo de configuração do módulo de leitura, * caso positivo, pergunta ao usuário se ele deseja iniciar a conexão com o leitor. ''' self.publisher = Publisher('response') self.subscriber = Subscriber('autorama/#') self.subscriber.set_topic('autorama/#') if os.path.isfile('configs/rfid.json'): start_rfid = input( f"{bcolors.YELLOW}Arquivo de configuração do RFID existente. Deseja iniciar conexão? (Y/n) {bcolors.COLOR_OFF}" ) if start_rfid == 'Y' or start_rfid == 'y': with open('configs/rfid.json', 'r') as file: data = json.load(file) self.__start_connection_rfid(data) print('') def set_sensor(self, sensor): self.sensor = sensor # Método com as definições das rotas existentes def routes(self, url, body=''): url = url.replace('/#', '') if body != '': try: body = json.loads(body) except: return # Condicionais para chamar o método referente a rota chamada if url == '/rfid/config': response = self.__post_rfid_config(body) elif url == '/rfid/tags': response = self.__get_rfid_tags(body) elif url == '/race/config': response = self.__post_race_config(body) elif url == '/race/qualification/start': response = self.__start_qualification() elif url == '/race/start': response = self.__start_race() else: response = '{"status":"NOT_FOUND"}' self.publisher.send_message(response.encode("utf-8"), f"response{url}") ''' * Método checa se chegou nova mensagem no tópico de autorama, * caso positivo ele chama método de rotas para tratar requisição ''' def check_new_messages(self): if self.subscriber.has_new_message(): body = self.subscriber.get_message() route = self.subscriber.get_topic_msg() self.routes(route.replace('autorama', ''), body) def __post_rfid_config(self, data): with open('configs/rfid.json', 'w') as file: json.dump(data, file, indent=2) self.__start_connection_rfid(data) return '' def __start_connection_rfid(self, data): sensor = Sensor(self, data['serial'], data['baudrate'], data['region'], data['protocol'], data['antenna'], data['frequency']) sensor.run() if self.sensor != None: print( f"{bcolors.GREEN}Conexão com RFID iniciado... {bcolors.COLOR_OFF}" ) def __get_rfid_tags(self, data): if data['teste'] == None: data['teste'] = False return self.sensor.get_tags(data['teste']) def __post_race_config(self, data): self.race = data return '' def __start_qualification(self): self.buffer = __buffer_sensor__() self.producer_qualification = Producer(self.buffer, self.sensor, self.race, 'qualification') self.consumer_qualification = Consumer(self.buffer, self.race, self.publisher, 'qualification') self.producer_qualification.start() self.consumer_qualification.start() return '' def __start_race(self): self.buffer = __buffer_sensor__() self.producer_race = Producer(self.buffer, self.sensor, self.race, 'race') self.consumer_race = Consumer(self.buffer, self.race, self.publisher, 'race') self.producer_race.start() self.consumer_race.start() return ''
def run(self, announceStartup): producerConnectionList = [] consumerConnectionList = [] consumer_threads = [] producer_threads = [] stats = PrintStats( self.samplingInterval, self.latencyLimitation, self.producerCount > 0, self.consumerCount > 0, ("mandatory" in self.flags or "immediate" in self.flags), self.confirm != -1) # Create connection producer_host, producer_port = self.gethostandportfromuri(self.puri) consumer_host, consumer_port = self.gethostandportfromuri(self.curi) producer_parameters = pika.ConnectionParameters( host=producer_host, port=producer_port, frame_max=self.frameMax, heartbeat_interval=self.heartbeat) consumer_parameters = pika.ConnectionParameters( host=consumer_host, port=consumer_port, frame_max=self.frameMax, heartbeat_interval=self.heartbeat) # support all exchange types if self.exchangeType == 'direct': # direct for i in range(self.consumerCount): if announceStartup: print("starting consumer *" + str(i)) conn = pika.BlockingConnection(parameters=consumer_parameters) consumerConnectionList.append(conn) consumer_threads.append( self.createConsumer(conn, stats, self.routingKey)) if self.shouldConfigureQueue(): conn = pika.BlockingConnection(parameters=consumer_parameters) self.configureQueue(conn, self.routingKey) conn.close() for i in range(self.producerCount): if announceStartup: print("starting producer *" + str(i)) conn = pika.BlockingConnection(parameters=producer_parameters) producerConnectionList.append(conn) producer_threads.append( self.createProducer(conn, stats, self.routingKey)) elif self.exchangeType == 'topic': # topic for i in range(self.consumerCount): if announceStartup: print("starting consumer #" + str(i)) conn = pika.BlockingConnection(parameters=consumer_parameters) consumerConnectionList.append(conn) consumer_threads.append( self.createConsumer(conn, stats, self.routingPattern)) if self.shouldConfigureQueue(): conn = pika.BlockingConnection(parameters=consumer_parameters) self.configureQueue(conn, self.routingPattern) conn.close() for i in range(self.producerCount): if announceStartup: print("starting producer #" + str(i)) conn = pika.BlockingConnection(parameters=producer_parameters) producerConnectionList.append(conn) producer_threads.append( self.createProducer(conn, stats, self.routingKey + "." + str(i))) elif self.exchangeType == 'fanout': # uncompleted # fanout for i in range(self.consumerCount): if announceStartup: print("starting consumer *" + str(i)) conn = pika.BlockingConnection(parameters=consumer_parameters) consumerConnectionList.append(conn) consumer_threads.append( self.createConsumer(conn, stats, self.routingKey)) if self.shouldConfigureQueue(): conn = pika.BlockingConnection(parameters=consumer_parameters) self.configureQueue(conn, self.routingPattern) conn.close() for i in range(self.producerCount): if announceStartup: print("starting producer *" + str(i)) conn = pika.BlockingConnection(parameters=producer_parameters) producerConnectionList.append(conn) producer_threads.append( self.createProducer(conn, stats, self.routingKey)) elif self.exchangeType == 'headers': # uncompleted # headers for i in range(self.consumerCount): if announceStartup: print("starting consumer *" + str(i)) conn = pika.BlockingConnection(parameters=consumer_parameters) consumerConnectionList.append(conn) consumer_threads.append( self.createConsumer(conn, stats, self.routingKey)) for i in range(self.producerCount): if announceStartup: print("starting producer *" + str(i)) conn = pika.BlockingConnection(parameters=producer_parameters) producerConnectionList.append(conn) producer_threads.append( self.createProducer(conn, stats, self.routingKey)) producer_threads.append( Producer(conn, self.exchangeName, self.exchangeType, self.routingKey, self.randomRoutingKey, self.flags, self.producerTxSize, self.producerRateLimit, self.producerMsgCount, self.timeLimit, self.minMsgSize, stats)) # Start Threads for i in range(len(consumer_threads)): consumer_threads[i].start() consumerConnectionList[i].add_timeout(self.timeLimit, consumer_threads[i].kill) for i in range(len(producer_threads)): producer_threads[i].start() # Wait Threads finished for i in range(len(consumer_threads)): consumer_threads[i].join() consumerConnectionList[i].close() for i in range(len(producer_threads)): producer_threads[i].join() producerConnectionList[i].close() stats.printFinal()
def __importProducers(self, df): arr = [] for index, row in df.iterrows(): arr.append(Producer(index, row)) return arr
from Producer import Producer from StringIO import StringIO import pycurl # get the assignment from the assignment url assignment_buffer = StringIO() c = pycurl.Curl() c.setopt( c.URL, 'https://raw.githubusercontent.com/rpfk/python-kafka-producer-assignment/master/assignment.json' ) c.setopt(c.WRITEDATA, assignment_buffer) c.perform() c.close() assignment = assignment_buffer.getvalue() # run the producer Producer('localhost:21', assignment)
''' Created on: 03.06.16 @author: Group 6 ''' import sys from Buffer import Buffer from Consumer import Consumer from Producer import Producer from threading import Thread #Creates buffer with size given by argument 1 assert (int(sys.argv[1]) > 0), "Buffer is too small" b = Buffer(int(sys.argv[1])) producer = {} consumer = {} #Creates an amount of consumer set by argument 2 assert (int(sys.argv[2]) > 0), "No Consumer-Thread Running" for i in range(int(sys.argv[2])): consumer[i] = Consumer(b) Thread(target=consumer[i].consume).start() #Creates an amount of producer set by argument 3 assert (int(sys.argv[3]) > 0), "No Producer-Thread Running" for i in range(int(sys.argv[3])): producer[i] = Producer(b) Thread(target=producer[i].produce).start()