LIDB2775-23.4 Begins
438189
public long getBeanTimeoutTime(BeanId beanId) {
        TimeoutElement elt = ivStatefulBeanList.get(beanId);
        long timeoutTime = 0;
        if (elt != null) {
            if (elt.timeout != 0) {
                timeoutTime = elt.lastAccessTime + elt.timeout;
                if (timeoutTime < 0) { // F743-6605.1
                    timeoutTime = Long.MAX_VALUE; // F743-6605.1
                }
            }
        }
        return timeoutTime;
    }
1359693
@Override
	public void start(BundleContext context) throws Exception {

		System.out.println("******************************** WebsocketActivator STARTUP **********************************");

		Config config = new Config();
		config.setProperty(GroupProperties.PROP_VERSION_CHECK_ENABLED, "false");
		config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(true);

		hazelcastNode = Hazelcast.newHazelcastInstance(config);
		hazelcastTopic = hazelcastNode.getTopic("cloud");
		hazelcastTopic.addMessageListener(new MessageListener<Object>() {

			public void onMessage(Message<Object> arg0) {
				publishToAll(arg0.getMessageObject().toString());
			}
		});

	}
335416
public void join()
    {
        while(isStarted()&&_pool!=null)
        {
            synchronized(_join)
            {
                try
                {
                    if(isStarted()&&_pool!=null)
                        _join.wait(30000);
                }
                catch(Exception e)
                {
                    LogSupport.ignore(log,e);
                }
            }
        }
    }
969326
def start (self):
        '''
        

        '''
        self.sub = rospy.Subscriber(self.topic, LaserScan, self.__callback)
1121093
@Override
  public void start(InetSocketAddress address) throws IOException {
    mName = address.getHostName() + ":" + address.getPort();
    mLeaderSelector.setId(mName);
    mLeaderSelector.start();
  }
562839
@Override
  public void requestStartupUpdates(String from,
                                    byte []tableKey,
                                    int podIndex,
                                    long deltaTime,
                                    Result<Boolean> cont)
  {
    if (log.isLoggable(Level.FINEST)) {
      log.finest("CacheRequestUpdates " + from + " shard=" + podIndex
                 + " delta=" + deltaTime);
    }
    
    // ChampCloudManager cloudManager = ChampCloudManager.create();
    
    //ServiceManagerAmp rampManager = AmpSystem.getCurrentManager();
    
    //String address = "champ://" + from + ClusterServiceKraken.UID;
    
    //ClusterServiceKraken peerService = rampManager.lookup(address).as(ClusterServiceKraken.class);

    // ArrayList<CacheData> entryList = null;
    long accessTime = CurrentTime.currentTime() + deltaTime;

    // int count = 0;
    
    TablePod tablePod = _clientKraken.getTable(tableKey);
    
    if (tablePod == null) {
      // This server does not have any information about the table. 
      if (log.isLoggable(Level.FINEST)) {
        log.finest(L.l("{0} is an unknown table key ({1})",
                      Hex.toShortHex(tableKey),
                      BartenderSystem.getCurrentSelfServer()));
      }
      
      cont.ok(true);
      return;
    }
    
    tablePod.getUpdatesFromLocal(podIndex, accessTime, cont);
    
                                 // new ResultUpdate(peerService, cont));

    // start reciprocating update request
    // tablePod.startRequestUpdates();
  }
1001769
@Override
  public synchronized void start() {
    LOGGER.info("Starting the Gobblin Cluster Manager");

    this.eventBus.register(this);
    this.multiManager.connect();

    configureHelixQuotaBasedTaskScheduling();

    if (this.isStandaloneMode) {
      // standalone mode starts non-daemon threads later, so need to have this thread to keep process up
      this.idleProcessThread = new Thread(new Runnable() {
        @Override
        public void run() {
          while (!GobblinClusterManager.this.stopStatus.isStopInProgress() && !GobblinClusterManager.this.stopIdleProcessThread) {
            try {
              Thread.sleep(300);
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
              break;
            }
          }
        }
      });

      this.idleProcessThread.start();

      // Need this in case a kill is issued to the process so that the idle thread does not keep the process up
      // since GobblinClusterManager.stop() is not called this case.
      Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run() {
          GobblinClusterManager.this.stopIdleProcessThread = true;
        }
      });
    } else {
      startAppLauncherAndServices();
    }
  }
31691
function start() {
      // Listen to the port
      app.listen(hrsConfigs.port, function (err) {
        if (err) {
          info(err);
        }
        info('Running on http://%s:%s', hrsConfigs.address, hrsConfigs.port);
      });
    }
959496
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance();
        printMemberPort(hz);
    }
664167
@Override
    public void begin() {
        if(null != entityManager.get()) {
            throw new IllegalStateException("Work already begun on this thread. " +
                "Looks like you have called UnitOfWork.begin() twice without a balancing call to end() in between.");
        }

        entityManager.set(EntityManagerProxyFactory.createProxy((HibernateEntityManagerFactory)entityManagerFactory));
    }
