Activates a universe that's then starting to sending every second.
        See http://tsp.esta.org/tsp/documents/docs/E1-31-2016.pdf for more information
        :param universe: the universe to activate
184036
def activate_output(self, universe: int) -> None:
        
        check_universe(universe)
        # check, if the universe already exists in the list:
        if universe in self._outputs:
            return
        # add new sending:
        new_output = Output(DataPacket(cid=self.__CID, sourceName=self.source_name, universe=universe))
        self._outputs[universe] = new_output
403331
def _control(self, state):
        

        # Renew subscription if necessary
        if not self._subscription_is_recent():
            self._subscribe()

        cmd = MAGIC + CONTROL + self._mac + PADDING_1 + PADDING_2 + state
        _LOGGER.debug("Sending new state to %s: %s", self.host, ord(state))
        ack_state = self._udp_transact(cmd, self._control_resp, state)
        if ack_state is None:
            raise S20Exception(
                "Device didn't acknowledge control request: {}".format(
                    self.host))
783368
def activate(options = {})
      options = options.merge(
        user_name: @user_name,
        access_key_id: @id,
        status: "Active"
      )
      resp = @client.update_access_key(options)
      resp.data
    end
238421
def get_universe(self, as_str=False):
        
        result = self._iface.get_connected_universe()

        if as_str:
            return Universe.get_alias(result)

        return result
644507
public void activate() {
        super.activate();
        LOG.debug("Activating receipt of incoming messages");

        Class<?> serviceClass = endpointInfo.getProperty("serviceClass", Class.class);
        if (serviceClass != null && this.loader == null) {
            final ClassLoader cl = serviceClass.getClassLoader();
            LOG.debug("Using classloader {} obtained via endpointInfo serviceClass", cl);
            this.loader = cl;
        }

        if (engine != null) {
            UndertowHTTPHandler jhd = createJettyHTTPHandler(this, contextMatchOnExact());
            engine.addServant(nurl, jhd);
        }
    }
100589
def start
      channel.prefetch(10)
      queue.subscribe(manual_ack: true, exclusive: false) do |delivery_info, metadata, payload|
        begin
          body = JSON.parse(payload).with_indifferent_access
          status = run(body)
        rescue => e
          status = :error
        end

        if status == :ok
          channel.ack(delivery_info.delivery_tag)
        elsif status == :retry
          channel.reject(delivery_info.delivery_tag, true)
        else # :error, nil etc
          channel.reject(delivery_info.delivery_tag, false)
        end
      end

      wait_for_threads
    end
595765
function(item) {
      var t = this,
          now = Date.now(),
          msSinceLastSend = now - t.lastSendTime;

      // Queue the item
      t.queue.push(item);

      // Send the bundle?
      if (msSinceLastSend > t.interval) {
        // It's been a while since the last send.  Send it now.
        t._send();
      }
      else {
        // Start the timer if it's not already running
        if (!t.timer) {
          t.timer = setTimeout(function(){
            t._send();
          }, t.interval - msSinceLastSend);
        }
      }
    }
1308233
function activate () {
    if (_active) return node
    _active = true
    debug('activated')

    if (!external) {
      _masterBroker.bind()
      _masterResolver.bind()
    }
    if (!node.isReady) _seekForMaster()
    return node
  }
1253831
def initiate(self, **kwargs):
        ''''''
        run_startup = kwargs.pop('run_startup', True)

        setter = lambda value, name: setattr(self, name, value)

        d = defer.Deferred()
        d.addCallback(defer.drop_param,
                      self.agency._messaging.get_connection, self)
        d.addCallback(setter, "_messaging")
        d.addCallback(defer.drop_param,
                      self.agency._database.get_connection)
        d.addCallback(setter, '_database')
        d.addCallback(defer.drop_param,
                      self._reload_descriptor)
        d.addCallback(defer.drop_param,
                      self._subscribe_for_descriptor_changes)
        d.addCallback(defer.drop_param, self._store_instance_id)
        d.addCallback(defer.drop_param, self._load_configuration)
        d.addCallback(setter, '_configuration')
        d.addCallback(defer.drop_param,
                      self.join_shard, self._descriptor.shard)
        d.addCallback(defer.drop_param,
                      self.journal_agent_created)
        d.addCallback(defer.drop_param,
                      self._call_initiate, **kwargs)
        d.addCallback(defer.drop_param, self.call_next, self._call_startup,
                      call_startup=run_startup)
        d.addCallback(defer.override_result, self)
        d.addErrback(self._startup_error)

        # Ensure the execution chain is broken
        self.call_next(d.callback, None)

        return d
211174
def begin(self, access_mode=None):
        
        if self._active_transaction:
            raise SystemError("Transaction in progress")
        self._active_transaction = self.driver.session(access_mode=access_mode).begin_transaction()
58660
def send(self, message):
        
        message.update(self._globalFields)
        errors = []
        for dest in self._destinations:
            try:
                dest(message)
            except:
                errors.append(sys.exc_info())
        if errors:
            raise _DestinationsSendError(errors)
169535
def start(self, interval_s):
    
    if self.running:
      return False

    self.stopped.clear()

    def _execute():
      # Always execute immediately once
      if not self.method() and self.stop_if_false:
        return
      while not self.stopped.wait(interval_s):
        if not self.method() and self.stop_if_false:
          return

    self.thread = threading.Thread(target=_execute)
    self.thread.daemon = True
    self.thread.start()
    return True
543295
def activate_eco(self):
        """"""
        value = struct.pack('B', PROP_ECO)
        self._conn.make_request(PROP_WRITE_HANDLE, value)
1046773
@Override
    public void activate(String topologyName) throws TException {
        try {
            NimbusUtils.transitionName(data, topologyName, true, StatusType.activate);
            notifyTopologyActionListener(topologyName, "activate");
        } catch (NotAliveException e) {
            String errMsg = "Activate Error, topology " + topologyName + " is not alive!";
            LOG.error(errMsg, e);
            throw new NotAliveException(errMsg);
        } catch (Exception e) {
            String errMsg = "Failed to activate topology " + topologyName;
            LOG.error(errMsg, e);
            throw new TException(errMsg);
        }
    }
810484
def start(self):
        
        rs = self.connection.start_instances([self.id])
        if len(rs) > 0:
            self._update(rs[0])
1165336
def activate(self, bounce_id):
        '''
        
        '''
        self._check_values()
        req_url = '/bounces/' + str(bounce_id) + '/activate'
        # print req_url
        h1 = HTTPConnection('api.postmarkapp.com')
        dta = urlencode({"data": "blank"}).encode('utf8')
        req = h1.request(
            'PUT',
            req_url,
            dta,
            {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'X-Postmark-Server-Token': self.__api_key,
                'User-agent': self.__user_agent
            }
        )
        r = h1.getresponse()
        return json.loads(r.read())
516987
def server_side_activation=(activation)
      raise JSS::InvalidDataError, 'Activation must be a Time' unless activation.is_a? Time
      @server_side_limitations[:activation] = activation
      @need_to_update = true
    end