Inform the policy to lease this message continually.

        .. note::
            This method is called by the constructor, and you should never
            need to call it manually.
193162
def lease(self):
        
        self._request_queue.put(
            requests.LeaseRequest(ack_id=self._ack_id, byte_size=self.size)
        )
949610
def _store(self, messages, response, *args, **kwargs):
        
        return [message for message in messages if not message.level in STICKY_MESSAGE_LEVELS]
218936
@Override
    public final void refresh() {
        if (wrappedPolicy != null) {
            wrappedPolicy.refresh();
        }
        try {
            listener.policyRefreshed();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
202887
public function keep()
    {
        foreach ($this->messages['prev'] as $key => $val) {
            $this->next($key, $val);
        }
    }
548683
def alwaysCalledWith(cls, spy, *args, **kwargs): #pylint: disable=invalid-name
        
        cls.__is_spy(spy)
        if not (spy.alwaysCalledWith(*args, **kwargs)):
            raise cls.failException(cls.message)
1203942
def set_progress_message(self, message, line_break=False):
        

        end = '\r' if not line_break else None

        @self.connect
        def on_progress(value, value_max, **kwargs):
            kwargs['end'] = None if value == value_max else end
            _default_on_progress(message, value, value_max, **kwargs)
1168050
def write(self, *args, **kwargs):
        
        message = 'Will be removed in the future. Please use to_zmat().'
        with warnings.catch_warnings():
            warnings.simplefilter("always")
            warnings.warn(message, DeprecationWarning)
        return self.to_zmat(*args, **kwargs)
1360647
def growl( title, message, priority )
      message.tr!("`", "'")
      if @coalesce then coalesce(title, message, priority)
      else call_growl(title, message, priority) end
    end
250298
def promote(self):
        
        if self.expiry is not None:
            self.promoted = self.time_module.time() + self.expiry
1207353
def log(self, message, type='notice'):
        
        if self.logger and not callable(self.logger):
            raise ValueError(u"Invalid logger set, must be a callable")
        if self.verbose and self.logger:
            self.logger(message, type)
260468
def lock(self):
        
        if isinstance(self._session, manager.Manager):
            self._session.lock()
598799
function() {
    
        that.connected = true;
        that.tcp_connection.setKeepAlive( true );	
        
        if ( that.message_buffer.length ) {
            while( that.message_buffer.length ) {
                that.tcp_connection.write( that.message_buffer.shift() );
            }
        }
    }
1017868
def persistant_debug(request, message, extra_tags='', fail_silently=False, *args, **kwargs):
    
    add_message(request, DEBUG_PERSISTENT, message, extra_tags=extra_tags,
                fail_silently=fail_silently, *args, **kwargs)
219746
def warn(self, message):
        
        if message not in self._warnings:
            self._warnings.append(message)

        self.logger.warn(message)
1319641
def onOpen(self):
        
        self.factory.add_client(self)

        # Publish ON_OPEN message
        self.factory.mease.publisher.publish(
            message_type=ON_OPEN, client_id=self._client_id, client_storage=self.storage)
671500
@Override
  protected void onMethodEnter() {
    if (withPreconditions || withPostconditions || withInvariants) {
      enterContractedMethod();

      if (withPostconditions) {
        allocateOldValues(ContractKind.OLD, oldValueLocals);
        allocateOldValues(ContractKind.SIGNAL_OLD, signalOldValueLocals);
      }

      mark(methodStart);

      Label skip = enterBusySection();

      if (withInvariants && !statik && !isConstructor && !isStaticInit) {
        invokeInvariants();
      }

      if (withPreconditions) {
        invokePreconditions();
      }

      if (withPostconditions) {
        invokeOldValues(ContractKind.OLD, oldValueLocals);
        invokeOldValues(ContractKind.SIGNAL_OLD, signalOldValueLocals);
      }

      leaveBusySection(skip);
    }
  }
911520
public void setAuthorizationPersistencePolicy(PersistencePolicy policy) {
        if (policy == null) {
            throw new IllegalArgumentException("The policy argument cannot be null");
        }

        if (preferences.persistencePolicy.get() != policy) {
            preferences.persistencePolicy.set(policy);

            preferences.accessToken.updateStateByPolicy();
            preferences.idToken.updateStateByPolicy();
        }
    }