class RedisSubscriber(object): def __init__(self, topic, host='localhost', port=6379, db=0): self.rqueue = RedisQueue(topic, 1, host=host, port=port, db=db) def redis_recv_pyobj(self, blocking=True): item = self.rqueue.get(isBlocking=blocking) if item is None: return None return pkl.loads(item) def redis_recv(self, blocking=True): return self.rqueue.get(isBlocking=blocking)
class RedisQueueWorker(object): def __init__(self, redis_mgr, service_name, custom_key, func_name, callback_to_main_thread=False): self.service_name = service_name self.func_name = func_name self.redis_queue = RedisQueue(redis_mgr) self.custom_key = custom_key self.redis_queue.subscribe(self.service_name, custom_key) self.callback_to_main_thread = callback_to_main_thread def _real_start(self): while True: try: item = self.redis_queue.get(self.custom_key) if self.callback_to_main_thread: IOLoop.instance().add_callback(self.func_name, item) else: self.func_name(item) except Exception, e: logger.warn("start_work error:%s not found msg", e.message) time.sleep(1)
class WebServerClass(BaseHTTPRequestHandler): def __init__(self, *args, **kwargs): self.singleton = Singleton() self.queue_chart = RedisQueue(name="data_chart", namespace="data_chart") super(WebServerClass, self).__init__(*args, **kwargs) def _set_headers(self): self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() def do_GET(self): if self.path == "/": self.path = self.singleton.template_path self._set_headers() f = open(self.singleton.template_path, "rb") self.wfile.write(f.read()) f.close() while True: data = self.queue_chart.get().decode("utf-8") data = data.replace("\'", "\"") data = json.loads(data) if data: self.wfile.write( "<script type=\"text/javascript\">AddDataChart(chart_id={}, data={});</script>" .format( # noqa data["chart_id"], data["data"]).encode(encoding='utf_8')) return
class A3C(object): def __init__(self): self.device = '/gpu:0' if USE_GPU else '/cpu:0' self.stop_requested = False self.global_t = 0 if USE_LSTM: self.global_network = A3CLSTMNetwork(STATE_DIM, STATE_CHN, ACTION_DIM, self.device, -1) else: self.global_network = A3CFFNetwork(STATE_DIM, STATE_CHN, ACTION_DIM, self.device) self.global_network.create_loss(ENTROPY_BETA) self.initial_learning_rate = log_uniform(INITIAL_ALPHA_LOW, INITIAL_ALPHA_HIGH, INITIAL_ALPHA_LOG_RATE) print 'initial_learning_rate:', self.initial_learning_rate self.learning_rate_input = tf.placeholder('float') self.optimizer = tf.train.RMSPropOptimizer(learning_rate=self.learning_rate_input, decay=RMSP_ALPHA, momentum=0.0, epsilon=RMSP_EPSILON) grads_and_vars = self.optimizer.compute_gradients( self.global_network.total_loss, self.global_network.get_vars()) self.apply_gradients = self.optimizer.apply_gradients(grads_and_vars) self.actor_threads = [] for i in range(PARALLEL_SIZE): actor_thread = A3CActorThread(i, self.global_network) self.actor_threads.append(actor_thread) self.sess = tf.InteractiveSession() self.sess.run(tf.initialize_all_variables()) self.reward_input = tf.placeholder(tf.float32) tf.scalar_summary('reward', self.reward_input) self.time_input = tf.placeholder(tf.float32) tf.scalar_summary('living_time', self.time_input) self.summary_op = tf.merge_all_summaries() self.summary_writer = tf.train.SummaryWriter(LOG_FILE, self.sess.graph) self.saver = tf.train.Saver() self.restore() self.lock = threading.Lock() self.rq = RedisQueue(REDIS_QUEUE_NAME) self.train_count = 0 return def restore(self): checkpoint = tf.train.get_checkpoint_state(CHECKPOINT_DIR) if checkpoint and checkpoint.model_checkpoint_path: self.saver.restore(self.sess, checkpoint.model_checkpoint_path) print("checkpoint loaded:", checkpoint.model_checkpoint_path) tokens = checkpoint.model_checkpoint_path.split("-") # set global step self.global_t = int(tokens[1]) print(">>> global step set: ", self.global_t) else: print("Could not find old checkpoint") return def backup(self): if not os.path.exists(CHECKPOINT_DIR): os.mkdir(CHECKPOINT_DIR) self.saver.save(self.sess, CHECKPOINT_DIR + '/' + 'checkpoint', global_step=self.global_t) return def predict_function(self, parallel_index, lock): actor_thread = self.actor_threads[parallel_index] while True: if self.stop_requested or (self.global_t > MAX_TIME_STEP): break diff_global_t = actor_thread.process( self.sess, self.global_t, self.summary_writer, self.summary_op, self.reward_input, self.time_input ) self.global_t += diff_global_t if self.global_t % 1000000 < LOCAL_T_MAX: self.backup() # print 'global_t:', self.global_t return def train_function(self, index, lock): batch_state = [] batch_action = [] batch_td = [] batch_R = [] while True: if self.stop_requested or (self.global_t > MAX_TIME_STEP): break data = self.rq.get() (state, action, td, R) = cPickle.loads(data) batch_state.append(state) batch_action.append(action) batch_td.append(td) batch_R.append(R) if len(batch_R) < BATCH_SIZE: continue lock.acquire() self.sess.run(self.apply_gradients, feed_dict={ self.global_network.state_input: batch_state, self.global_network.action_input: batch_action, self.global_network.td: batch_td, self.global_network.R: batch_R, self.learning_rate_input: self.initial_learning_rate }) self.train_count += 1 lock.release() batch_state = [] batch_action = [] batch_td = [] batch_R = [] print 'train_index:', index, 'train_count:', self.train_count return def signal_handler(self, signal_, frame_): print 'You pressed Ctrl+C !' self.stop_requested = True return def run(self): predict_treads = [] for i in range(PARALLEL_SIZE): predict_treads.append(threading.Thread(target=self.predict_function, args=(i, self.lock))) signal.signal(signal.SIGINT, self.signal_handler) for t in predict_treads: t.start() train_threads = [] for i in range(TRAIN_SIZE): train_threads.append(threading.Thread(target=self.train_function, args=(i, self.lock))) train_threads[i].start() print 'Press Ctrl+C to stop' signal.pause() print 'Now saving data....' for t in predict_treads: t.join() for t in train_threads: t.join() self.backup() return
class Sender(threading.Thread): def __init__(self, status_queue, stop_event, config): super(Sender, self).__init__() self.normal_data_queue = RedisQueue('normal') self.retry_data_queue = RedisQueue('retry') self.status_queue = status_queue self.stop_event = stop_event self.base_url = config["api_url"] self.key = config["key"] self.store_energy_url = self.base_url + "/v2/energy" self.backup_file = "backup" self.console_mode = True if config["console_mode"] == "true" else False self.connected = False def run(self): self.send_message_to_listeners(Status.RUNNING, description="Sender has been started") while not self.stop_event.is_set(): if not self.connected: self.connect_to_api() while self.connected: retry_data = self.read_messages_from_retry_queue() if len(retry_data) > 0: self.send_data_to_api(retry_data) break normal_data = self.read_messages_from_normal_queue() if len(normal_data) > 0: self.send_data_to_api(normal_data) break time.sleep(1) time.sleep(5) self.send_message_to_listeners( Status.STOPPED, description="Sender has been terminated") def read_messages_from_retry_queue(self): retry_data = [] while not self.retry_data_queue.empty(): retry_message = self.retry_data_queue.get() retry_data.append(json.loads(retry_message.decode('utf-8'))) if len(retry_data) > 30: break return retry_data def read_messages_from_normal_queue(self): normal_data = [] while not self.normal_data_queue.empty(): normal_message = self.normal_data_queue.get() normal_data.append(json.loads(normal_message.decode('utf-8'))) if len(normal_data) > 30: break return normal_data def connect_to_api(self): try: response = requests.get(self.base_url) self.connected = response.status_code == requests.codes.ok if response.status_code == requests.codes.ok: self.connected = True self.send_message_to_listeners( Status.RUNNING, description="Connected to server running on {}".format( self.base_url)) except requests.exceptions.ConnectionError as e: self.connected = False self.send_message_to_listeners(Status.RUNNING, Error.SERVER_UNREACHABLE, "Could not connect to the server") def send_data_to_api(self, messages): headers = { 'Content-type': 'application/json', 'Accept': 'application/json' } try: response = requests.post(self.store_energy_url, data=json.dumps({ 'data': messages, "rpi_key": self.key }), headers=headers) if response.status_code == requests.codes.created: if self.console_mode: self.send_message_to_listeners( Status.RUNNING, description="Succesfully stored energy data") return if response.status_code == requests.codes.unauthorized: self.send_message_to_listeners( Status.STOPPED, Error.UNAUTHORIZED, "Could not authorize with given key") self.stop_event.set() except requests.exceptions.ConnectionError as e: self.send_message_to_listeners(Status.RUNNING, Error.SERVER_UNREACHABLE, "Could not reach the server") self.connected = False for message in messages: self.retry_data_queue.put(json.dumps(message)) def send_message_to_listeners(self, status, error=None, description=None): message = dict() message["thread"] = Thread.SENDER message["status"] = status if error is not None: message["error"] = error if message is not None: message["description"] = description self.status_queue.put(message)
class MyTaskSet(CountResults): def __init__(self, time_execution_in_sec, chart_title, slave, *args, **kwargs): super(MyTaskSet, self).__init__(time_execution_in_sec, chart_title, slave, *args, **kwargs) self.running = True self.slave = slave self.code = None self.queue_chart = RedisQueue(name="data_chart", namespace="data_chart") self.queue_tasks = RedisQueue(name="data_tasks", namespace="data_tasks") self.chart = ReportCharts(time_execution_in_sec, chart_title, self.slave) self.db = create_engine(self.config["database"]["db_string"]) def purge_queues(self): self.queue_chart.purge() self.queue_tasks.purge() self.queue_data.purge() def set_tasks(self): while self.running: self.queue_tasks.put("heartbeat") def vacuum(self): try: self.db.execute("vacuum analyze films;") self.db.execute("vacuum films;") except InternalError: from table import Films films = Films() films.metadata.create_all(bind=self.db) return def run(self, thread=0): self.chart.update_chart(self.queue_chart, 5, "thread", data=1) while self.running and self.queue_tasks.get(): try: self.read() self.write() except Exception as e: self.RESPONSE_TIME_AVERAGE["errors"] += 1 def read(self): self.db.execute("SELECT * FROM films;".format( str(uuid.uuid4())[-5:], random.randint(0, self.LIMIT * 100))) def write(self): # INSERTS self.code = str(uuid.uuid4())[-5:] self.db.execute( "INSERT into films (code, title, did, kind) VALUES('{}', 'test', {}, 't');" .format( # noqa self.code, random.randint(0, self.LIMIT * 100))) # UPDATES new_code = str(uuid.uuid4())[-5:] self.db.execute("UPDATE films set code='{}' where code='{}';".format( new_code, self.code)) def on_finish(self): self.running = False time.sleep(5) print("Getting time here to wait all queue get empty") while self.queue_data.qsize() > 0 or self.queue_chart.qsize() > 0: print("Waiting finishing all pendents query") time.sleep(1) if not self.slave: table = PrettyTable([ "Item", "Total", "Average Execution (sec)", "Total Errors", "Total Executed (sec)" ]) table.add_row([ "INSERTS", self.RESPONSE_TIME_AVERAGE["count"]["insert"], self.RESPONSE_TIME_AVERAGE["average"]["insert"], "", "" ]) table.add_row([ "UPDATES", self.RESPONSE_TIME_AVERAGE["count"]["update"], self.RESPONSE_TIME_AVERAGE["average"]["update"], "", "" ]) table.add_row([ "SELECTS", self.RESPONSE_TIME_AVERAGE["count"]["select"], self.RESPONSE_TIME_AVERAGE["average"]["select"], "", "" ]) table.add_row([ "", "", "", self.RESPONSE_TIME_AVERAGE["errors"], "Finished execution after {} seconds".format(self.TIMING) ]) print(table) while self.queue_data.qsize() > 0 or self.queue_chart.qsize() > 0: print("Waiting finishing all pendents query") time.sleep(1) self.purge_queues() print("Finished! See http://localhost:9111/ to full report") os._exit(0)