Beispiel #1
0
 def _acquire_method_lock(self, method, this):
     method_id = id(method)
     if method.is_static:
         this_id = id(method.declaring_type)
     else:
         this_id = this.object_id
     thread_id = helpers.get_current_thread_id()
     while True:
         event, event_owner = self._locks.get((method_id, this_id),
                                              (None, None))
         if event:
             if event_owner == thread_id:
                 event = None
                 break
             else:
                 event.wait()
         else:
             event = eventlet.event.Event()
             self._locks[(method_id, this_id)] = (event, thread_id)
             break
     try:
         yield
     finally:
         if event is not None:
             del self._locks[(method_id, this_id)]
             event.send()
 def _run_loop(self, kind, event, idle_for_func,
               initial_delay=None, stop_on_exception=True):
     func_name = reflection.get_callable_name(self.f)
     func = self.f if stop_on_exception else _safe_wrapper(self.f, kind,
                                                           func_name)
     if initial_delay:
         greenthread.sleep(initial_delay)
     try:
         watch = timeutils.StopWatch()
         while self._running:
             watch.restart()
             result = func(*self.args, **self.kw)
             watch.stop()
             if not self._running:
                 break
             idle = idle_for_func(result, watch.elapsed())
             LOG.trace('%(kind)s %(func_name)r sleeping '
                       'for %(idle).02f seconds',
                       {'func_name': func_name, 'idle': idle,
                        'kind': kind})
             greenthread.sleep(idle)
     except LoopingCallDone as e:
         event.send(e.retvalue)
     except Exception:
         exc_info = sys.exc_info()
         try:
             LOG.error(_LE('%(kind)s %(func_name)r failed'),
                       {'kind': kind, 'func_name': func_name},
                       exc_info=exc_info)
             event.send_exception(*exc_info)
         finally:
             del exc_info
         return
     else:
         event.send(True)
Beispiel #3
0
 def _acquire_method_lock(self, method, this):
     method_id = id(method)
     if method.is_static:
         this_id = id(method.declaring_type)
     else:
         this_id = this.object_id
     thread_id = helpers.get_current_thread_id()
     while True:
         event, event_owner = self._locks.get(
             (method_id, this_id), (None, None))
         if event:
             if event_owner == thread_id:
                 event = None
                 break
             else:
                 event.wait()
         else:
             event = eventlet.event.Event()
             self._locks[(method_id, this_id)] = (event, thread_id)
             break
     try:
         yield
     finally:
         if event is not None:
             del self._locks[(method_id, this_id)]
             event.send()
    def _invoke_method_implementation(self, method, this, murano_class,
                                      context, params):
        body = method.body
        if not body:
            return None

        current_thread = eventlet.greenthread.getcurrent()
        if not hasattr(current_thread, '_murano_dsl_thread_marker'):
            thread_marker = current_thread._murano_dsl_thread_marker = \
                uuid.uuid4().hex
        else:
            thread_marker = current_thread._murano_dsl_thread_marker

        method_id = id(body)
        this_id = this.object_id

        event, marker = self._locks.get((method_id, this_id), (None, None))
        if event:
            if marker == thread_marker:
                return self._invoke_method_implementation_gt(
                    body, this, params, murano_class, context)
            event.wait()

        event = eventlet.event.Event()
        self._locks[(method_id, this_id)] = (event, thread_marker)
        gt = eventlet.spawn(self._invoke_method_implementation_gt, body, this,
                            params, murano_class, context, thread_marker)
        result = gt.wait()
        del self._locks[(method_id, this_id)]
        event.send()
        return result
