Use this operation to start Repeater Instance.
423156
public static br start(nitro_service client, br resource) throws Exception
	{
		return ((br[]) resource.perform_operation(client, "start"))[0];
	}
1271857
def start(self):
        """"""
        target = getattr(self._target, '__qualname__', self._target.__name__)
        self._log.debug('starting fiber {}, target {}', self.name, target)
        self._hub.run_callback(self.switch)
1277817
def start(self):
        """"""
        assert not self._timer, '%r is already started; to restart it, cancel it first' % self
        loop = evergreen.current.loop
        current = evergreen.current.task
        if self.seconds is None or self.seconds < 0:
            # "fake" timeout (never expires)
            self._timer = None
        elif self.exception is None or isinstance(self.exception, bool):
            # timeout that raises self
            self._timer = loop.call_later(self.seconds, self._timer_cb, current.throw, self)
        else:
            # regular timeout with user-provided exception
            self._timer = loop.call_later(self.seconds, self._timer_cb, current.throw, self.exception)
136360
public void start () throws SchedulerException
  {

    if (m_bShuttingDown || m_bClosed)
    {
      throw new SchedulerException ("The Scheduler cannot be restarted after shutdown() has been called.");
    }

    // QTZ-212 : calling new schedulerStarting() method on the listeners
    // right after entering start()
    notifySchedulerListenersStarting ();

    if (m_aInitialStart == null)
    {
      m_aInitialStart = new Date ();
      m_aResources.getJobStore ().schedulerStarted ();
      _startPlugins ();
    }
    else
    {
      m_aResources.getJobStore ().schedulerResumed ();
    }

    m_aSchedThread.togglePause (false);

    LOGGER.info ("Scheduler " + m_aResources.getUniqueIdentifier () + " started.");

    notifySchedulerListenersStarted ();
  }
1060267
def start(port, root_directory, bucket_depth):
    """"""
    application = S3Application(root_directory, bucket_depth)
    http_server = httpserver.HTTPServer(application)
    http_server.listen(port)
    ioloop.IOLoop.current().start()
158173
def start_instance(self):
        
        start_url = self._get_url('start_path')
        res = self.rest_client.session.put(start_url, json={})
        _handle_http_errors(res)
        return res.json()
626015
public void start() {
        if (!isStarted()) {
            if (getEndpointConfiguration().getWebDriver() != null) {
                webDriver = getEndpointConfiguration().getWebDriver();
            } else if (StringUtils.hasText(getEndpointConfiguration().getRemoteServerUrl())) {
                webDriver = createRemoteWebDriver(getEndpointConfiguration().getBrowserType(), getEndpointConfiguration().getRemoteServerUrl());
            } else {
                webDriver = createLocalWebDriver(getEndpointConfiguration().getBrowserType());
            }

            if (!CollectionUtils.isEmpty(getEndpointConfiguration().getEventListeners())) {
                EventFiringWebDriver wrapper = new EventFiringWebDriver(webDriver);
                log.info("Add event listeners to web driver: " + getEndpointConfiguration().getEventListeners().size());
                for (WebDriverEventListener listener : getEndpointConfiguration().getEventListeners()) {
                    wrapper.register(listener);
                }
            }
        } else {
            log.warn("Browser already started");
        }
    }
288474
def start(self):
        
        if not self.is_run:
            # set class attribute
            ThreadingTCPServer.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET
            ThreadingTCPServer.daemon_threads = True
            # init server
            self._service = ThreadingTCPServer((self.host, self.port), self.ModbusService, bind_and_activate=False)
            # set socket options
            self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
            # TODO test no_delay with bench
            self._service.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            # bind and activate
            self._service.server_bind()
            self._service.server_activate()
            # serve request
            if self.no_block:
                self._serve_th = Thread(target=self._serve)
                self._serve_th.daemon = True
                self._serve_th.start()
            else:
                self._serve()
503773
void start() {
    for (int i = 0; i < threadCount; i++) {
      Runnable r = null;
      switch (config.getPayloadConfig().getPayloadCase()) {
        case SIMPLE_PARAMS: {
          if (config.getClientType() == Control.ClientType.ASYNC_CLIENT) {
            if (config.getRpcType() == Control.RpcType.UNARY) {
              r = new AsyncUnaryWorker(clients[i % clients.length]);
            } else if (config.getRpcType() == Control.RpcType.STREAMING) {
              r = new AsyncPingPongWorker(mat, clients[i % clients.length]);
            }
          }
          break;
        }
        default: {
          throw Status.UNIMPLEMENTED.withDescription(
              "Unknown payload case " + config.getPayloadConfig().getPayloadCase().name())
              .asRuntimeException();
        }
      }
      if (r == null) {
        throw new IllegalStateException(config.getRpcType().name()
            + " not supported for client type "
            + config.getClientType());
      }
      fixedThreadPool.execute(r);
    }
    if (osBean != null) {
      lastMarkCpuTime = osBean.getProcessCpuTime();
    }
  }
