def f():
self.io_loop.add_callback((yield gen.Callback("k1")))
yield gen.Wait("k1")
1 / 0
def install_project(self, project_name):
logger.debug('Install project %s', project_name)
self.installed_projects.discard(project_name)
if project_name in self.projects and not self.installing:
self.installing = project_name
self.install_output = []
project = self.projects[project_name]
project_path = os.path.join(self.projects_dir, project_name)
self.on_project_installing(self, project)
if project_name in self.failed_projects:
if os.path.exists(project_path):
shutil.rmtree(project_path)
self.failed_projects.discard(project_name)
if os.path.exists(project_path):
subprocess.Popen(args=[
"git", "config", "remote.origin.url", project["repository"]
],
cwd=project_path).communicate()
logger.debug('git pull from %s', project["repository"])
p = AsyncPopen2(args=["git", "pull"],
cwd=project_path,
env=self.gitenv)
else:
logger.debug('git clone')
p = AsyncPopen2(
args=["git", "clone", project["repository"], project_path],
env=self.gitenv)
p.on_output += self.collect_install_output
p.on_end += yield gen.Callback("gitend")
p.run()
result = yield gen.Wait("gitend")
if result != 0:
self.install_output.append("\ngit returned %d\n" % result)
logger.error("Project failed to install: %s",
"".join(self.install_output))
self.on_project_installation_failed(
self, project, "".join(self.install_output))
self.installing = None
self.failed_projects.add(project_name)
raise gen.Return(False)
else:
logger.debug("git operation: %s", "".join(self.install_output))
project_install_file = os.path.join(project_path,
"warrior-install.sh")
if os.path.exists(project_install_file):
p = AsyncPopen2(args=[project_install_file], cwd=project_path)
p.on_output += self.collect_install_output
p.on_end += yield gen.Callback("installend")
p.run()
result = yield gen.Wait("installend")
if result != 0:
self.install_output.append(
"\nCustom installer returned %d\n" % result)
logger.error("Custom installer failed to install: %s",
"".join(self.install_output))
self.on_project_installation_failed(
self, project, "".join(self.install_output))
self.installing = None
self.failed_projects.add(project_name)
raise gen.Return(False)
data_dir = os.path.join(self.data_dir, "data")
if os.path.exists(data_dir):
shutil.rmtree(data_dir)
os.makedirs(data_dir)
project_data_dir = os.path.join(project_path, "data")
if os.path.islink(project_data_dir):
os.remove(project_data_dir)
elif os.path.isdir(project_data_dir):
shutil.rmtree(project_data_dir)
os.symlink(data_dir, project_data_dir)
self.installed_projects.add(project_name)
logger.debug('Install complete %s', "".join(self.install_output))
self.on_project_installed(self, project,
"".join(self.install_output))
self.installing = None
raise gen.Return(True)
def put(self, key):
'''
Resend deletion of micropost with *key* as key to the contact given in
the posted JSON. Corresponding activity ID is given inside the posted
json.
Here is the format : {"contactId":"data","activityId":"data"}
'''
data = self.get_body_as_dict(
expectedFields=["contactId", "activityId", "extra"])
if data:
contactId = data["contactId"]
activityId = data["activityId"]
date = data["extra"]
contact = ContactManager.getTrustedContact(contactId)
activity = ActivityManager.get_activity(activityId)
if not contact:
self.return_failure("Contact not found", 404)
elif not activity:
self.return_failure("Activity not found", 404)
else:
user = UserManager.getUser()
micropost = MicroPost(
authorKey=user.key,
date=date_util.get_date_from_db_date(date))
logger.info(
"Attempt to resend a post deletion to contact: {}.".format(
contact.name))
httpClient = ContactClient()
body = micropost.toJson(localized=False)
try:
httpClient.put(contact,
CONTACT_PATH,
body,
callback=(yield gen.Callback("retry")))
response = yield gen.Wait("retry")
if response.error:
self.return_failure(
"Deleting micropost to contact failed.")
else:
for error in activity.errors:
if error["contactKey"] == contact.key:
activity.errors.remove(error)
activity.save()
self.return_success(
"Micropost correctly redeleted.")
except:
self.return_failure(
"Deleting micropost to contact failed.")
else:
self.return_failure("Micropost not found", 404)
def f():
(yield gen.Callback("k1"))("v1")
(yield gen.Callback("k2"))("v2")
results = yield dict(foo=gen.Wait("k1"), bar=gen.Wait("k2"))
self.assertEqual(results, dict(foo="v1", bar="v2"))
self.stop()
def f():
(yield gen.Callback("k1"))()
res = yield gen.Wait("k1")
self.assertTrue(res is None)
self.stop()
def f():
self.io_loop.add_callback((yield gen.Callback(0)))
yield gen.Wait(0)
self.stop()
def f():
(yield gen.Callback("k1"))("v1")
(yield gen.Callback("k2"))("v2")
results = yield [gen.Wait("k1"), gen.Wait("k2")]
self.assertEqual(results, ["v1", "v2"])
self.stop()
def f():
yield gen.Callback("k1")
yield gen.Wait("k2")
self.stop()
def f():
yield gen.Callback((1, 2))
yield gen.Wait((2, 3))
self.stop()
def f():
(yield gen.Callback("k1"))(42)
res = yield gen.Wait("k1")
self.assertEqual(42, res)
self.stop()
def f():
(yield gen.Callback((1, 2)))((3, 4))
res = yield gen.Wait((1, 2))
self.assertEqual((3, 4), res)
self.stop()
def test_yield_outside_with_exception_stack_context(self):
cb = yield gen.Callback('k1')
with ExceptionStackContext(lambda t, v, tb: False):
self.io_loop.add_callback(cb)
yield gen.Wait('k1')
def test_yield_outside_with(self):
# This pattern avoids the problem in the previous test.
cb = yield gen.Callback('k1')
with StackContext(functools.partial(self.context, 'c1')):
self.io_loop.add_callback(cb)
yield gen.Wait('k1')
def f():
(yield gen.Callback("k1"))()
res = yield gen.Wait("k1")
assert res is None
self.stop()
def get_authenticated_user(self,
redirect_uri,
callback,
scope=None,
**args):
"""
class RenrenHandler(tornado.web.RequestHandler, RenrenGraphMixin):
@tornado.web.asynchronous
@gen.engine
def get(self):
self.get_authenticated_user(
callback=(yield gen.Callback('key')),
redirect_uri=url)
user = yield gen.Wait('key')
if not user:
raise web.HTTPError(500, "Renren auth failed")
# do something else
self.finish()
"""
code = self.get_argument('code', None)
if not code:
self.authorize_redirect(redirect_uri, scope=scope, **args)
return
self.get_access_token(
code,
callback=(
yield
gen.Callback('_RenrenGraphMixin.get_authenticated_user')),
redirect_uri=redirect_uri)
response = yield gen.Wait('_RenrenGraphMixin.get_authenticated_user')
if not response:
callback(None)
return
try:
user = json_decode(response.body)
except:
logging.warning("Error response %s fetching %s", response.body,
response.request.url)
callback(None)
return
if 'error' in user:
logging.warning("Error response %s fetching %s",
user['error_description'], response.request.url)
callback(None)
return
#{{{ get session key
self.renren_request(
'renren_api/session_key',
user['access_token'],
callback=(yield gen.Callback('_RenrenGraphMixin._session_key')))
response = yield gen.Wait('_RenrenGraphMixin._session_key')
if response.error and not response.body:
logging.warning("Error response %s fetching %s", response.error,
response.request.url)
elif response.error:
logging.warning("Error response %s fetching %s: %s",
response.error, response.request.url,
response.body)
else:
try:
user['session'] = json_decode(response.body)
except:
pass
#}}} #TODO delete when renren graph api released
callback(user)
return
def install_project(self, project_name):
logger.debug('Install project %s', project_name)
self.installed_projects.discard(project_name)
if project_name in self.projects and not self.installing:
self.installing = project_name
self.install_output = []
project = self.projects[project_name]
project_path = os.path.join(self.projects_dir, project_name)
self.on_project_installing(self, project)
if project_name in self.failed_projects:
if os.path.exists(project_path):
shutil.rmtree(project_path)
self.failed_projects.discard(project_name)
if os.path.exists(project_path):
subprocess.Popen(
args=["git", "config", "remote.origin.url",
project["repository"]],
cwd=project_path
).communicate()
logger.debug('git pull from %s', project["repository"])
p = AsyncPopen2(
args=["git", "pull"],
cwd=project_path,
env=self.gitenv
)
else:
logger.debug('git clone')
p = AsyncPopen2(
args=["git", "clone", project["repository"], project_path],
env=self.gitenv
)
p.on_output += self.collect_install_output
p.on_end += yield gen.Callback("gitend")
try:
p.run()
except OSError as error:
logger.exception("Install command error")
result = 9999
self.install_output.append(str(error))
else:
result = yield gen.Wait("gitend")
if result != 0:
self.install_output.append("\ngit returned %d\n" % result)
logger.error(
"Project failed to install: %s",
"".join(self.install_output)
)
self.on_project_installation_failed(
self, project, "".join(self.install_output))
self.installing = None
self.failed_projects.add(project_name)
raise gen.Return(False)
else:
logger.debug(
"git operation: %s", "".join(self.install_output)
)
project_install_file = os.path.join(project_path,
"warrior-install.sh")
if os.path.exists(project_install_file):
if not is_executable(project_install_file):
logger.warning('File %s is not executable. '
'Automatically changing it to be executable!',
project_install_file)
set_file_executable(project_install_file)
p = AsyncPopen2(
args=[project_install_file],
cwd=project_path
)
p.on_output += self.collect_install_output
p.on_end += yield gen.Callback("installend")
try:
p.run()
except OSError as error:
logger.exception("Custom project install file error")
result = 9999
self.install_output.append(str(error))
else:
result = yield gen.Wait("installend")
if result != 0:
self.install_output.append(
"\nCustom installer returned %d\n" % result)
logger.error(
"Custom installer failed to install: %s",
"".join(self.install_output)
)
self.on_project_installation_failed(
self, project, "".join(self.install_output))
self.installing = None
self.failed_projects.add(project_name)
raise gen.Return(False)
else:
logger.debug('Project install file result: %s', result)
data_dir = os.path.join(self.data_dir, "data")
if os.path.exists(data_dir):
shutil.rmtree(data_dir)
os.makedirs(data_dir)
project_data_dir = os.path.join(project_path, "data")
if os.path.islink(project_data_dir):
os.remove(project_data_dir)
elif os.path.isdir(project_data_dir):
shutil.rmtree(project_data_dir)
os.symlink(data_dir, project_data_dir)
self.installed_projects.add(project_name)
logger.debug('Install complete %s', "".join(self.install_output))
self.on_project_installed(self, project,
"".join(self.install_output))
self.installing = None
raise gen.Return(True)
else:
logger.warning('Not installing project %s because it is not a '
'known project or an install is already in progress',
project_name)
