Starts the watching.

@return the current pipeline.
348003
public Pipeline watch() {
        // Delete all error reports before starting the watcher.
        error = new File(baseDir, "target/pipeline");
        FileUtils.deleteQuietly(error);
        mojo.getLog().debug("Creating the target/pipeline directory : " + error.mkdirs());

        // Start the watching process.
        watcher = new FileAlterationMonitor(Integer.getInteger("watch.period", 2) * 1000);
        watcher.setThreadFactory(new DefensiveThreadFactory("wisdom-pipeline-watcher", mojo));
        FileAlterationObserver srcObserver = new FileAlterationObserver(new File(baseDir, "src"),
                TrueFileFilter.INSTANCE);
        PipelineWatcher listener = new PipelineWatcher(this);
        srcObserver.addListener(listener);
        watcher.addObserver(srcObserver);

        if (pomFileMonitoring) {
            FileAlterationObserver pomObserver = new FileAlterationObserver(baseDir, new FileFilter() {
                @Override
                public boolean accept(File file) {
                    return file.equals(new File(baseDir, "pom.xml"));
                }
            });
            pomObserver.addListener(listener);
            watcher.addObserver(pomObserver);
        }

        try {
            mojo.getLog().info("Start watching " + baseDir.getAbsolutePath());
            watcher.start();
        } catch (Exception e) {
            mojo.getLog().error("Cannot start the watcher", e);
        }
        return this;
    }
176083
@Override
  public void start() {
    if (mIsRunning || mAnimationBackend == null || mAnimationBackend.getFrameCount() <= 1) {
      return;
    }
    mIsRunning = true;
    mStartTimeMs = now();
    mExpectedRenderTimeMs = mStartTimeMs;
    mLastFrameAnimationTimeMs = -1;
    mLastDrawnFrameNumber = -1;
    invalidateSelf();
    mAnimationListener.onAnimationStart(this);
  }
980079
@Override
    public ExecutorService executorService() {
        InternalEventPipeline pipeline = currentPipeline.get();
        if (pipeline != null) {
            return pipeline.executorService();
        }
        return fallback.executorService();
    }
338569
def start(self):
        """""" 
        logger.info("starting process")
        process = os.fork()
        time.sleep(0.01)
        if process != 0:
            logger.debug('starting child watcher')
            self.loop.reset()
            self.child_pid = process
            self.watcher = pyev.Child(self.child_pid, False, self.loop, self._child)
            self.watcher.start()
        else:
            self.loop.reset()
            logger.debug('running main function')
            self.run(*self.args, **self.kwargs) 
            logger.debug('quitting')
            sys.exit(0)
1011120
public JMProgressiveManager<T, R> start() {
		info(log, "start");
		this.completableFuture = JMThread
				.runAsync(() -> targetCollection.stream()
						.filter(negate(isStopped())).map(this::moveNextTarget)
						.map(t -> JMMap.putGetNew(resultMap, t, process(t)))
						.forEach(lastResult::set))
				.thenRun(this::setStopped)
				.thenRun(() -> Optional.ofNullable(completedConsumerList)
						.ifPresent(list -> list.parallelStream()
								.forEach(c -> c.accept(this))));
		return this;
	}
1195949
public boolean start()
  {
    Thread thread = Thread.currentThread();
    ClassLoader oldLoader = thread.getContextClassLoader();
    
    try {
      thread.setContextClassLoader(classLoader());

      if (! _lifecycle.toStarting()) {
        return false;
      }

      _startTime = CurrentTime.currentTime();

      _lifecycle.toStarting();
      
      startImpl();

      _lifecycle.toActive();
      
      return true;
    } catch (RuntimeException e) {
      log.log(Level.WARNING, e.toString(), e);

      _lifecycle.toError();

      throw e;
    } catch (Throwable e) {
      log.log(Level.WARNING, e.toString(), e);

      _lifecycle.toError();

      // if the server can't start, it needs to completely fail, especially
      // for the watchdog
      throw new RuntimeException(e);

      // log.log(Level.WARNING, e.toString(), e);

      // _configException = e;
    } finally {
      thread.setContextClassLoader(oldLoader);
    }
  }
1295091
public void start() {
        //log.info("Stream start: {}", publishedName);
        checkVideoCodec = true;
        checkAudioCodec = true;
        firstPacketTime = -1;
        latestTimeStamp = -1;
        bytesReceived = 0;
        IConsumerService consumerManager = (IConsumerService) getScope().getContext().getBean(IConsumerService.KEY);
        connMsgOut = consumerManager.getConsumerOutput(this);
        if (connMsgOut != null && connMsgOut.subscribe(this, null)) {
            // technically this would be a 'start' time
            startTime = System.currentTimeMillis();
        } else {
            log.warn("Subscribe failed");
        }
        setState(StreamState.STARTED);
    }
