def attach(self, args):
""" Attach a file to a bug given a filename. """
filename = args.filename
content_type = args.content_type
bugid = args.bugid
summary = args.summary
is_patch = args.is_patch
comment = args.comment
if not os.path.exists(filename):
raise BugzError('File not found: %s' % filename)
if content_type is None:
content_type = get_content_type(filename)
if comment is None:
comment = block_edit('Enter optional long description of attachment')
if summary is None:
summary = os.path.basename(filename)
params = {}
params['ids'] = [bugid]
fd = open(filename, 'rb')
params['data'] = xmlrpclib.Binary(fd.read())
fd.close()
params['file_name'] = os.path.basename(filename)
params['summary'] = summary
if not is_patch:
params['content_type'] = content_type;
params['comment'] = comment
params['is_patch'] = is_patch
result = self.bzcall(self.bz.Bug.add_attachment, params)
self.log("'%s' has been attached to bug %s" % (filename, bugid))
def main(parameters, arguments):
"""Main entry point.
:param parameters: Command line parameters.
:param arguments: Command line arguments.
"""
address = "%s://%s:%s@%s:%s%s" % (PROTOCOL, parameters.username,
parameters.password, parameters.server,
parameters.port, ENDPOINT)
print "Connecting to: %s" % hide_password(address)
server = xmlrpclib.ServerProxy(address, verbose=VERBOSE)
try:
plugin_id, version_id = server.plugin.upload(
xmlrpclib.Binary(open(arguments[0]).read()))
print "Plugin ID: %s" % plugin_id
print "Version ID: %s" % version_id
except xmlrpclib.ProtocolError, err:
print "A protocol error occurred"
print "URL: %s" % hide_password(err.url, 0)
print "HTTP/HTTPS headers: %s" % err.headers
print "Error code: %d" % err.errcode
print "Error message: %s" % err.errmsg
def flush(self):
'''
Writes out the latest metadata information stored in memory
to the metadata file.
'''
try:
self.acquire_lock()
# Write out to the local metadata storage.
client = riak.RiakClient(host=self._config.get('metadata_server'))
bucket = client.bucket(UKAI_METADATA_BUCKET)
metadata_riak = bucket.new(self.name, data=self._metadata)
metadata_riak.store()
# Send the latest metadata information to all the
# hypervisors listed in the hypervisor list of the metadata
# information.
for hv in self.hypervisors.keys():
if UKAIIsLocalNode(hv):
continue
try:
remote = xmlrpclib.ServerProxy(
'http://%s:%d/' % (hv, self._config.get('proxy_port')))
self._set_hypervisor_sync_status(hv, UKAI_IN_SYNC)
remote.proxy_update_metadata(
self.name,
xmlrpclib.Binary(
zlib.compress(json.dumps(self._metadata))))
except (IOError, xmlrpclib.Error), e:
print e.__class__
print 'Failed to update metadata at %s. You cannot migrate a virtual machine to %s' % (
hv, hv)
self._set_hypervisor_sync_status(hv, UKAI_OUT_OF_SYNC)
finally:
self.release_lock()
def create_account(self, account_name, amount):
"""Create account with account_name starting amount
Args:
account_name(string): name for account
amount(string): initial balance
Returns:
Returns random uuid (string) on Success.
False on Failure.
"""
card_id = str(uuid.uuid4())
try:
amount = int(amount)
except ValueError:
logging.info('amount must be a integer')
return False
if self.db_obj.admin_create_account(account_name, card_id, amount):
logging.info('admin create account success')
return xmlrpclib.Binary(card_id)
logging.info('admin create account failed')
return False
def get_pipeline_device_config(self, device_hostname):
"""
Name
----
`get_pipeline_device_config` (`device_hostname`)
Description
-----------
Get the pipeline device configuration for given device hostname.
Arguments
---------
`device_hostname`: string
Device hostname for which the configuration is required.
Return value
------------
This function returns an XML-RPC binary data of output file.
"""
if not device_hostname:
raise xmlrpclib.Fault(400, "Bad request: Device hostname was not "
"specified.")
element = DeviceDictionary.get(device_hostname)
if element is None:
raise xmlrpclib.Fault(404, "Specified device not found.")
data = devicedictionary_to_jinja2(element.parameters,
element.parameters['extends'])
template = prepare_jinja_template(device_hostname, data, system_path=True)
device_configuration = template.render()
# validate against the device schema
validate_device(yaml.load(device_configuration))
return xmlrpclib.Binary(device_configuration.encode('UTF-8'))
def get_wallet(self):
"""
Return the xmlrpclib.Binary object with current wallet.
For 'parity' it is gzipped tar archive of 'keys' directory.
"""
try:
res = check_output("tar czf /secrets/wallet.tgz *",
cwd='/secrets/keys',
stderr=STDOUT,
shell=True)
except CalledProcessError as e:
self.payload['status'] = 'Error'
self.payload['data'] = 'RC {}: {}'.format(e.returncode, e.output)
return self.payload
try:
with open('/secrets/wallet.tgz', 'rb') as w_bak:
self.payload['data'] = xmlrpclib.Binary(w_bak.read())
self.payload['file_type'] = 'tgz'
self.payload['status'] = 'OK'
except IOError:
self.payload['data'] = 'Can not read /secrets/wallet.tgz'
self.payload['status'] = 'Error'
return self.payload
def test_default(self):
t = xmlrpclib.Binary()
self.assertEqual(str(t), '')
def _decodeData(self, data):
""" Decode data. """
binary_decoder = xmlrpclib.Binary()
binary_decoder.decode(data)
return binary_decoder.data
def start_analysis(self, options):
"""Start analysis.
@param options: options.
@return: operation status.
"""
log.info("Starting analysis on guest (id=%s, ip=%s)", self.id, self.ip)
# TODO: deal with unicode URLs.
if options["category"] == "file":
options["file_name"] = sanitize_filename(options["file_name"])
# If the analysis timeout is higher than the critical timeout,
# automatically increase the critical timeout by one minute.
if options["timeout"] > self.timeout:
log.debug("Automatically increased critical timeout to %s",
self.timeout)
self.timeout = options["timeout"] + 60
# Get and set dynamically generated resultserver port.
options["port"] = str(ResultServer().port)
try:
# Wait for the agent to respond. This is done to check the
# availability of the agent and verify that it's ready to receive
# data.
if self.platform == "android_device":
self._fm = FridaManager(self.ip, options)
self.wait(CUCKOO_GUEST_INIT)
# Invoke the upload of the analyzer to the guest.
self.upload_analyzer()
# Give the analysis options to the guest, so it can generate the
# analysis.conf inside the guest.
try:
self.server.add_config(options)
except:
raise CuckooGuestError("{0}: unable to upload config to "
"analysis machine".format(self.id))
# If the target of the analysis is a file, upload it to the guest.
if options["category"] == "file":
try:
file_data = open(options["target"], "rb").read()
except (IOError, OSError) as e:
raise CuckooGuestError("Unable to read {0}, error: "
"{1}".format(options["target"], e))
data = xmlrpclib.Binary(file_data)
try:
self.server.add_malware(data, options["file_name"])
except Exception as e:
raise CuckooGuestError("{0}: unable to upload malware to "
"analysis machine: {1}".format(
self.id, e))
# Launch the analyzer.
if self._fm:
self._fm.init()
self._fm.start()
self._fm.wait_for_startup()
pid = self.server.execute()
log.debug("%s: analyzer started with PID %d", self.id, pid)
# If something goes wrong when establishing the connection, raise an
# exception and abort the analysis.
except (socket.timeout, socket.error):
raise CuckooGuestError("{0}: guest communication timeout, check "
"networking or try to increase "
"timeout".format(self.id))
import xmlrpclib
proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
image_data = xmlrpclib.Binary(open('test_image.jpg').read())
# url = "http://mmbiz.qpic.cn/mmbiz_jpg/YnnndYgX6CibQ8kgxLcNDmakc2WAyRdw9ye6vrWVCFZZMAwNylOFgF4gV1BKCLoT5hdugS7KvjcsElnic7zVIiclg/0"
print "3 is even: %s" % str(proxy.get_score(image_data))
def passwords_getitem(self, key):
newkey, buf = PAW2_Buffer.pack(self.storage.passwords[key])
return xmlrpclib.Binary(buf)
#!/usr/bin/python
from __future__ import with_statement
import sys, string, xmlrpclib, re, os
if len(sys.argv) < 5:
exit("Usage: " + sys.argv[0] + " spacekey pagetitle contentType filename")
spacekey = sys.argv[1]
pagetitle = sys.argv[2]
contentType = sys.argv[3]
filename = sys.argv[4]
with open(filename, 'rb') as f:
data = f.read()
# slurp all the data
server = xmlrpclib.ServerProxy('https://your-url/confluence/rpc/xmlrpc')
token = server.confluence2.login('your-login', 'your-password')
page = server.confluence2.getPage(token, spacekey, pagetitle)
if page is None:
exit("Could not find page " + spacekey + ":" + pagetitle)
attachment = {}
attachment['fileName'] = os.path.basename(filename)
attachment['contentType'] = contentType
server.confluence2.addAttachment(token, page['id'], attachment,
xmlrpclib.Binary(data))
def _handle_binary(self, arg):
try:
arg = str(arg)
except UnicodeError:
raise ValueError('Cannot represent %r as binary.' % arg)
return xmlrpclib.Binary(arg)
def upload_file():
with open(filepath, "rb") as handle:
binary_data = xmlrpclib.Binary(handle.read())
proxy.server_receive_file(filename, binary_data)
def installWindows(self, version, build, arch):
self.windows = True
if not os.path.exists(
"%s/%s/%s/autoinstall-%s.zip" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch)):
if not os.path.exists(
"%s/%s/%s/autoinstall-%s.tar" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch)):
raise xenrt.XRTError("No install files found for %s build %s" %
(version, build))
if version == "longhorn" or version[0:7] == "vistaee":
method = "longhorn"
else:
method = "normal"
self.distro = version
xenrt.TEC().progress("Preparing TFTP...")
tftp = "%s/xenrt/native" % (xenrt.TEC().lookup("TFTP_BASE"))
if not os.path.exists(tftp):
xenrt.sudo("mkdir -p %s" % (tftp))
xenrt.getTestTarball("native", extract=True)
xenrt.sudo("rsync -avxl %s/winpe32.wim %s/winpe.wim" %
(xenrt.TEC().lookup("IMAGES_ROOT"), tftp))
# Get a PXE directory to put boot files in.
xenrt.TEC().progress("Preparing PXE...")
serport = xenrt.TEC().lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = xenrt.TEC().lookup("SERIAL_CONSOLE_BAUD", "115200")
pxe = xenrt.PXEBoot()
pxe.copyIn("%s/native/pxe/pxeboot.0" % (xenrt.TEC().getWorkdir()))
xenrt.sudo("rsync -avxl %s/native/pxe/32/BCD %s/BCD" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/native/pxe/boot.sdi %s/boot.sdi" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/native/pxe/bootmgr.exe %s/bootmgr.exe" %
(xenrt.TEC().getWorkdir(), tftp))
# Set the boot files and options for PXE
pxe.setSerial(serport, serbaud)
pxe.addEntry("local", boot="local")
pxecfg = pxe.addEntry("winpe", default=1, boot="linux")
pxecfg.linuxSetKernel("pxeboot.0")
xenrt.TEC().progress("Preparing web directory")
w = xenrt.WebDirectory()
f = file("%s/native/pe/perun.cmd" % (xenrt.TEC().getWorkdir()), "r")
perun = f.read()
f.close()
if method == "longhorn":
t = xenrt.TempDirectory()
xenrt.command("tar xf %s/%s/%s/autoinstall-%s.tar -C %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
w.copyIn("%s/install/unattend.xml" % (t.path()))
perun += "wget %FILES%/unattend.xml\n"
# Count the number of install.wim fragments.
catcmd = "cat "
partpath = "%s/install/install.part" % (t.path())
numparts = len(glob.glob("%s*" % (partpath)))
for i in range(1, numparts + 1):
# Download install.wim fragment.
perun += "wget %%FILES%%/%s%d\n" % (os.path.basename(partpath),
i)
# Make sure fragments get recombined.
catcmd += "%s%d " % (os.path.basename(partpath), i)
# Make fragment available over the network.
w.copyIn("%s%d" % (partpath, i))
catcmd += "> c:\\win\\sources\\install.wim\n"
perun += catcmd
w.copyIn("%s/install/install.zip" % (t.path()), target="win.zip")
t.remove()
# 32-bit installs just require the one stage.
if arch == "x86-32":
perun += "c:\\win\\sources\\setup.exe /unattend:c:\\unattend.xml"
else:
t = xenrt.TempDirectory()
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip unattend.txt -d %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch,
t.path()))
try:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip runonce.cmd -d %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch,
t.path()))
except:
try:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip win/i386/runonce.cmd -d %s"
% (xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
except:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip win/I386/runonce.cmd -d %s"
% (xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
xenrt.command("mv %s/win/?386/runonce.cmd %s/runonce.cmd" %
(t.path(), t.path()))
xenrt.command("chmod a+rwx %s/runonce.cmd" % (t.path()))
perun += """
wget %FILES%/runonce.cmd
wget %FILES%/unattend.txt
bootsect /nt52 c: /force
c:\win\i386\winnt32.exe /makelocalsource /syspart:c: /s:c:\win\i386 /unattend:c:\unattend.txt /cmd:c:\runonce.cmd
wpeutil reboot
"""
f = file("%s/runonce.cmd" % (t.path()), "r")
data = f.read()
f.close()
# HACK to support Broadcom NICs on those machines that have them.
if xenrt.TEC().lookup("BROADCOM_POSTINSTALL", False, boolean=True):
data = string.replace(data, "EXIT", "")
data = data + 'REG ADD %KEY%\\050 /VE /D "Broadcom Driver" /f\n'
data = data + 'REG ADD %KEY%\\050 /V 1 /D ' \
'"%systemdrive%\\win\\post\\Broadcom\\setup.exe ' \
'/s /v/qn" /f\n'
data = data + "EXIT\n"
xenrt.TEC().copyToLogDir("%s/runonce.cmd" % (t.path()))
f = file("%s/runonce.cmd" % (t.path()), "w")
f.write(data)
f.close()
w.copyIn("%s/unattend.txt" % (t.path()))
w.copyIn("%s/runonce.cmd" % (t.path()))
w.copyIn("%s/%s/%s/autoinstall-%s.zip" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch),
target="win.zip")
t.remove()
# Copy common files.
w.copyIn("%s/native/pe/makepart.txt" % (xenrt.TEC().getWorkdir()))
perun_dir = os.path.dirname(xenrt.TEC().lookup("WINPE_START_FILE"))
if not os.path.exists(perun_dir):
xenrt.sudo("mkdir -p %s" % (perun_dir))
# Replace variables in perun.cmd.
perun = string.replace(perun, "%FILES%", "%s" % (w.getURL("/")))
f = file("%s/perun.cmd" % (xenrt.TEC().getWorkdir()), "w")
f.write(perun)
f.close()
xenrt.TEC().copyToLogDir("%s/perun.cmd" % (xenrt.TEC().getWorkdir()))
# Put perun.cmd where WinPE expects it.
lock = xenrt.resources.CentralResource()
for i in range(10):
try:
lock.acquire("WINPE_START_FILE")
break
except:
if i == 9:
raise xenrt.XRTError("Couldn't get lock on WINPE "
"bootstrap file.")
xenrt.sleep(60)
xenrt.sudo(
"cp %s/perun.cmd %s" %
(xenrt.TEC().getWorkdir(), xenrt.TEC().lookup("WINPE_START_FILE")))
# Start install.
xenrt.TEC().progress("Starting installation")
pxefile = pxe.writeOut(self.machine)
pfname = os.path.basename(pxefile)
xenrt.TEC().copyToLogDir(pxefile, target="%s.pxe.txt" % (pfname))
self.machine.powerctl.cycle()
xenrt.TEC().progress("Rebooted host to start installation.")
xenrt.sleep(120)
lock.release()
# 64-bit requires a two-stage installation.
if arch == "x86-64":
# Wait for first stage to complete.
xenrt.sleep(360)
xenrt.TEC().progress("Preparing TFTP for second stage.")
xenrt.sudo("rsync -avxl %s/native/pxe/64/ %s/" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/winpe64.wim %s/winpe.wim" %
(xenrt.TEC().lookup("IMAGES_ROOT"), tftp))
self.machine.powerctl.cycle()
xenrt.TEC().progress(
"Rebooted host into second installation stage.")
# Wait for PXE boot.
xenrt.sleep(120)
pxe.setDefault("local")
pxe.writeOut(self.machine)
# Wait for Windows to boot.
xenrt.TEC().progress("Waiting for host to boot")
self.waitforxmlrpc(7200)
w.remove()
if method == "longhorn":
self.winRegAdd(
"HKLM", "SYSTEM\\CurrentControlSet\\Control\\Terminal Server",
"fDenyTSConnections", "DWORD", 0)
self.winRegAdd("HKLM", "SYSTEM\\CurrentControlSet\\Control\\Lsa",
"LMCompatibilityLevel", "DWORD", 1)
if not method == "longhorn":
bootini = self.xmlrpcReadFile("c:\\boot.ini").strip()
if self.memory:
bootini += " /MAXMEM=%d" % (self.memory)
if self.vcpus:
bootini += " /NUMPROC=%d" % (self.vcpus)
self.xmlrpcRemoveFile("c:\\boot.ini")
self.xmlrpcCreateFile("c:\\boot.ini", xmlrpclib.Binary(bootini))
self.xmlrpcReboot()
xenrt.sleep(180)
self.waitforxmlrpc(300)
self.tailor()
# -*- coding:utf-8 -*-
# /usr/bin/env/python
import xmlrpclib
server = xmlrpclib.ServerProxy('http://localhost:9000')
s = 'This is a string with control characters' + '\0'
print 'Local string:', s
data = xmlrpclib.Binary(s)
print 'As binary:', server.send_back_binary(data)
try:
print 'As string:', server.show_type(s)
except xmlrpclib.Fault as err:
print '\nERROR:', err
# TODO: use the xmlrpc-c type indicators instead / additionally
if arg and arg[0] in "+-":
try:
arg = int(arg, 10)
except (ValueError, TypeError), exc:
self.LOG.warn("Not a valid number: %r (%s)" % (arg, exc))
elif arg.startswith('[['): # escaping, not a list
arg = arg[1:]
elif arg == '[]':
arg = []
elif arg.startswith('['):
arg = arg[1:].split(',')
if all(i.isdigit() for i in arg):
arg = [int(i, 10) for i in arg]
elif arg.startswith('@'):
arg = xmlrpclib.Binary(read_blob(arg))
args.append(arg)
return args
def execute(self, proxy, method, args):
"""Execute given XMLRPC call."""
try:
result = getattr(proxy, method)(raw_xml=self.options.xml, *tuple(args))
except xmlrpc.ERRORS as exc:
self.LOG.error("While calling %s(%s): %s" % (method, ", ".join(repr(i) for i in args), exc))
self.return_code = error.EX_NOINPUT if "not find" in getattr(exc, "faultString", "") else error.EX_DATAERR
else:
if not self.options.quiet:
if self.options.repr:
def wrapAndCompress(self, stringDoc):
import bz2
return xmlrpclib.Binary(bz2.compress(stringDoc))
"""
buf = self.cli.essids.getitem(essid, key)
if buf:
results = PYR2_Buffer(buf.data)
if results.essid != essid:
raise StorageError("Invalid ESSID in result-collection")
return results
else:
raise KeyError
@handle_xmlfault()
def __setitem__(self, (essid, key), results):
"""Store a iterable of (password,PMK)-tuples under the given
ESSID and key.
"""
b = xmlrpclib.Binary(PYR2_Buffer.pack(essid, results))
self.cli.essids.setitem(essid, key, b)
@handle_xmlfault()
def __len__(self):
"""Return the number of ESSIDs currently stored."""
return self.cli.essids.len()
@handle_xmlfault()
def __iter__(self):
"""Iterate over all essids currently stored."""
return self.cli.essids.essids().__iter__()
@handle_xmlfault()
def __contains__(self, essid):
"""Return True if the given ESSID is currently stored."""
def get_lights_and_image(self):
self.lock.acquire()
result = (copy.deepcopy(self.tracker.state()), xmlrpclib.Binary(self.im.tostring()))
self.lock.release()
return result
def commit_job(self, cmdline):
"""When finished with a job
Usage: commitjob [email] [sourceListId] [package]
note: package should archive with zip, with the following structure
sourcename.zip
--sourcename.xml
--sourcename.png //this is logo file
--webForumConfiguration.xml(forum)
--sourcename-url.xq & sourcename-thread.xq(forum))
--finished.xml(forum)
--sourcename.xq(blog)
--config.xml(blog)
--comment.txt
--sourcename.xml sample:
<meta>
<name>istofsports.co.uk</name>
<link>http://istofsports.co.uk</link>
<gmt>3</gmt>
</meta>
"""
arg = mu.get_second_arg(cmdline)
args = cmdline.strip().split();
if len(args) != 4:
print "Command not valid, see 'man commitjob' for more info."
return False
email = args[1]
source_id = args[2];
pack_path = args[3]
print "Be patient, I hate to wait either!"
try:
file = open(pack_path , "rb")
r , p = self._proxy.upload_file(os.path.basename(pack_path) , xmlrpclib.Binary(file.read()))
self._print_result(r, p)
except:
print "Failed upload package to server, Check whether package is correct?"
print "Needs commit again"
return False
is_prioritized, p2 = self._proxy.is_prioritized(arg)
r, p = self._proxy.commit_job(email , source_id , os.path.basename(pack_path))
if not r:
self._print_result(r, p)
return
# rest so assignjob will give the correct message
self._sourcelist_id = -1
if is_prioritized:
print "#" * 30
print "# The source you just committed is flagged as a high-priority."
print "# Please send the transformation to:"
print "# \t'*****@*****.**'"
print "# as SOON as possible."
print "#" * 30
self._print_result(r, p)
def readFile(filename):
data = xmlrpclib.Binary()
f = file(filename, "rb")
data.data = f.read()
f.close()
return data
whatnot['gamespot_review'] = gamespot_review
whatnot['user_reviews'] = user_reviews
return metadata, gamespot_review, user_reviews
except Exception as e:
traceback.print_exc()
gmail.send("exception!", "*****@*****.**")
ipdb.set_trace()
#metadata, gamespot_review, user_reviews = get_metadata_and_reviews(href)
#gamespot = "http://www.gamespot.com/"
# this is going to run on the client
import xmlrpclib
proxy = xmlrpclib.ServerProxy("http://research.seanneilan.com:80/")
global_password = "******"
next_url = proxy.get_a_url(global_password) # loop and a half! hooray!
while next_url != False:
print "Next url is: " + next_url
whatnot = get_metadata_and_reviews(next_url)
p = pickle.dumps(whatnot)
b = xmlrpclib.Binary(p)
proxy.commit_data(global_password, next_url, b)
print "Completed " + next_url
next_url = proxy.get_a_url(global_password)
def newflush():
oldflush()
self.proxy.set_contents(path, xmlrpclib.Binary(f.getvalue()))
def run(self, arglist):
duration = 7200
threads = 2
guest = self.getLocation()
self.storedguest = guest
self.getLogsFrom(guest.host)
if not guest.windows:
xenrt.TEC().skip("Not running on windows.")
return
guest.xmlrpcCreateEmptyFile("c:\\mappedfile.dat", 1024)
f = file(
"%s/progs/mappedfiletest.exe" %
(self.tec.lookup("LOCAL_SCRIPTDIR")), "rb")
mfte = f.read()
f.close()
guest.xmlrpcCreateFile("c:\\mappedfiletest.exe",
xmlrpclib.Binary(mfte))
readers = []
writers = []
for i in range(threads):
readers.append(None)
writers.append(None)
started = xenrt.timenow()
w = 0
r = 0
f = 0
stop = False
xenrt.TEC().logverbose("Starting main loop")
while True:
time.sleep(15)
now = xenrt.timenow()
if now > (started + duration):
stop = True
# Check the status of the threads
any = False
for i in range(threads):
if not readers[i] and not stop:
readers[i] = guest.xmlrpcStart("c:\\mappedfiletest.exe "
"READ c:\\mappedfile.dat")
if not writers[i] and not stop:
writers[i] = guest.xmlrpcStart("c:\\mappedfiletest.exe "
"WRITE 1024")
try:
if readers[i] and guest.xmlrpcPoll(readers[i], retries=3):
ref = readers[i]
self.tec.log(guest.xmlrpcLog(ref))
readers[i] = None
r = r + 1
if guest.xmlrpcReturnCode(ref) != 0:
f = f + 1
except socket.error:
pass
try:
if writers[i] and guest.xmlrpcPoll(writers[i], retries=3):
ref = writers[i]
self.tec.log(guest.xmlrpcLog(ref))
writers[i] = None
w = w + 1
if guest.xmlrpcReturnCode(ref) != 0:
f = f + 1
except socket.error:
pass
if readers[i]:
any = True
if writers[i]:
any = True
if stop and not any:
break
self.tec.comment("%u writers and %u readers completed" % (w, r))
if f > 0:
self.tec.warning("One or more operations returned an error")
def open(self,
path,
mode='r',
buffering=-1,
encoding=None,
errors=None,
newline=None,
line_buffering=False,
**kwargs):
# TODO: chunked transport of large files
epath = self.encode_path(path)
if "w" in mode:
self.proxy.set_contents(epath, xmlrpclib.Binary(b("")))
if "r" in mode or "a" in mode or "+" in mode:
try:
data = self.proxy.get_contents(epath, "rb").data
except IOError:
if "w" not in mode and "a" not in mode:
raise ResourceNotFoundError(path)
if not self.isdir(dirname(path)):
raise ParentDirectoryMissingError(path)
self.proxy.set_contents(path, xmlrpclib.Binary(b("")))
else:
data = b("")
f = StringIO(data)
if "a" not in mode:
f.seek(0, 0)
else:
f.seek(0, 2)
oldflush = f.flush
oldclose = f.close
oldtruncate = f.truncate
def newflush():
self._lock.acquire()
try:
oldflush()
self.proxy.set_contents(epath, xmlrpclib.Binary(f.getvalue()))
finally:
self._lock.release()
def newclose():
self._lock.acquire()
try:
f.flush()
oldclose()
finally:
self._lock.release()
def newtruncate(size=None):
self._lock.acquire()
try:
oldtruncate(size)
f.flush()
finally:
self._lock.release()
f.flush = newflush
f.close = newclose
f.truncate = newtruncate
return f
except ImportError:
threading = None
try:
unicode
except NameError:
have_unicode = False
else:
have_unicode = True
alist = [{'astring': '*****@*****.**',
'afloat': 7283.43,
'anint': 2**20,
'ashortlong': 2L,
'anotherlist': ['.zyx.41'],
'abase64': xmlrpclib.Binary("my dog has fleas"),
'boolean': xmlrpclib.False,
'unicode': u'\u4000\u6000\u8000',
u'ukey\u4000': 'regular value',
'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
'datetime2': xmlrpclib.DateTime(
(2005, 02, 10, 11, 41, 23, 0, 1, -1)),
'datetime3': xmlrpclib.DateTime(
datetime.datetime(2005, 02, 10, 11, 41, 23)),
}]
class XMLRPCTestCase(unittest.TestCase):
def test_dump_load(self):
self.assertEqual(alist,
xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0])
def set_binary_exr(self, path):
with open(path, 'rb') as f:
b = xmlrpclib.Binary(f.read())
rospy.set_param(self._server_node_name + "/p2g", b)
def test_string(self):
d = '\x01\x02\x03abc123\xff\xfe'
t = xmlrpclib.Binary(d)
self.assertEqual(str(t), d)
def _handle_bytes(self, arg):
# http://bugs.jython.org/issue2429
if IRONPYTHON or JYTHON:
arg = str(arg)
return xmlrpclib.Binary(arg)
