class Config(object):
SECRET_KEY = '33456@#$456@#$12%^&*('
ROOT_PATH = dn(dn(dn(ap(__file__))))
# 可见性超时时间定义了等待职程在消息分派到其他职程之前确认收到任务的秒数。一定要阅读下面的 警示 一节。
# 这个选项通过 BROKER_TRANSPORT_OPTIONS 设置:
BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600} # 1 hour.
BROKER_URL = 'redis://127.0.0.1:6379/6'
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/5'
CELERY_TIMEZONE = 'Asia/Shanghai'
CELERY_ENABLE_UTC = True
# 读取任务结果一般性能要求不高，所以使用了可读性更好的JSON
CELERY_RESULT_SERIALIZER = 'json'
# 指定接受的内容类型
CELERY_ACCEPT_CONTENT = ['json', 'msgpack', 'yaml', 'pickle']
# 任务序列化和反序列化使用msgpack方案
CELERY_TASK_SERIALIZER = 'msgpack'
# 任务过期时间，不建议直接写86400，应该让这样的magic数字表述更明显
CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24
MAIL_HOST = os.getenv("MAIL_HOST") # 设置服务器
MAIL_USER = os.getenv("MAIL_USER") # 用户名
MAIL_PASS = os.getenv("MAIL_PASS") # 口令
def load_presets():
with open(join(dirname(ap(__file__)), "presets/obj_presets.json")) as f:
data = json.loads(f.read())
camel = (lambda dat: ''.join("{} ".format(x.title())
for x in dat.split("_"))[:-1])
return [(key, camel(key), "Load lk_{}".format(key))
for key in data.keys()]
def setUp(self):
self.testhost = os.environ.get('EASYAVRO_TESTING_HOST', 'localhost')
c = CachedSchemaRegistryClient(url='http://{}:4002'.format(self.testhost))
self.topic = 'easyavro-testing-topic'
rp = ap(dn(__file__))
with open(opj(rp, 'key.avsc'), 'rt') as f:
avro_key_schema = schema.Parse(f.read())
with open(opj(rp, 'value.avsc'), 'rt') as f:
avro_value_schema = schema.Parse(f.read())
c.register(self.topic + '-key', avro_key_schema)
c.register(self.topic + '-value', avro_value_schema)
self.bp = EasyAvroProducer(
schema_registry_url='http://{}:4002'.format(self.testhost),
kafka_brokers=['{}:4001'.format(self.testhost)],
kafka_topic=self.topic
)
self.bc = EasyAvroConsumer(
schema_registry_url='http://{}:4002'.format(self.testhost),
kafka_brokers=['{}:4001'.format(self.testhost)],
consumer_group='easyavro.testing',
kafka_topic=self.topic,
offset='earliest'
)
def on_recieve(key: str, value: str) -> None:
self.recieved.append((key, value))
L.info("Recieved message")
self.recieved = []
self.on_recieve = on_recieve
def main(argv): # {{{
hexagon_path = None
elf_path = None
i = 0
while i < len(argv):
arg = argv[i]
if arg.lower() == '--hexagon-path':
if not (i + 1 < len(argv)):
return print_err(file_name,
'Expecting argument after --hexagon-path')
hexagon_path = argv[i + 1]
i += 2
continue
elif arg.lower().startswith('--hexagon-path='):
path = '='.join(arg.split('=')[1:])
if len(path) < 1:
return print_err(file_name,
'Expecting argument after --hexagon-path=')
hexagon_path = path
i += 1
continue
elif arg.lower() == '-v' or arg.lower() == '--verbose':
global verbose
verbose = True
else:
elf_path = arg
i += 1
if not elf_path:
return print_err(file_name, 'No ELF path given')
if not os.path.exists(elf_path):
return print_err(file_name, 'ELF does not exist: %s' % elf_path)
print '%s\n' % (ps(ap(elf_path))[-1], )
# get elf data
mc = MemoryChecker(elf_path, hexagon_path=hexagon_path)
mc.pull_info()
dp('') # separate verbose data from regular data
ok = mc.print_info()
if not ok:
return 1
else:
return 0
def update_enum_presets(self, context):
print("Load pre-made {} data".format(self.presets))
obj = context.object
# Fetch data
with open(join(dirname(ap(__file__)), "presets/obj_presets.json")) as f:
data = json.loads(f.read())[self.presets]
obj.liquidknot.params.clear()
preset_to_lk(data, obj)
def unpack():
# Preparations
genepool = {
"mkdir": ("mkdir", "md"),
"python": ("/bin/python3.7m", "/bin/python.exe"),
"pip": ("bin/pip", "Scripts/pip.exe")
}
index = int(not sys.platform == 'linux')
python_exec = sys.exec_prefix + genepool["python"][index]
venv_path = join(dirname(ap(__file__)), '../openGL/.venv')
temp_path = join(dirname(ap(__file__)), '../openGL/temp')
# Worthless cases
if isdir(venv_path) and isdir(temp_path):
return
call([
python_exec,
# Path to script
"{}".format(join(dirname(ap(__file__)), 'get_pip.py'))
])
call([python_exec, '-m', 'pip', 'install', 'virtualenv', '--user'])
call([
python_exec,
'-m',
'virtualenv',
venv_path # Path to venv
])
call([
join(venv_path, genepool["pip"][index]), "install", "-r",
join(dirname(ap(__file__)), 'requirements.txt')
])
print(temp_path)
mkdir(temp_path)
def execute(self, context):
if not context.mode == "Object":
mesh = bpy.data.meshes.new('LK_{}'.format(camel))
obj = bpy.data.objects.new('LK_{}'.format(camel), mesh)
# Construct the bmesh
bm = bmesh.new()
try:
meshtod = getattr(bmesh.ops, "create_{}".format(snake))
meshtod(bm)
except:
path_to_file = join(dirname(ap(__file__)),
"{}.obj".format(snake))
bpy.ops.import_scene.obj(filepath=path_to_file)
mesh_host = context.selected_objects[0]
bm.from_mesh(mesh_host.data)
bpy.ops.object.delete()
bm.to_mesh(mesh)
bm.free()
# Set location to cursor
obj.location = context.scene.cursor.location
# Set Liquidknot props
obj.liquidknot.active = True
preset_to_lk(data[CAPS_SNAKE], obj)
context.scene.collection.objects.link(obj)
# Finishing touches
shade_s(obj, snake not in flats)
else:
self.report({'WARNING'},
"Liquidknot: Option only valid in Object mode")
return {'CANCELED'}
return {'FINISHED'}
from gevent import monkey
monkey.patch_all()
import os
import sys
from os.path import abspath as ap, dirname as dn
sys.path.append(dn(dn(ap(__file__))))
from kervice.utils import when
from kervice.utils.app import Application
from kervice.app.const import Env
from kervice.app.main import init_app
app = Application.instance()
app.env = os.getenv("SERVICE_ENV", Env.local)
app.root_path = dn(dn(ap(__file__)))
app.name = os.getenv("SERVICE_NAME", None) or "test"
print(app.name)
app.debug = when(app.env == Env.production, False, True)
from kervice.utils.log_util import KLog
from kervice.bussiness.log import log_callback
KLog(callback=log_callback).init_log()
init_app()
app.config_from_object(app.config)
def main():
# Use optparse to set up usage
use = "Usage: python %prog [options] <Input ELF> <Output ELF>"
use += "\n python %prog -s symbolName <ELF>"
parser = optparse.OptionParser(usage=use, version="%prog 1.11")
parser.add_option("-d",
action="store_true",
dest="debug",
help="enable debug")
parser.add_option("-r",
action="store",
dest="removeSection",
type="str",
help="Section to remove")
parser.add_option("-t",
action="store_true",
dest="timing",
help="print program execution time")
parser.add_option("-V",
action="store_true",
dest="verification",
help="enable ELF verification (currently none)")
parser.add_option("-R",
action="store_true",
dest="ro_fatal",
help="Enable ro fatal section removal/compression")
parser.add_option("-M",
action="store_true",
dest="overlay_mem_dump",
help="Enable memory dump overlay")
parser.add_option("-c",
action="store",
dest="compressorRoot",
help="Specify the root folder of the Q6Zip compressor")
parser.add_option("-s",
action="store",
dest="coprocMerge",
type="str",
help="Path of coprocessor (silver) ELF")
options, arguments = parser.parse_args()
# Check arguments
if len(arguments) != 2:
parser.error("Unexpected argument length")
exit(const.RC_ERROR)
baseELF = arguments[0]
modifiedELF = arguments[1]
if not pe(baseELF):
parser.error("Specified ELF file does not exist.")
exit(const.RC_ERROR)
# Print configuration
if not options.debug:
print "================================================================"
print " elfManipulator.py - Generic manipulator for ELF files"
print "----------------------------------------------------------------"
print " Base ELF: ".ljust(20) + baseELF
print " Modified ELF: ".ljust(20) + modifiedELF
print " Debug: ".ljust(20) + str(options.debug)
print " Verification: ".ljust(20) + str(options.verification)
print "================================================================"
# Record the starting time
if options.timing:
start_time = time.time()
# Get the elf file as an elfFile object
if not options.debug:
print "----------------------------------------------------------------"
print " Getting ELF data from input ELF..."
print "----------------------------------------------------------------"
elf = elfFileClass.elfFile(baseELF)
# If debug is enabled, show ELF contents similarly to readelf -a
if options.debug:
elf.printInfo()
if not options.debug:
print "----------------------------------------------------------------"
print " Applying requested ELF modifications..."
print "----------------------------------------------------------------"
"""
HERE IS WHERE ALL THE ELF MODIFICATIONS SHOULD HAPPEN
"""
# -r option: Remove specified section
if options.removeSection:
if not options.debug:
print "Attempting to remove section '" + options.removeSection + "'"
elf.removeSectionByName(options.removeSection)
symbolDict = {}
# -M option: Remove BSS section for 'overlay_mem_dump' feature
overlay_mem_dumpSize = -1
if options.overlay_mem_dump:
print "OVERLAY_MEM_DUMP"
overlay_mem_dumpSh = elf.getSectionByName("overlay_mem_dump")
ro_fatalSh = elf.getSectionByName("ro_fatal")
if overlay_mem_dumpSh != const.RC_ERROR and ro_fatalSh != const.RC_ERROR:
# If an overlay_mem_dump section is found
print "\t'overlay_mem_dump' section found"
print "\tAttempting to remove 'overlay_mem_dump' BSS section."
overlay_mem_dumpSize = overlay_mem_dumpSh.sh_size
elf.removeBssOverlaySectionByName("overlay_mem_dump")
if overlay_mem_dumpSize > ro_fatalSh.sh_size:
# It is expected that size of ro_fatal section matches the
# program segment size in subsequent steps. elfManipulator is
# currently written to manipulate single section segments,
# with the EXCEPTION of removing BSS sections.
print "\t'overlay_mem_dump' exceeded 'ro_fatal' size. Re-sizing."
elf.resizeSectionByName("ro_fatal", len(ro_fatalSh.contents))
else:
if overlay_mem_dumpSh == const.RC_ERROR:
print "\tNo 'overlay_mem_dump' section found. No-op."
if ro_fatalSh == const.RC_ERROR:
print "\tNo 'ro_fatal' section found. No-op."
# -R option: Remove or compress 'ro_fatal' section
if options.ro_fatal:
print
print "RO_FATAL COMPRESSION"
# Get the section in question
sh = elf.getSectionByName("ro_fatal")
if sh != const.RC_ERROR:
# If an ro_fatal section is found
print "\t'ro_fatal' section found"
if sh.sh_size == 0:
# If 0 size section is found, remove the section for mbn
print "\tZero-sized 'ro_fatal' section. Attempting removal."
elf.removeSectionByName("ro_fatal")
else:
# Move up the ro_fatal section and then compress it
print "\tMoving up 'ro_fatal' to closest section"
symbolDict["__ro_fatal_old_start"] = sh.sh_addr
oldSize = sh.sh_size
elf.moveupSectionByName("ro_fatal")
print "\tCompressing 'ro_fatal' contents using zlib"
sh = elf.compressSectionByName("ro_fatal")
if (sh != const.RC_ERROR):
# If compression is successful, update symbols accordingly
symbolDict["__ro_fatal_new_start"] = sh.sh_addr
symbolDict["__ro_fatal_new_end"] = sh.sh_addr + len(
sh.contents)
else:
utils.raiseElfManipulatorError(
"Failed to compress ro_fatal")
# Print out statistics
print "\tOld Size: " + str(oldSize)
print "\tNew Size: " + str(sh.sh_size)
else:
# The last segment is still created due to linker script
print "\tNo 'ro_fatal' section found, checking for zero-sized segment"
if ((elf.programHeaderTable[-1].p_memsz == 0)
and (elf.programHeaderTable[-1].p_vaddr == 0)):
print "\tRemoving zero-sized segment"
elf.elfHeader.e_phnum -= 1
elf.programHeaderTable.pop()
#=============================================
# START: Q6_ZIP CHANGES
#=============================================
q6_roSection = ".candidate_compress_section"
q6_rwSection = ".rw_candidate_compress_section"
pageSize = 4096
# determine where the compressors reside
my_d = ps(inspect.getframeinfo(inspect.currentframe()).filename)[0]
compressorDirs = [
ap(pj(my_d, "../../core/kernel/dlpager/compressor")),
ap(pj(my_d, "../../../core/kernel/dlpager/compressor")),
ap(pj(my_d, "./include")),
]
if options.compressorRoot:
compressorDirs.insert(0, options.compressorRoot)
for d in compressorDirs:
if os.path.isdir(d) and 'q6zip_compress.py' in os.listdir(d):
sys.path.insert(0, d)
break
print
print "Q6ZIP FEATURE (RO)"
# Get the ELF section containing the code to compress
sh = elf.getSectionByName(q6_roSection)
# Check if the section exists
if (sh != const.RC_ERROR):
# Save the old VA before ANY modifications to the section/segment
oldVA = sh.sh_addr
# Save old size
oldSize = sh.sh_size
print "oldVA = " + hex(oldVA)
print "Size of " + q6_roSection + " is " + str(sh.sh_size)
symbolDict["start_va_uncompressed_text"] = sh.sh_addr
symbolDict["end_va_uncompressed_text"] = sh.sh_addr + sh.sh_size
# Move up the vaddr of the section, corresponding segment and mark all
# its symbols as SHN_UNDEF. Will fail if q6_roSection is part of multi-
# section segment in the ELF.
# Save the new VA after moving up the section/segment
print "Moving up " + q6_roSection + " to closest segment"
elf.moveupSectionByName(q6_roSection)
newVA = sh.sh_addr
print "newVA = " + hex(newVA)
print "Compress " + q6_roSection
import q6zip_compress
try:
text_nonpartial_start = elf.getSymbolByName(
"__swapped_range_text_partial_end__").st_value
if text_nonpartial_start != 0:
size_partial = text_nonpartial_start - oldVA
print "text nonpartial start = " + hex(text_nonpartial_start)
print "text partial size = " + str(size_partial)
sh.contents = q6zip_compress.compress(pageSize, newVA, sh.contents,
size_partial)
except:
sh.contents = q6zip_compress.compress(pageSize, newVA, sh.contents)
# Alignment needed for Q6ZIP RW in the next section
alignedSize = pageSize * (len(sh.contents) / pageSize + 1)
for i in xrange(alignedSize - len(sh.contents)):
sh.contents += '\0'
elf.resizeSectionByName(q6_roSection, alignedSize)
print "Size of " + q6_roSection + " after compression " + str(
sh.sh_size)
print("Memory Savings Report: Q6Zip RO: Gross Memory Saved: %u\n" %
(oldSize - sh.sh_size))
symbolDict["start_va_compressed_text"] = newVA
symbolDict["end_va_compressed_text"] = sh.sh_addr + sh.sh_size
# Change permissions (remove execute)
print "\tRemoving X from " + q6_roSection
sh.sh_flags = sh.sh_flags & ~const.sectionFlags.SHF_EXECINSTR
ph = elf.getProgramHeaderBySectionName(q6_roSection)
if ph != const.RC_ERROR:
ph.p_flags &= ~const.segmentFlags.PF_X
else:
utils.raiseElfManipulatorError(
"Unexpected error while changing permissions for " +
q6_roSection)
if (sh != const.RC_ERROR):
print "Success compressing " + q6_roSection
else:
utils.raiseElfManipulatorError("Failed to compress " +
q6_roSection)
else:
# Like ro_fatal, need to check for zero-sized segment
print "No " + q6_roSection + " section found, checking for zero-sized segment"
if ((elf.programHeaderTable[-1].p_memsz == 0)
and (elf.programHeaderTable[-1].p_vaddr == 0)):
print "Removing zero-sized segment"
elf.elfHeader.e_phnum -= 1
elf.programHeaderTable.pop()
print
print "Q6ZIP FEATURE (RW)"
# Get the ELF section containing the code to compress
sh = elf.getSectionByName(q6_rwSection)
# Check if the section exists
if (sh != const.RC_ERROR):
print "\t'" + q6_rwSection + " section found"
print "Size of " + q6_rwSection + " is " + str(sh.sh_size)
# Save the old VA before ANY modifications to the section/segment
oldSize = sh.sh_size
bss_common_start = elf.getSymbolByName(
"__swapped_segments_bss_start__").st_value
print "\bss_common_start = " + hex(bss_common_start)
symbolDict["start_va_uncompressed_rw"] = sh.sh_addr
symbolDict["end_va_uncompressed_rw"] = sh.sh_addr + sh.sh_size
rw_contents = bss_common_start - sh.sh_addr
print "\t rw_contents = " + hex(rw_contents)
# Move up the section
print "\tMoving up " + q6_rwSection + " to closest section"
elf.moveupSectionByName(q6_rwSection)
newVA = sh.sh_addr
print "\tCompressing " + q6_rwSection + " contents using q6 compressor"
import rw_py_compress
sh.contents = rw_py_compress.rw_py_compress(pageSize, newVA,
sh.contents[0:rw_contents])
#pad with 0s till pageSize
rem = len(sh.contents) % pageSize
if rem != 0:
sh.contents = sh.contents.ljust(
len(sh.contents) + pageSize - rem, '0')
# Resize the section
elf.resizeSectionByName(q6_rwSection, len(sh.contents))
symbolDict["start_va_compressed_rw"] = newVA
symbolDict["end_va_compressed_rw"] = sh.sh_addr + sh.sh_size
# Change permissions (remove execute)
print "\tRemoving X from " + q6_rwSection
sh.sh_flags = sh.sh_flags & ~const.sectionFlags.SHF_EXECINSTR
ph = elf.getProgramHeaderBySectionName(q6_rwSection)
if ph != const.RC_ERROR:
ph.p_flags &= ~const.segmentFlags.PF_X
else:
utils.raiseElfManipulatorError(
"Unexpected error while changing permissions for " +
q6_rwSection)
# Print out statistics
print "Size of " + q6_rwSection + " after compression " + str(
sh.sh_size)
print("Memory Savings Report: Q6Zip RW: Gross Memory Saved: %u" %
(oldSize - sh.sh_size))
# Moving up sections
elf.moveupElfOffsetSectionByName(q6_roSection)
elf.moveupElfOffsetSectionByName(q6_rwSection)
# moving this part to pplkcmd.py for prototyping.
#elf.moveupElfOffsetSectionByName(dynrec_section)
#elf.moveupElfOffsetSectionByName("QSR_STRING")
else:
# Like ro_fatal, need to check for zero-sized segment
print "\tNo " + q6_rwSection + " section found, checking for zero-sized segment"
if ((elf.programHeaderTable[-1].p_memsz == 0)
and (elf.programHeaderTable[-1].p_vaddr == 0)):
print "\tRemoving zero-sized segment"
elf.elfHeader.e_phnum -= 1
elf.programHeaderTable.pop()
#=============================================
# END: Q6_ZIP CHANGES
#=============================================
# -M option: Remove BSS section for 'overlay_mem_dump' feature
if options.overlay_mem_dump and overlay_mem_dumpSize >= 0:
# Need to check that the overlay_memdump does not exceed ro_fatal +
# candidate_compress_section AFTER manipulations.
roFatalSh = elf.getSectionByName("ro_fatal")
roCompressSh = elf.getSectionByName(q6_roSection)
rwCompressSh = elf.getSectionByName(q6_rwSection)
roFatalSz = 0
roCompressSz = 0
rwCompressSz = 0
if roFatalSh != const.RC_ERROR:
roFatalSz = roFatalSh.sh_size
if roCompressSh != const.RC_ERROR:
roCompressSz = roCompressSh.sh_size
if rwCompressSh != const.RC_ERROR:
rwCompressSz = rwCompressSh.sh_size
if overlay_mem_dumpSize > (roFatalSz + roCompressSz + rwCompressSz):
print "FATAL ERROR: memdump exceeds ro_fatal + ro/rw candidate_compress_sections."
print "ro_fatal size: %s bytes" % str(roFatalSz)
print "ro candidate_compress_section size: %s bytes" % str(
roCompressSz)
print "rw candidate_compress_section size: %s bytes" % str(
rwCompressSz)
print "FW memdump overlay size: %s bytes" % str(
overlay_mem_dumpSize)
print "Short by: %s bytes" % (
(roFatalSz + roCompressSz + rwCompressSz) -
overlay_mem_dumpSize)
print "Aborting"
exit(const.RC_ERROR)
# After all modifications, update image_vend pointing to the end of the
# last program segment, aligned using integer division
lastPh = elf.programHeaderTable[-1]
for ph in elf.programHeaderTable:
if ph.p_vaddr > lastPh.p_vaddr:
lastPh = ph
endAddress = lastPh.p_vaddr + lastPh.p_align * (
lastPh.p_memsz / lastPh.p_align + 1)
symbolDict["image_vend"] = endAddress
#===========================================================================
# Option: -s <COPROC_ELF>
# Description: Combine silver coprocessor image with primary ELF. No debug
# information will be preserved.
# Requirements:
# [1] Coprocessor image only has a single segment
# [2] Primary image has a single section segment (COPROC_IMAGE)
# [3] Coprocessor segment does not exceed the original size of COPROC_IMAGE
# [4] Coprocessor segment contents becomes the contents of COPROC_IMAGE
# [5] __coproc_image_start__ must point to the start of the section
#===========================================================================
if options.coprocMerge:
print "Combining coprocessor image with primary image..."
# Ensure that coprocessor segment does not exceed COPROC_IMAGE size
coproc_imageSh = elf.getSectionByName("COPROC_IMAGE")
coproc_imagePh = elf.getProgramHeaderBySectionName("COPROC_IMAGE")
coproc_align = 256 * (1 << 10)
print "\tLooking for COPROC_IMAGE section in primary image"
if coproc_imageSh != const.RC_ERROR and coproc_imagePh != const.RC_ERROR:
print "\tCOPROC_IMAGE section found in primary image"
print "\tValidating coprocessor ELF"
coprocELF = options.coprocMerge
# Read in the coprocessor ELF and verify [1]
coproc = elfFileClass.elfFile(coprocELF)
if len(coproc.programHeaderTable) != 1:
utils.raiseElfManipulatorError(
"Coproc image has more than 1 segment")
print "\tComparing size of coprocessor image with reserved COPROC_IMAGE"
if coproc_imagePh.p_filesz >= coproc.programHeaderTable[0].p_filesz:
# Move up COPROC_IMAGE, if required (both VA/PA and ELF offsets)
print "\tMoving up COPROC_IMAGE (address and ELF offset)"
elf.moveupSectionByName("COPROC_IMAGE", align=coproc_align)
elf.moveupElfOffsetSectionByName("COPROC_IMAGE")
# Read in the coprocessor image
coprocImage = utils.getDataFromELF(
coprocELF, coproc.programHeaderTable[0].p_offset,
coproc.programHeaderTable[0].p_filesz)
# Replace the contents of COPROC_IMAGE
print "\tReplacing contents of COPROC_IMAGE and resizing"
coproc_imageSh.contents = coprocImage
coprocFinalSize = coproc_imagePh.p_align * (
len(coproc_imageSh.contents) / coproc_imagePh.p_align + 1)
for i in xrange(coprocFinalSize -
len(coproc_imageSh.contents)):
coproc_imageSh.contents += '\0'
elf.resizeSectionByName("COPROC_IMAGE",
len(coproc_imageSh.contents))
print "\tUpdating __coproc_image_start__"
symbolDict["__coproc_image_start__"] = coproc_imagePh.p_vaddr
symbolDict["fw_coproc_image_start"] = coproc_imagePh.p_vaddr
print "\tUpdating MMU entries surrounding the coprocessor"
symbolDict[
"__MMU_region_unmapped_align_padding_start_coproc"] = coproc_imagePh.p_vaddr
coproc_end = coproc_imagePh.p_vaddr + len(
coproc_imageSh.contents)
coproc_end = (coproc_end + coproc_imagePh.p_align -
1) & ~(coproc_imagePh.p_align - 1)
symbolDict[
"__MMU_region_start_name_qsr_A0_1_R_1_W_1_X_0_lock_1"] = coproc_end
# move this step to pplkcmd.py for CR800980.
#print "\tMoving up QSR_STRING"
#elf.moveupElfOffsetSectionByName("QSR_STRING")
else:
# If coprocessor segment exists but is larger than reserved size, need to catch this immediately
utils.raiseElfManipulatorError(
"Coprocessor segment > COPROC_IMAGE")
else:
print "\tPrimary image does not have COPROC_IMAGE (no-op)"
# Update all symbols
if symbolDict:
print "----------------------------------------------------------------"
print " Updating symbol values from all ELF modifications..."
print "----------------------------------------------------------------"
elf.updateSymbolValuesByDict(symbolDict)
# If verification is enabled, enable verification on
if options.verification:
print "----------------------------------------------------------------"
print " Verifying modified ELF data..."
print "----------------------------------------------------------------"
elf.verify()
# Write out the ELF file based on the elfFile object
if not options.debug:
print "----------------------------------------------------------------"
print " Writing out modified ELF..."
print "----------------------------------------------------------------"
elf.writeOutELF(modifiedELF)
# Record the starting time
if options.timing:
print("Execution time: %.2f seconds" % (time.time() - start_time))
# elfManipulator ran to completed, exit with return code 0
exit(const.RC_SUCCESS)
parser.add_argument('input', type=str,
help='NIfTI image to run SPM12 segmentation pipeline on')
parser.add_argument('--subject', type=str,
help='subject identifier to name Nipype nodes after')
parser.add_argument('--destdir', type=str,
help='destination folder where to write/run the jobs.')
args = parser.parse_args()
source = args.input
basedir = args.destdir
log.info('Workflow base directory set to: %s'%basedir)
if not args.subject:
from brainvisa import axon
axon.initializeProcesses()
subject = _get_subject_(ap(source))
else:
subject = args.subject
log.info('Processing file %s (subject: %s)'%(ap(source), subject))
w = create_workflow([ap(source)], [subject], basedir=basedir)
res = w.run()
if not args.subject:
spm_node_name = [e for e in w.list_node_names() if 'spm12' in e][0]
log.info('SPM node name: %s'%spm_node_name)
spm_node = w.get_node(spm_node_name)
import gzip, pickle
import os.path as osp
pp = pickle.load(gzip.open(osp.join(w.base_dir, w.name, spm_node_name,
'result_%s.pklz'%spm_node_name), 'rb'))
def __init__(self, target, source, env, debug=False, keeplog=True): # {{{
'''Take everything we need from 'env' and prep it for our subroutines.
Note: to find env items:
print [i for i in env._dict.keys() if 'search_string' in i.lower()]
'''
self.elfpath = ap(str(source[0]))
self.outdir = ap(ps(self.elfpath)[0])
if target is not None:
self.outpath = ap(str(target[0]))
if len(target) == 1:
self.qdbpath = ""
elif len(target) == 2:
self.qdbpath = ap(str(target[1]))
else:
self.outpath = None
self.qdbpath = None
self.buildms = ap(env.subst('${BUILD_MS_ROOT}'))
self.buildpath = ap(env.subst('${BUILD_ROOT}'))
self.memreport = (env.subst('${MEMREPORT}') == '1' or
('USES_INTERNAL_BUILD' in env and
# last dir of $TARGET_ROOT is 'b'
ps(env.subst('${TARGET_ROOT}'))[-1] == 'b'))
self.buildroot = env.subst('${TARGET_ROOT}')
self.objcopy = env.subst('${OBJCOPY}')
self.threads = []
self.python = env.subst('${PYTHONCMD}')
self.short_buildpath = env.subst('${SHORT_BUILDPATH}')
self.cust_config = env.FindConfigFiles('cust_config.xml')[0]
self.core_root = env.subst('${COREBSP_ROOT}')
self.debug = debug
if len(source) > 1 and source[1] is not None:
self.coproc_path = ap(str(source[1]))
else:
self.coproc_path = None
# BYO OrderedDict implementation: [0]: order list, [1]: dict
self.savings_report = [[], {}]
self.mypspath = ap(file_dir)
if env.subst('${FAKE_ENV}') == '1':
self.replay = True
else:
self.replay = False
self.executed_manips = []
self.finalized = False
if keeplog:
self.log_handle = open(
ap(pj(self.buildms, 'pplk-%s.log' % self.short_buildpath)),
'wb',
)
else:
self.log_handle = tempfile.TemporaryFile(
prefix='pplk-tmp-%s-' % (self.short_buildpath,),
suffix='.log',
dir=self.buildms,
)
self.log('pplkcmd log version: %i' % (self.log_version,))
self.log('pplkcmd __dict__: %s' % (base64.b64encode(repr(self.__dict__)),))
if type(v) is not float:
exp = re.search(r"([A-Z]+_[A-Z]{1,3}) ?(.*)", v).groups()
add_driver(obj.liquidknot.params[i], 'value', -1, obj, exp[0],
exp[1])
def preset_to_lk(data, obj):
add_params(data["params"], obj)
obj.liquidknot.de = data["de"]
# List the Flat Shaded primitives
flats = ["cube", "octahedron", "cylinder"]
# Fetch data
with open(join(dirname(ap(__file__)), "obj_presets.json")) as f:
data = json.loads(f.read())
def shade_s(obj, mode=True):
if not obj.data.polygons[0] == mode:
for poly in obj.data.polygons:
poly.use_smooth = mode
def OperatorFactory(name):
snake = re.sub(" ", "_", name.lower())
camel = '_'.join([x.title() for x in re.sub("_", " ", name).split()])
CAPS_SNAKE = snake.upper()
def execute(self, context):
#pylint: disable=too-many-locals,no-self-use
#pylint: disable=too-many-public-methods,too-many-statements
"""
General unit tests.
Run 'python3 -m unittest -v' from the ebml directory.
"""
import unittest
from io import BytesIO
import os
import sys
import random
from os.path import dirname as dn, abspath as ap
sys.path.append(dn(dn(dn(ap(__file__)))))
TEST_DATA_DIR = os.path.dirname(__file__)
TEST_FILE = os.path.join(TEST_DATA_DIR, 'test.mkv')
__all__ = ['EbmlTest', 'UtilityTest', 'HeaderTest', 'TagsTest', 'ParsedTest',
'FilesTest', 'UNK_ID', 'TEST_FILE_DATA']
import logging
LOG = logging.getLogger(__name__)
LOG.setLevel(logging.INFO)
UNK_ID = 0x01223344
with open(TEST_FILE, 'rb') as mkv_file:
TEST_FILE_DATA = mkv_file.read()
from os.path import abspath as ap, dirname as dn
from sqlalchemy import Column, ForeignKey, Integer, String, Date, Float, Text, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine
Base = declarative_base()
DB_PATH = '{0}/d2modeling.db'.format(dn(dn(ap(__file__))))
DB_NAME = 'sqlite:///{0}'.format(DB_PATH)
engine = create_engine(DB_NAME)
Base.metadata.bind = engine
class Team(Base):
__tablename__ = 'team'
name = Column("name", String(250), primary_key=True)
elo = Column("elo", Float, default=1200)
class Match(Base):
__tablename__ = 'match'
id = Column("id", Integer, primary_key=True)
dire_score = Column("dire_score", Integer)
radiant_score = Column("radiant_score", Integer)
time = Column("time", Float)
date = Column("date", Date, index=True)
winner = Column("winner", String(250))
dire_name = Column("dire_name", String(250), ForeignKey('team.name'), index=True)
if __name__ == "__main__":
import sys
from os.path import abspath as ap, dirname as dn
sys.path.append(dn(dn(ap(__file__))))
from kservices.main import app
app.run(host="0.0.0.0", port=8110, workers=1, debug=True)
class Config(object):
SECRET_KEY = '33456@#$456@#$12%^&*('
ROOT_PATH = dn(dn(dn(ap(__file__))))
def gen_memreport(self): # {{{
'''Call mpssmem.py and QMAT'''
t1 = timer()
base_outdir = ap(pj(self.buildms, 'reports'))
self.p('\nGenerating MPSS memory reports in %s' % base_outdir)
memreport = {
'mpssmem': {
'paths': [
'mpssmem.py',
],
'arguments': [
'-b',
ap(self.buildroot),
'-f',
'-v',
self.short_buildpath],
'pyscript': True},
'qcmat': {
'paths': [
pj('reports', 'QMAT', 'rel', 'QMemoryAnalyzer_unix_cmd'),
pj('reports', 'QMAT', 'rel', 'QMemoryAnalyser_cmd.exe')],
'arguments': [
'-b',
ap(self.buildroot)],
'pyscript': False}}
for report_tool, items in memreport.iteritems():
self.p(' Generating the "%s" memory report' % report_tool)
command = None
for path in items['paths']:
if items['pyscript']:
potential_command = self.python
else:
potential_command = ap(pj(self.mypspath, path))
if self.test_executable(potential_command):
command = [potential_command]
break
if command:
outdir = ap(pj(base_outdir, report_tool))
if not os.path.exists(outdir):
os.makedirs(outdir)
if memreport[report_tool]['pyscript']:
retcode, stdout, stderr = self.call(
command +
[ap(pj(self.mypspath, memreport[report_tool]['paths'][0]))] +
memreport[report_tool]['arguments'] +
['-o', outdir])
else:
retcode, stdout, stderr = self.call(
command +
memreport[report_tool]['arguments'] +
['-o', outdir])
self.log('memreport - %s:' % report_tool)
self.log('return code: %s' % repr(retcode))
self.log('stdout:\n%s' % stdout)
self.log('stderr:\n%s' % stderr)
self.log()
else:
self.p(' Could not execute the "%s" tool' % report_tool)
t2 = timer()
t_diff = t2 - t1
self.p(' Memory report execution time: %s' % t_str(t_diff))