def validate_params(self): self.validate_subscribe_key() if self._channels is None or len(self._channels) == 0: raise PubNubException(pn_error=PNERR_CHANNEL_MISSING) if self._include_meta is None: self._include_meta = False if self._include_message_actions is None: self._include_message_actions = False if self._include_message_actions is False: if self._maximum_per_channel is None or self._maximum_per_channel < FetchMessages.DEFAULT_MESSAGES: self._maximum_per_channel = FetchMessages.DEFAULT_MESSAGES logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES) elif self._maximum_per_channel > FetchMessages.MAX_MESSAGES: self._maximum_per_channel = FetchMessages.MAX_MESSAGES logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES) else: if len(self._channels) > 1: raise PubNubException( pn_error=PNERR_HISTORY_MESSAGE_ACTIONS_MULTIPLE_CHANNELS) if self._maximum_per_channel is None or self._maximum_per_channel < 1 or\ self._maximum_per_channel > FetchMessages.MAX_MESSAGES_ACTIONS: self._maximum_per_channel = FetchMessages.MAX_MESSAGES_ACTIONS logger.info("maximum_per_channel param defaulting to %d", FetchMessages.DEFAULT_MESSAGES)
def validate_timetokens(self): if self._message_timetoken is None: raise PubNubException(pn_error=PNERR_MESSAGE_TIMETOKEN_MISSING) if self._action_timetoken is None: raise PubNubException( pn_error=PNERR_MESSAGE_ACTION_TIMETOKEN_MISSING)
def validate_params(self): self.validate_subscribe_key() if not isinstance(self._device_id, six.string_types) or len(self._device_id) == 0: raise PubNubException(pn_error=PNERR_PUSH_DEVICE_MISSING) if self._push_type is None: raise PubNubException(pn_error=PNERROR_PUSH_TYPE_MISSING)
def validate_params(self): self.validate_subscribe_key() if len(self._channels) == 0: raise PubNubException(pn_error=PNERR_CHANNELS_MISSING) if not isinstance(self._channel_group, str) or len(self._channel_group) == 0: raise PubNubException(pn_error=PNERR_GROUP_MISSING)
def _invoke_request(self, p_options, e_options, base_origin): assert isinstance(p_options, PlatformOptions) assert isinstance(e_options, RequestOptions) if base_origin: url = p_options.pn_config.scheme( ) + "://" + base_origin + e_options.path else: url = e_options.path if e_options.request_headers: p_options.update(e_options.request_headers) args = { "method": e_options.method_string, "headers": p_options.headers, "url": url, "params": e_options.query_string, "timeout": (e_options.connect_timeout, e_options.request_timeout), "allow_redirects": e_options.allow_redirects } if e_options.is_post() or e_options.is_patch(): args["data"] = e_options.data args["files"] = e_options.files logger.debug( "%s %s %s" % (e_options.method_string, utils.build_url(p_options.pn_config.scheme(), base_origin, e_options.path, e_options.query_string), e_options.data)) else: logger.debug( "%s %s" % (e_options.method_string, utils.build_url(p_options.pn_config.scheme(), base_origin, e_options.path, e_options.query_string))) try: res = self.session.request(**args) logger.debug("GOT %s" % res.text) except requests.exceptions.ConnectionError as e: raise PubNubException(pn_error=PNERR_CONNECTION_ERROR, errormsg=str(e)) except requests.exceptions.HTTPError as e: raise PubNubException(pn_error=PNERR_HTTP_ERROR, errormsg=str(e)) except requests.exceptions.Timeout as e: raise PubNubException(pn_error=PNERR_CLIENT_TIMEOUT, errormsg=str(e)) except requests.exceptions.TooManyRedirects as e: raise PubNubException(pn_error=PNERR_TOO_MANY_REDIRECTS_ERROR, errormsg=str(e)) except Exception as e: raise PubNubException(pn_error=PNERR_UNKNOWN_ERROR, errormsg=str(e)) return res
def validate_params(self): self.validate_subscribe_key() self.validate_channels_and_groups() if len(self._channels) == 0 and len(self._groups) > 0: raise PubNubException( pn_error=PNERR_STATE_SETTER_FOR_GROUPS_NOT_SUPPORTED_YET) if self._state is None or not isinstance(self._state, dict): raise PubNubException(pn_error=PNERR_STATE_MISSING)
def validate_params(self): self.validate_subscribe_key() if not isinstance(self._device_id, str) or len(self._device_id) == 0: raise PubNubException(pn_error=PNERR_PUSH_DEVICE_MISSING) if self._push_type is None: raise PubNubException(pn_error=PNERROR_PUSH_TYPE_MISSING) if self._push_type == PNPushType.APNS2: if not isinstance(self._topic, str) or len(self._topic) == 0: raise PubNubException(pn_error=PNERR_PUSH_TOPIC_MISSING)
def _invoke_request(p_options, e_options, base_origin): assert isinstance(p_options, PlatformOptions) assert isinstance(e_options, RequestOptions) url = utils.build_url(p_options.pn_config.scheme(), base_origin, e_options.path, e_options.query_string) args = { "method": e_options.method_string, 'headers': p_options.headers, "url": url, 'params': e_options.query_string, 'timeout': (e_options.connect_timeout, e_options.request_timeout) } if e_options.is_post(): args['data'] = e_options.data logger.debug("%s %s %s" % (e_options.method_string, url, e_options.data)) else: logger.debug("%s %s" % (e_options.method_string, url)) try: req = urllib.request.Request(url, e_options.data, p_options.headers) res = urllib.request.urlopen(req) except urllib.error.URLError as e: # For Python 2.6 if isinstance(e.reason, socket.timeout): raise PubNubException( pn_error=PNERR_CLIENT_TIMEOUT, errormsg=str(e) ) else: # TODO: wrap raise except urllib.error.HTTPError as e: raise PubNubException( pn_error=PNERR_HTTP_ERROR, errormsg=str(e) ) except socket.timeout as e: raise PubNubException( pn_error=PNERR_CLIENT_TIMEOUT, errormsg=str(e) ) except Exception as e: raise PubNubException( pn_error=PNERR_UNKNOWN_ERROR, errormsg=str(e) ) return res
def validate_message_action(self): if self._message_action is None: raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_MISSING) if self._message_action.message_timetoken is None: raise PubNubException(pn_error=PNERR_MESSAGE_TIMETOKEN_MISSING) if self._message_action.type is None or len( self._message_action.type) == 0: raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_TYPE_MISSING) if self._message_action.value is None or len( self._message_action.value) == 0: raise PubNubException(pn_error=PNERR_MESSAGE_ACTION_VALUE_MISSING)
def build_data(self): params = {'ttl': str(self._ttl)} permissions = {} resources = {} patterns = {} utils.parse_resources(self._channels, "channels", resources, patterns) utils.parse_resources(self._groups, "groups", resources, patterns) utils.parse_resources(self._users, "users", resources, patterns) utils.parse_resources(self._spaces, "spaces", resources, patterns) permissions['resources'] = resources permissions['patterns'] = patterns if self._meta is not None: if isinstance(self._meta, dict): permissions['meta'] = self._meta else: raise PubNubException(pn_error=PNERR_INVALID_META) else: permissions['meta'] = {} params['permissions'] = permissions return utils.write_value_as_string(params)
def validate_params(self): self.validate_subscribe_key() self.validate_secret_key() # self.validate_channels_and_groups() if self._write is None and self._read is None and self._manage is None: raise PubNubException(pn_error=PNERR_PAM_NO_FLAGS)
def validate_params(self): self.validate_channel() if self._message is None: raise PubNubException(pn_error=PNERR_MESSAGE_MISSING) self.validate_subscribe_key() self.validate_publish_key()
def validate_params(self): self.validate_subscribe_key() self.validate_secret_key() self.validate_publish_key() # self.validate_channels_and_groups() if self._channels and self._groups and self._uuids: raise PubNubException( pn_error=PNERR_PAM_INVALID_ARGUMENTS, errormsg="Grants for channels or channelGroups can't be changed together with grants for UUIDs") if self._uuids and not self._auth_keys: raise PubNubException(pn_error=PNERR_PAM_INVALID_ARGUMENTS, errormsg="UUIDs grant management require " "providing non empty authKeys" ) if self._write is None and self._read is None and self._manage is None and self._get is None \ and self._update is None and self._join is None: raise PubNubException(pn_error=PNERR_PAM_NO_FLAGS)
def validate_params(self): self.validate_subscribe_key() if self._channels is None or len(self._channels) == 0: raise PubNubException(pn_error=PNERR_CHANNEL_MISSING) if self._include_meta is None: self._include_meta = False if self._include_message_actions is None: self._include_message_actions = False if not self._include_message_actions: if len(self._channels) == 1: if self._count is None or self._count < 1: self._count = FetchMessages.DEFAULT_SINGLE_CHANNEL_MESSAGES logger.info("count param defaulting to %d", self._count) elif self._count > FetchMessages.SINGLE_CHANNEL_MAX_MESSAGES: self._count = FetchMessages.DEFAULT_SINGLE_CHANNEL_MESSAGES logger.info("count param defaulting to %d", self._count) else: if self._count is None or self._count < 1: self._count = FetchMessages.DEFAULT_MULTIPLE_CHANNELS_MESSAGES logger.info("count param defaulting to %d", self._count) elif self._count > FetchMessages.MULTIPLE_CHANNELS_MAX_MESSAGES: self._count = FetchMessages.DEFAULT_MULTIPLE_CHANNELS_MESSAGES logger.info("count param defaulting to %d", self._count) else: if len(self._channels) > 1: raise PubNubException( pn_error=PNERR_HISTORY_MESSAGE_ACTIONS_MULTIPLE_CHANNELS) if self._count is None or self._count < 1 or\ self._count > FetchMessages.MAX_MESSAGES_ACTIONS: self._count = FetchMessages.DEFAULT_MESSAGES_ACTIONS logger.info("count param defaulting to %d", self._count)
def validate_params(self): self.validate_subscribe_key() if self._data is None: raise PubNubException('No data supplied.')
def build_path(self): if self._space_id is None: raise PubNubException('Provide space id.') return DeleteSpace.DELETE_DELETE_PATH % ( self.pubnub.config.subscribe_key, self._space_id)
def build_path(self): if self._space_id is None: raise PubNubException('Provide space id.') return UpdateSpace.UPDATE_SPACE_PATH % ( self.pubnub.config.subscribe_key, self._space_id)
def validate_params(self): self.validate_subscribe_key() if len(self._channels) == 0 and len(self._groups) == 0: raise PubNubException(pn_error=PNERR_CHANNEL_OR_GROUP_MISSING)
def validate_file_name(self): if not self._file_name: raise PubNubException(pn_error=PNERR_FILE_NAME_MISSING)
def validate_publish_key(self): if self.pubnub.config.publish_key is None or len( self.pubnub.config.publish_key) == 0: raise PubNubException(pn_error=PNERR_PUBLISH_KEY_MISSING)
def validate_params(self): self.validate_subscribe_key() self.validate_channel() if len(self._channels_timetoken) != len(self._channel): raise PubNubException('The number of channels and the number of timetokens do not match.')
def validate_secret_key(self): if self.pubnub.config.secret_key is None or len( self.pubnub.config.secret_key) == 0: raise PubNubException(pn_error=PNERR_SECRET_KEY_MISSING)
def validate_channels_and_groups(self): if len(self._channels) == 0 and len(self._groups) == 0: raise PubNubException(pn_error=PNERR_CHANNEL_OR_GROUP_MISSING)
def validate_subscribe_key(self): if self.pubnub.config.subscribe_key is None or len( self.pubnub.config.subscribe_key) == 0: raise PubNubException(pn_error=PNERR_SUBSCRIBE_KEY_MISSING)
def validate_file_id(self): if not self._file_id: raise PubNubException(pn_error=PNERR_FILE_ID_MISSING)
def validate_params(self): self.validate_subscribe_key() if not isinstance(self._channel_group, six.string_types)\ or len(self._channel_group) == 0: raise PubNubException(pn_error=PNERR_GROUP_MISSING)
def _validate_channel(self): if self._channel is None or len(self._channel) == 0: raise PubNubException(pn_error=PNERR_CHANNEL_MISSING)
def _build_envelope(self, p_options, e_options): """ A wrapper for _invoke_url to separate request logic """ status_category = PNStatusCategory.PNUnknownCategory response_info = None try: res = self._invoke_request(p_options, e_options, self.pubnub.base_origin) except PubNubException as e: if e._pn_error is PNERR_CONNECTION_ERROR: status_category = PNStatusCategory.PNUnexpectedDisconnectCategory elif e._pn_error is PNERR_CLIENT_TIMEOUT: status_category = PNStatusCategory.PNTimeoutCategory return Envelope(result=None, status=e_options.create_status( category=status_category, response=None, response_info=response_info, exception=e)) if res is not None: url = six.moves.urllib.parse.urlparse(res.url) query = six.moves.urllib.parse.parse_qs(url.query) uuid = None auth_key = None if 'uuid' in query and len(query['uuid']) > 0: uuid = query['uuid'][0] if 'auth_key' in query and len(query['auth_key']) > 0: auth_key = query['auth_key'][0] response_info = ResponseInfo(status_code=res.status_code, tls_enabled='https' == url.scheme, origin=url.hostname, uuid=uuid, auth_key=auth_key, client_request=res.request) if res.status_code != requests.codes.ok: if res.status_code == 403: status_category = PNStatusCategory.PNAccessDeniedCategory if res.status_code == 400: status_category = PNStatusCategory.PNBadRequestCategory if res.text is None: text = "N/A" else: text = res.text if res.status_code >= 500: err = PNERR_SERVER_ERROR else: err = PNERR_CLIENT_ERROR return Envelope(result=None, status=e_options.create_status( category=status_category, response=res.json(), response_info=response_info, exception=PubNubException( pn_error=err, errormsg=text, status_code=res.status_code))) else: return Envelope( result=e_options.create_response(res.json()), status=e_options.create_status( category=PNStatusCategory.PNAcknowledgmentCategory, response=res.json(), response_info=response_info, exception=None))
def _validate_uuid(self): if self._effective_uuid() is None or len(self._effective_uuid()) == 0: raise PubNubException(pn_error=PNERR_UUID_MISSING)
def build_path(self): if self._user_id is None: raise PubNubException('Provide user_id.') return DeleteUser.DELETE_USER_PATH % (self.pubnub.config.subscribe_key, self._user_id)