Beispiel #5
0
 def _acquire_method_lock(self, func, this):
     method_id = id(func)
     if isinstance(this, dsl_types.MuranoClass):
         this_id = id(this)
     else:
         this_id = this.object_id
     thread_id = helpers.get_current_thread_id()
     while True:
         event, event_owner = self._locks.get(
             (method_id, this_id), (None, None))
         if event:
             if event_owner == thread_id:
                 event = None
                 break
             else:
                 event.wait()
         else:
             event = eventlet.event.Event()
             self._locks[(method_id, this_id)] = (event, thread_id)
             break
     try:
         yield
     finally:
         if event is not None:
             del self._locks[(method_id, this_id)]
             event.send()
 def _run_loop(self, kind, event, idle_for_func, initial_delay=None):
     if initial_delay:
         greenthread.sleep(initial_delay)
     try:
         watch = timeutils.StopWatch()
         while self._running:
             watch.restart()
             result = self.f(*self.args, **self.kw)
             watch.stop()
             if not self._running:
                 break
             idle = idle_for_func(result, watch.elapsed())
             LOG.debug(
                 "%(kind)s %(func_name)r sleeping " "for %(idle).02f seconds",
                 {"func_name": self.f, "idle": idle, "kind": kind},
             )
             greenthread.sleep(idle)
     except LoopingCallDone as e:
         event.send(e.retvalue)
     except Exception:
         exc_info = sys.exc_info()
         try:
             LOG.error(_LE("%(kind)s %(func_name)r failed"), {"kind": kind, "func_name": self.f}, exc_info=exc_info)
             event.send_exception(*exc_info)
         finally:
             del exc_info
         return
     else:
         event.send(True)
Beispiel #7
0
 def _get_data(self, server_tail):
     print 'Starting data getter for ServerTail %s' % (server_tail.id,)
     client = paramiko.SSHClient()
     client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
     kwargs = {'timeout': 10}
     if server_tail.username:
         kwargs['username'] = server_tail.username
     if server_tail.password:
         kwargs['password'] = server_tail.password
     rsa_key = '/home/servertail/.ssh/id_rsa'
     if os.path.exists(rsa_key):
         kwargs['key_filename'] = rsa_key
     client.connect(server_tail.hostname, server_tail.port, **kwargs)
     
     command = 'uname -a'
     stdin, stdout, stderr = client.exec_command(command)
     if 'Darwin' in stdout.read():
         command = 'tail -n%s -F %s' % (self.buffer_limit, server_tail.path)
     else:
         command = 'tail -q -s0.08 -n%s -F %s 2>&1' % (self.buffer_limit,
             server_tail.path)
     
     stdin, stdout, stderr = client.exec_command(command)
     
     for line in stdout:
         line_id = str(uuid.uuid1())
         self.data[server_tail.id].append({
             'id': line_id,
             'line': line.rstrip(),
         })
         truncated = self.data[server_tail.id][-self.buffer_limit:]
         self.data[server_tail.id] = truncated
         events = self.events.pop(server_tail.id, [])
         for event in events:
             event.send({'error': False, 'id': line_id})
    def _invoke_method_implementation(self, method, this, murano_class, context, params):
        body = method.body
        if not body:
            return None

        current_thread = eventlet.greenthread.getcurrent()
        if not hasattr(current_thread, "_murano_dsl_thread_marker"):
            thread_marker = current_thread._murano_dsl_thread_marker = uuid.uuid4().hex
        else:
            thread_marker = current_thread._murano_dsl_thread_marker

        method_id = id(body)
        this_id = this.object_id

        event, marker = self._locks.get((method_id, this_id), (None, None))
        if event:
            if marker == thread_marker:
                return self._invoke_method_implementation_gt(body, this, params, murano_class, context)
            event.wait()

        event = eventlet.event.Event()
        self._locks[(method_id, this_id)] = (event, thread_marker)
        gt = eventlet.spawn(
            self._invoke_method_implementation_gt, body, this, params, murano_class, context, thread_marker
        )
        result = gt.wait()
        del self._locks[(method_id, this_id)]
        event.send()
        return result
Beispiel #9
0
    def _invoke_method_implementation(self, method, this, context, params):
        body = method.body
        if not body:
            return None

        murano_class = method.murano_class
        current_thread = eventlet.greenthread.getcurrent()
        if not hasattr(current_thread, '_muranopl_thread_marker'):
            thread_marker = current_thread._muranopl_thread_marker = \
                uuid.uuid4().hex
        else:
            thread_marker = current_thread._muranopl_thread_marker

        method_id = id(body)
        this_id = this.object_id

        while True:
            event, marker = self._locks.get((method_id, this_id), (None, None))
            if event:
                if marker == thread_marker:
                    return self._invoke_method_implementation_gt(
                        body, this, params, murano_class, context)
                event.wait()
            else:
                break

        event = eventlet.event.Event()
        self._locks[(method_id, this_id)] = (event, thread_marker)
        # noinspection PyProtectedMember
        method_info = '{0}.{1} ({2})'.format(murano_class.name, method._name,
                                             hash((method_id, this_id)))
        # Prepare caller information
        caller_ctx = helpers.get_caller_context(context)
        if caller_ctx:
            caller_info = trace.compose_stack_frame(caller_ctx)
            LOG.debug('{0}: Begin execution: {1} called from {2}'.format(
                thread_marker, method_info, trace.format_frame(caller_info)))
        else:
            LOG.debug('{0}: Begin execution: {1}'.format(
                thread_marker, method_info))

        try:
            gt = eventlet.spawn(self._invoke_method_implementation_gt, body,
                                this, params, murano_class, context,
                                thread_marker)
            result = gt.wait()
        except Exception as e:
            LOG.debug("{0}: End execution: {1} with exception {2}".format(
                thread_marker, method_info, e))
            raise
        else:
            LOG.debug("{0}: End execution: {1}".format(thread_marker,
                                                       method_info))
        finally:
            del self._locks[(method_id, this_id)]
            event.send()

        return result
