| > server/SrvDomainDir.py:render_POST
|  120         return self.perform(req)
|  > server/SrvBase.py:perform
|    91         op = req.args.get('op')
|    92         if op is None or len(op) != 1:
|    95         op = op[0]
|    96         op_method = self.get_op_method(op)
|   > server/SrvBase.py:get_op_method
|     76         op_method_name = 'op_' + op
|     77         return getattr(self, op_method_name, None)
|   < server/SrvBase.py:get_op_method
|    97         if op_method is None:
|   103             return self._perform(op, op_method, req)
|   > server/SrvBase.py:_perform
|    106         try:
|    107             val = op_method(op, req)
|    > server/SrvDomainDir.py:op_restore
|      98         fn = FormFn(self.xd.domain_restore,
|      99                     [['file', 'str']])
|    |> Args.py:__init__
|    | 136         Args.__init__(self, paramspec, keyspec)
|    | > Args.py:__init__
|    |   14         self.arg_ord = []
|    |   15         self.arg_dict = {}
|    |   16         self.key_ord = []
|    |   17         self.key_dict = {}
|    |   18         for (name, type) in paramspec:
|    |   19                 self.arg_ord.append(name)
|    |   20                 self.arg_dict[name] = type
|    |   18         for (name, type) in paramspec:
|    |   21         for (name, type) in keyspec:
|    | < Args.py:__init__
|    | 137         self.fn = fn
|    |< Args.py:__init__
|     100         deferred = fn(req.args)
|    |> Args.py:__call__
|    | 140         return self.call_with_form_args(self.fn, fargs, xargs=xargs)
|    | > Args.py:call_with_form_args
|    |  115         (params, keys) = self.get_form_args(fargs, xargs=xargs)
|    |  > Args.py:get_form_args
|    |    53         d = {}
|    |    54         for (k, v) in f.items():
|    |    55             if ((k not in self.arg_dict) and
|    |    58             if isinstance(v, types.ListType):
|    |    59                 n = len(v)
|    |    60                 if n == 0:
|    |    62                 elif n == 1:
|    |    63                     val = v[0]
|    |    68             d[k] = val
|    |    54         for (k, v) in f.items():
|    |    55             if ((k not in self.arg_dict) and
|    |    57                 continue
|    |    54         for (k, v) in f.items():
|    |    69         return self.get_args(d, xargs=xargs)
|    |   > Args.py:get_args
|    |     26         args = {}
|    |     27         keys = {}
|    |     28         params = []
|    |     29         if xargs:
|    |     31         self.split_args(d, args, keys)
|    |    > Args.py:split_args
|    |      40         for (k, v) in d.items():
|    |      41             if k in self.arg_dict:
|    |      42                 type = self.arg_dict[k]
|    |      43                 val = self.coerce(type, v)
|    |    |> Args.py:coerce
|    |    |  72         try:
|    |    |  73             if type == 'int':
|    |    |  75             elif type == 'long':
|    |    |  77             elif type == 'str':
|    |    |  78                 val = str(v)
|    |    |  83             return val
|    |    |< Args.py:coerce
|    |      44                 args[k] = val
|    |      40         for (k, v) in d.items():
|    |    < Args.py:split_args
|    |     32         for a in self.arg_ord:
|    |     33             if a in args:
|    |     34                 params.append(args[a])
|    |     32         for a in self.arg_ord:
|    |     37         return (params, keys)
|    |   < Args.py:get_args
|    |  < Args.py:get_form_args
|    |  116         return fn(*params, **keys)
|    |  > XendDomain.py:domain_restore
|    |   409             xmigrate = XendMigrate.instance()
|    |   > XendMigrate.py:instance
|    |    527     try:
|    |    528         inst
|    |   ! Exception:
Traceback (most recent call last):
  File "/usr/lib/python/xen/xend/XendMigrate.py", line 528, in instance
    inst
NameError: global name 'inst' is not defined
|    |    529     except:
|    |    530         inst = XendMigrate()
|    |    > XendMigrate.py:__init__
|    |     435         self.db = XendDB.XendDB(self.dbpath)
|    |    |> XendDB.py:__init__
|    |    |  18         self.dbpath = xroot.get_dbroot()
|    |    | > XendRoot.py:get_dbroot
|    |    |  154         return self.dbroot
|    |    | < XendRoot.py:get_dbroot
|    |    |  19         if path:
|    |    |  20             self.dbpath = os.path.join(self.dbpath, path)
|    |    |  21         pass
|    |    |< XendDB.py:__init__
|    |     436         self.session = {}
|    |     437         self.session_db = self.db.fetchall("")
|    |    |> XendDB.py:fetchall
|    |    |  67         dpath = self.filepath(path)
|    |    | > XendDB.py:filepath
|    |    |   24         return os.path.join(self.dbpath, path)
|    |    | < XendDB.py:filepath
|    |    |  68         d = {}
|    |    |  69         for k in dircache.listdir(dpath):
|    |    |  75         return d
|    |    |< XendDB.py:fetchall
|    |     438         self.xid = 0
|    |    < XendMigrate.py:__init__
|    |    531     return inst
|    |   < XendMigrate.py:instance
|    |   410             deferred = xmigrate.restore_begin(src)
|    |   > XendMigrate.py:restore_begin
|    |    520         xid = self.nextid()
|    |    > XendMigrate.py:nextid
|    |     441         self.xid += 1
|    |     442         return "%d" % self.xid
|    |    < XendMigrate.py:nextid
|    |    521         info = XendRestoreInfo(xid, file)
|    |    > XendMigrate.py:__init__
|    |     400         XfrdInfo.__init__(self)
|    |    |> XendMigrate.py:__init__
|    |    |  96         from xen.xend import XendDomain
|    |    |  97         self.xd = XendDomain.instance()
|    |    | > XendDomain.py:instance
|    |    |  795     try:
|    |    |  796         inst
|    |    |  799     return inst
|    |    | < XendDomain.py:instance
|    |    |  98         self.deferred = defer.Deferred()
|    |    |  99         self.suspended = {}
|    |    | 100         self.paused = {}
|    |    |< XendMigrate.py:__init__
|    |     401         self.xid = xid
|    |     402         self.state = 'begin'
|    |     403         self.file = file
|    |    < XendMigrate.py:__init__
|    |    522         return self.session_begin(info)
|    |    > XendMigrate.py:session_begin
|    |     485         def cbremove(val):
|    |     489         self._add_session(info)
|    |    |> XendMigrate.py:_add_session
|    |    | 455         xid = info.xid
|    |    | 456         self.session[xid] = info
|    |    | 457         self.session_db[xid] = info.sxpr()
|    |    | > XendMigrate.py:sxpr
|    |    |  406          sxpr = ['restore',
|    |    |  409          return sxpr
|    |    | < XendMigrate.py:sxpr
|    |    | 458         self.sync_session(xid)
|    |    | > XendMigrate.py:sync_session
|    |    |  448         print 'sync_session>', type(xid), xid, self.session_db[xid]
|    |    |  449         self.db.save(xid, self.session_db[xid])
|    |    |  > XendDB.py:save
|    |    |    51         fpath = self.filepath(path)
|    |    |   > XendDB.py:filepath
|    |    |     24         return os.path.join(self.dbpath, path)
|    |    |   < XendDB.py:filepath
|    |    |    52         return self.savefile(fpath, sxpr)
|    |    |   > XendDB.py:savefile
|    |    |     55         fdir = os.path.dirname(fpath)
|    |    |     56         if not os.path.isdir(fdir):
|    |    |     58         fout = file(fpath, "wb+")
|    |    |     59         try:
|    |    |     60             t = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
|    |    |     61             fout.write("# %s %s\n" % (fpath, t))
|    |    |     62             sxp.show(sxpr, out=fout)
|    |    |     64             fout.close()
|    |    |   < XendDB.py:savefile
|    |    |  < XendDB.py:save
|    |    | < XendMigrate.py:sync_session
|    |    |< XendMigrate.py:_add_session
|    |     490         info.deferred.addCallback(cbremove)
|    |     491         info.deferred.addErrback(cbremove)
|    |     492         xcf = XfrdClientFactory(info)
|    |    |> XendMigrate.py:__init__
|    |    |  70         self.xinfo = xinfo
|    |    |< XendMigrate.py:__init__
|    |     493         reactor.connectTCP('localhost', XFRD_PORT, xcf)
|    |    |> XendMigrate.py:startedConnecting
|    |    |  73         print 'Started to connect', 'self=', self, 'connector=', connector
|    |    |< XendMigrate.py:startedConnecting
|    |     494         return info.deferred
|    |    < XendMigrate.py:session_begin
|    |   < XendMigrate.py:restore_begin
|    |   411         return deferred
|    |  < XendDomain.py:domain_restore
|    | < Args.py:call_with_form_args
|    |< Args.py:__call__
|     101         deferred.addCallback(self._op_restore_cb, req)
|     102         return deferred
|    < server/SrvDomainDir.py:op_restore
|    111         if isinstance(val, defer.Deferred):
|    112             val.addCallback(self._perform_cb, op, req, dfr=1)
|    113             val.addErrback(self._perform_err, op, req, dfr=1)
|    114             return server.NOT_DONE_YET
|   < server/SrvBase.py:_perform
|  < server/SrvBase.py:perform
| < server/SrvDomainDir.py:render_POST
| > XendMigrate.py:buildProtocol
|   76         print 'buildProtocol>', addr
|   77         return Xfrd(self.xinfo)
|  > XendMigrate.py:__init__
|    35         self.parser = sxp.Parser()
|    36         self.xinfo = xinfo
|  < XendMigrate.py:__init__
| < XendMigrate.py:buildProtocol
| > XendMigrate.py:connectionMade
|   40         self.request(['xfr.hello', XFR_PROTO_MAJOR, XFR_PROTO_MINOR])
|  > XendMigrate.py:request
|    45         sxp.show(req, out=self.transport)
|  < XendMigrate.py:request
|   42         self.xinfo.request(self)
|  > XendMigrate.py:request
|   412         print '***request>', self.file
|   413         log.info('restore BEGIN: ' + str(self.sxpr()))
|   > XendMigrate.py:sxpr
|    406          sxpr = ['restore',
|    409          return sxpr
|   < XendMigrate.py:sxpr
|   414         xfrd.request(['xfr.restore', self.file ])
|   > XendMigrate.py:request
|     45         sxp.show(req, out=self.transport)
|   < XendMigrate.py:request
|  < XendMigrate.py:request
| < XendMigrate.py:connectionMade
| > XendMigrate.py:dataReceived
|   56         self.parser.input(data)
|   57         if self.parser.ready():
|   58             val = self.parser.get_val()
|   59             self.xinfo.dispatch(self, val)
|  > XendMigrate.py:dispatch
|   119         def cbok(v):
|   123         def cberr(err):
|   128         op = sxp.name(val)
|   129         op = op.replace('.', '_')
|   130         if op.startswith('xfr_'):
|   131             fn = getattr(self, op, self.unknown)
|   134         val = fn(xfrd, val)
|   > XendMigrate.py:xfr_err
|    149         print 'xfr_err>', val
|    150         v = sxp.child0(val)
|    151         print 'xfr_err>', type(v), v
|    152         err = int(sxp.child0(val))
|    153         if not err: return
|   < XendMigrate.py:xfr_err
|   135         if isinstance(val, defer.Deferred):
|   139             cbok(val)
|   > XendMigrate.py:cbok
|    120             if v is None: return
|   < XendMigrate.py:cbok
|  < XendMigrate.py:dispatch
|   60         if self.parser.at_eof():
| < XendMigrate.py:dataReceived
| > XendMigrate.py:dataReceived
|   56         self.parser.input(data)
|   57         if self.parser.ready():
|   58             val = self.parser.get_val()
|   59             self.xinfo.dispatch(self, val)
|  > XendMigrate.py:dispatch
|   119         def cbok(v):
|   123         def cberr(err):
|   128         op = sxp.name(val)
|   129         op = op.replace('.', '_')
|   130         if op.startswith('xfr_'):
|   131             fn = getattr(self, op, self.unknown)
|   134         val = fn(xfrd, val)
|   > XendMigrate.py:xfr_err
|    149         print 'xfr_err>', val
|    150         v = sxp.child0(val)
|    151         print 'xfr_err>', type(v), v
|    152         err = int(sxp.child0(val))
|    153         if not err: return
|    154         self.error(err);
|    > XendMigrate.py:error
|     111         print 'Error>', err
|     112         self.state = 'error'
|     113         if not self.deferred.called:
|     114             print 'Error> calling errback'
|     115             self.deferred.errback(err)
|    |> XendMigrate.py:cbremove
|    | 486             print '***cbremove>', val
|    | 487             self._delete_session(info.xid)
|    | > XendMigrate.py:_delete_session
|    |  461         print '***_delete_session>', xid
|    |  462         if xid in self.session:
|    |  463             del self.session[xid]
|    |  464         if xid in self.session_db:
|    |  465             del self.session_db[xid]
|    |  466             self.db.delete(xid)
|    |  > XendDB.py:delete
|    |    82         dpath = self.filepath(path)
|    |   > XendDB.py:filepath
|    |     24         return os.path.join(self.dbpath, path)
|    |   < XendDB.py:filepath
|    |    83         os.unlink(dpath)
|    |  < XendDB.py:delete
|    | < XendMigrate.py:_delete_session
|    | 488             return val
|    |< XendMigrate.py:cbremove
|    |> server/SrvBase.py:_perform_err
|    | 153         if isinstance(err, Failure):
|    | 154             err = err.getErrorMessage()
|    | 162         log.exception("op=%s: %s", op, str(err))
|    | 163         if self.use_sxp(req):
|    | > server/SrvBase.py:use_sxp
|    |   62         ok = 0
|    |   63         user_agent = req.getHeader('User-Agent')
|    |   64         accept = req.getHeader('Accept')
|    |   65         if (not user_agent) or (not accept) or (accept.find(sxp.mime_type) >= 0):
|    |   66             ok = 1
|    |   67         return ok
|    | < server/SrvBase.py:use_sxp
|    | 164             req.setHeader("Content-Type", sxp.mime_type)
|    | 165             sxp.show(['xend.err', str(err)], out=req)
|    | 171         if dfr:
|    | 172             req.finish()
|    |< server/SrvBase.py:_perform_err
|    < XendMigrate.py:error
|    155         xfrd.loseConnection()
|    > XendMigrate.py:loseConnection
|      48         print 'Xfrd>loseConnection>'
|      49         self.transport.loseConnection()
|    < XendMigrate.py:loseConnection
|    156         return None
|   < XendMigrate.py:xfr_err
|   135         if isinstance(val, defer.Deferred):
|   139             cbok(val)
|   > XendMigrate.py:cbok
|    120             if v is None: return
|   < XendMigrate.py:cbok
|  < XendMigrate.py:dispatch
|   60         if self.parser.at_eof():
| < XendMigrate.py:dataReceived
| > XendMigrate.py:connectionLost
|   52         print 'Xfrd>connectionLost>', reason
|   53         self.xinfo.connectionLost(reason)
|  > XendMigrate.py:connectionLost
|   247         print 'XfrdInfo>connectionLost>', reason
|   248         for vmid in self.suspended:
|   253         for vmid in self.paused:
|  < XendMigrate.py:connectionLost
| < XendMigrate.py:connectionLost
| > XendMigrate.py:clientConnectionLost
|   80         print 'clientConnectionLost>', 'connector=', connector, 'reason=', reason
| < XendMigrate.py:clientConnectionLost
| > server/SrvDir.py:getChild
|   56         if x == '': return self
|   57         try:
|   58             val = self.get(x)
|  > server/SrvDir.py:get
|    67         val = self.table.get(x)
|    68         if val is not None:
|    69             val = val.getobj()
|   > server/SrvDir.py:getobj
|     36         if not self.obj:
|     40         return self.obj
|   < server/SrvDir.py:getobj
|    70         return val
|  < server/SrvDir.py:get
|   61         if val is None:
|   64             return val
| < server/SrvDir.py:getChild
| > server/SrvDir.py:getChild
|   56         if x == '': return self
| < server/SrvDir.py:getChild