542060
void start(Handler<ConnectionOutputBatch> startHandler) {
    connection.doBatchStart(id, args);
    this.startHandler = startHandler;
  }
182987
public void start() {
        ObjectName beanName = null;
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            beanName = getObjectName();
            server.registerMBean(this, beanName);
        } catch (InstanceAlreadyExistsException e) {
            LOGGER.warn(JcrI18n.mBeanAlreadyRegistered, beanName);
        } catch (Exception e) {
            LOGGER.error(e, JcrI18n.cannotRegisterMBean, beanName);
        }
    }
930265
public void start() {
    instanceLock.writeLock().lock();
    try {
      for (final Map.Entry<MongoNamespace, NamespaceChangeStreamListener> streamerEntry :
          nsStreamers.entrySet()) {
        streamerEntry.getValue().start();
      }
    } finally {
      instanceLock.writeLock().unlock();
    }
  }
1256101
public void start() {
        if (state == State.RUNNING) return;
        final Lock lock = this.lock.writeLock();
        try {
            lock.lock();
            this.state = State.STARTING;

            // Create an executor service that we'll use to start the repositories ...
            ThreadFactory threadFactory = new NamedThreadFactory("modeshape-start-repo");
            repositoryStarterService = Executors.newCachedThreadPool(threadFactory);

            state = State.RUNNING;
        } catch (RuntimeException e) {
            state = State.NOT_RUNNING;
            throw e;
        } finally {
            lock.unlock();
        }
    }
1186534
def start (self):
        '''
        

        '''
        self.subrgb = rospy.Subscriber(self.topicrgb, ImageROS)
        self.subd = rospy.Subscriber(self.topicd, ImageROS)
        self.ts = message_filters.ApproximateTimeSynchronizer([subrgb, subd], 1, 0.1, allow_headerless=True)
        self.ts.registerCallback(self.__callback)
509061
public void startServer() {
        if (!System.getProperties().containsKey(JMX_ENABLED_PROPERTY)) {
            this.logger.info(
                    "System Property '"
                            + JMX_ENABLED_PROPERTY
                            + "' is not set, skipping initialization.");
            return;
        }

        try {
            // Get the base rmi port
            final int portOne = this.getPortOne();

            // Get the second rmi port or calculate it
            final int portTwo = this.calculatePortTwo(portOne);

            // Create the RMI registry on the base port
            try {
                LocateRegistry.createRegistry(portOne);

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Started RMI Registry on port " + portOne);
                }
            } catch (RemoteException re) {
                throw new IllegalStateException(
                        "Could not create RMI Registry on port " + portOne, re);
            }

            // Generate the JMX Service URL
            final JMXServiceURL jmxServiceUrl = this.getServiceUrl(portOne, portTwo);

            // Map for the JMX environment configuration
            final Map<String, Object> jmxEnv = this.getJmxServerEnvironment();

            // Create the MBean Server
            final MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();

            // Create the JMX Connector
            try {
                this.jmxConnectorServer =
                        JMXConnectorServerFactory.newJMXConnectorServer(
                                jmxServiceUrl, jmxEnv, mbeanServer);

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug(
                            "Created JMXConnectorServer for JMXServiceURL='"
                                    + jmxServiceUrl
                                    + "', jmxEnv='"
                                    + jmxEnv
                                    + "' MBeanServer='"
                                    + mbeanServer
                                    + "'");
                }
            } catch (IOException ioe) {
                throw new IllegalStateException(
                        "Failed to create a new JMXConnectorServer for JMXServiceURL='"
                                + jmxServiceUrl
                                + "', jmxEnv='"
                                + jmxEnv
                                + "' MBeanServer='"
                                + mbeanServer
                                + "'",
                        ioe);
            }

            // Start the JMX Connector
            try {
                this.jmxConnectorServer.start();
                this.logger.info(
                        "Started JMXConnectorServer. Listening on '" + jmxServiceUrl + "'");
            } catch (IOException ioe) {
                throw new IllegalStateException("Failed to start the JMXConnectorServer", ioe);
            }
        } catch (RuntimeException re) {
            if (this.failOnException) {
                throw re;
            }

            this.logger.error("Failed to initialize the JMX Server", re);
        }
    }
1330166
public void start() {
    //only start the thread if the interval is sane
    if(refreshInterval > 0) {
      refreshUsed = new Thread(new DURefreshThread(), 
          "refreshUsed-"+dirPath);
      refreshUsed.setDaemon(true);
      refreshUsed.start();
    }
  }
50052
public void start() {
    syncLock.lock();
    try {
      if (!this.isConfigured) {
        return;
      }
      instanceChangeStreamListener.stop();
      if (listenersEnabled) {
        instanceChangeStreamListener.start();
      }

      if (syncThread == null) {
        syncThread = new Thread(
            new DataSynchronizerRunner(
              new WeakReference<>(this),
              networkMonitor,
              logger
            ),
            "dataSynchronizerRunnerThread"
        );
      }
      if (syncThreadEnabled && !isRunning) {
        syncThread.start();
        isRunning = true;
      }
    } finally {
      syncLock.unlock();
    }
  }