from isserviceup.api import status as status_bp
from isserviceup.api import user as user_bp
from isserviceup.config import config
from isserviceup.helpers import exceptions
from isserviceup.helpers.exceptions import ApiException
static_url_path = '' if config.SERVE_STATIC_FILES else None
static_folder = '../frontend/dist' if config.SERVE_STATIC_FILES else None
app = Flask(__name__, static_url_path=static_url_path, static_folder=static_folder)
app.config.from_object(config)
app.debug = config.DEBUG
CORS(app)
sentry = None
if config.SENTRY_DSN:
sentry = Sentry(app, logging=True, level=logging.ERROR)
@app.errorhandler(Exception)
def handle_generic_exception(error):
print('Exception={}'.format(error))
traceback.print_exc()
if sentry:
sentry.captureException()
return exceptions.handle_exception(error)
app.register_blueprint(status_bp.mod, url_prefix='/status')
app.register_blueprint(auth_bp.mod, url_prefix='/auth')
from . import storage
# Application Basics
# ------------------
app = Flask(__name__)
app.secret_key = os.environ.get('APP_SECRET', 'CHANGEME')
app.debug = True
# Flask-Common.
common = Common(app)
# Sentry for catching application errors in production.
if 'SENTRY_DSN' in os.environ:
sentry = Sentry(app, dsn=os.environ['SENTRY_DSN'])
# Auth0 Integration
# -----------------
auth_id = os.environ['AUTH0_CLIENT_ID']
auth_secret = os.environ['AUTH0_CLIENT_SECRET']
auth_callback_url = os.environ['AUTH0_CALLBACK_URL']
auth_domain = os.environ['AUTH0_DOMAIN']
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
if 'profile' not in session:
return redirect('/')
from flask import jsonify, request
from marshmallow.exceptions import ValidationError
from raven.contrib.flask import Sentry
import traceback
import json
sentry = Sentry()
class ErrorCodes:
MALFORMED_OR_MISSING_BASIC_AUTH = 'MALFORMED_OR_MISSING_BASIC_AUTH'
UNKNOWN_ERROR = 'UNKNOWN_ERROR'
class BaseException(Exception):
# allows for a common parent.
def __init__(self):
self.status_code = 500
self.error_code = ErrorCodes.UNKNOWN_ERROR
pass
class AuthenticationException(BaseException):
def __init__(self, message, error_code=None):
Exception.__init__(self)
self.message = message
self.error_code = error_code
self.status_code = 401
def make_client_and_raven(self, *args, **kwargs):
app = create_app(*args, **kwargs)
raven = TempStoreClient()
Sentry(app, client=raven)
return app.test_client(), raven
app = Flask(__name__)
app.config.from_object(config[config_name])
qiniu.init_app(app)
iosqn.init_app(app)
mail.init_app(app)
from apis import api
app.register_blueprint(api, url_prefix='/api')
return app
# restccnu app(flask app)
app = create_app()
# sentry app
sentry = Sentry(app, dsn=os.getenv('DSN_KEY'))
@app.route('/')
def index():
"""
:function: index
:args: none
:rv: html response
华师匣子下载主页
"""
platform = request.user_agent.platform
if platform in ["android", "iphone", "ipad"]:
return render_template('mobile-index.html')
else:
from flask_cors import CORS
import graphene
from mongoengine import connect
from raven.contrib.flask import Sentry
import query
with open('./playground_template.html', 'r') as myfile:
render_graphiql.TEMPLATE = myfile.read()
app = Flask(__name__)
app.debug = True
CORS(app)
Sentry(app)
connect(
os.getenv('GOLOS_DB_NAME', 'dacom'),
username=os.getenv('MONGO_USER'),
password=os.getenv('MONGO_PASSWORD'),
host=os.getenv('MONGO_HOST', 'localhost'),
port=int(os.getenv('MONGO_PORT', 27017))
)
# TODO Default query
default_query = """
{
post(identifier: "@avral/ru-golos-ql-anons-graphql-servera-dlya-golosa") {
title,
from data.proposal import summary_file
from data.technical_review import update_liaison_astronomers, update_reviews
from schema.query import schema
from util.action import Action
from util.error import InvalidUsage
from util.proposal_summaries import zip_proposal_summaries
from util.user import basic_login, get_user_token, is_valid_token, create_token
app = Flask(__name__)
# Set CORS options on app configuration
app.config['CORS_HEADERS'] = "Content-Type"
app.config['CORS_RESOURCES'] = {r"/*": {"origins": "*"}}
sentry = None
if os.environ.get('SENTRY_DSN'):
sentry = Sentry(app, dsn=os.environ.get('SENTRY_DSN'))
else:
app.debug = True
token_auth = HTTPTokenAuth(scheme='Token')
basic_auth = HTTPBasicAuth()
multi_auth = MultiAuth(HTTPBasicAuth, HTTPTokenAuth)
@token_auth.verify_token
def verify_token(token):
g.user_id = None
try:
is_valid = is_valid_token(token)
return is_valid
except:
import logging
import os
logger = logging.getLogger(__name__)
if 'SENTRY_DSN' in os.environ:
from raven.contrib.flask import Sentry
sentry = Sentry(logging=True, level=logging.INFO)
else:
class FakeSentry:
def init_app(self, *args, **kwargs):
pass
def captureMessage(self, message, *args, **kwargs):
logger.info(message, *args, **kwargs)
def captureException(self, *args, **kwargs):
logger.exception('Error')
sentry = FakeSentry() # noqa
ADMINS, 'error')
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
from logging.handlers import RotatingFileHandler
from logging import Formatter
def setup_logging(app):
log_file_path = app.config.get('LOG_FILE')
log_level = app.config.get('LOG_LEVEL', logging.WARN)
if log_file_path:
file_handler = RotatingFileHandler(log_file_path)
file_handler.setFormatter(Formatter(
'%(name)s:%(levelname)s:[%(asctime)s] %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
file_handler.setLevel(log_level)
app.logger.addHandler(file_handler)
logger = logging.getLogger('pybossa')
logger.setLevel(log_level)
logger.addHandler(file_handler)
login_manager = LoginManager()
login_manager.login_view = 'account.signin'
login_manager.login_message = u"Please sign in to access this page."
app = create_app()
db = SQLAlchemy(app)
mail = Mail(app)
signer = URLSafeTimedSerializer(app.config['ITSDANGEORUSKEY'])
if app.config.get('SENTRY_DSN'):
sentr = Sentry(app)
from flask import Flask
from flask.ext import restful
from backend.register import RegisterUser
from backend.search import Search
from backend.search import BoxOffice
from backend.search import Upcoming
from backend.trailer import Trailers,Trailer
from backend.pins import PinMovie, MyPins, UnPin
from backend.gcmclient import GCMClient
from raven.contrib.flask import Sentry
app = Flask(__name__)
api = restful.Api(app)
sentry = Sentry(app,dsn='https://*****:*****@app.getsentry.com/23855')
api.add_resource(RegisterUser, '/users/')
api.add_resource(PinMovie, '/pin/')
api.add_resource(Search, '/search/<string:search_string>/')
#api.add_resource(Trailers, '/trailers/<string:search_string>/')
api.add_resource(Upcoming, '/upcoming/')
api.add_resource(BoxOffice, '/boxoffice/')
api.add_resource(MyPins, '/mypins/')
api.add_resource(UnPin, '/unpin/')
api.add_resource(GCMClient, '/gcm/')
api.add_resource(Trailer, '/trailers/<string:search_string>/')
#api.add_resource(Showtimes, '/showtimes/<string:movie>/')
if __name__ == '__main__':
app.run(debug=True)
def get_token(self):
return session.get('user_token')
app = Flask("SaltPad", template_folder="templates")
app.config.from_object('settings')
# Setup logging
if not app.debug:
from logging import FileHandler
app.logger.addHandler(FileHandler(app.config['LOG_FILE']))
# Setup sentry
try:
from raven.contrib.flask import Sentry
sentry = Sentry(app, dsn=app.config['SENTRY_DSN'])
except ImportError:
if app.config.get('SENTRY_DSN'):
install_cmd = "pip install raven[flask]"
print "Couldn't import raven, please install it with '%s'" % install_cmd
sys.exit(1)
client = FlaskHTTPSaltStackClient(app.config['API_URL'],
app.config.get('VERIFY_SSL', True))
from flask_wtf import Form
from wtforms import StringField, PasswordField, TextAreaField
from wtforms.validators import DataRequired
class LoginForm(Form):
def test_does_add_to_extensions(self):
client = TempStoreClient()
sentry = Sentry(self.app, client=client)
self.assertIn('sentry', self.app.extensions)
self.assertEquals(self.app.extensions['sentry'], sentry)
application.logger.addHandler(handler)
# API logger
logger.setLevel(logging.DEBUG)
# lib logger
formatter = logging.Formatter('%(asctime)s - %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
liblog = logging.getLogger('f8a_jobs')
liblog.setLevel(logging.DEBUG)
liblog.addHandler(handler)
app = connexion.App(__name__)
app.app.wsgi_app = ProxyFix(app.app.wsgi_app)
sentry = Sentry(app.app,
dsn=defaults.SENTRY_DSN,
logging=True,
level=logging.ERROR)
application = app.app
# Setup Logging
logger = logging.getLogger(__name__)
init_logging(logger)
app.add_api(defaults.SWAGGER_YAML_PATH)
# Expose for uWSGI
application.json_encoder = SafeJSONEncoder
manager = Manager(application)
# Needed for session
try:
# Due: https://www.python.org/dev/peps/pep-0476
import ssl
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
except ImportError:
pass
application = Flask(__name__)
sentry = Sentry(application)
sentry.captureMessage("Modul backend inicat", level=logging.INFO)
Backend(application, url_prefix='/')
required = [
'openerp_server',
'openerp_database',
]
config = config_from_environment('BACKEND', required, session_cookie_name=None)
for k, v in config.items():
k = k.upper()
print('CONFIG: {0}: {1}'.format(k, v))
if v is not None:
application.config[k] = v
if __name__ == "__main__":
application.run(host='0.0.0.0', debug=True)
if exc_value is e:
reraise(exc_value, tb)
else:
raise e
self.log_exception((exc_type, exc_value, tb))
if handler is None:
return InternalServerError()
return handler(e, tb) # don't forget traceback argument in your handler!
app = TracebackFlask(__name__)
app.config.from_pyfile('flask.cfg')
config = configparser.ConfigParser()
config.read(app.root_path + "/tools4lulz.ini")
sentry_dsn = config["sentry"]["dsn"]
if not app.debug:
sentry = Sentry(app, dsn=sentry_dsn)
# registering modules
app.register_blueprint(server.server_view, static_folder=app.static_folder)
app.register_blueprint(banhammer.banhammer_view, url_prefix="/banhammer", static_folder=app.static_folder)
app.register_blueprint(vk_utils.vk_view, url_prefix="/vk", static_folder=app.static_folder)
app.register_blueprint(ipg.ipg_view, url_prefix="/ipg", static_folder=app.static_folder)
if __name__ == '__main__':
app.run(app.config['IP'], app.config['PORT'])
def add_error_reporting(app):
sentry = Sentry(app) # set SENTRY_DSN env!
app.add_url_rule('/sentry', 'is_sentry', is_sentry(sentry))
return sentry
import json
import urllib.request
import sys
from flask import Flask, request, make_response, jsonify
from raven.contrib.flask import Sentry
import app_config
from tasks import run_scripts
app = Flask(__name__)
app.config.from_object(app_config)
app.url_map.strict_slashes = False
sentry = Sentry(app, dsn=app_config.SENTRY_DSN)
# expects GeoJSON object as a string
# client will need to use JSON.stringify() or similar
class AppError(Exception):
def __init__(self, message, status_code=None, payload=None):
Exception.__init__(self)
self.message = message
if status_code is not None:
self.status_code = status_code
self.payload = payload
def to_dict(self):
rv = dict(self.payload or ())
from sqlalchemy.types import DateTime, Integer
from pipet.utils.celery import make_celery
class Base(Model):
id = Column(Integer, primary_key=True)
created = Column(DateTime, server_default=func.now(), nullable=False)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
load_dotenv()
csrf = CSRFProtect()
db = SQLAlchemy(model_class=Base)
login_manager = LoginManager()
sentry = Sentry(logging=True, level=logging.ERROR, wrap_wsgi=True)
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('POSTGRES_URI')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SERVER_NAME'] = os.environ.get('SERVER_NAME', None)
app.config['PREFERRED_URL_SCHEME'] = os.environ.get('PREFERRED_URL_SCHEME')
app.config['GOOGLE_PICKER_API_KEY'] = os.environ.get(
'GOOGLE_PICKER_API_KEY')
app.config['WEBPACK_MANIFEST_PATH'] = 'static/build/manifest.json'
app.secret_key = os.environ.get('FLASK_SECRET_KEY')
return app
from lib.utils.queries import (SELECT_SITE_HEADERS, GET_HTTP_HEADER_PERCENT)
load_env_config()
db = MySQL()
compress = Compress()
app = Flask(__name__, static_folder="static")
app.secret_key = 'some_secret'
app.config['COMPRESS_MIMETYPES'] = os.getenv('MIME_TYPES').split(',')
app.register_blueprint(api_header.bp)
app.register_blueprint(api_headers.bp)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
if os.getenv("SENTRY_ENABLED"):
sentry = Sentry(
app,
dsn='%s' % os.getenv(
'SENTRY_DSN',
'https://*****:*****@sentry.io/144923'
))
sentry = Sentry(app, dsn='%s' % os.getenv('SENTRY_DSN', ''))
compress.init_app(app)
cache.init_app(app)
@cache.cached(timeout=600)
@app.route('/service-worker.js')
def service_worker():
return send_from_directory('static/', 'service-worker.js')
@app.route('/')
def index():
# -*- coding: utf-8 -*-
import logging
from flask import Flask
from raven.contrib.flask import Sentry
import config.config as cf
from flask_bootstrap import Bootstrap
from flask_moment import Moment
app = Flask(__name__)
# app.config.from_object('config')
app.config.from_pyfile('../config/config.py')
sentry = Sentry(dsn=cf.SENTRY_SECRECT, logging=True, level=logging.DEBUG)
def create_app():
sentry.init_app(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
from app.views.login import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from app.views.wx import wx as wx_blueprint
app.register_blueprint(wx_blueprint, url_prefix='/wx')
from app.views.home import home as home_blueprint
app.register_blueprint(home_blueprint)
from app.views.errors import error as error_blueprint
def bind_sentry(self):
self.raven = TempStoreClient()
self.middleware = Sentry(self.app, client=self.raven)
app.register_blueprint(mobile_pages.mobile_pages)
app.register_blueprint(system_admin_pages.system_admin_pages)
app.register_blueprint(survey_designer.survey_designer)
app.register_blueprint(admin_api.admin_api)
app.register_blueprint(participant_administration.participant_administration)
app.register_blueprint(survey_api.survey_api)
app.register_blueprint(data_access_api.data_access_api)
app.register_blueprint(data_access_web_form.data_access_web_form)
app.register_blueprint(copy_study_api.copy_study_api)
app.register_blueprint(data_pipeline_api.data_pipeline_api)
app.register_blueprint(dashboard_api.dashboard_api)
# Don't set up Sentry for local development
if os.environ['DJANGO_DB_ENV'] != 'local':
sentry = Sentry(app, dsn=SENTRY_ELASTIC_BEANSTALK_DSN)
@app.route("/<page>.html")
def strip_dot_html(page):
# Strips away the dot html from pages
return redirect("/%s" % page)
@app.context_processor
def inject_dict_for_all_templates():
return {"SENTRY_JAVASCRIPT_DSN": SENTRY_JAVASCRIPT_DSN}
# Extra Production settings
if not __name__ == '__main__':
Talisman(
app,
content_security_policy={
"style-src": [
"'self'",
"'unsafe-inline'",
"maxcdn.bootstrapcdn.com",
"fonts.googleapis.com",
"fonts.gstatic.com",
],
"script-src": [
"'self'",
"'unsafe-inline'",
"code.jquery.com",
"cdn.ravenjs.com",
"https://cdn.usefathom.com",
],
"img-src":
["'self'", "camo.githubusercontent.com", "https://*.usefathom.com"],
"content_security_policy_report_uri":
("https://sentry.io/api/132394/security/"
"?sentry_key=c813e4a1c67c4965a1ef3d6e2949d76b"),
},
)
# Sentry DSN should be configured by setting SENTRY_DSN environment variable.
# Other configuration is done in app.config.SENTRY_CONFIG.
sentry = Sentry(app,
logging=True,
level=logging.getLevelName(app.config.get("LOG_LEVEL")))
registry=registry
)
return gauge, request_count_gauge, time_count_gauge
# Initialize flask app
app = Flask(__name__)
# Setup Logging
setup_logging(app)
# Get gauge, histogram and counter handles
gauge, request_count_gauge, time_count_gauge = init_prometheus_client()
SENTRY_DSN = os.environ.get("SENTRY_DSN", "")
sentry = Sentry(app, dsn=SENTRY_DSN, logging=True, level=logging.ERROR)
app.logger.info('App initialized, ready to roll...')
def create_custom_gauge_metrics():
"""Create custom gauge metrics to maintain moving average.
Group by Method Type, Endpoint Name, Status Code.
"""
global total_gauge_time
total_gauge_time = {}
global total_gauge_count
total_gauge_count = {}
global reset_counter
populate_gauge_dicts()
import os
from flaskext.mysql import MySQL
from raven.contrib.flask import Sentry
mysql = MySQL()
RAVEN_DSN = os.getenv('RAVEN_DSN')
sentry = Sentry(dsn=RAVEN_DSN) if RAVEN_DSN else None
import logging from flask_sqlalchemy import SQLAlchemy from flask_marshmallow import Marshmallow from raven.contrib.flask import Sentry from black_market.config import SENTRY_DSN sentry = Sentry(logging=True, level=logging.ERROR, dsn=SENTRY_DSN) db = SQLAlchemy() ma = Marshmallow()
"""Assetdb app setup. """
import logging
import os
from flask import Flask
from raven.contrib.flask import Sentry
from flask_restful import Api
from .. import __about__
APP = Flask(__about__.__name__)
API = Api(APP, prefix='/api')
if os.getenv('ASSETDB_DEBUG'):
logging.basicConfig(level=logging.DEBUG)
else:
SENTRY = Sentry(APP, logging=bool(os.getenv('SENTRY_DSN')),
level=logging.WARNING)
import jinja2
import eve
import settings
import superdesk
from flask.ext.mail import Mail
from eve.io.mongo import MongoJSONEncoder
from eve.render import send_response
from superdesk import signals
from superdesk.celery_app import init_celery
from eve.auth import TokenAuth
from superdesk.storage.desk_media_storage import SuperdeskGridFSMediaStorage
from superdesk.validator import SuperdeskValidator
from raven.contrib.flask import Sentry
logger = logging.getLogger('superdesk')
sentry = Sentry(register_signal=False, wrap_wsgi=False)
def get_app(config=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
for key in dir(settings):
if key.isupper():
config.setdefault(key, getattr(settings, key))
"hint_false": {"type": "string"},
"hint_true": {"type": "string"},
"required": {"type": "string"},
"tester": {"type": "string"},
'''
count_malformedjson = 0
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'[%(levelname)s][%(asctime)s][PID:%(process)d] - %(message)s')
ch.setFormatter(formatter)
app = Flask(__name__)
app.logger.handlers = []
app.logger.addHandler(ch)
sentry = Sentry(app)
@app.route('/status', methods=['GET'])
def get_tasks():
app.logger.info('Returning status')
return jsonify({
'count_total': Question.count_total,
'count_error': Question.count_error,
'count_timeout': Question.count_timeout,
'version_flask': flask.__version__,
'version_sympy': sympy.__version__
})
@app.route('/test', methods=['POST'])
static_folder=os.path.join(os.path.dirname(__file__), '..',
'public'),
template_folder=os.path.join(os.path.dirname(__file__), '..',
'public'))
app.secret_key = settings.FLASK_SECRET_KEY
url_parts = urlparse(settings.BASE_URL)
app.config['SERVER_NAME'] = url_parts.netloc
app.config['JSONIFY_MIMETYPE'] = 'application/json; charset=utf-8'
app.config['MAX_CONTENT_LENGTH'] = settings.FLASK_MAX_CONTENT_LENGTH
# Register Flask integrations
oauth.init_app(app)
login_manager.init_app(app)
if settings.SENTRY_DSN:
Sentry(app, dsn=settings.SENTRY_DSN)
# Register blueprints
app.register_blueprint(api)
app.register_blueprint(site)
app.register_blueprint(user)
# Register integrations
app.register_blueprint(github)
app.register_blueprint(s3)
# Set error handlers
@app.errorhandler(401)
def not_authorized_error(err):
return _error_response(401, err)
