def create_queue(self, req, resp): #check parameter CreateQueueValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s/%s" % (URISEC_QUEUE, req.queue_name)) req_inter.data = QueueEncoder.encode(req) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": lheader = self.lower_header(resp.header) resp.queue_url = lheader["location"] raise_logger( "CreateQueue RequestId:%s QueueName:%s QueueURL:%s" % (resp.get_requestid(), req.queue_name, resp.queue_url), 'rs_info')
def list_topic(self, req, resp): #check parameter ListTopicValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s" % URISEC_TOPIC) if req.prefix != "": req_inter.header["x-mns-prefix"] = req.prefix if req.ret_number != -1: req_inter.header["x-mns-ret-number"] = str(req.ret_number) if req.marker != "": req_inter.header["x-mns-marker"] = str(req.marker) if req.with_meta: req_inter.header["x-mns-with-meta"] = "true" self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.topicurl_list, resp.next_marker, resp.topicmeta_list = ListTopicDecoder.decode( resp_inter.data, req.with_meta, req_inter.get_req_id()) first_topicurl = "" if len( resp.topicurl_list) == 0 else resp.topicurl_list[0] last_topicurl = "" if len( resp.topicurl_list) == 0 else resp.topicurl_list[ len(resp.topicurl_list) - 1] raise_logger("ListTopic RequestId:%s Prefix:%s RetNumber:%s Marker:%s TopicCount:%s FirstTopicURL:%s LastTopicURL:%s NextMarker:%s" % \ (resp.get_requestid(), req.prefix, req.ret_number, req.marker,\ len(resp.topicurl_list), first_topicurl, last_topicurl, resp.next_marker))
def send_request(self, req_inter): try: raise_logger("SendRequest %s" % req_inter) self.conn.request(req_inter.method, req_inter.uri, req_inter.data, req_inter.header) self.conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) try: http_resp = self.conn.getresponse() except BadStatusLine: #open another connection when keep-alive timeout #httplib will not handle keep-alive timeout, so we must handle it ourself self.conn.close() self.conn.request(req_inter.method, req_inter.uri, req_inter.data, req_inter.header) self.conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) http_resp = self.conn.getresponse() headers = dict(http_resp.getheaders()) resp_inter = ResponseInternal(status=http_resp.status, header=headers, data=http_resp.read()) resp_inter.data = resp_inter.data.decode('utf-8') self.request_size = self.conn.request_length self.response_size = len(resp_inter.data) if not self.is_keep_alive(): self.conn.close() raise_logger("GetResponse %s" % resp_inter) return resp_inter except Exception as e: self.conn.close() raise MNSClientNetworkException( "NetWorkException", str(e), req_inter.get_req_id()) #raise netException
def main(ip_addr, port, endpoint_class=server.SimpleHttpNotifyEndpoint, msg_type=u"XML", prefix=u"http://"): #init logger global logger endpoint_class.access_log_file = "access_log.%s" % port endpoint_class.msg_type = msg_type log_file = "endpoint_log.%s" % port logger = logging.getLogger() file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=100 * 1024 * 1024) formatter = logging.Formatter( '[%(asctime)s] [%(name)s] [%(levelname)s] [%(filename)s:%(lineno)d] [%(thread)d] %(message)s', '%Y-%m-%d %H:%M:%S') file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.setLevel(logging.INFO) #start endpoint addr_info = "Start Endpoint! Address: %s%s:%s" % (prefix, ip_addr, port) print(addr_info) try: raise_logger(addr_info) httpd = server.ThreadedHTTPServer(('', port), endpoint_class) httpd.serve_forever() except KeyboardInterrupt: print("Shutting down the simple notify endpoint!") httpd.socket.close()
def subscribe(self, req, resp): #check parameter SubscribeValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, uri="/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_SUBSCRIPTION, req.subscription_name)) req_inter.data = SubscriptionEncoder.encode(req) self.build_header(req, req_inter) #send request req_inter.data = req_inter.data.decode('utf-8') resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": lheader = self.lower_header(resp.header) resp.subscription_url = lheader["location"] raise_logger("Subscribe RequestId:%s TopicName:%s SubscriptionName:%s SubscriptionURL:%s" % \ (resp.get_requestid(), req.topic_name, req.subscription_name, resp.subscription_url))
def get_subscription_attributes(self, req, resp): #check parameter GetSubscriptionAttrValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_SUBSCRIPTION, req.subscription_name)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": subscription_attr = GetSubscriptionAttrDecoder.decode( resp_inter.data, req_inter.get_req_id()) resp.topic_owner = subscription_attr["TopicOwner"] resp.topic_name = subscription_attr["TopicName"] resp.subscription_name = subscription_attr["SubscriptionName"] resp.endpoint = subscription_attr["Endpoint"] resp.filter_tag = subscription_attr[ "FilterTag"] if "FilterTag" in subscription_attr.keys() else "" resp.notify_strategy = subscription_attr["NotifyStrategy"] resp.notify_content_format = subscription_attr[ "NotifyContentFormat"] resp.create_time = int(subscription_attr["CreateTime"]) resp.last_modify_time = int(subscription_attr["LastModifyTime"]) raise_logger("GetSubscriptionAttributes RequestId:%s TopicName:%s SubscriptionName:%s" % \ (resp.get_requestid(), req.topic_name, req.subscription_name))
def list_queue(self, req, resp): #check parameter ListQueueValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s" % URISEC_QUEUE) if req.prefix != u"": req_inter.header["x-mns-prefix"] = req.prefix if req.ret_number != -1: req_inter.header["x-mns-ret-number"] = str(req.ret_number) if req.marker != u"": req_inter.header["x-mns-marker"] = str(req.marker) if req.with_meta: req_inter.header["x-mns-with-meta"] = u"true" self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.queueurl_list, resp.next_marker, resp.queuemeta_list = ListQueueDecoder.decode( resp_inter.data, req.with_meta, req_inter.get_req_id()) firstQueueURL = "" if resp.queueurl_list == [] else resp.queueurl_list[ 0] lastQueueURL = "" if resp.queueurl_list == [] else resp.queueurl_list[ len(resp.queueurl_list) - 1] raise_logger("ListQueue RequestId:%s Prefix:%s RetNumber:%s Marker:%s QueueCount:%s FirstQueueURL:%s LastQueueURL:%s NextMarker:%s" % \ (resp.get_requestid(), req.prefix, req.ret_number, req.marker, len(resp.queueurl_list), firstQueueURL, lastQueueURL, resp.next_marker) , 'rs_info')
def get_topic_attributes(self, req, resp): #check parameter GetTopicAttrValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s/%s" % (URISEC_TOPIC, req.topic_name)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": topic_attr = GetTopicAttrDecoder.decode(resp_inter.data, req_inter.get_req_id()) resp.message_count = int(topic_attr["MessageCount"]) resp.create_time = int(topic_attr["CreateTime"]) resp.last_modify_time = int(topic_attr["LastModifyTime"]) resp.maximum_message_size = int(topic_attr["MaximumMessageSize"]) resp.message_retention_period = int( topic_attr["MessageRetentionPeriod"]) resp.topic_name = topic_attr["TopicName"] resp.logging_enabled = True if topic_attr["LoggingEnabled"].lower( ) == "true" else False raise_logger("GetTopicAttributes RequestId:%s TopicName:%s" % (resp.get_requestid(), req.topic_name))
def peek_message(self, req, resp): #check parameter PeekMessageValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s?peekonly=true" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": data = PeekMessageDecoder.decode(resp_inter.data, req.base64decode, req_inter.get_req_id()) self.make_peekresp(data, resp) raise_logger("PeekMessage RequestId:%s QueueName:%s MessageInfo \ MessageId:%s BodyMD5:%s EnqueueTime:%s DequeueCount:%s" % \ (resp.get_requestid(), req.queue_name, resp.message_id, resp.message_body_md5,\ resp.enqueue_time, resp.dequeue_count))
def wrapped_func(*args, **kwargs): try: func_data = func(*args, **kwargs) return func_data except HTTPException as e: if not self.cover_http_exception: raise e else: exceptions = traceback.format_exc() if exceptions: exception_list = exceptions.split(':') if not exception_list[0] == 'NoneType': for i in exception_list: for j in i.split("\n"): raise_logger(j, 'rs_error') pass return_msg = self.get_return_msg() return return_msg except Exception: exceptions = traceback.format_exc() if exceptions: exception_list = exceptions.split(':') if not exception_list[0] == 'NoneType': for i in exception_list: for j in i.split("\n"): raise_logger(j, 'rs_error') return_msg = self.get_return_msg() return return_msg
def batch_receive_message(self, req, resp): #check parameter BatchReceiveMessageValidator.validate(req) #make request internal req_url = "/%s/%s/%s?numOfMessages=%s" % ( URISEC_QUEUE, req.queue_name, URISEC_MESSAGE, req.batch_size) if req.wait_seconds != -1: req_url += "&waitseconds=%s" % req.wait_seconds req_inter = RequestInternal(req.method, req_url) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.message_list = BatchRecvMessageDecoder.decode( resp_inter.data, req.base64decode, req_inter.get_req_id()) raise_logger("BatchReceiveMessage RequestId:%s QueueName:%s WaitSeconds:%s BatchSize:%s MessageCount:%s \ MessagesInfo\n%s" % (resp.get_requestid(), req.queue_name, req.wait_seconds, req.batch_size, len(resp.message_list),\ "\n".join(["MessageId:%s MessageBodyMD5:%s NextVisibilityTime:%s ReceiptHandle:%s EnqueueTime:%s DequeueCount:%s" % \ (msg.message_id, msg.message_body_md5, msg.next_visible_time, msg.receipt_handle, msg.enqueue_time, msg.dequeue_count) for msg in resp.message_list])))
def list_subscription_by_topic(self, req, resp): #check parameter ListSubscriptionByTopicValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_SUBSCRIPTION)) if req.prefix != "": req_inter.header["x-mns-prefix"] = req.prefix if req.ret_number != -1: req_inter.header["x-mns-ret-number"] = str(req.ret_number) if req.marker != "": req_inter.header["x-mns-marker"] = req.marker self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.subscriptionurl_list, resp.next_marker = ListSubscriptionByTopicDecoder.decode( resp_inter.data, req_inter.get_req_id()) first_suburl = "" if len(resp.subscriptionurl_list ) == 0 else resp.subscriptionurl_list[0] last_suburl = "" if len( resp.subscriptionurl_list) == 0 else resp.subscriptionurl_list[ len(resp.subscriptionurl_list) - 1] raise_logger("ListSubscriptionByTopic RequestId:%s TopicName:%s Prefix:%s RetNumber:%s \ Marker:%s SubscriptionCount:%s FirstSubscriptionURL:%s LastSubscriptionURL:%s" % \ (resp.get_requestid(), req.topic_name, req.prefix, req.ret_number, \ req.marker, len(resp.subscriptionurl_list), first_suburl, last_suburl))
def receive_message(self, req, resp): #check parameter ReceiveMessageValidator.validate(req) #make request internal req_url = "/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE) if req.wait_seconds != -1: req_url += "?waitseconds=%s" % req.wait_seconds req_inter = RequestInternal(req.method, req_url) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": data = RecvMessageDecoder.decode(resp_inter.data, req.base64decode, req_inter.get_req_id()) self.make_recvresp(data, resp) raise_logger("ReceiveMessage RequestId:%s QueueName:%s WaitSeconds:%s MessageId:%s MessageBodyMD5:%s NextVisibilityTime:%s ReceiptHandle:%s EnqueueTime:%s DequeueCount:%s" % \ (resp.get_requestid(), req.queue_name, req.wait_seconds, resp.message_id, \ resp.message_body_md5, resp.next_visible_time, resp.receipt_handle, resp.enqueue_time, resp.dequeue_count))
def batch_send_message(self, req, resp): #check parameter BatchSendMessageValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, uri="/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE)) req_inter.data = MessagesEncoder.encode(req.message_list, req.base64encode) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp, BatchSendMessageDecoder) if resp.error_data == "": resp.message_list = BatchSendMessageDecoder.decode( resp_inter.data, req_inter.get_req_id()) raise_logger("BatchSendMessage RequestId:%s QueueName:%s MessageCount:%s MessageInfo\n%s" % \ (resp.get_requestid(), req.queue_name, len(req.message_list), \ "\n".join(["MessageId:%s MessageBodyMD5:%s" % (msg.message_id, msg.message_body_md5) for msg in resp.message_list])))
def get(self, path): argument_dict = self.get_request_content(set_default=False) raise_logger('CommonTransferToPlatformController' + json.dumps(argument_dict)) transfer_url = get_transfer_to_platform_config( )['default_ip'] + request.path response_dict = transfer_to_platform(transfer_url, data=argument_dict) return response_dict
def post(self, path): all_path_list = request.path.split("/")[1:] path_list = path.split("/") # 1.0 区别前后台用户 if all_path_list[0] == 'bg': if len(path_list) < 2: self.return_error(10043) self.user_type = _USER_TYPE_ADMIN # 后台用户需要校验ip result = check_bg_ip() if result is False: self.return_error(30000) elif all_path_list[0] == 'users': pass else: self.return_error(10004) # 2.0 获取参数 argument_dict, share_key, nonce = self.get_argument_dict( must_keys=self.must_keys, is_transfer=True, api_type=self.user_type, request_type=self.request_type, invariable_key=self.invariable_key, check_token=self.check_token, check_user_id=self.check_user_id, verify_timeliness=self.verify_timeliness, encrypt=self.encrypt, check_form_token=self.check_form_token) raise_logger('UsersTransferToPlatformController' + json.dumps(argument_dict)) # 3.0 后台用户校验权限 user_service = UserBaseService(aes_share_key=share_key, aes_nonce=nonce) if self.user_type == _USER_TYPE_ADMIN: user_id = argument_dict['user_id'] module_url = path_list[0] transfer_check_result = user_service.check_admin_user_module_rights_by_user_id( user_id, module_url) if not transfer_check_result: self.return_error(30232) transfer_url = get_transfer_to_platform_config( )['default_ip'] + request.path response_dict = transfer_to_platform(transfer_url, data=argument_dict) if self.return_aes: return response_dict, share_key, nonce else: return response_dict
def __init__(self, host, access_id, access_key, version="2015-06-06", security_token="", logger=None): self.host, self.is_https = self.process_host(host) self.access_id = access_id self.access_key = access_key self.version = version self.security_token = security_token self.logger = logger self.http = MNSHttp(self.host, logger=logger, is_https=self.is_https) raise_logger("InitClient Host:%s Version:%s" % (host, version))
def get_account_attributes(self, req, resp): #make request internal req_inter = RequestInternal(req.method, "/?accountmeta=true") self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": account_attr = GetAccountAttrDecoder.decode( resp_inter.data, req_inter.get_req_id()) resp.logging_bucket = account_attr["LoggingBucket"] raise_logger("GetAccountAttributes RequestId:%s LoggingBucket:%s" % (resp.get_requestid(), resp.logging_bucket))
def delete_topic(self, req, resp): #check parameter DeleteTopicValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s/%s" % (URISEC_TOPIC, req.topic_name)) self.build_header(req, req_inter) #send reqeust resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger("DeleteTopic RequestId:%s TopicName:%s" % (resp.get_requestid(), req.topic_name))
def delete_message(self, req, resp): #check parameter DeleteMessageValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s?ReceiptHandle=%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE, req.receipt_handle)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger("DeleteMessage RequestId:%s QueueName:%s ReceiptHandle:%s" % \ (resp.get_requestid(), req.queue_name, req.receipt_handle))
def delete_queue(self, req, resp): #check parameter DeleteQueueValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s/%s" % (URISEC_QUEUE, req.queue_name)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger( "DeleteQueue RequestId:%s QueueName:%s" % (resp.get_requestid(), req.queue_name), 'rs_info')
def __init__(self, host, connection_timeout=60, keep_alive=True, logger=None, is_https=False): if is_https: self.conn = MNSHTTPSConnection(host) else: self.conn = MNSHTTPConnection( host, connection_timeout=connection_timeout) self.host = host self.is_https = is_https self.connection_timeout = connection_timeout self.keep_alive = keep_alive self.request_size = 0 self.response_size = 0 self.logger = logger raise_logger("InitMNSHttp KeepAlive:%s ConnectionTime:%s" % (self.keep_alive, self.connection_timeout))
def set_topic_attributes(self, req, resp): #check parameter SetTopicAttrValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s?metaoverride=true" % (URISEC_TOPIC, req.topic_name)) req_inter.data = TopicEncoder.encode(req) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger("SetTopicAttributes RequestId:%s TopicName:%s" % (resp.get_requestid(), req.topic_name))
def main(ip_addr, port, endpoint_class=server.SimpleHttpNotifyEndpoint, msg_type=u"XML", prefix=u"https://"): #init logger global logger endpoint_class.access_log_file = "access_log.%s" % port endpoint_class.msg_type = msg_type log_file = "endpoint_log.%s" % port logger = logging.getLogger() file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=100 * 1024 * 1024) formatter = logging.Formatter( '[%(asctime)s] [%(name)s] [%(levelname)s] [%(filename)s:%(lineno)d] [%(thread)d] %(message)s', '%Y-%m-%d %H:%M:%S') file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.setLevel(logging.INFO) tmpcertfile = "x509_public_certificate_checkhttp.pem" tmpkeyfile = "rsa_private_key_checkhttp.pem" open(tmpcertfile, 'w').write(CERTIFICATE) open(tmpkeyfile, 'w').write(RSA_PRIVATE_KEY) #start endpoint addr_info = "Start Endpoint! Address: %s%s:%s" % (prefix, ip_addr, port) print(addr_info) try: raise_logger(addr_info) httpd = HTTPServer((ip_addr, port), endpoint_class) httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=tmpkeyfile, certfile=tmpcertfile, server_side=True) httpd.serve_forever() #httpd = server.ThreadedHTTPServer(('', port), endpoint_class) except KeyboardInterrupt: print("Shutting down the simple notify endpoint!") httpd.socket.close()
def set_queue_attributes(self, req, resp): #check parameter SetQueueAttrValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s?metaoverride=true" % (URISEC_QUEUE, req.queue_name)) req_inter.data = QueueEncoder.encode(req, False) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger( "SetQueueAttributes RequestId:%s QueueName:%s" % (resp.get_requestid(), req.queue_name), 'rs_info')
def batch_delete_message(self, req, resp): #check parameter BatchDeleteMessageValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE)) req_inter.data = ReceiptHandlesEncoder.encode(req.receipt_handle_list) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp, BatchDeleteMessageDecoder) raise_logger("BatchDeleteMessage RequestId:%s QueueName:%s ReceiptHandles\n%s" % \ (resp.get_requestid(), req.queue_name, "\n".join(req.receipt_handle_list)))
def create_topic(self, req, resp): #check parameter CreateTopicValidator.validate(req) #make request internal req_inter = RequestInternal(req.method, "/%s/%s" % (URISEC_TOPIC, req.topic_name)) req_inter.data = TopicEncoder.encode(req) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.topic_url = self.lower_header(resp.header)["location"] raise_logger("CreateTopic RequestId:%s TopicName:%s TopicURl:%s" % \ (resp.get_requestid(), req.topic_name, resp.topic_url))
def unsubscribe(self, req, resp): #check parameter UnsubscribeValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, "/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_SUBSCRIPTION, req.subscription_name)) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) raise_logger( "Unsubscribe RequestId:%s TopicName:%s SubscriptionName:%s" % (resp.get_requestid(), req.topic_name, req.subscription_name))
def publish_message(self, req, resp): #check parameter PublishMessageValidator.validate(req) #make request internal req_inter = RequestInternal( req.method, uri="/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_MESSAGE)) req_inter.data = TopicMessageEncoder.encode(req) self.build_header(req, req_inter) #send request resp_inter = self.http.send_request(req_inter) #handle result, make response resp.status = resp_inter.status resp.header = resp_inter.header self.check_status(req_inter, resp_inter, resp) if resp.error_data == "": resp.message_id, resp.message_body_md5 = PublishMessageDecoder.decode( resp_inter.data, req_inter.get_req_id()) raise_logger("PublishMessage RequestId:%s TopicName:%s MessageId:%s MessageBodyMD5:%s" % \ (resp.get_requestid(), req.topic_name, resp.message_id, resp.message_body_md5))
def check_vcode_picture(self, vcode_str, vcode_key='', vcode_type=_REQUEST_TYPE_REGISTER, user_type=_USER_TYPE_INVEST): env = get_conf('env') if vcode_str == "111111" and env == 'dev': return True if vcode_key == '': redis_key = self.vcode_picture_key + str(vcode_type) + ':' + str( user_type) + ':' + str(vcode_str).lower() else: redis_key = self.vcode_picture_key + str(vcode_type) + ':' + str( user_type) + ':' + str(vcode_key) redis_tools = RedisTools() redis_result = redis_tools.get(redis_key) raise_logger('check vcode' + ' ' + str(redis_key)) if redis_result is None: self.return_aes_error(30052) if str(redis_result, encoding='utf-8').lower() != str(vcode_str).lower(): self.return_aes_error(30060) redis_tools.delete(redis_key) return True