1257994
void doInitiation(RejoinMessage message)
    {
        m_coordinatorHsId = message.m_sourceHSId;
        m_hasPersistentTables = message.schemaHasPersistentTables();
        if (m_hasPersistentTables) {
            m_streamSnapshotMb = VoltDB.instance().getHostMessenger().createMailbox();
            m_rejoinSiteProcessor = new StreamSnapshotSink(m_streamSnapshotMb);
            // Start the watchdog so if we never get data it will notice
            kickWatchdog(TimerCallback.initialTimer());
        } else {
            m_streamSnapshotMb = null;
            m_rejoinSiteProcessor = null;
        }

        // MUST choose the leader as the source.
        long sourceSite = m_mailbox.getMasterHsId(m_partitionId);
        // The lowest partition has a single source for all messages whereas all other partitions have a real
        // data source and a dummy data source for replicated tables that are used to sync up replicated table changes.
        boolean haveTwoSources = VoltDB.instance().getLowestPartitionId() != m_partitionId;
        // Provide a valid sink host id unless it is an empty database.
        long hsId = (m_rejoinSiteProcessor != null
                        ? m_rejoinSiteProcessor.initialize(haveTwoSources?2:1,
                                                           message.getSnapshotDataBufferPool(),
                                                           message.getSnapshotCompressedDataBufferPool())
                        : Long.MIN_VALUE);

        REJOINLOG.debug(m_whoami
                + "received INITIATION message. Doing rejoin"
                + ". Source site is: "
                + CoreUtils.hsIdToString(sourceSite)
                + " and destination rejoin processor is: "
                + CoreUtils.hsIdToString(hsId)
                + " and snapshot nonce is: "
                + message.getSnapshotNonce());

        registerSnapshotMonitor(message.getSnapshotNonce());
        // Tell the RejoinCoordinator everything it will need to know to get us our snapshot stream.
        RejoinMessage initResp = new RejoinMessage(m_mailbox.getHSId(), sourceSite, hsId);
        m_mailbox.send(m_coordinatorHsId, initResp);

        // Start waiting for snapshot data
        m_taskQueue.offer(this);
    }
211466
@Validate
    public void start() {
        module = new SimpleModule(MonitorExtension.class.getName());
        module.addSerializer(MonitorExtension.class, new JsonSerializer<MonitorExtension>() {
            @Override
            public void serialize(MonitorExtension monitorExtension, JsonGenerator jsonGenerator,
                                  SerializerProvider serializerProvider) throws IOException {
                jsonGenerator.writeStartObject();
                jsonGenerator.writeStringField("label", monitorExtension.label());
                jsonGenerator.writeStringField("url", monitorExtension.url());
                jsonGenerator.writeStringField("category", monitorExtension.category());
                jsonGenerator.writeEndObject();
            }
        });
        repository.register(module);
    }
550464
@Override
    protected void doStart() {
        log.info("{}: Starting.", this.traceObjectId);

        Services.startAsync(this.durableLog, this.executor)
                .thenComposeAsync(v -> startWhenDurableLogOnline(), this.executor)
                .whenComplete((v, ex) -> {
                    if (ex == null) {
                        // We are started and ready to accept requests when DurableLog starts. All other (secondary) services
                        // are not required for accepting new operations and can still start in the background.
                        notifyStarted();
                    } else {
                        doStop(ex);
                    }
                });
    }
750373
@Override
    public void start() {
        ConnectionPoolMBeanManager.getInstance().registerMonitor(config.getName(), this);

        String seeds = config.getSeeds();
        if (seeds != null && !seeds.isEmpty()) {
            setHosts(config.getSeedHosts());
        }

        config.getLatencyScoreStrategy().start(new Listener() {
            @Override
            public void onUpdate() {
                rebuildPartitions();
            }

            @Override
            public void onReset() {
                rebuildPartitions();
            }
        });
    }
191942
def start(self):
        ""
        log.info("starting")

        self._listener_coro = backend.greenlet(self._listener)
        self._udp_listener_coro = backend.greenlet(self._udp_listener)
        backend.schedule(self._listener_coro)
        backend.schedule(self._udp_listener_coro)

        for addr in self._peers:
            self.add_peer(addr)
176217
private void startLevel34Containers() {
    level3 = start(new PlatformLevel3(level2));
    level4 = start(new PlatformLevel4(level3, level4AddedComponents));
  }
792283
public void start() 
		{
		        try 
		        {
		            this.regularBootstrap.bind(new InetSocketAddress(regularConfiguration.getHost(), regularConfiguration.getPort()));
		            if(logger.isInfoEnabled()) {
		            logger.info(regularConfiguration.getName() + " started at " + regularConfiguration.getHost() + " : " + regularConfiguration.getPort());
		            }
		            if(this.securedConfiguration!=null)
		            {
		            	this.securedBootstrap.bind(new InetSocketAddress(securedConfiguration.getHost(), securedConfiguration.getPort()));	
		            	if(logger.isInfoEnabled()) {
		            	logger.info(securedConfiguration.getName() + " uses port : " + securedConfiguration.getPort() + " for TLS clients.");
		            	}
		            }
		        } 
		        catch (ChannelException e) 
		        {
		        	logger.error("Smpp Channel Exception:", e);
		        }
		}