Beispiel #10
0
 def get_data(self, server_tail):
     try:
         return self._get_data(server_tail)
     except (KeyboardInterrupt, SystemExit):
         raise
     except:
         events = self.events.pop(server_tail.id, [])
         for event in events:
             event.send({'error': True})
Beispiel #11
0
    def _invoke_method_implementation(self, method, this, context, params):
        body = method.body
        if not body:
            return None

        murano_class = method.murano_class
        current_thread = eventlet.greenthread.getcurrent()
        if not hasattr(current_thread, '_muranopl_thread_marker'):
            thread_marker = current_thread._muranopl_thread_marker = \
                uuid.uuid4().hex
        else:
            thread_marker = current_thread._muranopl_thread_marker

        method_id = id(body)
        this_id = this.object_id

        while True:
            event, marker = self._locks.get((method_id, this_id), (None, None))
            if event:
                if marker == thread_marker:
                    return self._invoke_method_implementation_gt(
                        body, this, params, murano_class, context)
                event.wait()
            else:
                break

        event = eventlet.event.Event()
        self._locks[(method_id, this_id)] = (event, thread_marker)
        # noinspection PyProtectedMember
        method_info = '{0}.{1} ({2})'.format(murano_class.name, method._name,
                                             hash((method_id, this_id)))
        # Prepare caller information
        caller_ctx = helpers.get_caller_context(context)
        if caller_ctx:
            caller_info = trace.compose_stack_frame(caller_ctx)
            LOG.debug(
                '{0}: Begin execution: {1} called from {2}'.format(
                    thread_marker, method_info, trace.format_frame(
                        caller_info)))
        else:
            LOG.debug(
                '{0}: Begin execution: {1}'.format(
                    thread_marker, method_info))

        gt = eventlet.spawn(self._invoke_method_implementation_gt, body,
                            this, params, murano_class, context,
                            thread_marker)
        result = gt.wait()
        del self._locks[(method_id, this_id)]
        LOG.debug(
            "{0}: End execution: {1}".format(thread_marker, method_info))
        event.send()
        return result
Beispiel #12
0
 def _run_loop(self,
               kind,
               event,
               idle_for_func,
               initial_delay=None,
               stop_on_exception=True):
     func_name = reflection.get_callable_name(self.f)
     func = self.f if stop_on_exception else _safe_wrapper(
         self.f, kind, func_name)
     if initial_delay:
         greenthread.sleep(initial_delay)
     try:
         watch = timeutils.StopWatch()
         while self._running:
             watch.restart()
             result = func(*self.args, **self.kw)
             watch.stop()
             if not self._running:
                 break
             idle = idle_for_func(result, watch.elapsed())
             LOG.trace(
                 '%(kind)s %(func_name)r sleeping '
                 'for %(idle).02f seconds', {
                     'func_name': func_name,
                     'idle': idle,
                     'kind': kind
                 })
             greenthread.sleep(idle)
     except LoopingCallDone as e:
         event.send(e.retvalue)
     except Exception:
         exc_info = sys.exc_info()
         try:
             LOG.error(_LE('%(kind)s %(func_name)r failed'), {
                 'kind': kind,
                 'func_name': func_name
             },
                       exc_info=exc_info)
             event.send_exception(*exc_info)
         finally:
             del exc_info
         return
     else:
         event.send(True)