236292
def start(self):
        
        # Subscribe to broadcast prompts published by a process
        # application in the parent operating system process.
        subscribe(handler=self.forward_prompt, predicate=self.is_prompt)

        # Initialise the system actor.
        msg = SystemInitRequest(
            self.system.process_classes,
            self.infrastructure_class,
            self.system.followings,
            self.pipeline_ids
        )
        response = self.actor_system.ask(self.system_actor, msg)

        # Keep the pipeline actor addresses, to send prompts directly.
        assert isinstance(response, SystemInitResponse), type(response)

        assert list(response.pipeline_actors.keys()) == self.pipeline_ids, (
            "Configured pipeline IDs mismatch initialised system {} {}").format(
            list(self.pipeline_actors.keys()), self.pipeline_ids
        )

        self.pipeline_actors = response.pipeline_actors
1221803
def start(self):
        """"""
        if self.started:
            raise ConnectorStartedError()

        self.started = True

        try:
            self.connect_watcher.start()
            self.timeout_watcher.start()
            self.sock.connect(self.addr)
        except IOError as e:
            self.errored = True
            self._finish()
            self.deferred.errback(e)

        return self.deferred
595102
def start(self):
        
        self.thread = threading.Thread(target=self._animate)
        self.thread.start()
        return
547038
private void startWatcher() {

        if (m_watcher == null) {
            try {
                m_watcher = new CmsUploadTimeoutWatcher(this);
                m_watcher.start();
            } catch (Exception e) {
                LOG.info(
                    Messages.get().getBundle().key(Messages.LOG_UPLOAD_CREATE_WATCH_DOG_2, getId(), e.getMessage()));
            }
        }
    }
1008544
public final void start() {
    if (this.started) {
      log.warn(String.format("Reporter %s has already been started.", this.name));
      return;
    }
    try {
      startImpl();
      this.started = true;
    } catch (Exception exception) {
      log.warn(String.format("Reporter %s did not start correctly.", this.name), exception);
    }
  }
1076426
@Override
    public void run() {

        try {

            // Set up
            Path path = FileSystems.getDefault().getPath(this.path);
            watcher = FileSystems.getDefault().newWatchService();
            Scanner.start(path, watcher);

            while (true) {

                // Reload when notified
                synchronized (this) {
                    this.wait();
                }

                // Keep reloading until all changes have notified:
                while (reloadRequested) {
                    reloadRequested = false;
                    Reflections reflections = ClassFinder.newReflections();
                    ApiHandler.setupApi(reflections);
                    Main.mainHandler.setupFilters(reflections);
                    Main.mainHandler.runStartups(reflections);
                }

            }

        } catch (IOException | InterruptedException e) {
            try {
                shutdown();
                throw new RuntimeException("Error in " + ClassReloader.class.getSimpleName() + ", exiting.", e);
            } catch (IOException e1) {
                e.printStackTrace();
            }
        }

    }
355997
public function start() {
        if (!$this->isStarted) {
            $this->generateIpcServer();
            $this->isStarted = true;
            for ($i=0;$i<$this->poolSizeMin;$i++) {
                $this->spawnWorker();
            }
            $this->registerTaskTimeoutWatcher();
        }

        return $this;
    }
1122605
def _start_watching_blocks(self):
        '''
        
        '''
        if sum(map(len, (self.solid_watchers, self.block_watchers))) == 1:
            eth.filter('latest').watch(self._new_block)
736101
public void start()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "start");

        int priorityDelta = obtainIntConfigParameter(_msi,
                                                     MessageStoreConstants.PROP_JDBC_SPILL_THREAD_PRIORITY_DELTA,
                                                     MessageStoreConstants.PROP_JDBC_SPILL_THREAD_PRIORITY_DELTA_DEFAULT,
                                                     Thread.MIN_PRIORITY - Thread.NORM_PRIORITY,
                                                     Thread.MAX_PRIORITY - Thread.NORM_PRIORITY);

        _threads = new Thread[_maxThreads];
        _workers = new SpillDispatcherThread[_maxThreads];

        synchronized(this)
        {
            _stopRequested = false;
            _running = true;
        }

        // Get the ME_UUID so that we can tell which ME our
        // threads belong to.
        String meUUID = "";
        if (_msi != null)
        {
            JsMessagingEngine me = _msi._getMessagingEngine();
            if (me != null)
            {
                meUUID = me.getUuid().toString()+"-";
            }
        }

        for (int i = 0; i < _maxThreads; i++)
        {
            String threadName = "sib.SpillDispatcher-"+meUUID+i;
            _workers[i] = new SpillDispatcherThread(i, threadName);
            _threads[i] = new Thread(_workers[i], threadName);
            _threads[i].setDaemon(true);
            _threads[i].setPriority(Thread.NORM_PRIORITY + priorityDelta);
            _threads[i].start();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "start");
    }
198156
def start(self):
        """"""
        if self.closed:
            raise ConnectionClosed()

        self.read_watcher.start()
        if self.write == self.buffered_write:
            self.write_watcher.start()