class TestHTTPBasicAuth(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler.auth = HTTPBasicAuth() self.scheduler.api_enabled = True self.scheduler.init_app(self.app) self.scheduler.start() self.scheduler.authenticate(self._authenticate) self.client = self.app.test_client() def _authenticate(self, auth): return auth['username'] == 'test' and auth['password'] == 'test' def test_valid_credentials(self): headers = {'Authorization': 'Basic ' + base64.b64encode(b'test:test').decode('ascii')} response = self.client.get(self.scheduler.api_prefix + '', headers=headers) self.assertEqual(response.status_code, 200) def test_invalid_credentials(self): headers = {'Authorization': 'Basic ' + base64.b64encode(b'guest:guest').decode('ascii')} response = self.client.get(self.scheduler.api_prefix + '', headers=headers) self.assertEqual(response.status_code, 401) self.assertEqual(response.headers['WWW-Authenticate'], 'Basic realm="Authentication Required"') def test_invalid_header_format(self): headers = {'Authorization': 'Basic 1231234'} response = self.client.get(self.scheduler.api_prefix + '', headers=headers) self.assertEqual(response.status_code, 401) self.assertEqual(response.headers['WWW-Authenticate'], 'Basic realm="Authentication Required"') def test_missing_credentials(self): response = self.client.get(self.scheduler.api_prefix + '') self.assertEqual(response.status_code, 401) self.assertEqual(response.headers['WWW-Authenticate'], 'Basic realm="Authentication Required"')
def create_app(): app = Flask(__name__) if os.environ.get('SITTER_SETTINGS'): app.config.from_envvar('SITTER_SETTINGS') else: for path in (os.path.dirname(os.path.dirname(__file__)), os.path.dirname(__file__)): settings = os.path.join(path, 'settings.cfg') if os.path.isfile(settings): app.config.from_pyfile(settings) break if not os.path.exists(app.config['SESSION_STORAGE_DIR']): os.makedirs(app.config['SESSION_STORAGE_DIR']) kv = KVSessionExtension(FilesystemStore(app.config['SESSION_STORAGE_DIR']), app) # Remove extra white space. app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True def cleanup_sessions(): kv.cleanup_sessions(app) # Add some scheduled jobs. scheduler = APScheduler() scheduler.init_app(app) scheduler.add_job(id="kv-session-cleanup", func=cleanup_sessions, seconds=10, trigger='interval') scheduler.start() return app
class TestAPIPrefix(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler.api_enabled = True self.scheduler.api_prefix = '/api' self.scheduler.init_app(self.app) self.scheduler.start() self.client = self.app.test_client() def test_api_prefix(self): response = self.client.get(self.scheduler.api_prefix + '/jobs') self.assertEqual(response.status_code, 200) def test_invalid_api_prefix(self): response = self.client.get('/invalidapi/jobs') self.assertEqual(response.status_code, 404)
def stacosys_server(config_pathname): app = Flask(__name__) config.initialize(config_pathname, app) # configure logging logger = logging.getLogger(__name__) configure_logging(logging.INFO) logging.getLogger("werkzeug").level = logging.WARNING logging.getLogger("apscheduler.executors").level = logging.WARNING # initialize database from core import database database.setup() # cron email fetcher app.config.from_object( JobConfig( config.getInt(config.MAIL_POLLING), config.getInt(config.COMMENT_POLLING) ) ) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() logger.info("Start Stacosys application") # generate RSS for all sites from core import rss rss.generate_all() # start Flask from interface import api from interface import form logger.debug("Load interface %s" % api) logger.debug("Load interface %s" % form) app.run( host=config.get(config.HTTP_HOST), port=config.get(config.HTTP_PORT), debug=False, use_reloader=False, )
class TestScheduler(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() def test_running(self): self.assertFalse(self.scheduler.running) self.scheduler.start() self.assertTrue(self.scheduler.running) def test_start_with_allowed_hosts(self): self.app.config['SCHEDULER_ALLOWED_HOSTS'] = ['any_server_name'] self.scheduler.init_app(self.app) self.scheduler.start() self.assertFalse(self.scheduler.running) def test_start_without_allowed_hosts(self): self.app.config['SCHEDULER_ALLOWED_HOSTS'] = [] self.scheduler.init_app(self.app) self.scheduler.start() self.assertFalse(self.scheduler.running) def test_shutdown(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertTrue(self.scheduler.running) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_load_jobs_from_config(self): self.app.config['JOBS'] = [ { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'interval', 'seconds': 10 } ] self.scheduler.init_app(self.app) job = self.scheduler.get_job('job1') self.assertIsNotNone(job) def test_task_decorator(self): @self.scheduler.task('interval', seconds=10, id='job1') def decorated_job(): pass job = self.scheduler.get_job('job1') self.assertIsNotNone(job)
class TestEndpointPrefix(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler.api_enabled = True self.scheduler.endpoint_prefix = 'api.' self.scheduler.init_app(self.app) self.scheduler.start() self.client = self.app.test_client() def test_endpoint_prefix(self): with self.scheduler.app.test_request_context(): valid_url = True if url_for(self.scheduler.endpoint_prefix + 'get_scheduler_info') else False self.assertTrue(valid_url) def test_invalid_endpoint_prefix(self): with self.scheduler.app.test_request_context(): try: valid_url = url_for('get_scheduler_info') except BuildError as _: valid_url = False self.assertFalse(valid_url)
def srmail_server(config_pathname): app = Flask(__name__) config.initialize(config_pathname, app) # configure logging logger = logging.getLogger(__name__) configure_logging(logging.INFO) # initialize database from core import database database.setup() # cron email fetcher app.config.from_object(JobConfig(config.getInt(config.IMAP_POLLING))) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() logger.info("Starting SRMAIL application") # start Flask from interface import api logger.debug("Load interface %s" % api) app.run( host=config.get(config.HTTP_HOST), port=config.get(config.HTTP_PORT), debug=False, use_reloader=False, ) # Exit application logger.info("Stopping SRMAIL application")
def scheduled_init(app): scheduler = APScheduler() app.config['JOBS'] = jobs scheduler.api_enabled = True scheduler.init_app(app) scheduler.start()
'args': (1, 2), 'trigger': 'interval', 'seconds': 10 }] SCHEDULER_AUTH_ENABLED = True SCHEDULER_API_ENABLED = True def job1(a, b): print(str(a) + ' ' + str(b)) app = Flask(__name__) app.config.from_object(Config()) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() @scheduler.authenticate def authenticate(auth): if auth.type != 'basic': return None return auth.username == 'guest' and auth.password == 'guest' app.run()
from flask import Flask, redirect, url_for, session from flask import render_template from flask import request from flask_apscheduler import APScheduler from datetime import timedelta from mysql_db import * import json from config import * from ip_address import * app = Flask(__name__) app.config.from_object('flask_config') app.config['SECRET_KEY'] = os.urandom(24) app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7) sched = APScheduler() sched.init_app(app) sched.start() @app.route('/') def index(): session.permanent = True return render_template("login.html") @app.route('/api/', methods=['GET']) def api(): try: # num = request.args.get('num') if request.args.get('num') != None else 1 # ip_type = request.args.get('type') if request.args.get('type') != None else 'http' page = request.args.get( 'page') if request.args.get('page') != None else 0
def initSchedule(): app.config.from_object(Config()) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() print("Scheduler Initialized\n")
class ApplicationWindow(QtWidgets.QMainWindow): def __init__(self): super(ApplicationWindow, self).__init__() self.bus_num = 1 self.bus = SMBus(self.bus_num) self.ui = Ui_MainWindow() self.ui.setupUi(self) # Get easy access to UI elements self.rgb = self.ui.lid_display.layout() self.minutes = self.ui.lcdMinutes self.seconds = self.ui.lcdSeconds self.potentiometer = self.ui.dial # TODO Make connections to functions # TODO Listen on the SMBus for messages and then call the right functions for h, button in self.keypad.items(): button.clicked.connect( partial( self.bus.write_byte, I2C.ARDUINO, h ) ) for _, checkbox in self.photo_resistor.items(): checkbox.clicked.connect( lambda: self.bus.write_byte(I2C.LASERS, self.laser_mask) ) self.potentiometer.valueChanged.connect( lambda: self.bus.write_byte(I2C.ROTARY, self.potentiometer.value())) for _, switch in self.switches.items(): switch.valueChanged.connect( lambda: self.bus.write_byte(I2C.SWITCHES, self.switch_mask) ) # Colored disconnectable wires self.ui.wire_red.clicked.connect(lambda: self.bus.write_byte(I2C.WIRE, 0xd)) self.ui.wire_blue.clicked.connect(lambda: self.bus.write_byte(I2C.WIRE, 0xb)) self.ui.wire_green.clicked.connect(lambda: self.bus.write_byte(I2C.WIRE, 0xe)) # Reset button self.ui.start_reset.clicked.connect(lambda: self.bus.write_byte(I2C.RESET, 0x1)) self.ui.ultrasonicSlider.valueChanged.connect( lambda: self.bus.write_byte(I2C.ULTRASONIC, self.ui.ultrasonicSlider.value()) ) self.scheduler = APScheduler(scheduler=BackgroundScheduler()) self.scheduler.add_job("poll", self.poll_sensors, max_instances=2, replace_existing=False) self.scheduler.start() def poll_sensors(self): for i in I2C: word = self.bus.read_i2c_block_data(i, 0, 10) if i is I2C.SEVENSEG: self.ui.lcdMinutes.display("0x{}{}".format(SevenSeg.inv_map.get(word[0], 0), SevenSeg.inv_map.get(word[2], 0))) self.ui.lcdSeconds.display("0x{}{}".format(SevenSeg.inv_map.get(word[6], 0), SevenSeg.inv_map.get(word[8], 0))) elif i is I2C.ARDUINO: self.ui.RGB_red.setChecked(False) self.ui.RGB_blue.setChecked(False) self.ui.RGB_green.setChecked(False) self.ui.RGB_red.setCheckable(bool(word[0])) self.ui.RGB_blue.setCheckable(bool(word[0])) self.ui.RGB_green.setCheckable(bool(word[0])) if not word[0]: pass elif word[0] < 20: self.ui.RGB_blue.setChecked(True) elif word[0] < 200: self.ui.RGB_green.setChecked(True) else: self.ui.RGB_red.setChecked(True) elif i is I2C.SOLENOID: if word[0] == 255: self.ui.solenoid.setChecked(True) else: # TODO lock the solenoid after 10 seconds like the real one self.ui.solenoid.setChecked(False) # sleep for a frame sleep(1/60) self.scheduler.add_job("poll", self.poll_sensors, max_instances=2, replace_existing=False) @property def time(self) -> str: """ :return: The current time shown on the lcd """ @time.setter def time(self, value): """ TODO set the value on the timer :param value: :return: """ @property def switches(self) -> Dict[int, QSlider]: return { 4: self.ui.verticalSlider_1, 3: self.ui.verticalSlider_2, 2: self.ui.verticalSlider_3, 1: self.ui.verticalSlider_4, 0: self.ui.verticalSlider_5, } @property def switch_mask(self) -> bin: result = 0b00000 for offset, sw in self.switches.items(): result ^= ((1 if sw.value() else 0) << offset) return result @property def laser_mask(self) -> bin: """ :return: An integer that represents all the photo resistors that have a laser shining on them """ result = 0b000000 for offset, box in self.photo_resistor.items(): result ^= ((1 if box.isChecked() else 0) << offset) return result @property def laser(self) -> Dict[int, QCheckBox]: return { 5: self.ui.laser_0, 4: self.ui.laser_1, 3: self.ui.laser_2, 2: self.ui.laser_3, 1: self.ui.laser_4, 0: self.ui.laser_5, } @property def photo_resistor(self) -> Dict[int, QCheckBox]: return { 5: self.ui.photodiode_0, 4: self.ui.photodiode_1, 3: self.ui.photodiode_2, 2: self.ui.photodiode_3, 1: self.ui.photodiode_4, 0: self.ui.photodiode_5, } @property def led(self) -> Dict[int, QCheckBox]: return { 0: self.ui.led_0, 1: self.ui.led_1, 2: self.ui.led_2, 3: self.ui.led_3, 4: self.ui.led_4, 5: self.ui.led_5, 6: self.ui.led_6, 7: self.ui.led_7, } @property def keypad(self) -> Dict[hex, QPushButton]: return { 0x0: self.ui.pushButton0, 0x1: self.ui.pushButton1, 0x2: self.ui.pushButton2, 0x3: self.ui.pushButton3, 0x4: self.ui.pushButton4, 0x5: self.ui.pushButton5, 0x6: self.ui.pushButton6, 0x7: self.ui.pushButton7, 0x8: self.ui.pushButton8, 0x9: self.ui.pushButton9, 0xa: self.ui.pushButtona, 0xb: self.ui.pushButtonb, 0xc: self.ui.pushButtonc, 0xd: self.ui.pushButtond, 0xe: self.ui.pushButtone, 0xf: self.ui.pushButtonf, } @staticmethod def run(): app = QtWidgets.QApplication(sys.argv) application = ApplicationWindow() application.show() return app.exec_()
def schedulerStart(): scheduler = APScheduler() scheduler.init_app(app) scheduler.start()
def load(app): # upgrade() app.db.create_all() CHALLENGE_CLASSES["dynamic_docker"] = DynamicValueDockerChallenge register_plugin_assets_directory( app, base_path="/plugins/ctfd-whale/assets/" ) page_blueprint = Blueprint( "ctfd-whale", __name__, template_folder="templates", static_folder="assets", url_prefix="/plugins/ctfd-whale" ) @page_blueprint.route('/admin/settings', methods=['GET']) @admins_only def admin_list_configs(): configs = DBUtils.get_all_configs() return render_template('config.html', configs=configs) @page_blueprint.route('/admin/settings', methods=['PATCH']) @admins_only def admin_save_configs(): req = request.get_json() DBUtils.save_all_configs(req.items()) return json.dumps({'success': True}) @page_blueprint.route("/admin/containers", methods=['GET']) @admins_only def admin_list_containers(): configs = DBUtils.get_all_configs() page = abs(request.args.get("page", 1, type=int)) results_per_page = 50 page_start = results_per_page * (page - 1) page_end = results_per_page * (page - 1) + results_per_page count = DBUtils.get_all_alive_container_count() containers = DBUtils.get_all_alive_container_page(page_start, page_end) pages = int(count / results_per_page) + (count % results_per_page > 0) return render_template("containers.html", containers=containers, pages=pages, curr_page=page, curr_page_start=page_start, configs=configs) @page_blueprint.route("/admin/containers", methods=['DELETE']) @admins_only def admin_delete_container(): user_id = request.args.get('user_id') ControlUtil.remove_container(user_id) return json.dumps({'success': True}) @page_blueprint.route("/admin/containers", methods=['PATCH']) @admins_only def admin_renew_container(): user_id = request.args.get('user_id') challenge_id = request.args.get('challenge_id') DBUtils.renew_current_container(user_id=user_id, challenge_id=challenge_id) return json.dumps({'success': True}) @page_blueprint.route('/container', methods=['POST']) @authed_only def add_container(): user_id = current_user.get_current_user().id lock_util = LockUtils(app=app, user_id=user_id) if not lock_util.acquire(): return json.dumps({'success': False, 'msg': 'Request Too Fast!'}) if ControlUtil.frequency_limit(): return json.dumps({'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.'}) ControlUtil.remove_container(user_id) challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) configs = DBUtils.get_all_configs() current_count = DBUtils.get_all_alive_container_count() if int(configs.get("docker_max_container_count")) <= int(current_count): return json.dumps({'success': False, 'msg': 'Max container count exceed.'}) dynamic_docker_challenge = DynamicDockerChallenge.query \ .filter(DynamicDockerChallenge.id == challenge_id) \ .first_or_404() flag = "flag{" + str(uuid.uuid4()) + "}" if dynamic_docker_challenge.redirect_type == "http": ControlUtil.add_container(user_id=user_id, challenge_id=challenge_id, flag=flag) else: port = random.randint(int(configs.get("frp_direct_port_minimum")), int(configs.get("frp_direct_port_maximum"))) while True: if DBUtils.get_container_by_port(port) is None: break port = random.randint(int(configs.get("frp_direct_port_minimum")), int(configs.get("frp_direct_port_maximum"))) ControlUtil.add_container(user_id=user_id, challenge_id=challenge_id, flag=flag, port=port) lock_util.release() return json.dumps({'success': True}) @page_blueprint.route('/container', methods=['GET']) @authed_only def list_container(): user_id = current_user.get_current_user().id challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) data = DBUtils.get_current_containers(user_id=user_id) configs = DBUtils.get_all_configs() domain = configs.get('frp_http_domain_suffix', "") if data is not None: if int(data.challenge_id) != int(challenge_id): return json.dumps({}) dynamic_docker_challenge = DynamicDockerChallenge.query \ .filter(DynamicDockerChallenge.id == data.challenge_id) \ .first_or_404() lan_domain = str(user_id) + "-" + data.uuid if dynamic_docker_challenge.redirect_type == "http": if int(configs.get('frp_http_port', "80")) == 80: return json.dumps({'success': True, 'type': 'http', 'domain': data.uuid + domain, 'remaining_time': 3600 - (datetime.now() - data.start_time).seconds, 'lan_domain': lan_domain}) else: return json.dumps({'success': True, 'type': 'http', 'domain': data.uuid + domain + ":" + configs.get('frp_http_port', "80"), 'remaining_time': 3600 - (datetime.now() - data.start_time).seconds, 'lan_domain': lan_domain}) else: return json.dumps({'success': True, 'type': 'redirect', 'ip': configs.get('frp_direct_ip_address', ""), 'port': data.port, 'remaining_time': 3600 - (datetime.now() - data.start_time).seconds, 'lan_domain': lan_domain}) else: return json.dumps({'success': True}) @page_blueprint.route('/container', methods=['DELETE']) @authed_only def remove_container(): user_id = current_user.get_current_user().id lock_util = LockUtils(app=app, user_id=user_id) if not lock_util.acquire(): return json.dumps({'success': False, 'msg': 'Request Too Fast!'}) if ControlUtil.frequency_limit(): return json.dumps({'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.'}) if ControlUtil.remove_container(user_id): lock_util.release() return json.dumps({'success': True}) else: return json.dumps({'success': False, 'msg': 'Failed when destroy instance, please contact admin!'}) @page_blueprint.route('/container', methods=['PATCH']) @authed_only def renew_container(): user_id = current_user.get_current_user().id lock_util = LockUtils(app=app, user_id=user_id) if not lock_util.acquire(): return json.dumps({'success': False, 'msg': 'Request Too Fast!'}) if ControlUtil.frequency_limit(): return json.dumps({'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.'}) configs = DBUtils.get_all_configs() challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) docker_max_renew_count = int(configs.get("docker_max_renew_count")) container = DBUtils.get_current_containers(user_id) if container is None: return json.dumps({'success': False, 'msg': 'Instance not found.'}) if container.renew_count >= docker_max_renew_count: return json.dumps({'success': False, 'msg': 'Max renewal times exceed.'}) DBUtils.renew_current_container(user_id=user_id, challenge_id=challenge_id) lock_util.release() return json.dumps({'success': True}) def auto_clean_container(): with app.app_context(): results = DBUtils.get_all_expired_container() for r in results: ControlUtil.remove_container(r.user_id) FrpUtils.update_frp_redirect() app.register_blueprint(page_blueprint) try: lock_file = open("/tmp/ctfd_whale.lock", "w") lock_fd = lock_file.fileno() fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job(id='whale-auto-clean', func=auto_clean_container, trigger="interval", seconds=10) print("[CTFd Whale]Started successfully") except IOError: pass
def handleAPISchedule(): scheduler = APScheduler() scheduler.add_job(func=callChurchMusicAPI, args=[], trigger='interval', id='callApiJob', minutes=30) scheduler.start() print("Music API Scheduler start!")
@app.route('/streams', methods=['GET']) def get_streams(): message = data_collector.stream_infos resp = jsonify(message) resp.status_code = 200 print(resp) return resp @app.route('/audio_devices') def get_audio_devices(): p = pyaudio.PyAudio() devices = [] for i in range(p.get_device_count()): device = p.get_device_info_by_index(i) devices.append(device) devices = [ device for device in devices if 'Sound Mapper' not in device['name'] and device['maxInputChannels'] ] resp = jsonify(devices) resp.status_code = 200 return resp if __name__ == '__main__': cron.start() atexit.register(lambda: cron.shutdown(wait=False)) app.run(debug=True, threaded=True, use_reloader=False, port=5010)
ping_timeout=10, ping_interval=5, cors_allowed_origins=flask_app.config['SOCKETIO_CORS_ALLOWED_ORIGIN']) flask_app.url_map.converters['int'] = IntegerConverter login_manager.init_app(flask_app) login_manager.login_message = 'Je moet aangemeld zijn om deze pagina te zien!' login_manager.login_view = 'auth.login' migrate = Migrate(flask_app, db) SCHEDULER_API_ENABLED = True message_scheduler = APScheduler() message_scheduler.init_app(flask_app) message_scheduler.start() soap = Client(flask_app.config['SMARTSCHOOL_URL']) def create_admin(): from app.data.models import User find_admin = User.query.filter(User.username == 'admin').first() if not find_admin: admin = User(username='******', password='******', level=User.LEVEL.ADMIN, user_type=User.USER_TYPE.LOCAL) db.session.add(admin) db.session.commit()
if (sender['card'] == ""): #没设置群名片 user_info = dbconn.get_friend_info(user_id) if (user_info): #好友库中有此人 user_name = user_info['mark_name'] else: user_name = sender['nickname'] else: user_name = sender['card'] goapi_recv.sendMsg( TARGET_USER_ID, f"[{user_name}]-{group_info['group_name']}\n{message}") #群聊消息,仅当成功转发时增加好友计数 dbconn.count_plus(user_id) else: #暂时不转发的消息逻辑 pass if __name__ == "__main__": #每次运行前自动更新好友和群库 dbconn.update_friends_info(goapi_recv.get_friends_list()) dbconn.update_group_info(goapi_recv.get_group_list()) scheduler = APScheduler() # 实例化APScheduler scheduler.init_app(app) # 把任务列表载入实例flask scheduler.start() # 启动任务计划 app.run(host=flask_addr, port=flask_port, debug=False)
class TestAPI(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler.api_enabled = True self.scheduler.init_app(self.app) self.scheduler.start() self.client = self.app.test_client() def test_scheduler_info(self): response = self.client.get(self.scheduler.api_prefix) self.assertEqual(response.status_code, 200) info = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(info['current_host']) self.assertEqual(info['allowed_hosts'], ['*']) self.assertTrue(info['running']) def test_add_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'date', 'run_date': '2020-12-01T12:30:01+00:00', } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('run_date'), job2.get('run_date')) def test_add_conflicted_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'date', 'run_date': '2020-12-01T12:30:01+00:00', } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 200) response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 409) def test_add_invalid_job(self): job = { 'id': None, } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 500) def test_delete_job(self): self.__add_job() response = self.client.delete(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 204) response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_delete_job_not_found(self): response = self.client.delete(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_get_job(self): job = self.__add_job() response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_get_job_not_found(self): response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_get_all_jobs(self): job = self.__add_job() response = self.client.get(self.scheduler.api_prefix + '/jobs') self.assertEqual(response.status_code, 200) jobs = json.loads(response.get_data(as_text=True)) self.assertEqual(len(jobs), 1) job2 = jobs[0] self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_update_job(self): job = self.__add_job() data_to_update = { 'args': [1], 'trigger': 'cron', 'minute': '*/1', 'start_date': '2021-01-01' } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(data_to_update.get('args'), job2.get('args')) self.assertEqual(data_to_update.get('trigger'), job2.get('trigger')) self.assertEqual('2021-01-01T00:00:00+00:00', job2.get('start_date')) self.assertEqual('2021-01-01T00:00:00+00:00', job2.get('next_run_time')) def test_update_job_not_found(self): data_to_update = { 'args': [1], 'trigger': 'cron', 'minute': '*/1', 'start_date': '2021-01-01' } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 404) def test_update_invalid_job(self): self.__add_job() data_to_update = { 'trigger': 'invalid_trigger', } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 500) def test_pause_and_resume_job(self): self.__add_job() response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/pause') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNone(job.get('next_run_time')) response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/resume') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(job.get('next_run_time')) def test_pause_and_resume_job_not_found(self): response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/pause') self.assertEqual(response.status_code, 404) response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/resume') self.assertEqual(response.status_code, 404) def test_run_job(self): self.__add_job() response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/run') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(job.get('next_run_time')) def test_run_job_not_found(self): response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/run') self.assertEqual(response.status_code, 404) def __add_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'interval', 'minutes': 10, } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) return json.loads(response.get_data(as_text=True))
def get_app(): import atexit import os import yaml from flask import Flask from flask_apscheduler import APScheduler from apscheduler.jobstores.redis import RedisJobStore from apscheduler.jobstores.memory import MemoryJobStore from tracker_client_plugins import tracker_clients import docker_worker_pool from docker_worker_pool import get_cron_workers, DockerWorker global _app if _app is not None: return _app _app = Flask(__name__) # load tracker plugins try: with open('tracker_client_plugins.yaml', 'r') as f: tracker_dict = yaml.load(f, Loader=yaml.FullLoader) for plugin_name, kwargs in tracker_dict.items(): tracker_clients.add(plugin_name, **kwargs) except FileNotFoundError: pass job_stores = { 'redis': RedisJobStore(host=tracker_dict['redis_tracker_client']['host'], port=tracker_dict['redis_tracker_client']['port']), 'default': MemoryJobStore() } _app.config['SCHEDULER_JOBSTORES'] = job_stores scheduler = APScheduler() # it is also possible to enable the API directly # scheduler.api_enabled = True scheduler.init_app(_app) atexit.register(lambda: scheduler.shutdown(wait=False)) num_workers = int(os.environ.get("NUM_WORKERS", 1)) for i in range(num_workers): docker_worker_pool.add() scheduler.start() loaded_scheduled_jobs = scheduler.get_jobs(jobstore='redis') _cron_workers = get_cron_workers() if loaded_scheduled_jobs: for cron_job in loaded_scheduled_jobs: cron_worker_index = docker_worker_pool.get_cron_worker_index( cron_job.id) _cron_workers[cron_worker_index] = DockerWorker( cron_job.id, cron_job) return _app
def index(): return "Welcome to the scheduler!" def scheduled_task(): # get data from google drive data_file = drive.get_data_file() # read lines and split each one by ',' lines = [item.strip().split(',') for item in data_file.split('\n')] # create scheduler result_data = scheduler.data_processing(lines[1:]) # create spreadsheet spreadsheet.create(result_data) # send email with spreadsheet attached, path= utils/ gmail.send() def counter(): print("1") if __name__ == '__main__': # apsscheduler.add_job(id='Scheduled task', func=scheduled_task, trigger='cron', day_of_week=0) apsscheduler.add_job(id='Scheduled task', func=scheduled_task, trigger='interval', seconds=60) apsscheduler.start() app.run(host='0.0.0.0', port=8080, debug=True) # app.run(host='0.0.0.0', port=8080, debug=False)
cache_json.pop(key) with open(cache_json_path, "w") as f: json.dump(cache_json, f, indent=2) app = Flask(__name__) cache = lru.LRUCacheDict(max_size=100, expiration=60 * 60, concurrent=True) files = lru.LRUCacheDict(max_size=5000, expiration=60 * 60, concurrent=True) buffer_size = 1024 * 1024 # 1MB youtube_url = "https://www.youtube.com/watch?v=" app.config.from_object(Config()) Scheduler.init_app(app) Scheduler.start() class VideoInfo: def __init__(self, id, title, url, audio_url, extension, size): self.id = id self.title = title self.url = url self.audio_url = audio_url self.extension = extension self.size = size def get_file_by_id(video_id): file_name = str(video_id) + '.mp4' files[file_name] = video_id
class App(FlaskApp): def __init__( self, name, use_tracer=None, use_metric=False, use_logging_level=logging.DEBUG, use_optimizer=None, use_cors=None, use_default_error=None, use_scheduler=None, all=None, flaskName=None, *args, **kwargs, ): # TODO: Add more text here for current situation """ Initialize Flask App with multiple microservice-related and usability features. None is for deactivating, so it equals to False. *use_tracer* must be of type: bool (True for defaults, False for deactivating), opentracing.Tracer (use it for configuration), dict (use default opentracing.Tracer and the given dict as config) or defaults: None *use_metric* must be of type: bool (True for defaults, False for deactivating) or defaults: None *use_logging_level* must be of type: logging.{INFO, WARNING, ERROR, DEBUG}, defaults: DEBUG *use_optimizer* must be of type: bool (True for defaults, False for deactivating) or defaults: None *use_cors* must be of type: bool (True for defaults, False for deactivating) or defaults: None *use_default_error* must be of type: bool (True for defaults, False for deactivating) or defaults: None *use_scheduler* must be of type: bool (True for defaults, False for deactivating) or defaults: None *all* must be of type: bool (True for use all functions with defaults, False for deactivating all functions) or defaults: None """ if flaskName is None: flaskName = __name__ super().__init__(flaskName, *args, **kwargs) logger = logging.getLogger("") self.name = name self.metrics = None self.tracing = None self.optimize = None self.cors = None self.default_errorhandler = None self.scheduler = None if all is not None and all is not False: use_tracer = True use_metric = True use_optimizer = True use_cors = True use_default_error = True use_scheduler = True logger.info("--- Start Connexion-Plus ---") if not isinstance(self.app, (Flask, FlaskApp)): logger.warning( "Given App is not flask, so it cannot get any functionality added from this lib currently." ) return # add default error if use_default_error is not None and use_default_error is not False: from werkzeug.exceptions import HTTPException from werkzeug.exceptions import default_exceptions logger.info("Add default error handler to Flask...") if callable(use_default_error): self.default_errorhandler = use_default_error logger.info("use given handler.") else: def handle_error(e): code = 500 if isinstance(e, HTTPException): code = e.code error = { "error": e.__class__.__name__, "http_code": code, "description": str(e), } logger.exception(error) return jsonify(error), code self.default_errorhandler = handle_error logger.info("use default one") # register for all json exceptions self.app.register_error_handler(Exception, self.default_errorhandler) # register handler for all http exceptions for ex in default_exceptions: self.app.register_error_handler(ex, self.default_errorhandler) if use_scheduler is not None and use_scheduler is not False: logger.info("Add background scheduler to Flask") from flask_apscheduler import APScheduler self.scheduler = APScheduler() self.scheduler.init_app(self.app) self.scheduler.start() # add optimizer if use_optimizer is not None and use_optimizer is not False: logger.info("Add optimizer to Flask...") from .Optimizer import FlaskOptimize config = {"compress": False, "minify": False} if isinstance(use_optimizer, dict): config.update(use_optimizer) if isinstance(use_optimizer, bool) and use_optimizer: config.update({"compress": True, "minify": True}) logger.info("use config {}.".format(config)) self.optimize = FlaskOptimize(self.app, config) # add CORS if use_cors is not None and use_cors is not False: logger.info("Add cors to Flask...") from flask_cors import CORS if isinstance(use_cors, dict): logger.info("use given settings.") self.cors = CORS(self.app, resources=use_cors) else: logger.info("use default ones.") self.cors = CORS(self.app) logger.info("CORS added.") # add prometheus if use_metric is not None and use_metric is not False: # TODO: add configuration https://github.com/rycus86/prometheus_flask_exporter#configuration from prometheus_flask_exporter import PrometheusMetrics self.metrics = PrometheusMetrics(self.app) logger.info("Add prometheus to Flask") # add tracing if use_tracer is not None and use_tracer is not False: logger.info("Add opentracing to Flask...") # add tracing to all routes in flaskApp from flask_opentracing import FlaskTracing import opentracing from functools import wraps from flask import request def wrapper(fn): @wraps(fn) def request_func(*args, **kwargs): if request.path != "/metrics": return fn(*args, **kwargs) return request_func FlaskTracing._before_request_fn = wrapper( FlaskTracing._before_request_fn) FlaskTracing._after_request_fn = wrapper( FlaskTracing._after_request_fn) config = None if not isinstance(use_tracer, opentracing.Tracer): logger.info("use default one.") from jaeger_client import Config as jConfig tracer_config = { "sampler": { "type": "const", "param": 1, }, "local_agent": { "reporting_host": "jaeger-agent", "reporting_port": 5775, }, "logging": True, } if isinstance(use_tracer, dict): tracer_config = use_tracer if isinstance(use_metric, bool) and use_metric is True: logger.info("Use metrics for tracer.") from jaeger_client.metrics.prometheus import ( PrometheusMetricsFactory, ) config = jConfig( config=tracer_config, service_name=f"{name}ConnexionPlus", metrics_factory=PrometheusMetricsFactory( namespace=f"{name}ConnexionPlus"), ) else: logger.info("no metrics for tracer configured.") config = jConfig( config=tracer_config, service_name=f"{name}ConnexionPlus", ) else: logger.info("use given tracer config.") tracer_obj = use_tracer if config is None else config.initialize_tracer( ) self.tracing = FlaskTracing(tracer_obj, True, self.app) # add tracer to everything to support spans through multiple microservices via rpc-calls from opentracing_instrumentation.client_hooks import install_all_patches install_all_patches() logger.info("All tracing relevant libs patched.") # add a TracingHandler for Logging from .TracingHandler import TracingHandler th = TracingHandler(use_tracer) th.setLevel(use_logging_level) logging.getLogger("").addHandler(th) logger.info("Finished Tracer adding.") logger.info("--- Finished Connexion-Plus ---")
def load(app): # upgrade() plugin_name = __name__.split('.')[-1] app.db.create_all() if not DBConfig.get_config("setup"): setup_default_configs() CHALLENGE_CLASSES["dynamic_docker"] = DynamicValueDockerChallenge register_plugin_assets_directory( app, base_path="/plugins/" + plugin_name + "/assets/" ) page_blueprint = Blueprint( "ctfd-whale", __name__, template_folder="templates", static_folder="assets", url_prefix="/plugins/ctfd-whale" ) register_admin_plugin_menu_bar( 'Whale', '/plugins/ctfd-whale/admin/settings' ) CTFd_API_v1.add_namespace(admin_namespace, path="/plugins/ctfd-whale/admin") CTFd_API_v1.add_namespace(user_namespace, path="/plugins/ctfd-whale") @page_blueprint.route('/admin/settings', methods=['GET', 'POST']) @admins_only def admin_list_configs(): if request.method == 'POST': data = request.form.to_dict() data.pop('nonce') DBConfig.set_all_configs(data) RedisUtils(app=current_app).init_redis_port_sets() session["nonce"] = generate_nonce() configs = DBConfig.get_all_configs() return render_template('config.html', configs=configs) @page_blueprint.route("/admin/containers") @admins_only def admin_list_containers(): result = AdminContainers.get() return render_template("containers.html", plugin_name=plugin_name, containers=result['data']['containers'], pages=result['data']['pages'], curr_page=abs(request.args.get("page", 1, type=int)), curr_page_start=result['data']['page_start']) def auto_clean_container(): with app.app_context(): results = DBContainer.get_all_expired_container() for r in results: ControlUtil.try_remove_container(r.user_id) configs = DBConfig.get_all_configs() containers = DBContainer.get_all_alive_container() config = ''.join([c.frp_config for c in containers]) try: # you can authorize a connection by setting # frp_url = http://user:pass@ip:port frp_addr = configs.get("frp_api_url") if not frp_addr: frp_addr = f'http://{configs.get("frp_api_ip", "frpc")}:{configs.get("frp_api_port", "7400")}' # backward compatibility common = configs.get("frp_config_template") if '[common]' in common: output = common + config else: remote = requests.get(f'{frp_addr.lstrip("/")}/api/config') assert remote.status_code == 200 configs["frp_config_template"] = remote.text output = remote.text + config assert requests.put( f'{frp_addr.lstrip("/")}/api/config', output, timeout=5 ).status_code == 200 assert requests.get( f'{frp_addr.lstrip("/")}/api/reload', timeout=5 ).status_code == 200 except (requests.RequestException, AssertionError): raise WhaleError( 'frpc request failed\n' + 'please check the frp related configs' ) app.register_blueprint(page_blueprint) try: lock_file = open("/tmp/ctfd_whale.lock", "w") lock_fd = lock_file.fileno() fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job( id='whale-auto-clean', func=auto_clean_container, trigger="interval", seconds=10 ) redis_util = RedisUtils(app=app) redis_util.init_redis_port_sets() print("[CTFd Whale]Started successfully") except IOError: pass
# manage 启动脚本 # app 入口 # __init__.py # models.py 数据模型 # static 静态文件 # home 前台 # __init__.py # views.py 前台视图 # forms.py 表单 # admin # __init__.py # views.py 管理视图 # forms.py 管理表单 # templates # home 前台模版 # admin 后台模版 from flask_apscheduler import APScheduler from app import app if __name__ == "__main__": scheduler = APScheduler() # 实例化APScheduler scheduler.init_app(app) # 把任务列表放进flask scheduler.start() # 启动任务列表 app.run(host='0.0.0.0', port=5000, debug=True)
from flask_apscheduler import APScheduler from resource.stockDB import start2 from flask_restful import Api app = Flask(__name__) # 建立application 物件 api = Api(app) aps = APScheduler() class schedulerConfig(object): JOBS = [{ 'id': 'job1', 'func': 'resource.stockDB:start2', 'args': (), 'trigger': 'interval', 'seconds': 5 }] SCHEDULER_API_ENABLED = True @app.route("/") def index(): return "hello world" if __name__ == "__main__": app.debug = True app.config.from_object(schedulerConfig()) aps.init_app(app) aps.start() app.run(host='0.0.0.0', port=80)
def run(self, isDaemon=False): #################################################### # Setup Logging #################################################### self.setup_logging() #################################################### # Setup Configuration #################################################### parser = SafeConfigParser() parser.read('RF.conf') for section_name in parser.sections(): featureBroker.features.Provide( 'conf_{name}'.format(name=section_name), dict(parser.items(section_name))) #################################################### # Start Flask #################################################### app.web = Flask("__main__") # Create Scheduler if not app.web.debug or os.environ.get('WERKZEUG_RUN_MAIN') == 'true': app.web.config['SCHEDULER_VIEWS_ENABLED'] = True app.web.config['SCHEDULER_JOBSTORES'] = { 'default': MemoryJobStore(), 'db': SQLAlchemyJobStore( url='sqlite:///' + featureBroker.RequiredFeature('conf_DB').result['jobs']) } scheduler = APScheduler() jobs = featureBroker.RequiredFeatures( 'job', featureBroker.HasMethods('register')).result for job in jobs: job.register(scheduler.scheduler) scheduler.init_app(app.web) scheduler.start() featureBroker.features.Provide('scheduler', scheduler.scheduler) # Register Controllers controllers = featureBroker.RequiredFeatures( 'controller', featureBroker.HasMethods('register')).result for controller in controllers: controller.register(app.web) # Set secret Key app.web.secret_key = 'A0ew:DE~7/T6yA^8vqNgjVB5tZr98j/3yX R~XHH!jmew:DE~7/T6yA^8vqNgjVB5tN]LWX/,?RT' # Flask-SQLAlchemy app.web.config[ 'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + featureBroker.RequiredFeature( 'conf_DB').result['rf'] app.db = SQLAlchemy(app.web) entities.Base.metadata.create_all(app.db.engine, checkfirst=True) # RF Sniffer if not app.web.debug or os.environ.get('WERKZEUG_RUN_MAIN') == 'true': sniffer = rfSniffer() app.web.run(host='0.0.0.0', port=parser.getint("Web", "port"), debug=(not isDaemon))
class Server(object): app = None def __init__(self): # print("initializing " * 20) self.async_mode = 'eventlet' # None self.app = Flask(__name__) self.app.config['SECRET_KEY'] = 'secret!' thread = None self.socketio = SocketIO(self.app, async_mode=self.async_mode) template_loader = jinja2.ChoiceLoader([ self.app.jinja_loader, jinja2.PackageLoader('mTree', 'base/admin_templates'), jinja2.PackageLoader('mTree', 'base/user_templates') ]) self.app.jinja_loader = template_loader self.app.config['BASIC_AUTH_USERNAME'] = '******' self.app.config['BASIC_AUTH_PASSWORD'] = '******' self.basic_auth = BasicAuth(self.app) self.add_routes() self.scheduler = APScheduler() self.scheduler.init_app(self.app) self.scheduler.start() #self.scheduler.add_listener(self.my_listener, events.EVENT_ALL) def my_listener(self, event): print("APSCHEDULER EVENT " + str(event)) def run_server(self): print("RUNNING " * 20) self.socketio.run(self.app, host='0.0.0.0', debug=True) def attach_experiment(self, experiment): self.experiment = experiment() self.experiment.attach_emitter(emit) self.experiment.attach_socketio(self.socketio) self.experiment.attach_app(self.app) self.experiment.attach_db(None) self.experiment.attach_scheduler(self.scheduler) def get_response(self, emit): return Response(emit, self.app, self.db) def add_scheduler(self, sched_function): self.scheduler.add_job(func=sched_function, trigger=IntervalTrigger(seconds=5), id="print_test", name="print something", replace_existing=True) def add_routes(self): @self.app.route('/admin_dashboard') # URL path for the admin screen @self.basic_auth.required def index(): return render_template('admin_base.html') @self.app.route('/static_content/<string:path>') def static_hosting(path): static_content_location = self.experiment.get_static_content_location( ) return send_from_directory(static_content_location, path) @self.app.route('/subject') # URL path for the subject screen def not_search(): assignment_id = request.args.get('assignmentId') hit_id = request.args.get('hitId') turk_submit_to = request.args.get('turkSubmitTo') worker_id = request.args.get('workerId') if assignment_id == "ASSIGNMENT_ID_NOT_AVAILABLE": # display the preview screen... presumably context = {} template = Environment(loader=FileSystemLoader( self.experiment.get_template_location() or './')).get_template( self.experiment.get_task_preview()).render(context) print("PREPARING FOR A PREVIEW...") return template else: return render_template('subject_base.html', async_mode=self.socketio.async_mode) @self.app.route( '/<string:experiment_id>/<request_page>' ) # TODO(@skunath) This is where it's failing. What's happening? def pageHandler(template): return render_template(template) @self.socketio.on('admin_control', namespace='/admin') def admin_control_message(message): #self.experiment.admin_event_handler(message) self.experiment.start_experiment() @self.socketio.on('user_configuration', namespace='/subject') def receive_user_configuration(message): # need to send user id information event = json.loads(message["data"]) print(event) user_id = event["user_id"] assignment_id = event["assignmentId"] hit_id = event["hitId"] worker_id = event["workerId"] self.experiment.add_user_property(user_id, "assignment_id", assignment_id) self.experiment.add_user_property(user_id, "hit_id", hit_id) #self.experiment.add_user_property(user_id, "turk_submit_to", turk_submit_to) self.experiment.add_user_property(user_id, "worker_id", worker_id) # print("PUT OCCUR -- " + str(event)) @self.socketio.on('put', namespace='/subject') def receive_put(message): # need to send user id information event = json.loads(message["data"]) #print("PUT OCCUR -- " + str(event)) self.experiment.event_handler(event) @self.socketio.on('join', namespace='/subject') def subjectJoin(message): print("\n\nSUBJECT JUST JOINED\n\n") join_room(message['room']) @self.socketio.on('connect', namespace='/subject') def subject_connect(): # need to send user id information assignment_id = request.args.get('assignmentId') hit_id = request.args.get('hitId') turk_submit_to = request.args.get('turkSubmitTo') worker_id = request.args.get('workerId') user_id = self.experiment.create_user(request.sid) join_room(user_id) print("\nCONNECTED\nUser: {}\n\n".format(user_id)) self.experiment.user_objects[user_id].display_welcome_screen( ) # display the welcome screen to the connected user self.experiment.check_experiment_state_to_run( user_id) # Auto start when subjects connect @self.socketio.on('disconnect', namespace='/subject') def subject_disconnect(): print("CLIENT DISCONNECTED") self.experiment.remove_user( request.sid ) # TODO(@messiest) Think of a better way to remove users
class TestAPI(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler.api_enabled = True self.scheduler.init_app(self.app) self.scheduler.start() self.client = self.app.test_client() def test_scheduler_info(self): response = self.client.get(self.scheduler.api_prefix) self.assertEqual(response.status_code, 200) info = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(info['current_host']) self.assertEqual(info['allowed_hosts'], ['*']) self.assertTrue(info['running']) def test_add_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'date', 'run_date': '2020-12-01T12:30:01+00:00', } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('run_date'), job2.get('run_date')) def test_add_conflicted_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'date', 'run_date': '2020-12-01T12:30:01+00:00', } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 200) response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 409) def test_add_invalid_job(self): job = { 'id': None, } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 500) def test_delete_job(self): self.__add_job() response = self.client.delete(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 204) response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_delete_job_not_found(self): response = self.client.delete(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_get_job(self): job = self.__add_job() response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_get_job_not_found(self): response = self.client.get(self.scheduler.api_prefix + '/jobs/job1') self.assertEqual(response.status_code, 404) def test_get_all_jobs(self): job = self.__add_job() response = self.client.get(self.scheduler.api_prefix + '/jobs') self.assertEqual(response.status_code, 200) jobs = json.loads(response.get_data(as_text=True)) self.assertEqual(len(jobs), 1) job2 = jobs[0] self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_update_job(self): job = self.__add_job() data_to_update = { 'args': [1], 'trigger': 'cron', 'minute': '*/1', 'start_date': '2021-01-01' } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(data_to_update.get('args'), job2.get('args')) self.assertEqual(data_to_update.get('trigger'), job2.get('trigger')) self.assertEqual('2021-01-01T00:00:00+00:00', job2.get('start_date')) self.assertEqual('2021-01-01T00:00:00+00:00', job2.get('next_run_time')) def test_update_job_not_found(self): data_to_update = { 'args': [1], 'trigger': 'cron', 'minute': '*/1', 'start_date': '2021-01-01' } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 404) def test_update_invalid_job(self): self.__add_job() data_to_update = { 'trigger': 'invalid_trigger', } response = self.client.patch(self.scheduler.api_prefix + '/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 500) def test_pause_and_resume_job(self): self.__add_job() response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/pause') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNone(job.get('next_run_time')) response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/resume') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(job.get('next_run_time')) def test_pause_and_resume_job_not_found(self): response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/pause') self.assertEqual(response.status_code, 404) response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/resume') self.assertEqual(response.status_code, 404) def test_run_job(self): self.__add_job() response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/run') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(job.get('next_run_time')) def test_run_job_not_found(self): response = self.client.post(self.scheduler.api_prefix + '/jobs/job1/run') self.assertEqual(response.status_code, 404) def __add_job(self): job = { 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'interval', 'minutes': 10, } response = self.client.post(self.scheduler.api_prefix + '/jobs', data=json.dumps(job)) return json.loads(response.get_data(as_text=True))
from flask import Flask from config import Config import os from flask_apscheduler import APScheduler import time from google.cloud import language_v1 app = Flask(__name__) app.config.from_object(Config) schedular = APScheduler() schedular.init_app(app) schedular.start() client = language_v1.LanguageServiceClient() from . import routes from .jobs.webScraper import webScrapeToJSONAndPush
REGEXCIDSTRING = r"^[\w]{3,20}(?:,[\w]{3,20})*$" REGEXMGSSTRING = r"^(?:\d{3})?[a-zA-Z]{2,6}-\d{3,5}(?:,(?:\d{3})?[a-zA-Z]{2,6}-\d{3,5})*$" REGEXPIDSTRING = r"^[\w]{3,25}(?:,[\w]{3,25})*$" REGEXNUM = re.compile(REGEXNUMSTRING) REGEXCID = re.compile(REGEXCIDSTRING, flags=re.ASCII) REGEXMGS = re.compile(REGEXMGSSTRING) REGEXPID = re.compile(REGEXPIDSTRING) LOGIN_MANAGER = LoginManager() LOGIN_MANAGER.login_view = "login" LOGIN_MANAGER.init_app(APP) SCHEDULER = APScheduler() SCHEDULER.init_app(APP) SCHEDULER.start() ASYNC_MODE = 'eventlet' THREAD_LOCK = Lock() SOCKETIO = SocketIO(async_mode=ASYNC_MODE) SOCKETIO.init_app(APP,cors_allowed_origins="*") class Task: def __init__(self): self.task_id = 0 self.task_index = 0 self.task_queue = deque([]) self.pushlog_finished = False self.background_thread = None self.task_status = 0
from flask import Flask from flask_apscheduler import APScheduler class Config(object): JOBS = [ { 'id': 'job1', 'func': '__main__:job1', 'args': (1, 2), 'trigger': 'interval', 'seconds': 10 } ] SCHEDULER_VIEWS_ENABLED = True def job1(a, b): print(str(a) + ' ' + str(b)) app = Flask(__name__) app.config.from_object(Config()) app.debug = True scheduler = APScheduler() scheduler.init_app(app) scheduler.start() app.run()
# 'args': (1, 2), 'trigger': 'interval', 'seconds': 5 } ] SCHEDULER_API_ENABLED = True app = Flask(__name__) sche = APScheduler() @app.route('/') def hello(): return "hello world" @app.route('/add') def add_myjob(): app.apscheduler.add_job(func='my_jobs:job2', id='job2', trigger='interval', seconds=2) return 'add success' @app.route('/add-cron') def add_cron_job(): app.apscheduler.add_job(func='my_jobs:job3', id='job3', trigger='cron', minute='*/3') return 'add success' if __name__ == '__main__': print('Let us run out of the loop') app.config.from_object(Config()) sche.init_app(app) sche.start() app.run(host='0.0.0.0', debug=True)
def load(app): # upgrade() app.db.create_all() CHALLENGE_CLASSES["dynamic_check_docker"] = DynamicCheckValueChallenge register_plugin_assets_directory(app, base_path="/plugins/ctfd-owl/assets/") owl_blueprint = Blueprint("ctfd-owl", __name__, template_folder="templates", static_folder="assets", url_prefix="/plugins/ctfd-owl") log_dir = app.config["LOG_FOLDER"] logger_owl = logging.getLogger("owl") logger_owl.setLevel(logging.INFO) logs = { "owl": os.path.join(log_dir, "owl.log"), } try: for log in logs.values(): if not os.path.exists(log): open(log, "a").close() container_log = logging.handlers.RotatingFileHandler(logs["owl"], maxBytes=10000) logger_owl.addHandler(container_log) except IOError: pass stdout = logging.StreamHandler(stream=sys.stdout) logger_owl.addHandler(stdout) logger_owl.propagate = 0 @owl_blueprint.route('/admin/settings', methods=['GET']) @admins_only # list plugin settings def admin_list_configs(): configs = DBUtils.get_all_configs() return render_template('configs.html', configs=configs) @owl_blueprint.route('/admin/settings', methods=['PATCH']) @admins_only # modify plugin settings def admin_save_configs(): req = request.get_json() DBUtils.save_all_configs(req.items()) return jsonify({'success': True}) @owl_blueprint.route("/admin/containers", methods=['GET']) @admins_only # list alive containers def admin_list_containers(): configs = DBUtils.get_all_configs() page = abs(request.args.get("page", 1, type=int)) results_per_page = 50 page_start = results_per_page * (page - 1) page_end = results_per_page * (page - 1) + results_per_page count = DBUtils.get_all_alive_container_count() containers = DBUtils.get_all_alive_container_page(page_start, page_end) pages = int(count / results_per_page) + (count % results_per_page > 0) return render_template("containers.html", containers=containers, pages=pages, curr_page=page, curr_page_start=page_start, configs=configs) @owl_blueprint.route("/admin/containers", methods=['PATCH']) @admins_only def admin_expired_container(): user_id = request.args.get('user_id') challenge_id = request.args.get('challenge_id') ControlUtil.expired_container(user_id=user_id, challenge_id=challenge_id) return jsonify({'success': True}) @owl_blueprint.route("/admin/containers", methods=['DELETE']) @admins_only def admin_delete_container(): user_id = request.args.get('user_id') ControlUtil.destroy_container(user_id) return jsonify({'success': True}) # instances @owl_blueprint.route('/container', methods=['GET']) @authed_only def list_container(): user_id = get_mode() challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) data = ControlUtil.get_container(user_id=user_id) configs = DBUtils.get_all_configs() remain_time = int(configs.get("docker_max_renew_count")) domain = configs.get('frp_http_domain_suffix', "") if data is not None: if int(data.challenge_id) != int(challenge_id): return jsonify({}) dynamic_docker_challenge = DynamicCheckChallenge.query \ .filter(DynamicCheckChallenge.id == data.challenge_id) \ .first_or_404() lan_domain = str(user_id) + "-" + data.docker_id if dynamic_docker_challenge.deployment == "single": return jsonify({ 'success': True, 'type': 'redirect', 'ip': configs.get('frp_direct_ip_address', ""), 'port': data.port, 'remaining_time': remain_time - (datetime.datetime.utcnow() - data.start_time).seconds, 'lan_domain': lan_domain }) else: if dynamic_docker_challenge.redirect_type == "http": if int(configs.get('frp_http_port', "80")) == 80: return jsonify({ 'success': True, 'type': 'http', 'domain': data.docker_id + "." + domain, 'remaining_time': remain_time - (datetime.datetime.utcnow() - data.start_time).seconds, 'lan_domain': lan_domain }) else: return jsonify({ 'success': True, 'type': 'http', 'domain': data.docker_id + "." + domain + ":" + configs.get('frp_http_port', "80"), 'remaining_time': remain_time - (datetime.datetime.utcnow() - data.start_time).seconds, 'lan_domain': lan_domain }) else: return jsonify({ 'success': True, 'type': 'redirect', 'ip': configs.get('frp_direct_ip_address', ""), 'port': data.port, 'remaining_time': remain_time - (datetime.datetime.utcnow() - data.start_time).seconds, 'lan_domain': lan_domain }) else: return jsonify({'success': True}) @owl_blueprint.route('/container', methods=['POST']) @authed_only def new_container(): user_id = get_mode() if ControlUtil.frequency_limit(): return jsonify({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) # check whether exist container before existContainer = ControlUtil.get_container(user_id) if existContainer: return jsonify({ 'success': False, 'msg': 'You have boot {} before.'.format( existContainer.challenge.name) }) else: challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) configs = DBUtils.get_all_configs() current_count = DBUtils.get_all_alive_container_count() # print(configs.get("docker_max_container_count")) if configs.get("docker_max_container_count") != "None": if int(configs.get("docker_max_container_count")) <= int( current_count): return jsonify({ 'success': False, 'msg': 'Max container count exceed.' }) dynamic_docker_challenge = DynamicCheckChallenge.query \ .filter(DynamicCheckChallenge.id == challenge_id) \ .first_or_404() if dynamic_docker_challenge.redirect_type == "http": ControlUtil.new_container(user_id=user_id, challenge_id=challenge_id) else: ControlUtil.new_container(user_id=user_id, challenge_id=challenge_id) return jsonify({'success': True}) @owl_blueprint.route('/container', methods=['DELETE']) @authed_only def destroy_container(): user_id = get_mode() if ControlUtil.frequency_limit(): return jsonify({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) if ControlUtil.destroy_container(user_id): return jsonify({'success': True}) else: return jsonify({ 'success': False, 'msg': 'Failed when destroy instance, please contact admin!' }) @owl_blueprint.route('/container', methods=['PATCH']) @authed_only def renew_container(): user_id = current_user.get_current_user().id if ControlUtil.frequency_limit(): return jsonify({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) configs = DBUtils.get_all_configs() challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id, user_id) docker_max_renew_count = int(configs.get("docker_max_renew_count")) container = ControlUtil.get_container(user_id) if container is None: return jsonify({'success': False, 'msg': 'Instance not found.'}) if container.renew_count >= docker_max_renew_count: return jsonify({ 'success': False, 'msg': 'Max renewal times exceed.' }) ControlUtil.expired_container(user_id=user_id, challenge_id=challenge_id) return jsonify({'success': True}) def auto_clean_container(): with app.app_context(): results = DBUtils.get_all_expired_container() for r in results: ControlUtil.destroy_container(r.user_id) FrpUtils.update_frp_redirect() app.register_blueprint(owl_blueprint) try: lock_file = open("/tmp/ctfd_owl.lock", "w") lock_fd = lock_file.fileno() fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job(id='owl-auto-clean', func=auto_clean_container, trigger="interval", seconds=5) print("[CTFd Owl]Started successfully") except IOError: pass
def load(app): # upgrade() plugin_name = __name__.split('.')[-1] set_config('whale:plugin_name', plugin_name) app.db.create_all() if not get_config("whale:setup"): setup_default_configs() register_plugin_assets_directory( app, base_path=f"/plugins/{plugin_name}/assets", endpoint='plugins.ctfd-whale.assets') register_admin_plugin_menu_bar(title='Whale', route='/plugins/ctfd-whale/admin/settings') DynamicValueDockerChallenge.templates = { "create": f"/plugins/{plugin_name}/assets/create.html", "update": f"/plugins/{plugin_name}/assets/update.html", "view": f"/plugins/{plugin_name}/assets/view.html", } DynamicValueDockerChallenge.scripts = { "create": "/plugins/ctfd-whale/assets/create.js", "update": "/plugins/ctfd-whale/assets/update.js", "view": "/plugins/ctfd-whale/assets/view.js", } CHALLENGE_CLASSES["dynamic_docker"] = DynamicValueDockerChallenge page_blueprint = Blueprint("ctfd-whale", __name__, template_folder="templates", static_folder="assets", url_prefix="/plugins/ctfd-whale") CTFd_API_v1.add_namespace(admin_namespace, path="/plugins/ctfd-whale/admin") CTFd_API_v1.add_namespace(user_namespace, path="/plugins/ctfd-whale") @page_blueprint.route('/admin/settings') @admins_only def admin_list_configs(): errors = WhaleChecks.perform() if not errors and get_config("whale:refresh", "false"): DockerUtils.init() CacheProvider(app=current_app).init_port_sets() set_config("whale:refresh", "false") return render_template('whale_config.html', errors=errors) @page_blueprint.route("/admin/containers") @admins_only def admin_list_containers(): result = AdminContainers.get() view_mode = request.args.get('mode', session.get('view_mode', 'list')) session['view_mode'] = view_mode return render_template("whale_containers.html", plugin_name=plugin_name, containers=result['data']['containers'], pages=result['data']['pages'], curr_page=abs( request.args.get("page", 1, type=int)), curr_page_start=result['data']['page_start']) def auto_clean_container(): with app.app_context(): results = DBContainer.get_all_expired_container() containers = DBContainer.get_all_alive_container() config = ''.join([c.frp_config for c in containers]) try: # you can authorize a connection by setting # frp_url = http://user:pass@ip:port frp_addr = get_config("whale:frp_api_url") if not frp_addr: frp_addr = f'http://{get_config("whale:frp_api_ip", "frpc")}:{get_config("whale:frp_api_port", "7400")}' # backward compatibility common = get_config("whale:frp_config_template", '') if '[common]' in common: output = common + config else: remote = requests.get(f'{frp_addr.rstrip("/")}/api/config') assert remote.status_code == 200 set_config("whale:frp_config_template", remote.text) output = remote.text + config assert requests.put(f'{frp_addr.rstrip("/")}/api/config', output, timeout=5).status_code == 200 assert requests.get(f'{frp_addr.rstrip("/")}/api/reload', timeout=5).status_code == 200 except (requests.RequestException, AssertionError) as e: raise WhaleError( '\nfrpc request failed\n' + (f'{e}\n' if str(e) else '') + 'please check the frp related configs') from None app.register_blueprint(page_blueprint) try: CacheProvider(app=app).init_port_sets() DockerUtils.init() except Exception: warnings.warn("Initialization Failed. Please check your configs.", WhaleWarning) try: lock_file = open("/tmp/ctfd_whale.lock", "w") lock_fd = lock_file.fileno() fcntl.lockf(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() # scheduler.add_job( # id='whale-auto-clean', func=auto_clean_container, # trigger="interval", seconds=10 # ) print("[CTFd Whale] Started successfully") except IOError: pass
"func": "timedTask:job_1", "args": (3, 4), "trigger": "interval", "seconds": 5 # 不指定时间每5S执行一次 } ] SCHEDULER_API_ENABLED = True def get_user_table(): filename = "./getUserInfo.py" os.system("python2 " + filename) def job_1(a, b): print a + b if __name__ == '__main__': app = Flask(__name__) app.config.from_object(Config()) scheduler = APScheduler() # 创建定时任务 # scheduler.api_enabled = True scheduler.init_app(app) # 初始化flask实例 scheduler.start() # 开启定时任务,每次项目重启会执行一次定时任务再开始计时 app.run(host="0.0.0.0", port=8081, debug=True, threaded=True)
class TestViews(TestCase): def setUp(self): self.app = Flask(__name__) self.app.config['SCHEDULER_VIEWS_ENABLED'] = True self.scheduler = APScheduler(app=self.app) self.scheduler.start() self.client = self.app.test_client() def test_add_job(self): job = { 'id': 'job1', 'func': 'test_views:job1', 'trigger': 'date', 'run_date': '2020-12-01T12:30:01+00:00', } response = self.client.post('/scheduler/jobs', data=json.dumps(job)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('run_date'), job2.get('run_date')) def test_delete_job(self): self.__add_job() response = self.client.delete('/scheduler/jobs/job1') self.assertEqual(response.status_code, 204) response = self.client.get('/scheduler/jobs/job1') self.assertEqual(response.status_code, 404) def test_get_job(self): job = self.__add_job() response = self.client.get('/scheduler/jobs/job1') self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_get_all_jobs(self): job = self.__add_job() response = self.client.get('/scheduler/jobs') self.assertEqual(response.status_code, 200) jobs = json.loads(response.get_data(as_text=True)) self.assertEqual(len(jobs), 1) job2 = jobs[0] self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_update_job(self): job = self.__add_job() data_to_update = { 'args': [1] } response = self.client.patch('/scheduler/jobs/job1', data=json.dumps(data_to_update)) self.assertEqual(response.status_code, 200) job2 = json.loads(response.get_data(as_text=True)) self.assertEqual(job.get('id'), job2.get('id')) self.assertEqual(job.get('func'), job2.get('func')) self.assertEqual(data_to_update.get('args'), job2.get('args')) self.assertEqual(job.get('trigger'), job2.get('trigger')) self.assertEqual(job.get('minutes'), job2.get('minutes')) def test_pause_and_resume_job(self): self.__add_job() response = self.client.post('/scheduler/jobs/job1/pause') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNone(job.get('next_run_time')) response = self.client.post('/scheduler/jobs/job1/resume') self.assertEqual(response.status_code, 200) job = json.loads(response.get_data(as_text=True)) self.assertIsNotNone(job.get('next_run_time')) def __add_job(self): job = { 'id': 'job1', 'func': 'test_views:job1', 'trigger': 'interval', 'minutes': 10, } response = self.client.post('/scheduler/jobs', data=json.dumps(job)) return json.loads(response.get_data(as_text=True))
class TestScheduler(TestCase): def setUp(self): self.app = Flask(__name__) self.scheduler = APScheduler() self.scheduler_two = APScheduler(app=self.app) def test_running(self): self.assertFalse(self.scheduler.running) self.scheduler.start() self.assertTrue(self.scheduler.running) def test_start_with_allowed_hosts(self): self.app.config['SCHEDULER_ALLOWED_HOSTS'] = ['any_server_name'] self.scheduler.init_app(self.app) self.scheduler.start() self.assertFalse(self.scheduler.running) def test_start_without_allowed_hosts(self): self.app.config['SCHEDULER_ALLOWED_HOSTS'] = [] self.scheduler.init_app(self.app) self.scheduler.start() self.assertFalse(self.scheduler.running) def test_shutdown(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertTrue(self.scheduler.running) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_load_jobs_from_config(self): self.app.config['JOBS'] = [{ 'id': 'job1', 'func': 'tests.test_api:job1', 'trigger': 'interval', 'seconds': 10, }] self.app.config['SCHEDULER_JOBSTORES'] = { "default": apscheduler.jobstores.memory.MemoryJobStore() } self.app.config['SCHEDULER_EXECUTORS'] = { "default": { "type": "threadpool" } } self.app.config['SCHEDULER_JOB_DEFAULTS'] = {"coalesce": True} self.app.config['SCHEDULER_TIMEZONE'] = utc self.scheduler.init_app(app=self.app) job = self.scheduler.get_job('job1') self.assertIsNotNone(job) def test_task_decorator(self): @self.scheduler.task('interval', seconds=10, id='job1') def decorated_job(): pass job = self.scheduler.get_job('job1') self.assertIsNotNone(job) def test_state_prop(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertTrue(self.scheduler.state) self.scheduler.shutdown() self.assertFalse(self.scheduler.state) def test_scheduler_prop(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertIsNotNone(self.scheduler.scheduler) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_pause_resume(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertTrue(self.scheduler.running) self.scheduler.pause() self.assertTrue(self.scheduler.state == 2) self.scheduler.resume() self.assertTrue(self.scheduler.state == 1) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_add_listener(self): self.scheduler.init_app(self.app) self.scheduler.start() self.assertTrue(self.scheduler.running) self.scheduler.add_listener(None) self.scheduler.remove_listener(None) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_add_remove_job(self): @self.scheduler.task('interval', seconds=10, id='job1') def decorated_job(): pass self.scheduler.init_app(self.app) self.scheduler.start() job = self.scheduler.get_job('job1') self.assertIsNotNone(job) self.scheduler.remove_job('job1') self.assertFalse(self.scheduler.get_job('job1')) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_add_delete_job(self): @self.scheduler.task('interval', seconds=10, id='job1') def decorated_job(): pass self.scheduler.init_app(self.app) self.scheduler.start() job = self.scheduler.get_job('job1') self.assertIsNotNone(job) self.scheduler.delete_job('job1') self.assertFalse(self.scheduler.get_job('job1')) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_add_remove_all_jobs(self): @self.scheduler.task('interval', hours=1, id='job1') def decorated_job(): pass @self.scheduler.task('interval', hours=1, id='job2') def decorated_job2(): pass self.scheduler.init_app(self.app) self.scheduler.start() jobs = self.scheduler.get_jobs() self.assertTrue(len(jobs) == 2) self.scheduler.remove_all_jobs() self.assertFalse(self.scheduler.get_job('job1')) self.assertFalse(self.scheduler.get_job('job2')) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_add_delete_all_jobs(self): @self.scheduler.task('interval', hours=1, id='job1') def decorated_job(): pass @self.scheduler.task('interval', hours=1, id='job2') def decorated_job2(): pass self.scheduler.init_app(self.app) self.scheduler.start() jobs = self.scheduler.get_jobs() self.assertTrue(len(jobs) == 2) self.scheduler.delete_all_jobs() self.assertFalse(self.scheduler.get_job('job1')) self.assertFalse(self.scheduler.get_job('job2')) self.scheduler.shutdown() self.assertFalse(self.scheduler.running) def test_job_to_dict(self): @self.scheduler.task('interval', hours=1, id='job1', end_date=datetime.datetime.now(), weeks=1, days=1, seconds=99) def decorated_job(): pass self.scheduler.init_app(self.app) self.scheduler.start() job = self.scheduler.get_job('job1') self.assertIsNotNone(job) self.assertTrue(len(utils.job_to_dict(job))) self.scheduler.delete_job('job1') self.assertFalse(self.scheduler.get_job('job1')) self.scheduler.shutdown() self.assertFalse(self.scheduler.running)
try: handler.handle(body, signature) except InvalidSignatureError: print( "Invalid signature. Please check your channel access token/channel secret." ) abort(400) return 'OK' # linebot處理文字訊息 @handler.add(MessageEvent, message=TextMessage) def handle_message(event): # linebot關鍵字回傳訊息 if '小幫手' in event.message.text: replyMsg = FindKeyWordInText(text=event.message.text, userId=event.source.user_id) line_bot_api.reply_message(event.reply_token, TextSendMessage(text=replyMsg)) # 開始運作Flask if __name__ == "__main__": scheduler = APScheduler( BackgroundScheduler(timezone="Asia/Taipei")) # 例項化APScheduler scheduler.init_app(app) # 把任務列表放進flask scheduler.start() # 啟動任務列表 app.run(host='0.0.0.0')
def load(app): # upgrade() app.db.create_all() CHALLENGE_CLASSES["dynamic_docker"] = DynamicValueDockerChallenge register_plugin_assets_directory(app, base_path="/plugins/ctfd-docker/assets/") page_admin_blueprint = Blueprint("ctfd-docker-admin-page", __name__, template_folder="templates", static_folder="assets", url_prefix="/admin/plugins/ctfd-docker") @page_admin_blueprint.route('/settings', methods=['GET']) @admins_only def admin_list_configs(): configs = DBUtils.get_all_configs() return render_template('config.html', configs=configs) @page_admin_blueprint.route('/settings', methods=['PATCH']) @admins_only def admin_save_configs(): req = request.get_json() DBUtils.save_all_configs(req.items()) return json.dumps({'success': True}) @page_admin_blueprint.route("/containers", methods=['GET']) @admins_only def admin_list_containers(): configs = DBUtils.get_all_configs() page = abs(request.args.get("page", 1, type=int)) results_per_page = 50 page_start = results_per_page * (page - 1) page_end = results_per_page * (page - 1) + results_per_page count = DBUtils.get_all_alive_container_count() containers = DBUtils.get_all_alive_container_page(page_start, page_end) pages = int(count / results_per_page) + (count % results_per_page > 0) return render_template("containers.html", containers=containers, pages=pages, curr_page=page, curr_page_start=page_start, configs=configs) @page_admin_blueprint.route("/containers", methods=['DELETE']) @admins_only def admin_delete_container(): user_id = request.args.get('user_id') ControlUtil.remove_container(user_id) return json.dumps({'success': True}) @page_admin_blueprint.route("/containers", methods=['PATCH']) @admins_only def admin_renew_container(): user_id = request.args.get('user_id') challenge_id = request.args.get('challenge_id') DBUtils.renew_current_container(user_id=user_id, challenge_id=challenge_id) return json.dumps({'success': True}) app.register_blueprint(page_admin_blueprint) page_blueprint = Blueprint("ctfd-docker-page", __name__, template_folder="templates", static_folder="assets", url_prefix="/plugins/ctfd-docker") @page_blueprint.route('/container', methods=['POST']) @authed_only def add_container(): if ControlUtil.frequency_limit(): return json.dumps({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) user_id = current_user.get_current_user().id ControlUtil.remove_container(user_id) challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id) configs = DBUtils.get_all_configs() current_count = DBUtils.get_all_alive_container_count() if int(configs.get("docker_max_container_count")) <= int( current_count): return json.dumps({ 'success': False, 'msg': 'Max container count exceed.' }) dynamic_docker_challenge = DynamicDockerChallenge.query \ .filter(DynamicDockerChallenge.id == challenge_id) \ .first_or_404() flag = "flag{" + str(uuid.uuid4()) + "}" host = configs.get("docker_client_ip") while True: port = random.randint(10000, 50000) if ControlUtil.is_container_port_invalid(str(host), int(port)): break if ControlUtil.add_container(user_id=user_id, challenge_id=challenge_id, flag=flag, port=port): return json.dumps({'success': True}) else: return json.dumps({ 'success': False, 'msg': 'ERROR: container start failed' }) @page_blueprint.route('/container', methods=['GET']) @authed_only def list_container(): user_id = current_user.get_current_user().id challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id) data = DBUtils.get_current_containers(user_id=user_id) configs = DBUtils.get_all_configs() if data is not None: if int(data.challenge_id) != int(challenge_id): return json.dumps({}) return json.dumps({ 'success': True, 'type': 'redirect', 'ip': configs.get('docker_client_ip'), 'port': data.port, 'remaining_time': 3600 - (datetime.now() - data.start_time).seconds }) else: return json.dumps({'success': True}) @page_blueprint.route('/container', methods=['DELETE']) @authed_only def remove_container(): if ControlUtil.frequency_limit(): return json.dumps({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) user_id = current_user.get_current_user().id ControlUtil.remove_container(user_id) return json.dumps({'success': True}) @page_blueprint.route('/container', methods=['PATCH']) @authed_only def renew_container(): if ControlUtil.frequency_limit(): return json.dumps({ 'success': False, 'msg': 'Frequency limit, You should wait at least 1 min.' }) configs = DBUtils.get_all_configs() user_id = current_user.get_current_user().id challenge_id = request.args.get('challenge_id') ControlUtil.check_challenge(challenge_id) docker_max_renew_count = int(configs.get("docker_max_renew_count")) container = DBUtils.get_current_containers(user_id) if container.renew_count >= docker_max_renew_count: return json.dumps({ 'success': False, 'msg': 'Max renewal times exceed.' }) DBUtils.renew_current_container(user_id=user_id, challenge_id=challenge_id) return json.dumps({'success': True}) def auto_clean_container(): with app.app_context(): results = DBUtils.get_all_expired_container() for r in results: ControlUtil.remove_container(r.user_id) app.register_blueprint(page_blueprint) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job(id='whale-auto-clean', func=auto_clean_container, trigger="interval", seconds=10)
def task_init(): scheduler = APScheduler() scheduler.init_app(app) scheduler.start() refresh()
def create_app(testing=False): # create and configure the app app = Flask(__name__, instance_relative_config=True) # Load conf depending on the mode if testing: app.config.from_pyfile("test.conf.py", silent=False) elif app.env == "development": app.config.from_pyfile("back.conf.py", silent=False) elif app.env == "production": app.config.from_pyfile("/etc/config/back.conf.py", silent=False) else: raise ValueError("App mode unknow: not in dev|prod|test") # K8sManager configuration changes with app mode app.k8s = None if not testing: if app.env == "development": k8s_configuration = kubernetes.client.Configuration() k8s_configuration.verify_ssl = False k8s_configuration.debug = False k8s_configuration.host = app.config["K8S_HOST"] k8s_configuration.api_key["authorization"] = app.config[ "K8S_API_KEY"] k8s_configuration.api_key_prefix["authorization"] = "Bearer" app.k8s = kubernetes.client.ApiClient(k8s_configuration) else: kubernetes.config.load_incluster_config() app.k8s = kubernetes.client.ApiClient() app.mongo = PyMongo(app) if not testing: # Scheduler to kill old challenges if (not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true"): # avoid double task exec in dev scheduler = APScheduler() scheduler.init_app(app) scheduler.start() @scheduler.task( "cron", id="do_stop_old_participation", hour="*/{}".format( app.config["CHECK_OLD_CHALLENGES_INTERVAL_HOURS"]), ) def stop_old(): with app.app_context(): stop_old_participations() login_manager = LoginManager() login_manager.init_app(app) app.logger = create_logger(app) @login_manager.user_loader def load_user(user_id): return UserManager().get(user_id) @app.errorhandler(EmmentalException) def handle_emmental_exception(e): app.logger.error(traceback.format_exc()) app.logger.error(e.internal_message) response = jsonify({ "error_code": e.error_code, "error_message": e.external_message, }) return response, e.status_code @app.errorhandler(Exception) def handle_exception(e): app.logger.error(traceback.format_exc()) response = jsonify({ "error_code": -1, "error_message": "Unknown Error", }) return response, 500 app.register_blueprint(users) app.register_blueprint(challenges) app.register_blueprint(challenge_categories) app.register_blueprint(challenge_participations) @app.route("/config") def config(): res = { "version": "0.0.1", "isAuthenticated": current_user.is_authenticated, "env": app.env, } if current_user.is_authenticated: res.update({"currentUser": current_user.to_dict()}) return jsonify(res) return app