def init_app(self, app): endpoint = app.config.setdefault("GITHUB_WEBHOOK_ENDPOINT", "/postreceive") secret = app.config.setdefault("GITHUB_WEBHOOK_SECRET", None) self._webhook = Webhook(app, endpoint=endpoint, secret=secret) app.extensions = getattr(app, "extensions", {}) app.extensions["github_webhook"] = self
def init_app(self, app): endpoint = app.config.setdefault('GITHUB_WEBHOOK_ENDPOINT', '/postreceive') secret = app.config.setdefault('GITHUB_WEBHOOK_SECRET', None) self._webhook = Webhook(app, endpoint=endpoint, secret=secret) app.extensions = getattr(app, 'extensions', {}) app.extensions['github_webhook'] = self
def create_app(): app = Flask(__name__) # Standard Flask app webhook = Webhook(app) # Defines '/postreceive' endpoint gitRepo = git.Repo("/meta") o = gitRepo.remotes.origin gitRepo.heads.master.set_tracking_branch(o.refs.master) gitRepo.heads.master.checkout() @app.route("/") # Standard Flask endpoint def on_get(): o.fetch() now = datetime.now() d1 = now.strftime("%Y/%m/%d %H:%M:%S") print(d1+" Git repo updated !") return "Git repo updated !" @webhook.hook() # Defines a handler for the 'push' event def on_push(data): print("Got push with: {0}".format(data)) o.fetch() gitRepo.git.clean("-f") gitRepo.git.reset("--hard", "origin/master") print("Git repo updated !") return "Git repo updated !" return app
class GithubWebhook(object): def __init__(self, app=None): if app is not None: self.init_app(app) def init_app(self, app): endpoint = app.config.setdefault('GITHUB_WEBHOOK_ENDPOINT', '/postreceive') secret = app.config.setdefault('GITHUB_WEBHOOK_SECRET', None) self._webhook = Webhook(app, endpoint=endpoint, secret=secret) app.extensions = getattr(app, 'extensions', {}) app.extensions['github_webhook'] = self def hook(self, event_type='push'): return self._webhook.hook(event_type=event_type)
class GithubWebhook(object): def __init__(self, app=None): if app is not None: self.init_app(app) def init_app(self, app): endpoint = app.config.setdefault("GITHUB_WEBHOOK_ENDPOINT", "/postreceive") secret = app.config.setdefault("GITHUB_WEBHOOK_SECRET", None) self._webhook = Webhook(app, endpoint=endpoint, secret=secret) app.extensions = getattr(app, "extensions", {}) app.extensions["github_webhook"] = self def hook(self, event_type="push"): return self._webhook.hook(event_type=event_type)
def do(self, event=None): app = Flask(__name__) @app.route("/") # Standard Flask endpoint def ping(): logging.info('got ping') event.set() return 'OK' webhook = Webhook(app) @webhook.hook() def on_push(data): logging.info('got github push') event.set() return 'OK' port = int(os.environ.get('UPDATER_PORT', '9345')) logging.info(f'running http server to updater in port {port}') app.run(host="0.0.0.0", port=port)
def __init__( self, config: Config, store: Storage, github: Github, repo: Repository, ): self.config = config self.github = github self.repo = repo self.command_handler = CommandHandler(config, store, repo) # Start a flash webserver self.app = Flask(__name__) webhook = Webhook( self.app, endpoint=self.config.webhook_path, secret=self.config.webhook_secret, ) @self.app.route("/") def hello_world(): return "Hello, world!" @webhook.hook("issue_comment") def on_issue_comment(data): log.debug( f"Got comment: {json.dumps(data, indent=4, sort_keys=True)}") self._process_comment(data) @webhook.hook("pull_request_review_comment") def on_pull_request_review_comment(data): log.debug( f"Got PR review comment: {json.dumps(data, indent=4, sort_keys=True)}" ) self._process_comment(data)
redirect, url_for, abort) from github_webhook import Webhook from dmsa import ddl, erd, __version__ from dmsa.utility import (get_template_models, get_service_version, get_template_dialects, ReverseProxied, dmsa_version) import dmsa.cache PERIODIC_REFRESH_DELAY = 3600 # seconds POST_HOOK_REFRESH_DELAY = 10 app = Flask('dmsa') app.wsgi_app = ReverseProxied(app.wsgi_app) dmsa.cache.set_cache_dir(app.instance_path) hmac_key = os.environ.get('DMSA_WEBHOOK_SECRET') webhook = Webhook(app, endpoint='/refresh', secret=hmac_key) def refresh_data_models_template(): """Retrieve the data models from the service and cache them""" get_template_models(app.config['service'], force_refresh=True) def refresh_data_models_template_and_reschedule(delay=None): """Refresh the data models summary data and optionally reschedule Arguments: delay - delay in seconds (to reschedule), or None (to not reschedule) """ refresh_data_models_template() if delay:
from github_webhook import Webhook from flask import Flask import os app = Flask(__name__) # Standard Flask app webhook = Webhook(app) # Defines '/postreceive' endpoint @app.route("/") # Standard Flask endpoint def hello_world(): return "Hello, World!" @webhook.hook() # Defines a handler for the 'push' event def on_push(data): print("Got push") os.system('sh deploy.sh ') if __name__ == "__main__": app.run(host="0.0.0.0", port=808)
import logging import os from functools import wraps import requests from flask import abort, Flask, request from flask import logging as flask_logging from github_webhook import Webhook from ipaddress import ip_address, ip_network app = Flask(__name__) webhook = Webhook(app, endpoint='/postreceive', secret=os.environ.get('GITHUB_WEBHOOK_SECRET')) @app.before_first_request def setup_logging(): if app.debug: return # Add handler to Flask logger to send records to gunicorn stderr. # https://github.com/benoitc/gunicorn/issues/379 handler = logging.StreamHandler() handler.setFormatter(logging.Formatter(flask_logging.PROD_LOG_FORMAT)) app.logger.addHandler(handler) app.logger.setLevel(logging.INFO) # ... and disable existing handlers to avoid duplicated entries app.config['LOGGER_HANDLER_POLICY'] = 'never'
app.config[ "SQLALCHEMY_DATABASE_URI"] = f"mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}/{MYSQL_DATABASE}" elif DATABASE_TYPE == "sqlite": app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///database/sponsorcord.db" else: raise Exception(f"invalid DATABASE_TYPE {DATABASE_TYPE}") app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # init db db.init_app(app) with app.app_context(): db.create_all() webhook = Webhook(app, endpoint="/github/webhook", secret=GITHUB_WEBHOOK_SECRET) def github_login_url(): return "https://github.com/login/oauth/authorize?%s" % "&".join(( f"client_id={GITHUB_CLIENT_ID}", f"redirect_uri={GITHUB_REDIRECT_URI}", )) def get_github_user_id(code): data = { "client_id": GITHUB_CLIENT_ID, "client_secret": GITHUB_CLIENT_SECRET, "code": code,
from github_webhook import Webhook from flask import Flask application = Flask(__name__) # Standard Flask application webhook = Webhook(application) # Defines '/postreceive' endpoint @application.route("/") # Standard Flask endpoint def hello_world(): return "Hello, World!" @webhook.hook() # Defines a handler for the 'push' event def on_push(data): print("Got push with: {0}".format(data)) if __name__ == "__main__": application.run(host="0.0.0.0", port=3000)
from flask import Flask from github_webhook import Webhook import telepot import utils GITHUB_URL = "https://github.com/" TOKEN = "484527904:AAHVkzp5hHuxWVfR0tYkIFPV-sgQkXQKqAQ" # CHANNEL = "-1001084328317" CHANNEL = "-398468065" SECRET = "Singapore2017" Bot = telepot.Bot(TOKEN) message = "<a href='{pusher_url}'>{pusher}</a> pushed to <a href='{branch_url}'>{branch_name}</a>:\n" commit_message = "{msg}<a href='{url}'>...</a>\n" application = Flask(__name__) webhook = Webhook(application, endpoint="/", secret=SECRET) @application.route("/hello") def hello(): print(1) return "<h1>Hello There!</h1>" @webhook.hook(event_type="ping") # Defines a handler for the 'push' event def on_ping(data): print("Got ping with: {0}".format(data)) @webhook.hook(event_type="push") # Defines a handler for the 'push' event def on_push(data):
rocketChatDomain = os.environ.get('ROCKET_DOMAIN') rocketChatChannel = os.environ.get('ROCKET_CHANNEL') webhookSecret = os.environ.get('WEBHOOK_SECRET') webhookPort = os.environ.get('WEBHOOOK_PORT') g = Github(ghAccessToken) rocketAPI = RocketChatAPI( settings={ 'username': rocketChatBotUsername, 'password': rocketChatBotPassword, 'domain': rocketChatDomain }) app = Flask(__name__) webhook = Webhook(app, secret=webhookSecret) def notifyInboundSolutionFocusTicket(data): app.logger.info('Checking if event is suitible...') # Check we really want to notift about this post if data['action'] != 'created': app.logger.info('Action is not type created, ignoring') return app.logger.info('Generating message') sender = data['sender']['login'] contentUrl = data['project_card']['content_url'] issueId = contentUrl.rsplit('/', 1)[-1] githubRepo = g.get_repo(data['repository']['id']) githubIssue = githubRepo.get_issue(int(issueId)) htmlURL = 'https://github.com/' + data['repository'][
from datetime import datetime from flask import current_app, request from github_webhook import Webhook from txsentinel.github import cache from txsentinel.github.tasks import maybe_merge webhook = Webhook(current_app, secret=current_app.config['GITHUB_WEBHOOK_SECRET']) @webhook.hook(event_type='push') def on_push(data): print('Got push with: {0}'.format(data)) @webhook.hook(event_type='pull_request_review') def on_pull_request_review(data): if data['review']['state'].lower() != 'approved': return print('Got pull request review with: {0}'.format(data)) maybe_merge.delay(data['repository']['full_name'], data['pull_request']['number']) @webhook.hook(event_type='status') def on_status(data): if data['state'] != 'success':
from app import app, db from github_webhook import Webhook url = app.config.get('GITHUB_WEBHOOK_URL', '/api/webhook') secret = app.config.get('GITHUB_WEBHOOK_SECRET') webhook = Webhook(app, url, secret) @webhook.hook() def on_push(data): print data @webhook.hook() def on_issues(data): print data @webhook.hook() def on_issue_comment(data): print data @webhook.hook() def on_commit_comment(data): print data @webhook.hook() def on_pull_request_review(data): print data
from github_webhook import Webhook from flask import Flask, jsonify import os, json, re, requests from distutils.util import strtobool import heroku3 import traceback app = Flask(__name__) webhook = Webhook(app, secret=os.getenv("GITHUB_WEBHOOK_SECRET_TOKEN")) # Get connection to heroku api heroku_conn = heroku3.from_key(os.getenv('HEROKU_KEY')) # Handle uncaught 500 Internal Server Errors def handle_internal_server_error(e): print(str(e)) traceback.print_tb(e.__traceback__) status = { 'status': 'error', 'message': str(e) } return jsonify(status), 500 app.register_error_handler(500, handle_internal_server_error) def get_heroku_app_name(branch): return re.sub(r'-*$','', f'joplin-pr-{branch}'[0:30]).lower() def has_deletion_protection(app):
#!/usr/bin/env python3 from github_webhook import Webhook from flask import Flask import json import os import subprocess # Mounted in by docker repobase = "/repos/" secret_file = "/etc/github_webhook_secret" with open(secret_file, "r") as file: secret = file.read().strip() app = Flask(__name__) # Standard Flask app webhook = Webhook(app, secret=secret) # Defines '/postreceive' endpoint @webhook.hook() # Defines a handler for the 'push' event def on_push(data): print(json.dumps(data)) if data["ref"] == "refs/heads/master": repo = data["repository"]["name"] url = data["repository"]["ssh_url"] if not os.path.isdir(repobase + repo + "/.git"): subprocess.run(["/usr/bin/git", "clone", url, repobase + repo]) print("Cloned " + url + " to " + repobase + repo) else: subprocess.run(["/usr/bin/git", "pull", "--rebase"], cwd=repobase + repo) print("Pulled " + repobase + repo)
import os from flask import Flask from github_webhook import Webhook from worker import invoke from github import Github app = Flask(__name__) webhook = Webhook(app, secret=os.environ.get('SECRET', 'youvebeenmade')) g = Github(os.environ.get('GH_ACCESS_TOKEN', '')) org = g.get_organization(os.environ.get('GH_ORGANIZATION', 'deviavir')) repo = org.get_repo(os.environ.get('GH_REPO', 'terraform-ci')) @app.route('/') def main(): return 'OK' @webhook.hook() def on_push(data): print("Got push data: {0}".format(data)) branch = data['ref'].replace('refs/heads/', '') if branch == 'master': provider = 'aws' tf_commit = False upstream = data['repository']['ssh_url'] modifieds = data['head_commit']['modified'] for change in modifieds: if 'terraform/' in change: tf_commit = True
from flask import redirect from github_webhook import Webhook from shared import configuration from shared_web.flask_app import PDFlask from . import webhooks APP = PDFlask(__name__) WEBHOOK = Webhook(APP, endpoint='/api/github') @APP.route('/') def home(): return 'build-commit-id: ' + APP.config['commit-id'] @WEBHOOK.hook() def on_push(data): ref = data['ref'] print(f'Got push on {ref}') if ref == 'refs/heads/master': webhooks.update_prs(data['repository']['full_name']) return data @WEBHOOK.hook(event_type='status') def on_status(data): sha = data.get('sha') context = data.get('context') state = data.get('state')
import pytest from flask import Flask from github_webhook import Webhook from communication import communication from compilation import compilation from downloader import downloader from notification import notification from testing import testing # ----------------------------------------------------------------------------# # App Config. # ----------------------------------------------------------------------------# app = Flask(__name__) webhook = Webhook(app) # ----------------------------------------------------------------------------# # Controllers. # ----------------------------------------------------------------------------# @app.route('/') def home(): return "Hello world!" @webhook.hook() def on_push(data): result = communication.Result() downloader.push_event(data, result)
sha_name, signature = header_signature.split('=') if sha_name != 'sha1': return False mac = hmac.new(SECRET_KEY, msg=request.data, digestmod='sha1') if not str(mac.hexdigest()) == str(signature): return False return True jenkins = GitKeeper(sys.argv[1]) app = Flask(__name__) webhook = Webhook(app) # /postreceive endpoint @webhook.hook() def on_push(data): if jenkins.validate_header(): name = data[u'repository'][u'name'] branch = data[u'ref'].split('/')[-1] app.logger.info('Push event received for {}'.format(name)) try: jenkins.pull(name, branch) app.logger.info('Pull success!') except Exception as e: app.logger.error('Pull failed with {}'.format(e)) return '200 OK!' app.logger.warning(' 403 - Unverified request received!')
from github_webhook import Webhook from flask import Flask import os app = Flask(__name__) webhook = Webhook(app, "/") REPOS = [ 'jpush-api-java-client', 'jpush-api-csharp-client', 'jpush-api-php-client', 'jpush-api-python-client', 'jpush-api-nodejs-client', 'jpush-api-ruby-client', 'jmessage-api-java-client', 'jmessage-api-csharp-client', 'jmessage-api-python-client', 'jmessage-api-php-client', 'jsms-api-java-client', 'jsms-api-php-client', 'jsms-api-csharp-client' ] current = os.path.split(os.path.realpath(__file__))[0] separator = "\n========================================================================\n" log_file = "{0}/hooks.log".format(current) def log_it(str): f = open(log_file, 'a') f.write(str) f.close() @app.route("/") # Standard Flask endpoint def hello_world(): return "Hello, World!"
import subprocess import os import shutil from github_webhook import Webhook from flask import Flask from make_readme import generate_READMEs app = Flask(__name__) github_webhook_secret = open("github_webhook_secret", "r").read().strip() webhook = Webhook(app, endpoint="/github", secret=github_webhook_secret) login = open("login").read().strip() token = open("token").read().strip() my_env = os.environ.copy() my_env["GIT_TERMINAL_PROMPT"] = "0" my_env["GIT_AUTHOR_NAME"] = "Yunohost-Bot" my_env["GIT_AUTHOR_EMAIL"] = "*****@*****.**" my_env["GIT_COMMITTER_NAME"] = "Yunohost-Bot" my_env["GIT_COMMITTER_EMAIL"] = "*****@*****.**" def git(cmd, in_folder=None): if not isinstance(cmd, list): cmd = cmd.split() if in_folder: cmd = ["-C", in_folder] + cmd cmd = ["git"] + cmd
def __init__(self, app): url = app.config.get('GITHUB_WEBHOOK_URL', '/api/webhook') secret = app.config.get('GITHUB_WEBHOOK_SECRET') Webhook.__init__(self, app, url, secret)
from app import app from github_webhook import Webhook from utils.cron.interfaceTestCron import Cron from models.cronTab import CronTab from app import cron_manager from utils import common import datetime webhook = Webhook(app, endpoint='/api/webhook') @webhook.hook(event_type='ExecTest' ) # Defines a handler for the 'ExecTest' event def on_exec_test(data): try: data['testCaseSuiteIdList'] = data['testCaseSuiteIdList'].strip( ).split(';') except BaseException: raise TypeError('参数 「testCaseSuiteIdList」 不合法') try: data['testDomain'] = data['testDomain'].strip() except BaseException: raise TypeError('参数 「testDomain」 不合法') try: data['dingdingAccessToken'] = data['dingdingAccessToken'].strip() except BaseException: raise TypeError('参数 「dingdingAccessToken」 不合法') data['isExecuteForbiddenedCase'] = True if common.can_convert_to_str(data.get('isExecuteForbiddenedCase'))\
from pprint import pprint from flask import Flask from github_webhook import Webhook from qmk_commands import discord_msg from update_kb_redis import update_needed # Setup app = Flask(__name__) app.config.from_object(__name__) github_secret = None webhook = Webhook(app, '/postreceive', github_secret) # Views @app.route("/") def index(): return "Hello, World!" @app.route("/healthcheck") def healthcheck(): return "GOOD" @webhook.hook('push') def on_push(data): """Handle a webhook from github. """ print('Got webhook request:')
import subprocess import os from flask import Blueprint, request from github_webhook import Webhook webhook_blueprint = Blueprint('webhooks', __name__) webhook = Webhook( webhook_blueprint ) # register GitHub webhook and define '/postreceive' endpoint # Constants GITHUB_WEBHOOK_BASH_SCRIPTS_PATH = './github_webhook_bash_scripts' @webhook.hook() # defines a handler for the 'push' event. def on_portfolio_website_push(data): """ This route is called when GitHub's webhook makes a request with a JSON payload. It executes a bash script depending on the :code:`full_name` key's value in the JSON payload. :param data: GitHub JSON payload. :type data: JSON :return: None :rtype: None """ full_name = data['repository']['full_name'] print(f'Received push from: {full_name}') if full_name == 'edmondchuc/portfolio-website': subprocess.call( os.path.join(GITHUB_WEBHOOK_BASH_SCRIPTS_PATH,