def start(self):
self.done = event.Event()
def _inner():
""" query the file_name size and get the progress"""
self._running = True
while self._running:
try:
transferred_size = self.threadSafePipe.transferred
LOG.debug("liuling transferred_size %d " , transferred_size )
LOG.debug("liuling total_size %d" ,self.total_size )
if transferred_size >= self.total_size:
self.stop()
self.done.send(True)
continue
progress="%.0f%%" % (transferred_size/self.total_size * 100)
task_state = self.task_state +'(' + progress + ')'
vm_uuid=self.volume['instance_uuid']
if vm_uuid:
instance = self.nova_client.servers.get(vm_uuid)
self.nova_client.servers.set_meta(instance,{'task_state':task_state})
greenthread.sleep(PROGRESS_REPORT_THREAD_SLEEP_TIME)
except Exception as exc:
self.stop()
LOG.exception(exc)
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def start(self, initial_delay=None, periodic_interval_max=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
idle = self.f(*self.args, **self.kw)
if not self._running:
break
if periodic_interval_max is not None:
idle = min(idle, periodic_interval_max)
LOG.debug(_('Dynamic looping call sleeping for %.02f '
'seconds'), idle)
greenthread.sleep(idle)
except LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
LOG.exception(_('in dynamic looping call'))
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self, interval, initial_delay=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
self.f(*self.args, **self.kw)
if not self._running:
break
greenthread.sleep(interval)
except LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
LOG.exception(_('in looping call'))
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self, initial_delay=None, periodic_interval_max=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
idle = self.f(*self.args, **self.kw) # callback
if not self._running:
break
if periodic_interval_max is not None:
idle = min(idle, periodic_interval_max)
logger.debug("Dynamic looping call sleeping for %d seconds", idle)
greenthread.sleep(idle)
except LoopingCallDone as e:
logger.info('DynamicLoopingCall _inner: Exception1')
self.stop()
done.send(e.retvalue)
except Exception as ex:
logger.info('DynamicLoopingCall _inner: Exception2')
logger.debug(ex)
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self._done_ = done
greenthread.spawn(_inner)
logger.debug('DynamicLoopingCall: Exiting...')
return self._done_
def start(self):
self.done = event.Event()
def _inner():
""" query the file_name size and get the progress"""
self._running = True
while self._running:
try:
transferred_size = self.threadSafePipe.transferred
if transferred_size >= self.total_size:
self.stop()
self.done.send(True)
continue
progress="%.0f%%" % (transferred_size/self.total_size * 100)
self.instance.task_state = self.task_state +'(' + progress + ')'
self.instance.save()
greenthread.sleep(PROGRESS_REPORT_THREAD_SLEEP_TIME)
except Exception as exc:
self.stop()
LOG.exception(exc)
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def start(self, initial_delay=None, periodic_interval_max=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
idle = self.f(*self.args, **self.kw)
if not self._running:
break
if periodic_interval_max is not None:
idle = min(idle, periodic_interval_max)
pass
greenthread.sleep(idle)
except LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
pass
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self, initial_delay=None, periodic_interval_max=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
idle = self.f(*self.args, **self.kw)
if not self._running:
break
if periodic_interval_max is not None:
idle = min(idle, periodic_interval_max)
LOG.debug(
"Dynamic looping call %(func_name)s sleeping " "for %(idle).02f seconds",
{"func_name": repr(self.f), "idle": idle},
)
greenthread.sleep(idle)
except LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
LOG.exception(_LE("in dynamic looping call"))
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self, interval, initial_delay=None):
self._running = True
done = event.Event()
def _inner():
if initial_delay:
greenthread.sleep(initial_delay)
cycle_counter = 0
try:
while self._running:
self.f(*self.args, **self.kw)
if not self._running:
break
if self.cycle_index > 0:
cycle_counter += 1
if cycle_counter >= self.cycle_index:
raise exceptions.AttemptsFailure()
greenthread.sleep(interval)
except LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
LOG.exception('in looping call')
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def test_spawn_is_not_cancelled(self):
def func():
greenthread.spawn(self.lst.pop)
# exiting immediatelly, but self.lst.pop must be called
greenthread.spawn(func)
greenthread.sleep(0.1)
assert self.lst == [], self.lst
def start(self):
self.done = event.Event()
def _inner():
"""Read data from input and write the same to output."""
self._running = True
while self._running:
try:
data = self.input_file.read(None)
if not data:
self.stop()
self.done.send(True)
self.output_file.write(data)
if hasattr(self.input_file, "update_progress"):
self.input_file.update_progress()
if hasattr(self.output_file, "update_progress"):
self.output_file.update_progress()
greenthread.sleep(IO_THREAD_SLEEP_TIME)
except Exception as exc:
self.stop()
LOG.exception(exc)
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def test_timer_cancelled_upon_greenlet_exit(self):
def func():
greenthread.spawn_after_local(0.1, self.lst.pop)
greenthread.spawn(func)
assert self.lst == [1], self.lst
greenthread.sleep(0.2)
assert self.lst == [1], self.lst
def test_timer_fired(self):
def func():
greenthread.spawn_after_local(0.1, self.lst.pop)
greenthread.sleep(0.2)
greenthread.spawn(func)
assert self.lst == [1], self.lst
greenthread.sleep(0.3)
assert self.lst == [], self.lst
def start(self):
self.done = event.Event()
def _inner():
"""Initiate write thread.
Function to do the image data transfer through an update
and thereon checks if the state is 'active'.
"""
LOG.debug("Initiating image service update on image: %(image)s "
"with meta: %(meta)s" % {'image': self.image_id,
'meta': self.image_meta})
try:
self.image_service.update(self.context,
self.image_id,
self.image_meta,
data=self.input_file)
self._running = True
while self._running:
image_meta = self.image_service.show(self.context,
self.image_id)
image_status = image_meta.get('status')
if image_status == 'active':
self.stop()
LOG.debug("Glance image: %s is now active." %
self.image_id)
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == 'killed':
self.stop()
msg = (_("Glance image: %s is in killed state.") %
self.image_id)
LOG.error(msg)
excep = error_util.ImageTransferException(msg)
self.done.send_exception(excep)
elif image_status in ['saving', 'queued']:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image %(id)s is in unknown state "
"- %(state)s") % {'id': self.image_id,
'state': image_status}
LOG.error(msg)
excep = error_util.ImageTransferException(msg)
self.done.send_exception(excep)
except Exception as ex:
self.stop()
msg = (_("Error occurred while writing to image: %s") %
self.image_id)
LOG.exception(msg)
excep = error_util.ImageTransferException(ex)
self.done.send_exception(excep)
greenthread.spawn(_inner)
return self.done
def start(self, initial_delay=None, starting_interval=1, timeout=300,
max_interval=300, jitter=0.75):
self._running = True
done = event.Event()
def _inner():
interval = starting_interval
error_time = 0
if initial_delay:
greenthread.sleep(initial_delay)
try:
while self._running:
no_error = self.f(*self.args, **self.kw)
if not self._running:
break
random_jitter = random.gauss(jitter, 0.1)
if no_error:
# Reset error state
error_time = 0
interval = starting_interval
idle = interval * random_jitter
else:
# Backoff
interval = min(interval * 2 * random_jitter,
max_interval)
idle = interval
# Don't go over timeout, end early if necessary. If
# timeout is 0, keep going.
if timeout > 0 and error_time + idle > timeout:
raise LoopingCallTimeOut(
'Looping call timed out after %.02f seconds'
% error_time)
error_time += idle
LOG.debug('Dynamic looping call sleeping for %.02f '
'seconds', idle)
greenthread.sleep(idle)
except loopingcall.LoopingCallDone as e:
self.stop()
done.send(e.retvalue)
except Exception:
LOG.exception('in dynamic looping call')
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self, interval, initial_delay=None):
self._running = True
done = event.Event()
def _inner():
try:
while self._running:
print "In loop"
greenthread.sleep(interval)
print "loop done"
except Exception as e:
print('in looping call')
return
self.done = done
greenthread.spawn(_inner)
return self.done
def start(self):
def _inner():
"""Read data from the input and write the same to the output
until the transfer completes.
"""
try:
self.callback(*self.args, **self.kwargs)
self._status = TASK_SUCCESS
except Exception as e:
LOG.exception(e)
self._status = TASK_ERROR
greenthread.spawn(_inner)
return self
def start(self):
self.done = event.Event()
def _inner():
"""Function to do the image data transfer through an update
and thereon checks if the state is 'active'.
"""
try:
self.image_service.update(self.context,
self.image_id,
self.image_meta,
data=self.input)
self._running = True
except exception.ImageNotAuthorized as exc:
self.done.send_exception(exc)
while self._running:
try:
image_meta = self.image_service.show(self.context,
self.image_id)
image_status = image_meta.get("status")
if image_status == "active":
self.stop()
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == "killed":
self.stop()
msg = (_("Glance image %s is in killed state") %
self.image_id)
LOG.error(msg)
self.done.send_exception(exception.CinderException(msg))
elif image_status in ["saving", "queued"]:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image "
"%(image_id)s is in unknown state "
"- %(state)s") % {
"image_id": self.image_id,
"state": image_status}
LOG.error(msg)
self.done.send_exception(exception.CinderException(msg))
except Exception as exc:
self.stop()
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def test_memory_leak():
# The RequestScope holds references to GreenThread objects which would
# cause memory leak
app = Flask(__name__)
FlaskInjector(app)
@app.route('/')
def index():
return 'test'
def get_request():
with app.test_client() as c:
c.get('/')
green_thread = greenthread.spawn(get_request)
green_thread.wait()
# Delete green_thread so the GreenThread object is dereferenced
del green_thread
# Force run garbage collect to make sure GreenThread object is collected if
# there is no memory leak
gc.collect()
greenthread_count = len([
obj for obj in gc.get_objects()
if type(obj) is greenthread.GreenThread])
eq_(greenthread_count, 0)
def start(self, interval=None):
def _inner():
self.run()
def _loopingcall_callback():
self._monitor_busy = True
try:
self._check_pending_tasks()
except Exception:
LOG.exception(_("Exception in _check_pending_tasks"))
self._monitor_busy = False
if self._thread is not None:
return self
if interval is None or interval == 0:
interval = self._interval
self._stopped = False
self._thread = greenthread.spawn(_inner)
self._monitor = loopingcall.FixedIntervalLoopingCall(
_loopingcall_callback)
self._monitor.start(interval / 1000.0,
interval / 1000.0)
# To allow the created thread start running
greenthread.sleep(0)
return self
def dispatch_lb(self, d_context, *args, **kwargs):
item = d_context.item
event = d_context.event
n_context = d_context.n_context
chain = d_context.chain
item_id = item["id"]
if event in self.handlers:
for f in self.handlers[event]:
first_run = False
if item_id not in self.sync_items:
self.sync_items[item_id] = [queue.Queue()]
first_run = True
self.sync_items[item_id][0].put(
ctx.OperationContext(event, n_context, item, chain, f,
args, kwargs))
if first_run:
t = greenthread.spawn(self._consume_lb,
item_id,
self.sync_items[item_id][0],
self._driver,
self._async)
self.sync_items[item_id].append(t)
if not self._async:
t = self.sync_items[item_id][1]
t.wait()
def dispatch_l3(self, d_context, args=(), kwargs={}):
item = d_context.item
event = d_context.event
n_context = d_context.n_context
chain = d_context.chain
item_id = item["id"]
handlers = router_operations.handlers
if event in handlers:
for f in handlers[event]:
first_run = False
if item_id not in self.sync_items:
self.sync_items[item_id] = (queue.Queue(),)
first_run = True
self.sync_items[item_id][0].put(
ctx.OperationContext(event, n_context, item, chain, f,
args, kwargs))
t = None
if first_run:
t = greenthread.spawn(self._consume_l3,
item_id,
self.sync_items[item_id][0],
self._plugin,
self._async)
self.sync_items[item_id] += (t,)
if not self._async:
t = self.sync_items[item_id][1]
t.wait()
def spawn(self, function, *args, **kwargs):
"""Run the *function* with its arguments in its own green thread.
Returns the :class:`GreenThread <eventlet.greenthread.GreenThread>`
object that is running the function, which can be used to retrieve the
results.
If the pool is currently at capacity, ``spawn`` will block until one of
the running greenthreads completes its task and frees up a slot.
This function is reentrant; *function* can call ``spawn`` on the same
pool without risk of deadlocking the whole thing.
"""
# if reentering an empty pool, don't try to wait on a coroutine freeing
# itself -- instead, just execute in the current coroutine
current = greenthread.getcurrent()
if self.sem.locked() and current in self.coroutines_running:
# a bit hacky to use the GT without switching to it
gt = greenthread.GreenThread(current)
gt.main(function, args, kwargs)
return gt
else:
self.sem.acquire()
gt = greenthread.spawn(function, *args, **kwargs)
if not self.coroutines_running:
self.no_coros_running = event.Event()
self.coroutines_running.add(gt)
gt.link(self._spawn_done)
return gt
def start(self, interval=None):
def _inner():
self.run()
def _loopingcall_callback():
try:
self._monitor_busy = True
self._check_pending_tasks()
self._monitor_busy = False
if self._monitor_stop:
self._monitor_stop.send()
except Exception:
LOG.exception(_("Exception in _check_pending_tasks"))
if self._thread:
return self
if interval is None or interval == 0:
interval = self._interval
self._thread = greenthread.spawn(_inner)
self._monitor = loopingcall.FixedIntervalLoopingCall(_loopingcall_callback)
self._monitor.start(interval / 1000.0, interval / 1000.0)
return self
def start(self):
self.done = event.Event()
def _inner():
"""Initiate write thread.
Function to do the image data transfer through an update
and thereon checks if the state is 'active'.
"""
LOG.debug(
"Initiating image service update on image: %(image)s "
"with meta: %(meta)s" % {"image": self.image_id, "meta": self.image_meta}
)
self.image_service.update(self.context, self.image_id, self.image_meta, data=self.input_file)
self._running = True
while self._running:
try:
image_meta = self.image_service.show(self.context, self.image_id)
image_status = image_meta.get("status")
if image_status == "active":
self.stop()
LOG.debug("Glance image: %s is now active." % self.image_id)
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == "killed":
self.stop()
msg = _("Glance image: %s is in killed state.") % self.image_id
LOG.error(msg)
excep = exception.CinderException(msg)
self.done.send_exception(excep)
elif image_status in ["saving", "queued"]:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image %(id)s is in unknown state " "- %(state)s") % {
"id": self.image_id,
"state": image_status,
}
LOG.error(msg)
excep = exception.CinderException(msg)
self.done.send_exception(excep)
except Exception as exc:
self.stop()
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def test_kill_meth(self):
gt = greenthread.spawn(passthru, 6)
gt.kill()
self.assert_dead(gt)
greenthread.sleep(0.001)
self.assertEquals(_g_results, [])
gt.kill()
self.assert_dead(gt)
def _start(self, idle_for, initial_delay=None):
if self._thread is not None:
raise RuntimeError(self._RUN_ONLY_ONE_MESSAGE)
self._running = True
self.done = event.Event()
self._thread = greenthread.spawn(self._run_loop, self._KIND, self.done, idle_for, initial_delay=initial_delay)
self._thread.link(self._on_done)
return self.done
def test_event_race(self):
event = eventletutils.EventletEvent()
def thread_a():
self.assertTrue(event.wait(2))
a = greenthread.spawn(thread_a)
def thread_b():
eventlet.sleep(0.1)
event.clear()
event.set()
a.wait()
b = greenthread.spawn(thread_b)
with eventlet.timeout.Timeout(0.5):
b.wait()
def start(self):
self.done = event.Event()
def _inner():
"""Initiate write thread.
Function to do the image data transfer through an update
and thereon checks if the state is 'active'.
"""
self.image_service.update(self.context,
self.image_id,
self.image_meta,
data=self.input)
self._running = True
while self._running:
try:
image_meta = self.image_service.show(self.context,
self.image_id)
image_status = image_meta.get('status')
if image_status == 'active':
self.stop()
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == 'killed':
self.stop()
msg = (_("Glance image: %s is in killed state.") %
self.image_id)
LOG.error(msg)
excep = exception.CinderException(msg)
self.done.send_exception(excep)
elif image_status in ['saving', 'queued']:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image %(id)s is in unknown state "
"- %(state)s") % {'id': self.image_id,
'state': image_status}
LOG.error(msg)
excep = exception.CinderException(msg)
self.done.send_exception(excep)
except Exception as exc:
self.stop()
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def start(self, interval):
self._running = True
def _inner():
try:
while self._running:
self.func(*self.args, **self.kwargs)
"""It is important to check `self._running`'s value, if it is False, break."""
if not self._running:
break
greenthread.sleep(interval)
except Exception:
LOG.error("Periodic task %s running failed..." %
self.func.__name__)
self.done.send_exception(*sys.exec_info())
greenthread.spawn(_inner)
def start(self):
def _inner():
"""Read data from the input and write the same to the output
until the transfer completes.
"""
try:
LOG.debug("starting doing task")
self.callback(*self.args, **self.kwargs)
self._code = self.TASK_SUCCESS
LOG.debug("ending doing task")
except Exception as e:
LOG.exception(e)
self._code = self.TASK_ERROR
self._msg = str(e.message)
greenthread.spawn(_inner)
return self
def _do_spawn(self, gtransport, protocol):
greenthread.spawn(self._run_handler, gtransport, protocol)
def _wrapped_spawn_n(*args, **kwargs):
rv = greenthread.spawn(*args, **kwargs)
self._services.append(rv)
def start(self):
"""Start the image write task.
:returns: the event indicating the status of the write task
"""
self._done = event.Event()
def _inner():
"""Task performing the image write operation.
This method performs image data transfer through an update call.
After the update, it waits until the image state becomes
'active', 'killed' or unknown. If the final state is not 'active'
an instance of ImageTransferException is thrown.
:raises: ImageTransferException
"""
LOG.debug(_("Calling image service update on image: %(image)s "
"with meta: %(meta)s"),
{'image': self._image_id,
'meta': self._image_meta})
try:
self._image_service.update(self._context,
self._image_id,
self._image_meta,
data=self._input_file)
self._running = True
while self._running:
LOG.debug(_("Retrieving status of image: %s."),
self._image_id)
image_meta = self._image_service.show(self._context,
self._image_id)
image_status = image_meta.get('status')
if image_status == 'active':
self.stop()
LOG.debug(_("Image: %s is now active."),
self._image_id)
self._done.send(True)
elif image_status == 'killed':
self.stop()
excep_msg = (_("Image: %s is in killed state.") %
self._image_id)
LOG.error(excep_msg)
excep = exceptions.ImageTransferException(excep_msg)
self._done.send_exception(excep)
elif image_status in ['saving', 'queued']:
LOG.debug(_("Image: %(image)s is in %(state)s state; "
"sleeping for %(sleep)d seconds."),
{'image': self._image_id,
'state': image_status,
'sleep': IMAGE_SERVICE_POLL_INTERVAL})
greenthread.sleep(IMAGE_SERVICE_POLL_INTERVAL)
else:
self.stop()
excep_msg = _("Image: %(image)s is in unknown state: "
"%(state)s.") % {'image': self._image_id,
'state': image_status}
LOG.error(excep_msg)
excep = exceptions.ImageTransferException(excep_msg)
self._done.send_exception(excep)
except Exception as excep:
self.stop()
excep_msg = (_("Error occurred while writing image: %s") %
self._image_id)
LOG.exception(excep_msg)
excep = exceptions.ImageTransferException(excep_msg, excep)
self._done.send_exception(excep)
LOG.debug(_("Starting image write task for image: %(image)s with"
" source: %(source)s."),
{'source': self._input_file,
'image': self._image_id})
greenthread.spawn(_inner)
return self._done
def start(self, *args):
self.event = threading.Event()
self.is_running = True
self.thread = greenthread.spawn(self.run)
def start(self):
self.done = event.Event()
def _inner():
"""Initiate write thread.
Function to do the image data transfer through an update
and thereon checks if the state is 'active'.
"""
LOG.debug("Initiating image service update on image: %(image)s "
"with meta: %(meta)s" % {
'image': self.image_id,
'meta': self.image_meta
})
try:
self.image_service.update(self.context,
self.image_id,
self.image_meta,
data=self.input_file)
self._running = True
while self._running:
image_meta = self.image_service.show(
self.context, self.image_id)
image_status = image_meta.get('status')
if image_status == 'active':
self.stop()
LOG.debug("Glance image: %s is now active." %
self.image_id)
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == 'killed':
self.stop()
msg = (_("Glance image: %s is in killed state.") %
self.image_id)
LOG.error(msg)
excep = error_util.ImageTransferException(msg)
self.done.send_exception(excep)
elif image_status in ['saving', 'queued']:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image %(id)s is in unknown state "
"- %(state)s") % {
'id': self.image_id,
'state': image_status
}
LOG.error(msg)
excep = error_util.ImageTransferException(msg)
self.done.send_exception(excep)
except Exception as ex:
self.stop()
msg = (_("Error occurred while writing to image: %s") %
self.image_id)
LOG.exception(msg)
excep = error_util.ImageTransferException(ex)
self.done.send_exception(excep)
greenthread.spawn(_inner)
return self.done
def start_timer():
return spawn(feed_timer)
def feed_timer():
while True:
global current_feed
current_feed = spawn(get_feed).wait()
sleep(30)
def start_audit(self):
LOG.info('Auditing interval %s' % CONF.certmon.audit_interval)
utils.init_keystone_auth_opts()
self.audit_thread = greenthread.spawn(self.audit_cert)
self.on_start_audit()
def container_update(self, op, account, container, obj, request,
headers_out, objdevice, policy):
"""
Update the container when objects are updated.
:param op: operation performed (ex: 'PUT', or 'DELETE')
:param account: account name for the object
:param container: container name for the object
:param obj: object name
:param request: the original request object driving the update
:param headers_out: dictionary of headers to send in the container
request(s)
:param objdevice: device name that the object is in
:param policy: the BaseStoragePolicy instance
"""
headers_in = request.headers
conthosts = [
h.strip()
for h in headers_in.get('X-Container-Host', '').split(',')
]
contdevices = [
d.strip()
for d in headers_in.get('X-Container-Device', '').split(',')
]
contpartition = headers_in.get('X-Container-Partition', '')
if len(conthosts) != len(contdevices):
# This shouldn't happen unless there's a bug in the proxy,
# but if there is, we want to know about it.
self.logger.error(
_('ERROR Container update failed: different '
'numbers of hosts and devices in request: '
'"%s" vs "%s"') % (headers_in.get('X-Container-Host', ''),
headers_in.get('X-Container-Device', '')))
return
if contpartition:
updates = zip(conthosts, contdevices)
else:
updates = []
headers_out['x-trans-id'] = headers_in.get('x-trans-id', '-')
headers_out['referer'] = request.as_referer()
headers_out['X-Backend-Storage-Policy-Index'] = int(policy)
update_greenthreads = []
for conthost, contdevice in updates:
gt = spawn(self.async_update,
op,
account,
container,
obj,
conthost,
contpartition,
contdevice,
headers_out,
objdevice,
policy,
logger_thread_locals=self.logger.thread_locals)
update_greenthreads.append(gt)
# Wait a little bit to see if the container updates are successful.
# If we immediately return after firing off the greenthread above, then
# we're more likely to confuse the end-user who does a listing right
# after getting a successful response to the object create. The
# `container_update_timeout` bounds the length of time we wait so that
# one slow container server doesn't make the entire request lag.
try:
with Timeout(self.container_update_timeout):
for gt in update_greenthreads:
gt.wait()
except Timeout:
# updates didn't go through, log it and return
self.logger.debug(
'Container update timeout (%.4fs) waiting for %s',
self.container_update_timeout, updates)
while self._running:
self.f(*self.args, **self.kw)
greenthread.sleep(interval)
except LoopingCallDone, e:
self.stop()
done.send(e.retvalue)
except Exception:
logging.exception('in looping call')
done.send_exception(*sys.exc_info())
return
else:
done.send(True)
self.done = done
greenthread.spawn(_inner)
return self.done
def stop(self):
self._running = False
def wait(self):
return self.done.wait()
def xhtml_escape(value):
"""Escapes a string so it is valid within XML or XHTML.
Code is directly from the utf8 function in
http://github.com/facebook/tornado/blob/master/tornado/escape.py
class GlanceWriteThread(object):
"""Ensures that image data is written to in the glance client and that
it is in correct ('active')state."""
def __init__(self,
context,
input,
image_service,
image_id,
image_meta=None):
if not image_meta:
image_meta = {}
self.context = context
self.input = input
self.image_service = image_service
self.image_id = image_id
self.image_meta = image_meta
self._running = False
def start(self):
self.done = event.Event()
def _inner():
"""Function to do the image data transfer through an update
and thereon checks if the state is 'active'."""
self.image_service.update(self.context,
self.image_id,
self.image_meta,
data=self.input)
self._running = True
while self._running:
try:
image_meta = self.image_service.show(
self.context, self.image_id)
image_status = image_meta.get("status")
if image_status == "active":
self.stop()
self.done.send(True)
# If the state is killed, then raise an exception.
elif image_status == "killed":
self.stop()
msg = (_("Glance image %s is in killed state") %
self.image_id)
LOG.error(msg)
self.done.send_exception(exception.NovaException(msg))
elif image_status in ["saving", "queued"]:
greenthread.sleep(GLANCE_POLL_INTERVAL)
else:
self.stop()
msg = _("Glance image "
"%(image_id)s is in unknown state "
"- %(state)s") % {
"image_id": self.image_id,
"state": image_status
}
LOG.error(msg)
self.done.send_exception(exception.NovaException(msg))
except Exception, exc:
self.stop()
self.done.send_exception(exc)
greenthread.spawn(_inner)
return self.done
def _do_spawn(self, gtransport, protocol):
g = greenthread.spawn(self._run_handler, gtransport, protocol)
self.greenlets.add(g)
g.link(lambda *_: self.greenlets.remove(g))
