def _my_raw_input(txt = ''): try: import readline except ImportError: # not available? ignore pass if not txt: txt = "" if const_is_python3(): try: response = input(darkgreen(txt)) except UnicodeEncodeError: response = input(darkgreen(txt.encode('utf-8'))) else: try: response = raw_input(darkgreen(txt)) except UnicodeEncodeError: response = raw_input(darkgreen(txt.encode('utf-8'))) _flush_stdouterr() # try to convert to unicode, because responses are stored that # way, fix bug #2006. if not const_isunicode(response): try: response = const_convert_to_unicode(response, enctype = "utf-8") except (UnicodeDecodeError, UnicodeEncodeError): # be fault tolerant, we just tried pass return response
def prepare_markup(text): """ Convert text to raw bytestring to make GTK3 happy. """ if const_isunicode(text): return \ const_convert_to_rawstring( text, from_enctype=etpConst['conf_encoding']) return text
def feed_child(self, txt): self.chars_count += len(txt) if self.chars_count > self.max_chars: self.reset() # Workaround vte.Terminal bug not passing to .feed proper message RAW # size. feed() supports UTF-8 but then, string length is wrongly passed # by python, because it does not consider the fact that UTF-8 chars can # be 16bits long. raw_txt_len = len(txt) if const_isunicode(txt): raw_txt_len = len(txt.encode('utf-8')) return vte.Terminal.feed(self, txt, raw_txt_len)
def feed_child(self, txt): # Workaround vte.Terminal bug not passing to .feed proper message RAW # size. feed() supports UTF-8 but then, string length is wrongly passed # by python, because it does not consider the fact that UTF-8 chars can # be 16bits long. raw_txt_len = len(txt) if const_isunicode(txt): raw_txt_len = len(txt.encode(etpConst['conf_encoding'])) try: return Vte.Terminal.feed(self, txt, raw_txt_len) except TypeError: # Vte.Terminal 0.32.x return Vte.Terminal.feed(self, prepare_markup(txt))
def add(self, set_name, set_atoms): """ Add a user-defined package set to Entropy Client (changes are permanent) @param set_name: package set name @type set_name: string @param set_atoms: list of package names in given set @type set_atoms: list (set) @raise entropy.exceptions.InvalidPackageSet: if package set data passed is invalid (non ASCII chars, invalid set_name). The encapsulated error string will contain a mnemonic reason. """ def _ensure_package_sets_dir(): sets_dir = SystemSettings.packages_sets_directory() if not os.path.isdir(sets_dir): if os.path.lexists(sets_dir): os.remove(sets_dir) os.makedirs(sets_dir, 0o775) const_setup_perms(sets_dir, etpConst['entropygid'], recursion = False) if not const_isunicode(set_name): raise InvalidPackageSet("%s %s" % ( set_name, "must be unicode",)) if set_name.startswith(etpConst['packagesetprefix']): raise InvalidPackageSet("%s %s '%s'" % ( set_name, "cannot start with", etpConst['packagesetprefix'],)) set_match = self.match(set_name) if set_match: raise InvalidPackageSet(_("Name already taken")) _ensure_package_sets_dir() set_file = os.path.join(SystemSettings.packages_sets_directory(), set_name) set_file_tmp = set_file + ".sets_add_tmp" enc = etpConst['conf_encoding'] try: with codecs.open(set_file_tmp, "w", encoding=enc) as f: for x in set_atoms: f.write(x) f.write("\n") os.rename(set_file_tmp, set_file) except (OSError, IOError) as err: raise InvalidPackageSet(_("Cannot create the element")) self._settings['system_package_sets'][set_name] = set(set_atoms)
def fake_callback(s): ## check if package set name is sane #if not entropy.tools.is_valid_string(s): # return False # does it exist? if not const_isunicode(s): s = s.decode('utf-8') set_match = sets.match(s) if set_match: return False # is the name valid after all? if (s not in current_sets) and (" " not in s) and \ (not s.startswith(etpConst['packagesetprefix'])): return True return False
def _std_write(msg, stderr=False): if not const_isstring(msg): msg = repr(msg) obj = sys.stdout if stderr: obj = sys.stderr if const_is_python3() and not const_isunicode(msg): obj.flush() obj.buffer.write(msg) obj.flush() return try: obj.write(msg) except UnicodeEncodeError: msg = msg.encode('utf-8') if const_is_python3(): obj.buffer.write(msg) else: obj.write(msg)
def remove(self, set_name): """ Remove a user-defined package set from Entropy Client (changes are permanent) @param set_name: package set name @type set_name: string @raise entropy.exceptions.InvalidPackageSet: if package set data passed is invalid (non ASCII chars, invalid set_name). The encapsulated error string will contain a mnemonic reason. """ if not const_isunicode(set_name): raise InvalidPackageSet("%s %s" % ( set_name, "must be unicode",)) if set_name.startswith(etpConst['packagesetprefix']): raise InvalidPackageSet("InvalidPackageSet: %s %s '%s'" % ( set_name, _("cannot start with"), etpConst['packagesetprefix'],)) set_match = self.match(set_name) if not set_match: raise InvalidPackageSet(_("Already removed")) set_id, set_x, set_y = set_match if set_id != etpConst['userpackagesetsid']: raise InvalidPackageSet(_("Not defined by user")) set_file = os.path.join(SystemSettings.packages_sets_directory(), set_name) try: os.remove(set_file) except OSError as err: if err.errno != errno.ENOENT: raise InvalidPackageSet(_("Set not found or unable to remove")) self._settings['system_package_sets'].pop(set_name, None)
def _generic_post_handler(self, function_name, params, file_params, timeout): """ Given a function name and the request data (dict format), do the actual HTTP request and return the response object to caller. WARNING: params and file_params dict keys must be ASCII string only. @param function_name: name of the function that called this method @type function_name: string @param params: POST parameters @type params: dict @param file_params: mapping composed by file names as key and tuple composed by (file_name, file object) as values @type file_params: dict @param timeout: socket timeout @type timeout: float @return: tuple composed by the server response string or None (in case of empty response) and the HTTPResponse object (useful for checking response status) @rtype: tuple """ if timeout is None: timeout = self._default_timeout_secs multipart_boundary = "---entropy.services,boundary---" request_path = self._request_path.rstrip("/") + "/" + function_name const_debug_write(__name__, "WebService _generic_post_handler, calling: %s at %s -- %s," " tx_callback: %s, timeout: %s" % (self._request_host, request_path, params, self._transfer_callback, timeout,)) connection = None try: if self._request_protocol == "http": connection = httplib.HTTPConnection(self._request_host, timeout = timeout) elif self._request_protocol == "https": connection = httplib.HTTPSConnection(self._request_host, timeout = timeout) else: raise WebService.RequestError("invalid request protocol", method = function_name) headers = { "Accept": "text/plain", "User-Agent": self._generate_user_agent(function_name), } if file_params is None: file_params = {} # autodetect file parameters in params for k in list(params.keys()): if isinstance(params[k], (tuple, list)) \ and (len(params[k]) == 2): f_name, f_obj = params[k] if isinstance(f_obj, file): file_params[k] = params[k] del params[k] elif const_isunicode(params[k]): # convert to raw string params[k] = const_convert_to_rawstring(params[k], from_enctype = "utf-8") elif not const_isstring(params[k]): # invalid ? if params[k] is None: # will be converted to "" continue int_types = const_get_int() supported_types = (float, list, tuple) + int_types if not isinstance(params[k], supported_types): raise WebService.UnsupportedParameters( "%s is unsupported type %s" % (k, type(params[k]))) list_types = (list, tuple) if isinstance(params[k], list_types): # not supporting nested lists non_str = [x for x in params[k] if not \ const_isstring(x)] if non_str: raise WebService.UnsupportedParameters( "%s is unsupported type %s" % (k, type(params[k]))) body = None if not file_params: headers["Content-Type"] = "application/x-www-form-urlencoded" encoded_params = urllib_parse.urlencode(params) data_size = len(encoded_params) if self._transfer_callback is not None: self._transfer_callback(0, data_size, False) if data_size < 65536: try: connection.request("POST", request_path, encoded_params, headers) except socket.error as err: raise WebService.RequestError(err, method = function_name) else: try: connection.request("POST", request_path, None, headers) except socket.error as err: raise WebService.RequestError(err, method = function_name) sio = StringIO(encoded_params) data_size = len(encoded_params) while True: chunk = sio.read(65535) if not chunk: break try: connection.send(chunk) except socket.error as err: raise WebService.RequestError(err, method = function_name) if self._transfer_callback is not None: self._transfer_callback(sio.tell(), data_size, False) # for both ways, send a signal through the callback if self._transfer_callback is not None: self._transfer_callback(data_size, data_size, False) else: headers["Content-Type"] = "multipart/form-data; boundary=" + \ multipart_boundary body_file, body_fpath = self._encode_multipart_form(params, file_params, multipart_boundary) try: data_size = body_file.tell() headers["Content-Length"] = str(data_size) body_file.seek(0) if self._transfer_callback is not None: self._transfer_callback(0, data_size, False) try: connection.request("POST", request_path, None, headers) except socket.error as err: raise WebService.RequestError(err, method = function_name) while True: chunk = body_file.read(65535) if not chunk: break try: connection.send(chunk) except socket.error as err: raise WebService.RequestError(err, method = function_name) if self._transfer_callback is not None: self._transfer_callback(body_file.tell(), data_size, False) if self._transfer_callback is not None: self._transfer_callback(data_size, data_size, False) finally: body_file.close() os.remove(body_fpath) try: response = connection.getresponse() except socket.error as err: raise WebService.RequestError(err, method = function_name) const_debug_write(__name__, "WebService.%s(%s), " "response header: %s" % ( function_name, params, response.getheaders(),)) total_length = response.getheader("Content-Length", "-1") try: total_length = int(total_length) except ValueError: total_length = -1 outcome = const_convert_to_rawstring("") current_len = 0 if self._transfer_callback is not None: self._transfer_callback(current_len, total_length, True) while True: try: chunk = response.read(65536) except socket.error as err: raise WebService.RequestError(err, method = function_name) if not chunk: break outcome += chunk current_len += len(chunk) if self._transfer_callback is not None: self._transfer_callback(current_len, total_length, True) if self._transfer_callback is not None: self._transfer_callback(total_length, total_length, True) if const_is_python3(): outcome = const_convert_to_unicode(outcome) if not outcome: return None, response return outcome, response except httplib.HTTPException as err: raise WebService.RequestError(err, method = function_name) finally: if connection is not None: connection.close()
def _generic_post_handler(self, function_name, params, file_params, timeout): """ Given a function name and the request data (dict format), do the actual HTTP request and return the response object to caller. WARNING: params and file_params dict keys must be ASCII string only. @param function_name: name of the function that called this method @type function_name: string @param params: POST parameters @type params: dict @param file_params: mapping composed by file names as key and tuple composed by (file_name, file object) as values @type file_params: dict @param timeout: socket timeout @type timeout: float @return: tuple composed by the server response string or None (in case of empty response) and the HTTPResponse object (useful for checking response status) @rtype: tuple """ if timeout is None: timeout = self._default_timeout_secs multipart_boundary = "---entropy.services,boundary---" request_path = self._request_path.rstrip("/") + "/" + function_name const_debug_write( __name__, "WebService _generic_post_handler, calling: %s at %s -- %s," " tx_callback: %s, timeout: %s" % ( self._request_host, request_path, params, self._transfer_callback, timeout, )) connection = None try: if self._request_protocol == "http": connection = httplib.HTTPConnection(self._request_host, timeout=timeout) elif self._request_protocol == "https": connection = httplib.HTTPSConnection(self._request_host, timeout=timeout) else: raise WebService.RequestError("invalid request protocol", method=function_name) headers = { "Accept": "text/plain", "User-Agent": self._generate_user_agent(function_name), } if file_params is None: file_params = {} # autodetect file parameters in params for k in list(params.keys()): if isinstance(params[k], (tuple, list)) \ and (len(params[k]) == 2): f_name, f_obj = params[k] if isinstance(f_obj, file): file_params[k] = params[k] del params[k] elif const_isunicode(params[k]): # convert to raw string params[k] = const_convert_to_rawstring( params[k], from_enctype="utf-8") elif not const_isstring(params[k]): # invalid ? if params[k] is None: # will be converted to "" continue int_types = const_get_int() supported_types = (float, list, tuple) + int_types if not isinstance(params[k], supported_types): raise WebService.UnsupportedParameters( "%s is unsupported type %s" % (k, type(params[k]))) list_types = (list, tuple) if isinstance(params[k], list_types): # not supporting nested lists non_str = [x for x in params[k] if not \ const_isstring(x)] if non_str: raise WebService.UnsupportedParameters( "%s is unsupported type %s" % (k, type(params[k]))) body = None if not file_params: headers["Content-Type"] = "application/x-www-form-urlencoded" encoded_params = urllib_parse.urlencode(params) data_size = len(encoded_params) if self._transfer_callback is not None: self._transfer_callback(0, data_size, False) if data_size < 65536: try: connection.request("POST", request_path, encoded_params, headers) except socket.error as err: raise WebService.RequestError(err, method=function_name) else: try: connection.request("POST", request_path, None, headers) except socket.error as err: raise WebService.RequestError(err, method=function_name) sio = StringIO(encoded_params) data_size = len(encoded_params) while True: chunk = sio.read(65535) if not chunk: break try: connection.send(chunk) except socket.error as err: raise WebService.RequestError(err, method=function_name) if self._transfer_callback is not None: self._transfer_callback(sio.tell(), data_size, False) # for both ways, send a signal through the callback if self._transfer_callback is not None: self._transfer_callback(data_size, data_size, False) else: headers["Content-Type"] = "multipart/form-data; boundary=" + \ multipart_boundary body_file, body_fpath = self._encode_multipart_form( params, file_params, multipart_boundary) try: data_size = body_file.tell() headers["Content-Length"] = str(data_size) body_file.seek(0) if self._transfer_callback is not None: self._transfer_callback(0, data_size, False) try: connection.request("POST", request_path, None, headers) except socket.error as err: raise WebService.RequestError(err, method=function_name) while True: chunk = body_file.read(65535) if not chunk: break try: connection.send(chunk) except socket.error as err: raise WebService.RequestError(err, method=function_name) if self._transfer_callback is not None: self._transfer_callback(body_file.tell(), data_size, False) if self._transfer_callback is not None: self._transfer_callback(data_size, data_size, False) finally: body_file.close() os.remove(body_fpath) try: response = connection.getresponse() except socket.error as err: raise WebService.RequestError(err, method=function_name) const_debug_write( __name__, "WebService.%s(%s), " "response header: %s" % ( function_name, params, response.getheaders(), )) total_length = response.getheader("Content-Length", "-1") try: total_length = int(total_length) except ValueError: total_length = -1 outcome = const_convert_to_rawstring("") current_len = 0 if self._transfer_callback is not None: self._transfer_callback(current_len, total_length, True) while True: try: chunk = response.read(65536) except socket.error as err: raise WebService.RequestError(err, method=function_name) if not chunk: break outcome += chunk current_len += len(chunk) if self._transfer_callback is not None: self._transfer_callback(current_len, total_length, True) if self._transfer_callback is not None: self._transfer_callback(total_length, total_length, True) if const_is_python3(): outcome = const_convert_to_unicode(outcome) if not outcome: return None, response return outcome, response except httplib.HTTPException as err: raise WebService.RequestError(err, method=function_name) finally: if connection is not None: connection.close()