def __init__(self): engine_options = { "pool_timeout": config.get("DB_POOL_TIMEOUT", 30), "pool_recycle": config.get("DB_POOL_RECYCLE", -1), "pool_size": config.get("DB_POOL_SIZE", 5), "max_overflow": config.get("DB_MAX_OVERFLOW", 10), "pool_pre_ping": config.get("DB_POOL_PRE_PING", False), } super().__init__(declarative_base=Base, engine_options=engine_options)
def setup(self): host = config.get("GRPC_BIND_HOST", "0.0.0.0") port = config.get("GRPC_BIND_PORT", 50051) ssl = SslConfig(config.get("GRPC_SSL")) def spawn_thread(target, args=(), kwargs=None, name=None): self.container.spawn_managed_thread( lambda: target(*args, **kwargs or {}), identifier=name) self.channel = ServerChannel(host, port, ssl, spawn_thread, self.handle_request)
def __init__(self, exception): self.exception = exception if config.get('MAX_RETRY_TIME') is not None: self.max_retry_time = config.get('MAX_RETRY_TIME') else: self.max_retry_time = 1 if config.get('MAX_RETRY') is not None: self.max_retries = config.get('MAX_RETRY') else: self.max_retries = 1
def setup(self): self.elasticsearch = Elasticsearch() self.index = config.get('ELASTIC_INDEX') host = config.get('ELASTIC_HOST') port = config.get('ELASTIC_PORT') username = config.get('ELASTIC_USER') password = config.get('ELASTIC_PASS') self.elasticsearch = Elasticsearch([f"{host}:{port}"], http_auth=(username, password), sniff_on_start=True, sniff_on_connection_fail=True, sniffer_timeout=60)
def auth_user(self, email, password): is_correct_password = self.storage.users.is_correct_password( email, password) if not is_correct_password: raise UserNotAuthorised("user not authorised for this request") # not the most ideal code but i want to keep the # requests here to storage quite easy to test # and maintain user_details = self.storage.users.get_from_email(email) if not user_details["verified"]: raise UserNotVerified("user is not verified") jwt_result = { "JWT": jwt.encode( { "user_id": user_details["id"], "email": user_details["email"], # exp is number of seconds since epoch. 1 day expiry "exp": datetime.datetime.utcnow() + datetime.timedelta(days=1), }, config.get("JWT_SECRET"), algorithm="HS256", ).decode("utf-8") } return jwt_result
def __init__(self, method, url, expected_exceptions=(), **kwargs): super().__init__(method, url, expected_exceptions=expected_exceptions) cors = config.get("DEFAULT_CORS", "*").split(",") self.allowed_origin = kwargs.get("origin", cors) self.allowed_methods = kwargs.get("methods", ["*"]) self.allow_credentials = kwargs.get("credentials", True) self.standard_mapped_errors_tuple = tuple( self.standard_mapped_errors.keys()) self.rate_limit = kwargs.get("rate_limit") self.private_rate_limit = kwargs.get("private_rate_limit") self.auth_required = kwargs.get("auth_required", False) if self.rate_limit is not None and not self.auth_required: raise ValueError( "if public rate limit is defined then auth_required must be true" ) if self.rate_limit and self.private_rate_limit: raise ValueError( "cant define an entrypoint with a public and private rate limit" ) if self.rate_limit or self.private_rate_limit: store_redis_rate_limit_for_url( self.url, self.rate_limit or self.private_rate_limit)
def setup(self): self.redis_client = walrus.Database().from_url(config.get("REDIS_URL")) self.consumer_group = self.redis_client.consumer_group( self.consumer_group, self.streams) self.consumer_group.create() # todo: investigate what this does! self.consumer_group.set_id(id="$")
def __init__(self, method, url, expected_exceptions=(), **kwargs): super().__init__(method, url, expected_exceptions=expected_exceptions) cors = config.get("DEFAULT_CORS", "*").split(",") self.allowed_origin = kwargs.get("origin", cors) self.allowed_methods = kwargs.get("methods", ["*"]) self.allow_credentials = kwargs.get("credentials", True) self.standard_mapped_errors_tuple = tuple(self.standard_mapped_errors.keys()) self.auth_required = kwargs.get("auth_required", False)
def setup(self): self.connection = rabbitpy.Connection(config.get(AMQP_URI_KEY)) self.channel = self.connection.channel() self.exchange = rabbitpy.Exchange(self.channel, 'exch_pi') self.exchange.declare() queue = rabbitpy.Queue( self.channel, 'q_pi_buzzer', arguments={'x-message-ttl': 3600000}) # 1h queue.declare() queue.bind(self.exchange, ROUTING_KEY)
def __init__(self): # setup logging logging.basicConfig( stream=sys.stdout, # filename=config.get('DEFAULT', 'log_file'), level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') self.db_engine = create_engine(config.get('db_connection'), connect_args={'connect_timeout': 60}) DbHelper(self.db_engine).init_db() self.lcms = [] self.s_orchs = []
def test_jwt_required_works_correctly_on_class(config): valid_token = jwt.encode({"test": "123"}, nameko_config.get("JWT_SECRET"), algorithm="HS256") mock_request = Mock() mock_request.headers = {"Authorization": valid_token.decode("utf-8")} service = FakeService() result = service.fake_function(mock_request) assert result == {"test": "123"}
def page(self, last): limit = config.get(PAGINATION_KEY) if last is None: chunk = self.collection.find().limit(limit) else: chunk = self.collection.find({ '_id': { '$gt': ObjectId(last) } }).limit(limit) data = [x for x in chunk] if not data: return None, None last_id = str(data[-1]['_id']) return data, last_id
def __init__(self, exchange=None, declare=None, **publisher_options): super(SchedulerPublisher, self).__init__(exchange=exchange, declare=declare, **publisher_options) default_ssl = config.get(AMQP_SSL_CONFIG_KEY) ssl = self.publisher_options.pop("ssl", default_ssl) with get_connection(self.amqp_uri, ssl) as conn: for entity in self.declare: maybe_declare(entity, conn.channel()) serializer = self.publisher_options.pop("serializer", "json") self.publisher = self.publisher_cls(self.amqp_uri, ssl=ssl, serializer=serializer, exchange=self.exchange, declare=self.declare, **self.publisher_options)
def test_jwt_required_raises_error_if_jwt_expired(config): mock_request = Mock() # exp is the expiry time epoch. # (1577208307 ~ 2019 - 12 - 24 @ 5:30pm UTC Christmas Eve) jwt.encode( { "test": "123", "exp": 1577208307 }, nameko_config.get("JWT_SECRET"), algorithm="HS256", ) mock_request.headers = {"Authorization": "random token!"} service = FakeService() with pytest.raises(UserNotAuthorised): service.fake_function(mock_request)
def default_error_from_exception(exc_info, code=None, message=None): """ Create a new GrpcError instance representing an underlying exception. If the `GRPC_DEBUG` key is set in the Nameko config, the `status` message will capture the underyling traceback in a `google.rpc.error_details.DebugInfo` message. """ exc_type, exc, tb = exc_info code = code or StatusCode.UNKNOWN message = message or str(exc) status = Status(code=STATUS_CODE_ENUM_TO_INT_MAP[code], message=message) if config.get("GRPC_DEBUG"): debug_info = Any() debug_info.Pack( DebugInfo( stack_entries=traceback.format_exception(*exc_info), detail=str(exc), ) ) status.details.append(debug_info) return GrpcError(code=code, message=message, status=status)
def decorator(*args, **kwargs): request = args[1] # https://security.stackexchange.com/a/205701 jwt_header = get_jwt_header(request) if not jwt_header: raise UserNotAuthorised() try: jwt_data = jwt.decode(jwt_header, config.get("JWT_SECRET"), algorithms=["HS256"]) request.jwt_data = jwt_data args = list(args) args[1] = request # todo: inject into request here! except ExpiredSignatureError: # todo: mainly here incase in the future we want to handle this # better for the flow for a user raise UserNotAuthorised() except InvalidTokenError: raise UserNotAuthorised() return fn(*args, **kwargs)
def setup(self): self.stripe = stripe self.stripe.api_key = config.get("STRIPE").get("API_KEY")
def __init__(self, *args, **kwargs): ssl = kwargs.pop("ssl", config.get("GRPC_SSL")) super().__init__(*args, ssl=ssl, **kwargs)
def redis_client(test_config): client = redis.StrictRedis.from_url(config.get(REDIS_URI_KEY)) yield client client.flushdb()
def setup(self): self.key = config.get("SENDGRID_KEY") self.web_app_address = config.get("WEB_APP_ADDRESS")
def setup(self): self.client = redis.StrictRedis.from_url(config.get(REDIS_URI_KEY))
def setup(self): self.redis_uri = config.get("REDIS_URL", "redis://127.0.0.1:6379/0")
def get_redis_connection(): redis_url = config.get("REDIS_URL", "redis://127.0.0.1:6379/0") return walrus.Database().from_url(redis_url)
def setup(self): self.api_key = config.get("STRIPE").get("API_KEY")
def __init__(self): self.retries = config.get('nr_retries') self.retires_interval = config.get('retires_interval')
import os from apscheduler.schedulers.background import BackgroundScheduler from kombu.common import maybe_declare from nameko import config from nameko.amqp.publish import get_connection from nameko.constants import AMQP_SSL_CONFIG_KEY from nameko.extensions import DependencyProvider from nameko.messaging import encode_to_headers, Publisher from nameko.standalone.events import get_event_exchange from nameko_apscheduler.schema import SchedulerSchema from nameko_apscheduler.utils import get, delete EXCHANGE_NAME = config.get("APSCHDULER", {}).get("exchange_name", "nameko-apscheduler") class SchedulerPublisher(Publisher): def __init__(self, exchange=None, declare=None, **publisher_options): super(SchedulerPublisher, self).__init__(exchange=exchange, declare=declare, **publisher_options) default_ssl = config.get(AMQP_SSL_CONFIG_KEY) ssl = self.publisher_options.pop("ssl", default_ssl) with get_connection(self.amqp_uri, ssl) as conn: for entity in self.declare: maybe_declare(entity, conn.channel()) serializer = self.publisher_options.pop("serializer", "json")
def setup(self): secret = config.get("JWT_SECRET") if not secret: raise ConfigurationError("Not found `JWT_SECRET`.") self.secret = secret
def setup(self): self.host = config.get('REDIS_HOST') self.port = config.get('REDIS_PORT') self.db = config.get('REDIS_DB') self.password = config.get('REDIS_PASS')
def create_appointment(self, request): """ Saves a new Appointment :param request: new Appointment that should be saved :return: 201 Detailed information for newly created Appointment :return: 404 No Treatment for given TreatmentID :return: 409 Appointment Details do not match the requirements :return: 500 Connection Error """ appointment_detail = json.loads(request.get_data()) if appointment_detail['start_time'] >= appointment_detail['end_time']: return 409, "Start time has to be before end time.\n" elif appointment_detail['start_time'] < 8 or appointment_detail[ 'start_time'] > 17 or appointment_detail[ 'end_time'] < 9 or appointment_detail['end_time'] > 18: return 409, "Appointments are only available from 8 - 18. Please choose another timeslot.\n" try: URL = "http://" + config.get( 'TREATMENTS_SERVICE') + "/treatments/" + str( appointment_detail['treatment_id']) t_response = requests.get(url=URL) t_response.encoding = 'utf-8' treatment_data = literal_eval(t_response.text) except SyntaxError: return 404, "No Treatment exists for given TreatmentID.\n" except requests.exceptions.ConnectionError: return 500, "Could not read Treatments.\n" if treatment_data['minduration'] > (appointment_detail['end_time'] - appointment_detail['start_time']): return 409, "An appointment for " + treatment_data[ 'name'] + " takes at least " + str( treatment_data['minduration'] ) + " hour(s). Please choose another timeslot.\n" elif treatment_data['maxduration'] < ( appointment_detail['end_time'] - appointment_detail['start_time']): return 409, "An appointment for " + treatment_data[ 'name'] + " takes maximum " + str( treatment_data['maxduration'] ) + " hour(s). Please choose another timeslot.\n" try: conflicts = 0 appointments = self.db.session.query(Appointment).all() for appointment in appointments: if treatment_data['name'] == appointment.treatment_name: if appointment_detail['date'] == appointment.date.strftime( "%Y-%m-%d"): if not (appointment_detail['start_time'] <= appointment.start_time and appointment_detail['end_time'] <= appointment.start_time) and not ( appointment.end_time <= appointment_detail['end_time'] and appointment.end_time <= appointment_detail['start_time']): conflicts += 1 if conflicts == 0: newappointment = Appointment( treatment_id=appointment_detail['treatment_id'], treatment_name=treatment_data['name'], customer_name=appointment_detail['customer_name'], date=appointment_detail['date'], start_time=appointment_detail['start_time'], end_time=appointment_detail['end_time'], duration=appointment_detail['end_time'] - appointment_detail['start_time']) with self.db.get_session() as session: session.add(newappointment) appointment_detail['treatment_name'] = treatment_data['name'] self.dispatch("booked_appointment", appointment_detail) return 201, u"\nAppointment: {}".format(appointment_detail) else: return 409, "There were " + str( conflicts ) + " conflicts with other appointments. Please choose a free timeslot.\n" except exc.SQLAlchemyError: return 500, "Could not save Appointment.\n"
def setup(self): self.client = MongoClient(config.get(MONGODB_URI_KEY)) self.db = self.client.streams