def __nodeready(self):
self.__domain = None
try:
self.node_ready()
except:
utils.log_exception()
def rpcserver_invoke(self, token, path, name, arg):
arg = arg.as_stdstr()
name = name.as_string()
func = self.get_rpc(path, name)
if func is None:
self.__completed(token, False, 'no such rpc %s:%s' % (path, name))
return
def result(deferred, status, msg=''):
self.__completed(token, status, msg)
self.__running.remove(deferred)
try:
r = func(arg)
if r is None: r = async .success()
if not isinstance(r, async .Deferred): r = async .success(r)
self.__running.add(r)
except:
utils.log_exception()
self.__completed(token, False, 'internal rpc error %s' % name)
return
r.setCallback(result, r, True).setErrback(result, r, False)
def __nodechanged(self, parts):
if 'domain' in parts:
self.__domain = None
try:
self.node_changed(parts)
except:
utils.log_exception()
def get_description_from_file(dbfile):
try:
db = state.open_database(dbfile, False)
snap = db.get_trunk()
desc = get_description(snap)
return desc
except:
utils.log_exception()
return ''
def file_bug(user, email, subj, desc):
try:
zf = resource.get_bugfile()
zip = zipfile.ZipFile(resource.WC(zf), 'w')
zip.writestr('description', desc)
zip.writestr('user', user)
zip.writestr('email', email)
zip.writestr('subject', subj)
zip.writestr(
'bugreport.txt',
"From: %s <%s>\n\nSubject: %s\n\n%s\n" % (user, email, subj, desc))
def_state_file = resource.user_resource_file(resource.global_dir,
resource.current_setup)
for statefile in resource.glob_glob(def_state_file + '*'):
zip.write(resource.WC(statefile),
resource.WC(
os.path.join('Setup', os.path.basename(statefile))),
compress_type=zipfile.ZIP_DEFLATED)
# add the crash reports of today to the bug report
if resource.is_macosx():
diag = os.path.expanduser("~/Library/Logs/DiagnosticReports")
today = datetime.date.today().strftime("_%Y-%m-%d-")
if resource.os_path_isdir(diag):
for crashfile in resource.glob_glob("%s/eigen*%s*.crash" %
(diag, today)):
zip.write(crashfile,
os.path.join("Crash",
os.path.basename(crashfile)),
compress_type=zipfile.ZIP_DEFLATED)
for crashfile in resource.glob_glob("%s/Workbench*%s*.crash" %
(diag, today)):
zip.write(crashfile,
os.path.join("Crash",
os.path.basename(crashfile)),
compress_type=zipfile.ZIP_DEFLATED)
#core_files = resource.glob_glob('/cores/*')
#if core_files:
# zip.write( core_files[0],compress_type=zipfile.ZIP_DEFLATED)
log_folder = resource.user_resource_dir(resource.log_dir)
for file in resource.glob_glob(os.path.join(log_folder, "*")):
path, filename = os.path.split(file)
full_path = os.path.join('Log', filename)
zip.write(resource.WC(file),
resource.WC(full_path),
compress_type=zipfile.ZIP_DEFLATED)
zip.close()
except:
utils.log_exception()
def rpc_fideal(self,arg):
try:
(path,cookie) = logic.parse_clause(arg)
cookie=int(cookie)
except:
utils.log_exception()
return async.failure('invalid cookie')
for name,val in self.clist:
if cookie==val:
return 'cmp([dsc(~(parent)"#2",%d)])' % val
return async.failure('invalid cookie')
def find_all_setups():
try:
m = Menu('Setups')
m.add_child(find_user_setups())
m.add_child(find_factory_setups())
m.add_child(find_example_setups())
m.add_child(find_experimental_setups())
m.add_child(find_old_setups())
return m.term()
except:
utils.log_exception()
return Menu('Setups')
def __init__(self, address, delegate=None):
proxy.AtomProxy.__init__(self)
self.__delegate = delegate or self
self.__anchor = piw.canchor()
self.__anchor.set_client(self)
self[2] = proxy.AtomProxy()
self[11] = HistoryProxy(self.__delegate)
self.__anchor.set_address_str(address)
try:
self.__connector = MetaConnector(self.__delegate)
self.set_meta_clone(self.__connector)
except:
utils.log_exception()
def fgdequeue(self):
while self.fgqueue:
(f,a,k,n) = self.fgqueue[0]
self.fgqueue = self.fgqueue[1:]
status = False
r = None
try:
try:
r = f(*a,**k)
status = True
except:
utils.log_exception()
finally:
try:
if n:
n(status,r)
except:
utils.log_exception()
def startup(mgr):
a = Agent(mgr,
opts.name,
opts.path,
logger=hostlogger,
icon='app_cmdline/agentd.png')
try:
if opts.target:
x = a.load_file(opts.target)
path, result[0] = x
result[0].setCallback(load_ok).setErrback(load_failed)
else:
for (name, plugin) in preload.iteritems():
a.add_agent(name, plugin)
except Exception, e:
utils.log_exception()
def traits(domain):
"""
Return traits object for a particular domain has the following attributes:
data2value(data) -> normal value object, throws ValueError if wrong
value2data(data) -> data object, throws ValueError if wrong
canonical() -> canonical form of domain name
normalizer() -> returns fast normalizer d2d functor
denormalizer() -> returns fast denormalizer d2d functor
default() -> a valid default normal value in the domain
"""
try:
term = logic.parse_term(domain)
klass = __traits.get(term.pred)
if not klass:
raise ValueError("bad domain")
return klass(*term.args)
except:
utils.log_exception()
raise ValueError("bad domain " + domain)
def update(self):
try:
doc_file = resource.user_resource_file('Help', 'documentation.xml')
((major, minor, build),
tag) = resource.split_version(version.version)
doc_url = "%s/%d.%d" % (doc_base, major, minor)
print 'loading documentation from', doc_url
doc_conn = urllib.urlopen(doc_url)
doc_text = doc_conn.read()
doc_conn.close()
doc_out = open(doc_file, 'w')
doc_out.write(doc_text)
doc_out.close()
print 'loaded documentation'
except:
print 'failed to update documentation'
utils.log_exception()
return
self.load_documentation()
def bg_ok(*args,**kwds):
a.run_fg_async(d.succeeded,*args,**kwds)
def bg_failed(*args,**kwds):
a.run_fg_async(d.failed,*args,**kwds)
def doit():
try:
r=utils.safe(func,*args,**kwds)
if not isinstance(r,async.Deferred):
a.run_fg_async(d.succeeded,r)
return
r.setCallback(bg_ok).setErrback(bg_failed)
except:
utils.log_exception()
a.run_fg_async(d.failed)
a.run_bg_async(doit)
return d
def defer_fg(func,*args,**kwds):
d=async.Deferred()
a=wx.GetApp()
def bg_ok(*args,**kwds):
a.run_bg_async(d.succeeded,*args,**kwds)
def bg_failed(*args,**kwds):
a.run_bg_async(d.failed,*args,**kwds)
def __noderemoved(self):
try:
self.node_removed()
except:
utils.log_exception()
