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