                     dbg("getting other project and ensuring that it is already opened")
                     @compute_server.project
                         project_id : opts.target_project_id
-                        open       : true
+                        opened     : true
                         cb         : (err, target_project) =>
                             if err
                                 dbg("error ")

    project: (opts) =>
        opts = defaults opts,
            project_id : required
            open       : false    # if true, only returns after ensuring project is opened on some host (which may take minutes)
            cb         : required
        if not @_project_cache?
            @_project_cache = {}
        p = @_project_cache[opts.project_id]
        async.series([
            (cb) =>
                if p?
                    cb()
                else

                                            p.once 'opened', () =>
                                                # TODO: some danger that this will never happen, e.g., in case
                                                # of socket disconnect while waiting.
                                                state = 'opened'
                                                cb()
                            if state == 'closed'
                                f()
                            else
                                p.once 'closed', () =>
                                    f()
            (cb) =>
                if not opts.running
                    cb()
                else
                    p.state
                        cb : (err, s) =>
                            if err
                                cb(err)
                                return
                            state = s.state
                            if state == 'starting'
                                p.once 'running', () =>
                                    cb()
                                return
                            if state != 'opened' and state != 'stopping'
                                cb(err)
                                return
                            # This is tricky: in close state, we request open and wait
                            # for project to open; in closing state, we wait until closed
                            # then request open and wait until open.
                            f = () =>
                                p.start
                                    cb : (err) =>
                                        if err
                                            cb(err)
                                        else
                                            p.once 'running', () =>
                                                # TODO: some danger that this will never happen, e.g., in case
                                                # of socket disconnect while waiting.
                                                cb()
                            if state == 'opened'
                                f()
                            else
                                p.once 'opened', () =>
                                    f()
        ], (err) =>
            if err