Beispiel #13
0
 def _handle_message(self, message):
     event, method, message = message
     if method == 'send':
         self._last_activity = time.time()
         if message:
             if isinstance(message, (tuple, list)):
                 message = ''.join(message)
             self.client.send(message)
         event.send()
     elif method == 'disconnect':
         # check last activity
         if time.time() - self._last_activity > \
                 self._inactivity_disconnect:
             self._disconnect = True
             self.client.disconnect()
             event.send(True)
         else:
             # warning, there's been activity, abort
             event.send(False)
     else:
         event.throw(Exception('Unknown XMPP Method'))
Beispiel #14
0
    def _acquire_method_lock(self, method, this, arg_val_dict):
        if this is None:
            if not arg_val_dict:
                # if neither "this" nor argument values are set then no
                # locking is needed
                key = None
            else:
                # if only the argument values are passed then find the lock
                # list only by the method
                key = (None, id(method))
        else:
            if method.is_static:
                # find the lock list by the type and method
                key = (id(method.declaring_type), id(method))
            else:
                # find the lock list by the object and method
                key = (this.object_id, id(method))
        thread_id = helpers.get_current_thread_id()
        while True:
            event, event_owner = None, None
            if key is None:  # no locking needed
                break

            lock_list = self._locks.setdefault(key, [])
            # lock list contains a list of tuples:
            # first item of each tuple is a dict with the values of locking
            # arguments (it is used for argument values comparison),
            # second item is an event to wait on,
            # third one is the owner thread id

            # If this lock list is empty it means no locks on this object and
            # method at all.
            for arg_vals, l_event, l_event_owner in lock_list:
                if arg_vals == arg_val_dict:
                    event = l_event
                    event_owner = l_event_owner
                    break

            if event:
                if event_owner == thread_id:
                    # this means a re-entrant lock: the tuple with the same
                    # value of the first element exists in the list, but it was
                    # acquired by the same green thread. We may proceed with
                    # the call in this case
                    event = None
                    break
                else:
                    event.wait()
            else:
                # this means either the lock list was empty or didn't contain a
                # tuple with the first element equal to arg_val_dict.
                # Then let's acquire a lock, i.e. create a new tuple and place
                # it into the list
                event = eventlet.event.Event()
                event_owner = thread_id
                lock_list.append((arg_val_dict, event, event_owner))
                break
        try:
            yield
        finally:
            if event is not None:
                lock_list.remove((arg_val_dict, event, event_owner))
                if len(lock_list) == 0:
                    del self._locks[key]
                event.send()
Beispiel #15
0
    def _acquire_method_lock(self, method, this, arg_val_dict):
        if this is None:
            if not arg_val_dict:
                # if neither "this" nor argument values are set then no
                # locking is needed
                key = None
            else:
                # if only the argument values are passed then find the lock
                # list only by the method
                key = (None, id(method))
        else:
            if method.is_static:
                # find the lock list by the type and method
                key = (id(method.declaring_type), id(method))
            else:
                # find the lock list by the object and method
                key = (this.object_id, id(method))
        thread_id = helpers.get_current_thread_id()
        while True:
            event, event_owner = None, None
            if key is None:  # no locking needed
                break

            lock_list = self._locks.setdefault(key, [])
            # lock list contains a list of tuples:
            # first item of each tuple is a dict with the values of locking
            # arguments (it is used for argument values comparison),
            # second item is an event to wait on,
            # third one is the owner thread id

            # If this lock list is empty it means no locks on this object and
            # method at all.
            for arg_vals, l_event, l_event_owner in lock_list:
                if arg_vals == arg_val_dict:
                    event = l_event
                    event_owner = l_event_owner
                    break

            if event:
                if event_owner == thread_id:
                    # this means a re-entrant lock: the tuple with the same
                    # value of the first element exists in the list, but it was
                    # acquired by the same green thread. We may proceed with
                    # the call in this case
                    event = None
                    break
                else:
                    event.wait()
            else:
                # this means either the lock list was empty or didn't contain a
                # tuple with the first element equal to arg_val_dict.
                # Then let's acquire a lock, i.e. create a new tuple and place
                # it into the list
                event = eventlet.event.Event()
                event_owner = thread_id
                lock_list.append((arg_val_dict, event, event_owner))
                break
        try:
            yield
        finally:
            if event is not None:
                lock_list.remove((arg_val_dict, event, event_owner))
                if len(lock_list) == 0:
                    del self._locks[key]
                event.send()