def startService(self):
		if self.loop != -1 or self._state == 'started':
			msg(self.name, 'start fail - already started', system='-')

			# Already started
			return

		# State
		self._state = 'starting'

		# Show info
		msg(self.name, 'start', system='-')

		# Cancel stop
		if self._stopCall:
			self._stopCall.cancel()
			self._stopCall = None

			# Call stop
			self._stopDeferred.callback(0)
			self._stopDeferred = None

		Service.startService(self)

		self.loop = 0
		self._state = 'started'

		# Start
		for name, (run, interval) in self._runs.iteritems():
			run.start(interval, now=False)

		# Show info
		msg(self.name, 'started', system='-')

 def stopService(self):
     print 'Stop PullRequest service: %s ...' % self.context.name
     Service.stopService(self)
     if self.watchLoop:
         self.watchLoop.stop()
     if self.schedulerLoop:
         self.schedulerLoop.stop()

		def s2(code, self=self):
			try:
				if code != 1:
					# Cancel stop
					return

				if not (self._state == 'stopping' and (self._process + self._workers) == 0):
					err(RuntimeError('{0} stop error: state-{1} p{2} w{3}'.format(
						self.name,
						self._state,
						self._process,
						self._workers,
					)))

				self._stopCall = None
				self._stopDeferred = None

				# Inside
				Service.stopService(self)

				self._state = 'stopped'

				# Show info
				msg(self.name, 'stopped', system='-')
			except:
				err()

    def startService(self, _reactor=reactor):
        assert not self._already_started, "can start the PullRequest service once"
        self._already_started = True

        Service.startService(self)

        print 'PullRequest service starting: %s ...' % self.context.name

        d = defer.Deferred()
        _reactor.callWhenRunning(d.callback, None)
        yield d

        try:
            from .serviceloops import PullRequestsWatchLoop, SchedulerLoop

            self.watchLoop = PullRequestsWatchLoop(self.context)
            yield self.watchLoop.start()

            self.schedulerLoop = SchedulerLoop(self.context)
            yield self.schedulerLoop.start();
        except:
            f = failure.Failure()
            log.err(f, 'while starting PullRequest service: %s' % self.context.name)
            _reactor.stop()

        log.msg('PullRequest service is running: %s' % self.context.name)

 def stopService(self):
     ntasks = len(self._tasks)
     for task in self.iterTasks():
         task.close()
     self._tasks = set()
     Service.stopService(self)
     logger.debug("stopped scheduler (%i tasks killed)" % ntasks)

 def startService(self):
     """
     Called when the plugin is started.  If a plugin needs to perform any
     startup tasks, they should override this method (be sure to chain up
     to the parent method) and perform them here.
     """
     Service.startService(self)

	def stopService(self):
		if self.running:
			Service.stopService(self)
			log.info("Stopping master heartbeat service...")
			return self._hb.stop()
		else:
			return defer.succeed(None)

    def startService(self):
        """
        Make sure that the necessary properties are set on the root Flocker zfs
        storage pool.
        """
        Service.startService(self)

        # These next things are logically part of the storage pool creation
        # process.  Since Flocker itself doesn't yet have any involvement with
        # that process, it's difficult to find a better time/place to set these
        # properties than here - ie, "every time we're about to interact with
        # the storage pool".  In the future it would be better if we could do
        # these things one-off - sometime around when the pool is created or
        # when Flocker is first installed, for example.  Then we could get rid
        # of these operations from this method (which eliminates the motivation
        # for StoragePool being an IService implementation).
        # https://clusterhq.atlassian.net/browse/FLOC-635

        # Set the root dataset to be read only; IService.startService
        # doesn't support Deferred results, and in any case startup can be
        # synchronous with no ill effects.
        _sync_command_error_squashed(
            [b"zfs", b"set", b"readonly=on", self._name], self.logger)

        # If the root dataset is read-only then it's not possible to create
        # mountpoints in it for its child datasets.  Avoid mounting it to avoid
        # this problem.  This should be fine since we don't ever intend to put
        # any actual data into the root dataset.
        _sync_command_error_squashed(
            [b"zfs", b"set", b"canmount=off", self._name], self.logger)

 def startService(self):
     Service.startService(self)
     self.configuration.load()
     self.connectionRegistry = \
         ConnectionRegistry( self.createConfiguredDeviceMap())
     self.timer.start(self.updateInterval).addErrback(log.err)
     self.statusIcon.show()

    def startService(self):
        Service.startService(self)

        # Now we're ready to build the command lines and actualy add the
        # processes to procmon.  This step must be done prior to setting
        # active to 1
        for processObject, env in self.processObjects:
            name = processObject.getName()
            self.addProcess(
                name,
                processObject.getCommandLine(),
                env=env
            )
            self._extraFDs[name] = processObject.getFileDescriptors()

        self.active = 1
        delay = 0

        if config.MultiProcess.StaggeredStartup.Enabled:
            delay_interval = config.MultiProcess.StaggeredStartup.Interval
        else:
            delay_interval = 0

        for name in self.processes.keys():
            if name.startswith("caldav"):
                when = delay
                delay += delay_interval
            else:
                when = 0
            callLater(when, self.startProcess, name)

        self.consistency = callLater(
            self.consistencyDelay,
            self._checkConsistency
        )

 def stopService(self):
     """
     Stop the service by calling stored function
     """
     Service.stopService(self)
     if self._stop:
         return self._stop()

   def startService(self):
      ## this implementation of startService overrides the original

      if self.running:
         return

      Service.startService(self)
      pingFunc, args, kwargs = self.call

      def pingFail(failure):
         failure.trap(defer.TimeoutError)
         #print 'Call to %s timed out. Calling onTimeout and stopping service.' % (pingFunc.__name__,)
         self.onTimeout()
         self.stopService()

      def sendPing():
         self.ping = defer.Deferred()
         ## the pingFunc is assumed to be a syncronous function that
         ## sends the request along to the client and returns immediately.
         ## TODO: maybe assume that this returns a deferred that is fired when
         ## the response is received?
         pingFunc(*args, **kwargs)
         self.ping.addErrback(pingFail)
         self.ping.setTimeout(self.step - 1) # timeout if no response before next iteration
         return self.ping ## LoopingCall will reschedule as soon as this fires

      self._loop = LoopingCall(sendPing)
      self._loop.start(self.step, now=self.now).addErrback(self._failed)

 def startService(self):
     Service.startService(self)
     self._registered = False
     self._timer_service = TimerService(
         self.check_interval.total_seconds(), self._check_certs)
     self._timer_service.clock = self._clock
     self._timer_service.startService()

 def __init__(self):
     Service.__init__(self)
     self.seq   = -1
     self.freq  = 4000 
     self.mag   = 15.0 
     self.tamb  = 3 
     self.tsky  = self.tamb - 30

	def startService(self):
		Service.startService(self)

		log.info("Starting RPC service...")
		self.cleanSocket(None)
		self._localPort=reactor.listenUNIX(core.cfg['UNIX_PORT'], pb.PBServerFactory(LocalRPC(self._master)))
		self._remotePort=reactor.listenTCP(core.cfg['TCP_PORT'], pb.PBServerFactory(RemoteRPC(self._master)))

 def stopService(self):
     try:
         file_cache_idxs = MetricCache.getAllFileCaches()
         writeCachedDataPointsWhenStop(file_cache_idxs)
     except Exception as e:
         log.err('write error when stopping service: %s' % e)
     Service.stopService(self)

 def stopService(self):
     """
     Stop service by stopping the timerservice and disconnecting cass client
     """
     Service.stopService(self)
     d = self._service.stopService()
     return d.addCallback(lambda _: self._client.disconnect())

 def startService(self):
     log.info("starting DBase Service")
     yield self.schema()
     self.startTasks()
     # Remainder Service initialization
     Service.startService(self)
     log.info("Database operational.")

    def startService(self):
        app = self._prov_service.app
        dhcp_request_processing_service = self._dhcp_process_service.dhcp_request_processing_service
        if self._config['general.rest_authentication']:
            credentials = (self._config['general.rest_username'],
                           self._config['general.rest_password'])
            server_resource = new_restricted_server_resource(app, dhcp_request_processing_service, credentials)
            logger.info('Authentication is required for REST API')
        else:
            server_resource = new_server_resource(app, dhcp_request_processing_service)
            logger.warning('No authentication is required for REST API')
        root_resource = Resource()
        root_resource.putChild('provd', server_resource)
        rest_site = Site(root_resource)

        port = self._config['general.rest_port']
        interface = self._config['general.rest_ip']
        if interface == '*':
            interface = ''
        logger.info('Binding HTTP REST API service to "%s:%s"', interface, port)
        if self._config['general.rest_ssl']:
            logger.info('SSL enabled for REST API')
            context_factory = ssl.DefaultOpenSSLContextFactory(self._config['general.rest_ssl_keyfile'],
                                                               self._config['general.rest_ssl_certfile'])
            self._tcp_server = internet.SSLServer(port, rest_site, context_factory, interface=interface)
        else:
            self._tcp_server = internet.TCPServer(port, rest_site, interface=interface)
        self._tcp_server.startService()
        Service.startService(self)

    def main(self):
        """Parse arguments and run the script's main function via ``react``."""
        # If e.g. --version is called this may throw a SystemExit, so we
        # always do this first before any side-effecty code is run:
        options = self._parse_options(self.sys_module.argv[1:])

        if self.logging:
            log_writer = eliot_logging_service(
                options.eliot_destination, self._reactor, True
            )
        else:
            log_writer = Service()
        log_writer.startService()

        # XXX: We shouldn't be using this private _reactor API. See
        # https://twistedmatrix.com/trac/ticket/6200 and
        # https://twistedmatrix.com/trac/ticket/7527
        def run_and_log(reactor):
            d = maybeDeferred(self.script.main, reactor, options)

            def got_error(failure):
                if not failure.check(SystemExit):
                    err(failure)
                return failure
            d.addErrback(got_error)
            return d
        try:
            self._react(run_and_log, [], _reactor=self._reactor)
        finally:
            log_writer.stopService()