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 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 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 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 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()
