def setServiceParent(self, parent): """ @type parent: L{buildbot.master.BuildMaster} """ StatusReceiverMultiService.setServiceParent(self, parent) self.master_status = self.parent self.master_status.subscribe(self)
def __init__(self, api_token, announce_room_id, room_id, localhost_replace=False, **kwargs): StatusReceiverMultiService.__init__(self) self.api_token = api_token self.announce_room_id = announce_room_id self.room_id = room_id self.localhost_replace = localhost_replace
def __init__(self, weburl, localhost_replace=False, username=None, icon=None, notify_on_success=True, notify_on_failure=True, **kwargs): """ Creates a SlackStatusPush status service. :param weburl: Your Slack weburl :param localhost_replace: If your Buildbot web fronted doesn't know its public address it will use "localhost" in its links. You can change this by setting this variable to true. :param username: The user name of the "user" positing the messages on Slack. :param icon: The icon of the "user" posting the messages on Slack. :param notify_on_success: Set this to False if you don't want messages when a build was successful. :param notify_on_failure: Set this to False if you don't want messages when a build failed. """ StatusReceiverMultiService.__init__(self) self.weburl = weburl self.localhost_replace = localhost_replace self.username = username self.icon = icon self.notify_on_success = notify_on_success self.notify_on_failure = notify_on_failure self.watched = []
def __init__(self, server, username, reviewCB=DEFAULT_REVIEW, startCB=None, port=29418, reviewArg=None, startArg=None, summaryCB=DEFAULT_SUMMARY, summaryArg=None, identity_file=None, **kwargs): StatusReceiverMultiService.__init__(self) # If neither reviewCB nor summaryCB were specified, default to sending # out "summary" reviews. But if we were given a reviewCB and only a # reviewCB, disable the "summary" reviews, so we don't send out both # by default. if reviewCB is DEFAULT_REVIEW and summaryCB is DEFAULT_SUMMARY: reviewCB = None summaryCB = defaultSummaryCB if reviewCB is DEFAULT_REVIEW: reviewCB = None if summaryCB is DEFAULT_SUMMARY: summaryCB = None # Parameters. self.gerrit_server = server self.gerrit_username = username self.gerrit_port = port self.gerrit_version = None self.gerrit_version_time = 0 self.gerrit_identity_file = identity_file self.reviewCB = reviewCB self.reviewArg = reviewArg self.startCB = startCB self.startArg = startArg self.summaryCB = summaryCB self.summaryArg = summaryArg
def __init__(self, weburl, localhost_replace=False, username=None, icons=None, builders=None, notify_on_success=True, notify_on_failure=True, **kwargs): """ Creates a SlackStatusPush status service. :param weburl: Your Slack weburl :param localhost_replace: If your Buildbot web fronted doesn't know its public address it will use "localhost" in its links. You can change this by setting this variable to true. :param username: The user name of the "user" positing the messages on Slack. :param icons: tuple str (succ, fail) emoji names or icon urls :param notify_on_success: Set this to False if you don't want messages when a build was successful. :param notify_on_failure: Set this to False if you don't want messages when a build failed. :param builders: List of builder names to filter on. The default value of None will result in notifications for every builder. """ StatusReceiverMultiService.__init__(self) self.weburl = weburl self.localhost_replace = localhost_replace self.username = username self.icons = icons self.builders = builders self.notify_on_success = notify_on_success self.notify_on_failure = notify_on_failure self.watched = []
def __init__(self, api_token, room_id, localhost_replace=False, get_additional_info=None, **kwargs): StatusReceiverMultiService.__init__(self) self.api_token = api_token self.room_id = room_id self.localhost_replace = localhost_replace self.get_additional_info = get_additional_info
def __init__(self, settings_mod, queue=None, path=None, filter=True, bufferDelay=1, retryDelay=5, blackList=None): """ @filter: when True (default), removes all "", None, False, [] or {} entries. @bufferDelay: amount of time events are queued before sending, to reduce the number of push requests rate. This is the delay between the end of a request to initializing a new one. @retryDelay: amount of time between retries when no items were pushed on last serverPushCb call. @blackList: events that shouldn't be sent. """ setup_environ(settings_mod) from django.core.cache import cache StatusReceiverMultiService.__init__(self) # Parameters. self.cache = cache self.filter = filter self.bufferDelay = bufferDelay self.retryDelay = retryDelay self.blackList = blackList # Other defaults. # IDelayedCall object that represents the next queued push. self.task = None self.stopped = False self.lastIndex = -1 self.state = {} self.state['started'] = str(datetime.datetime.utcnow()) self.state['next_id'] = 1 self.state['last_id_pushed'] = 0
def __init__(self, url, username=None, channel=None, localhost_replace=False, *args, **kwargs): self.url = url self.username = username self.channel = channel self.localhost_replace = localhost_replace self.master_status = None StatusReceiverMultiService.__init__(self, *args, **kwargs)
def __init__(self, serverPushCb, queue=None, path=None, filter=True, bufferDelay=1, retryDelay=5, blackList=None): """ @serverPushCb: callback to be used. It receives 'self' as parameter. It should call self.queueNextServerPush() when it's done to queue the next push. It is guaranteed that the queue is not empty when this function is called. @queue: a item queue that implements IQueue. @path: path to save config. @filter: when True (default), removes all "", None, False, [] or {} entries. @bufferDelay: amount of time events are queued before sending, to reduce the number of push requests rate. This is the delay between the end of a request to initializing a new one. @retryDelay: amount of time between retries when no items were pushed on last serverPushCb call. @blackList: events that shouldn't be sent. """ StatusReceiverMultiService.__init__(self) # Parameters. self.queue = queue if self.queue is None: self.queue = MemoryQueue() self.queue = IndexedQueue(self.queue) self.path = path self.filter = filter self.bufferDelay = bufferDelay self.retryDelay = retryDelay if not callable(serverPushCb): raise NotImplementedError('Please pass serverPushCb parameter.') def hookPushCb(): # Update the index so we know if the next push succeed or not, don't # update the value when the queue is empty. if not self.queue.nbItems(): return self.lastIndex = self.queue.getIndex() return serverPushCb(self) self.serverPushCb = hookPushCb self.blackList = blackList # Other defaults. # IDelayedCall object that represents the next queued push. self.task = None self.stopped = False self.lastIndex = -1 self.state = {} self.state['started'] = str(datetime.datetime.utcnow()) self.state['next_id'] = 1 self.state['last_id_pushed'] = 0 # Try to load back the state. if self.path and os.path.isdir(self.path): state_path = os.path.join(self.path, 'state') if os.path.isfile(state_path): with open(state_path, 'r') as f: self.state.update(json.load(f)) if self.queue.nbItems(): # Last shutdown was not clean, don't wait to send events. self.queueNextServerPush()
def __init__(self): StatusReceiverMultiService.__init__(self) timer = TimerService(60*60, self.report_pending_builds) timer.setServiceParent(self) timer = TimerService(30, self.metrics) timer.setServiceParent(self)
def startService(self): StatusReceiverMultiService.startService(self) self.agent = twisted.web.client.Agent(reactor, WebClientContextFactory()) self.status = self.parent.getStatus() self.status.subscribe(self)
def startService(self): print """Starting up.""" if self.summaryCB: # TODO: handle deferred self.summarySubscribe().addErrback(log.err, 'while subscribing') StatusReceiverMultiService.startService(self)
def __init__(self, subdomain, api_token, channel_name, localhost_replace=False, builder_name=False, **kwargs): StatusReceiverMultiService.__init__(self) self.subdomain = subdomain self.api_token = api_token self.channel_name = channel_name self.localhost_replace = localhost_replace self.builder_name = builder_name
def __init__(self, slaves): StatusReceiverMultiService.__init__(self) assert isinstance(slaves,list) for name in slaves: assert isinstance(name,str) self.slaves = slaves
def startService(self): StatusReceiverMultiService.startService(self) if self.dry_run: return self.integrator_starting = self._start_integrator() common.log_on_error(self.integrator_starting, 'Could not start integrator') self._run_when_started(self.integrator.poll_builds) self.parent.getStatus().subscribe(self)
def startService(self): """Start the service and subscribe for updates.""" self._create_logger() self._create_event_logger() self._create_ts_mon_logger() StatusReceiverMultiService.startService(self) self.status = self.parent.getStatus() self.status.subscribe(self)
def startService(self): """Twisted service is starting up.""" StatusReceiverMultiService.startService(self) # Subscribe to get status updates. self._status = self.parent.getStatus() self._status.subscribe(self) # Schedule our first push. self._schedulePush()
def __init__(self, gerrit_host, review_factory=None): """Creates a TryJobGerritStatus. Args: gerrit_host: a URL of the Gerrit instance. review_factory: a function (self, builder_name, build, result) => review, where review is a dict described in Gerrit docs: https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#review-input """ StatusReceiverMultiService.__init__(self) self.review_factory = review_factory or TryJobGerritStatus.createReview self.agent = GerritAgent(gerrit_host) self.status = None
def __init__(self, logfile='status.log'): """Create a StatusEventLogger. Args: logfile: base filename for events to be written to. """ self.logfile = logfile # Will be initialized in startService self.logger = None self.status = None self._active = False self._last_checked_active = 0 # Can't use super because StatusReceiverMultiService is an old-style class. StatusReceiverMultiService.__init__(self)
def __init__(self, integrator, buildbucket_service_factory, dry_run): """Creates a new BuildBucketStatus. Args: integrator (BuildBucketIntegrator): integrator to notify about status changes. buildbucket_service_factory (function): returns a DeferredResource as Deferred that will be used to access buildbucket service API. dry_run (bool): if True, do not start integrator. """ StatusReceiverMultiService.__init__(self) self.integrator = integrator self.buildbucket_service_factory = buildbucket_service_factory self.dry_run = dry_run self.integrator_starting = None
def __init__(self, base_url, user, password): """ :param base_url: The base url of the stash host, up to the path. For example, https://stash.example.com/ :param user: The stash user to log in as using http basic auth. :param password: The password to use with the stash user. :return: """ StatusReceiverMultiService.__init__(self) if not base_url.endswith('/'): base_url += '/' self.base_url = '%srest/build-status/1.0/commits/' % (base_url, ) self.auth = b64encode('%s:%s' % (user, password)) self._sha = Interpolate('%(src::revision)s') self.master_status = None
def __init__( self, api_token, localhost_replace=False, endpoint="data.logentries.com", port=10000, tls=False, **kwargs ): StatusReceiverMultiService.__init__(self) self.api_token = api_token self.localhost_replace = localhost_replace self.endpoint = endpoint self.port = port self.tls = tls self.f = PlainTextAppenderFactory(token=api_token) if tls: self.r = reactor.connectSSL(endpoint, port, self.f, ssl.ClientContextFactory()) else: self.r = reactor.connectTCP(endpoint, port, self.f)
def startService(self): """Twisted service is starting up.""" StatusReceiverMultiService.startService(self) # Subscribe to get status updates. self._status = self.parent.getStatus() self._status.subscribe(self) @defer.inlineCallbacks def start_loop(): # Load and start our master push resource. self._res = yield self._loadResource() self._res.start() # Schedule our first push. self._schedulePush() reactor.callWhenRunning(start_loop)
def __init__(self, server, username, reviewCB=defaultReviewCB, port=29418, reviewArg=None, **kwargs): """ @param server: Gerrit SSH server's address to use for push event notifications. @param username: Gerrit SSH server's username. @param reviewCB: Callback that is called each time a build is finished, and that is used to define the message and review approvals depending on the build result. @param port: Gerrit SSH server's port. @param reviewArg: Optional argument that is passed to the callback. """ StatusReceiverMultiService.__init__(self) # Parameters. self.gerrit_server = server self.gerrit_username = username self.gerrit_port = port self.reviewCB = reviewCB self.reviewArg = reviewArg
def stopService(self): """Shutting down.""" self.finalPush() self.stopped = True # Make sure all Deferreds are called on time and in a sane order. defers = filter(None, [d, StatusReceiverMultiService.stopService(self)]) return defer.DeferredList(defers)
def __init__(self, activeMaster, server=None, master=None, discoveryUrlTemplate=None, pushInterval=None): """ Instantiates a new StatusPush service. The server and master values are used to form the BuildBot URL that a given build references. For example: - server: http://build.chromium.org/p - master: chromium Args: activeMaster: The current Master instance. server: (str) The server URL value for the status pushes. master: (str) The master name. discoveryUrlTemplate: (str) If not None, the discovery URL template to use for 'chrome-build-extract' cloud endpoint API service discovery. pushInterval: (number/timedelta) The data push interval. If a number is supplied, it is the number of seconds. """ assert activeMaster, 'An active master must be supplied.' StatusReceiverMultiService.__init__(self) # Infer server/master from 'buildbot_url' master configuration property, # if possible. if hasattr(activeMaster, 'buildbot_url') and not (server and master): inf_server, inf_master = self.inferServerMaster(activeMaster.buildbot_url) server = server or inf_server master = master or inf_master assert server and master, 'A server and master value must be supplied.' # Parameters. self.activeMaster = activeMaster self.server = server self.master = master self.discoveryUrlTemplate = (discoveryUrlTemplate or CBE_DISCOVERY_SERVICE_URL) self.pushInterval = self._getTimeDelta(pushInterval or self.DEFAULT_PUSH_INTERVAL_SEC) self._status = None self._res = None self._updated_builds = set() self._pushTimer = None self._sequence = 0
def __init__(self, server, username, reviewCB=DEFAULT_REVIEW, startCB=None, port=29418, reviewArg=None, startArg=None, summaryCB=DEFAULT_SUMMARY, summaryArg=None, identity_file=None, **kwargs): """ @param server: Gerrit SSH server's address to use for push event notifications. @param username: Gerrit SSH server's username. @param reviewCB: Callback that is called each time a build is finished, and that is used to define the message and review approvals depending on the build result. @param startCB: Callback that is called each time a build is started. Used to define the message sent to Gerrit. @param port: Gerrit SSH server's port. @param reviewArg: Optional argument passed to the review callback. @param startArg: Optional argument passed to the start callback. @param summaryCB: Callback that is called each time a buildset finishes, and that is used to define a message and review approvals depending on the build result. @param summaryArg: Optional argument passed to the summary callback. """ StatusReceiverMultiService.__init__(self) # If neither reviewCB nor summaryCB were specified, default to sending # out "summary" reviews. But if we were given a reviewCB and only a # reviewCB, disable the "summary" reviews, so we don't send out both # by default. if reviewCB is DEFAULT_REVIEW and summaryCB is DEFAULT_SUMMARY: reviewCB = None summaryCB = defaultSummaryCB if reviewCB is DEFAULT_REVIEW: reviewCB = None if summaryCB is DEFAULT_SUMMARY: summaryCB = None # Parameters. self.gerrit_server = server self.gerrit_username = username self.gerrit_port = port self.gerrit_version = None self.gerrit_version_time = 0 self.gerrit_identity_file = identity_file self.reviewCB = reviewCB self.reviewArg = reviewArg self.startCB = startCB self.startArg = startArg self.summaryCB = summaryCB self.summaryArg = summaryArg
def startService(self): """Start the service and subscribe for updates.""" logger = logging.getLogger(__name__) logger.propagate = False logger.setLevel(logging.INFO) # %(bbEvent)19s because builderChangedState is 19 characters long formatter = logging.Formatter('%(asctime)s - %(bbEvent)19s - %(message)s') # Use delay=True so we don't open an empty file while self.active=False. handler = TimedRotatingFileHandler( os.path.join(self.parent.basedir, self.logfile), when='H', interval=1, delay=True) handler.setFormatter(formatter) logger.addHandler(handler) self.logger = logger StatusReceiverMultiService.startService(self) self.status = self.parent.getStatus() self.status.subscribe(self)
def __init__(self, token, repoOwner, repoName, sha=None, startDescription=None, endDescription=None, baseURL=None): """ Token for GitHub API. """ if not GitHubAPI: config.error("GitHubStatus requires txgithub package installed") StatusReceiverMultiService.__init__(self) self._sha = sha or Interpolate("%(src::revision)s") self._repoOwner = repoOwner self._repoName = repoName self._startDescription = startDescription or "Build started." self._endDescription = endDescription or "Build done." self._github = GitHubAPI(oauth2_token=token, baseURL=baseURL) self._status = None
def __init__(self, gerrit_host, review_factory=None, cq_builders=None, **kwargs): """Creates a TryJobGerritStatus. Args: gerrit_host: a URL of the Gerrit instance. review_factory: a function (self, builder_name, build, result) => review, where review is a dict described in Gerrit docs: https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#review-input cq_builders: a list of buildernames, if specified, patchset will be submitted if all builders have completed successfully. kwargs: keyword arguments passed to GerritAgent. """ StatusReceiverMultiService.__init__(self) self.review_factory = review_factory or TryJobGerritStatus.createReview self.agent = GerritAgent(gerrit_host, **kwargs) self.status = None self.cq_builders = cq_builders
def setServiceParent(self, parent): StatusReceiverMultiService.setServiceParent(self, parent) self.master_status = self.parent self.master_status.subscribe(self) self.master = self.master_status.master
def startService(self): self.status = self.parent self.master = self.status.master StatusReceiverMultiService.startService(self) self.status.subscribe(self)
def startService(self): StatusReceiverMultiService.startService(self) self._status = self.parent.getStatus() self._status.subscribe(self) log.msg("GitHubStatus: Service started.")
def stopService(self): StatusReceiverMultiService.stopService(self) self._status.unsubscribe(self) log.msg("GitHubStatus: Service stopped.")
def setServiceParent(self, parent): StatusReceiverMultiService.setServiceParent(self, parent) self.setup()
def disownServiceParent(self): self.master_status.unsubscribe(self) self.master_status = None return StatusReceiverMultiService.disownServiceParent(self)
def disownServiceParent(self): """Unsubscribe from watched builders""" for w in self.watched: w.unsubscribe(self) return StatusReceiverMultiService.disownServiceParent(self)
def __init__(self): StatusReceiverMultiService.__init__(self) timer = TimerService(30, self.metrics) timer.setServiceParent(self)
def startService(self): print """Starting up.""" if self.summaryCB: self.summarySubscribe() StatusReceiverMultiService.startService(self)
def startService(self): print """Starting up StashStatusPush""" self.summarySubscribe() StatusReceiverMultiService.startService(self)
def startService(self): StatusReceiverMultiService.startService(self) self.status = self.parent.getStatus() # pylint: disable=W0201 self.status.subscribe(self)
def startService(self): StatusReceiverMultiService.startService(self) self._status = self.parent.getStatus() self._status.subscribe(self)
def startService(self): log.msg("""Starting up StashStatusPush""") self.summarySubscribe() StatusReceiverMultiService.startService(self)
def __init__(self, serverPushCb, queue=None, path=None, filter=True, bufferDelay=1, retryDelay=5, blackList=None): """ @serverPushCb: callback to be used. It receives 'self' as parameter. It should call self.queueNextServerPush() when it's done to queue the next push. It is guaranteed that the queue is not empty when this function is called. @queue: a item queue that implements IQueue. @path: path to save config. @filter: when True (default), removes all "", None, False, [] or {} entries. @bufferDelay: amount of time events are queued before sending, to reduce the number of push requests rate. This is the delay between the end of a request to initializing a new one. @retryDelay: amount of time between retries when no items were pushed on last serverPushCb call. @blackList: events that shouldn't be sent. """ StatusReceiverMultiService.__init__(self) # Parameters. self.watched = [] self.queue = queue if self.queue is None: self.queue = MemoryQueue() self.queue = IndexedQueue(self.queue) self.path = path self.filter = filter self.bufferDelay = bufferDelay self.retryDelay = retryDelay if not callable(serverPushCb): raise NotImplementedError('Please pass serverPushCb parameter.') def hookPushCb(): # Update the index so we know if the next push succeed or not, don't # update the value when the queue is empty. if not self.queue.nbItems(): return defer.succeed(None) self.lastIndex = self.queue.getIndex() return defer.maybeDeferred(serverPushCb, self) self.serverPushCb = hookPushCb self.blackList = blackList # Other defaults. # IDelayedCall object that represents the next queued push. self.task = None self.stopped = False self.lastIndex = -1 self.state = {} self.state['started'] = str(datetime.datetime.utcnow()) self.state['next_id'] = 1 self.state['last_id_pushed'] = 0 # Try to load back the state. if self.path and os.path.isdir(self.path): state_path = os.path.join(self.path, 'state') if os.path.isfile(state_path): with open(state_path, 'r') as f: self.state.update(json.load(f)) if self.queue.nbItems(): # Last shutdown was not clean, don't wait to send events. self.queueNextServerPush()
def disownServiceParent(self): self.master_status.unsubscribe(self) self.master_status = None for w in self.watched: w.unsubscribe(self) return StatusReceiverMultiService.disownServiceParent(self)
def __init__(self, api_token, room_id, localhost_replace=False, **kwargs): StatusReceiverMultiService.__init__(self) self.api_token = api_token self.room_id = room_id self.localhost_replace = localhost_replace
def __init__(self, gerrit_url, buildbot_url): StatusReceiverMultiService.__init__(self) self.agent = GerritAgent(gerrit_url) self.buildbot_url = buildbot_url
def stopService(self): self.integrator.stop() StatusReceiverMultiService.stopService(self)
def startService(self): print """Starting up.""" StatusReceiverMultiService.startService(self) self.status = self.parent.getStatus() self.status.subscribe(self)
def stopService(self): StatusReceiverMultiService.stopService(self) self._status.unsubscribe(self)
def __init__(self, url, username=None, channel=None, *args, **kwargs): self.url = url self.username = username self.channel = channel self.master_status = None StatusReceiverMultiService.__init__(self, *args, **kwargs)
def setServiceParent(self, parent): StatusReceiverMultiService.setServiceParent(self, parent) self.master = parent.master s = self.master.getStatus() s.subscribe(self)
def startService(self): """Starting up.""" StatusReceiverMultiService.startService(self) self.status = self.parent.getStatus() self.status.subscribe(self) self.initialPush()
def __init__(self): StatusReceiverMultiService.__init__(self) self.status = None self.thread_pool = threadpool.ThreadPool(1, 1, 'MonitoringStatusReceiver') self.loop = task.LoopingCall(self.updateMetricsAndFlush)