def test_engine_options_setup(config, container): engine_options = { 'pool_size': 100, 'pool_recycle': 3600, } db_session = DatabaseSession(DeclBase, engine_options=engine_options) db_session = db_session.bind(container, 'database') db_session.setup() assert db_session.engine.pool.size == 100 assert db_session.engine.pool._recycle == 3600
def test_session_options_setup(config, container): session_options = { 'autoflush': False, 'expire_on_commit': False, } db_session = DatabaseSession(DeclBase, session_options=session_options) db_session = db_session.bind(container, 'database') db_session.setup() assert db_session.Session.kw['autoflush'] is False assert db_session.Session.kw['expire_on_commit'] is False
class ExampleServiceWithDatabaseSession: name = 'exampleservice' session = DatabaseSession(DeclBase) @dummy def create_record(self): self.session.add(ExampleModel(data='hello')) self.session.commit() @dummy @transaction_retry(session=operator.attrgetter('session')) def get_record_count(self): return self.session.query(ExampleModel).count() @dummy def get_record_count_retry_inside(self): session = self.session @transaction_retry(session=session) def foo(): return session.query(ExampleModel).count() return foo() @dummy def get_record_count_no_retry(self): return self.session.query(ExampleModel).count()
class UsersService(UserMixin): name = "users" auth = Auth() tracer = Tracer() db_session = DatabaseSession(DeclarativeBase) event_dispatcher = EventDispatcher() @http("GET", "/healthcheck") def health_check_http(self, request): return json.dumps(self.health_check()) @rpc def health_check(self): result = {"status": "ok"} return result @rpc def check_jwt(self): try: decoded_jwt = self.auth.decode_jwt() except InvalidToken: return None try: user = self.get_user(uuid=decoded_jwt["uuid"]) except UserNotFound: return None return self.auth.encode_jwt({ "uuid": user["uuid"], "email": user["email"] })
class ContactsService: name = 'contacts' session = DatabaseSession(DeclarativeBase) dispatch = EventDispatcher() auto_crud = AutoCrudWithEvents( session, dispatch, 'contact', model_cls=Contact, get_method_name='get_contact', create_method_name='create_contact', update_method_name='update_contact', list_method_name='list_contacts', count_method_name='count_contacts', create_event_name='contact_created', update_event_name='contact_updated', ) @rtm.handle_message('^create contact (?P<name>\w+)') def slack_create_contact(self, event, message, name=None): return 'Contact created on platform: {}'.format( self.create_contact({'name': name}))
class UserService(object): name = "user" db = DatabaseSession(Base) @rpc def create(self, username, email, password): user = User( username=username, email=email, password=password, ) self.db.add(user) self.db.commit() user = UserSchema().dump(user).data return user @rpc def get(self, user_id): user = self.db.query(User).get(user_id) return UserSchema().dump(user).data @rpc def login(self, username, pwd): user = self.db.query(User).filter_by(username=username).first() if user.password == pwd: return UserSchema().dump(user).data @rpc def delete(self, id): user = self.db.query(User).get(id) self.db.delete(user) self.db.commit()
class RefreshTokenService(object): name = "refresh_token" db = DatabaseSession(Base) @rpc def create(self, uid, cid, ip_address, user_agent): token = RefreshToken( user_id=uid, client_id=cid, ip_address=ip_address, user_agent=user_agent ) self.db.add(token) self.db.commit() refresh_token = RefreshTokenSchema().dump(token).data return refresh_token @rpc def get(self, token_uuid): refresh_token = self.db.query(RefreshToken).get(token_uuid) return RefreshTokenSchema().dump(refresh_token).data @rpc def get_tokens(self, id, uid): refresh_tokens = self.db.query(RefreshToken.id, RefreshToken.ip_address, RefreshToken.user_agent, RefreshToken.user_id, case([(RefreshToken.id==id, True)], else_=False).label("is_current")).filter_by(user_id = uid, revoke = False) return TokensSchema.dump(refresh_tokens).data @rpc def set_revoke(self, token_uuid): refresh_token = self.db.query(RefreshToken).get(token_uuid) refresh_token.revoke = True self.db.commit() return RefreshTokenSchema().dump(refresh_token).data
class Command: name = 'command_politics' dispatch = EventDispatcher() db = DatabaseSession(Base) @rpc def add_news(self, data): try: version = 1 if data.get('version'): version = (data.get('version') + 1) if data.get('id'): id = data.get('id') else: id = self.db.execute(Sequence('news_id_seq')) news = CommandNewsModel( id=id, version=version, title=data['title'], content=data['content'], author=data['author'], published_at=data.get('published_at'), tags=data['tags'], ) self.db.add(news) self.db.commit() data['id'] = news.id data['version'] = news.version self.dispatch('replicate_db_event', data) return data except Exception as e: self.db.rollback() return e
class Service: name = 'service' db = DatabaseSession(DeclarativeBase) event_dispatcher = EventDispatcher() @rpc def get_pessoa(self, pessoa_id): pessoa = self.db.query(Pessoa)(pessoa_id) if not pessoa: raise Notfound('Pessoa com id {} não encontrada'.format(pessoa_id)) return PessoaSchema().dump(pessoa) @rpc def create_pessoa(self, pessoa): p = Pessoa( nome=pessoa['nome'], endereco=pessoa['endereco'], cpf=pessoa['cpf'] ) self.db.add(p) self.db.commit() p = PessoaSchema().dump(p) self.event_dispatcher('pessoa_criada', { 'pessoa': p, }) return pessoa @rpc def get_dividas(self, pessoa_id): dividas = self.db.query(Divida)(pessoa_id) if not dividas: raise Notfound('Dividas para pessoa com id {} não encontradas'.format(pessoa_id)) return DividaSchema().dump(dividas) @rpc def create_divida(self, divida_nova): divida = Divida( pessoa_id=divida_nova['pessoa_id'], ) self.db.add(divida) self.db.commit() divida = DividaSchema().dump(divida) self.event_dispatcher('divida_criada', { 'divida': divida, }) return divida
class OrdersService: name = 'orders' db = DatabaseSession(DeclarativeBase) event_dispatcher = EventDispatcher() @rpc def get_order(self, order_id): order = self.db.query(Order).get(order_id) if not order: raise NotFound('Order with id {} not found'.format(order_id)) return OrderSchema().dump(order).data @rpc def create_order(self, order_details): order = Order(order_details=[ OrderDetail(product_id=order_detail['product_id'], price=order_detail['price'], quantity=order_detail['quantity']) for order_detail in order_details ]) self.db.add(order) self.db.commit() order = OrderSchema().dump(order).data self.event_dispatcher('order_created', { 'order': order, }) return order @rpc def update_order(self, order): order_details = { order_details['id']: order_details for order_details in order['order_details'] } order = self.db.query(Order).get(order['id']) for order_detail in order.order_details: order_detail.price = order_details[order_detail.id]['price'] order_detail.quantity = order_details[order_detail.id]['quantity'] self.db.commit() return OrderSchema().dump(order).data @rpc def delete_order(self, order_id): order = self.db.query(OrderDetail).get(order_id) self.db.delete(order) self.db.commit() order = self.db.query(Order).get(order_id) self.db.delete(order) self.db.commit()
class CommandBrands: name = BRANDS_COMMAND_SERVICE dispatch = EventDispatcher() db = DatabaseSession(DeclarativeBase) def fire_replicate_db_event(self, data): """ fires off a replication event, this expose the event-sourcing pattern which will send the record to the query database from the command database """ self.dispatch(REPLICATE_EVENT, data) @rpc def add(self, payload): if isinstance(payload, str): payload = json.loads(payload) name = payload.get('name') item = ProductBrand() item.name = name self.db.add(item) self.db.commit() payload['id'] = item.id payload['updated_at'] = item.updated_at payload['created_at'] = item.created_at self.fire_replicate_db_event(payload) return payload @rpc def update(self, id, payload): brand = self.db.query(ProductBrand).get(id) if brand is None: raise NotFound() brand.name = payload.get('name') brand.updated_at = datetime.datetime.utcnow() self.db.add(brand) self.db.commit() payload['id'] = brand.id payload['created_at'] = brand.created_at payload['updated_at'] = brand.updated_at self.fire_replicate_db_event(payload) return payload @rpc def delete(self, id): product_brand = self.db.query(ProductBrand).get(id) self.db.delete(product_brand) self.db.commit()
class ProcessesService: """Discovery of processes that are available at the back-end. """ name = "processes" db = DatabaseSession(Base) @rpc def create(self, user_id: str=None, **process_args): """The request will ask the back-end to create a new process using the description send in the request body. Keyword Arguments: user_id {str} -- The identifier of the user (default: {None}) """ try: parameters = process_args.pop("parameters", {}) process = Process(**{"user_id": user_id, **process_args}) for parameter_name, parameter_specs in parameters.items(): parameter = Parameter(**{"name":parameter_name, "process_id": process.id, **parameter_specs}) self.db.add(parameter) self.db.add(process) self.db.commit() return { "status": "success", "code": 201, "data": "The process {0} has been successfully created.".format(process_args["name"]) } except exc.IntegrityError as exp: msg = "Process '{0}' does already exist.".format( process_args["name"]) return ServiceException(ProcessesService.name, 400, user_id, msg, internal=False, links=["#tag/EO-Data-Discovery/paths/~1processes/post"]).to_dict() except Exception as exp: return ServiceException(ProcessesService.name, 500, user_id, str(exp)).to_dict() @rpc def get_all(self, user_id: str=None): """The request asks the back-end for available processes and returns detailed process descriptions. Keyword Arguments: user_id {str} -- The identifier of the user (default: {None}) """ try: processes = self.db.query(Process).order_by(Process.name).all() return { "status": "success", "code": 200, "data": ProcessSchema(many=True).dump(processes).data } except Exception as exp: return ServiceException(ProcessesService.name, 500, user_id, str(exp)).to_dict()
class ClientService(object): name = "client" db = DatabaseSession(Base) @rpc def get(self, ecoded_cid): cid = b64decode(ecoded_cid) client = self.db.query(Client).filter_by(cid = cid).first() return ClientSchema().dump(client).data
class ExampleService(object): name = "exampleservice" session = DatabaseSession(dec_base) event_dispatcher = EventDispatcher() example_crud = AutoCrudWithEvents( 'session', 'event_dispatcher', model_cls=example_model, to_event_serializable=lambda obj: {'name': obj.name})
class Service: name = "service" db = DatabaseSession(Base) @rpc def save(self, value): result = Result(value=value) self.db.add(result) self.db.commit()
class ExampleService(object): name = "exampleservice" session = DatabaseSession(dec_base) event_dispatcher = EventDispatcher() example_crud = AutoCrudWithEvents( 'session', 'event_dispatcher', model_cls=example_model, )
class CommandSite: name = SITE_COMMAND dispatch = EventDispatcher() db = DatabaseSession(DeclarativeBase) def _save_to_db(self, item): self.db.add(item) self.db.commit() @rpc def add(self, payload): if isinstance(payload, str): payload = json.loads(payload) name = payload.get('name') zip_code = payload.get('zip_code') type_id = payload.get('type_id') site = Site(name=name, zip_code=zip_code, type_id=type_id) self._save_to_db(site) payload['id'] = site.id payload['created_at'] = site.created_at payload['updated_at'] = site.updated_at self.dispatch(REPLICATE_EVENT, payload) return payload @rpc def update(self, id, payload): if isinstance(payload, str): payload = json.loads(payload) site = self.db.query(Site).get(id) if site is None: raise NotFound() site.name = payload.get('name', site.name) site.zip_code = payload.get('zip_code', site.zip_code) site.type_id = payload.get('type_id', site.type_id) site.updated_at = datetime.datetime.utcnow() self._save_to_db(site) payload['id'] = site.id payload['updated_at'] = site.updated_at self.dispatch(REPLICATE_EVENT, payload)
class Events: name = 'events' db = DatabaseSession(Base) @event_handler('command_stack', 'user_created') def user_created_normalize_db(self, data): try: UsersQueryModel(id=data['id'], name=data['name'], email=data.get('email'), description=data.get('description'), permission=data.get('permission')).save() except Exception as e: return e
class AuthService: name = "auth" db = DatabaseSession(Base) crypt = CryptHandler() @rpc def health(self, request): return { "status": "success"} @rpc def login(self, user_id, password): try: user = self.db.query(User).filter_by(user_id=user_id).first() if not user: raise NotFound("User does not exist.") if user.password != self.crypt.generate_hash(password, user.password): raise LoginError("Password is not correct.") return { "status": "success", "data": { "user_id": user.user_id, "auth_token": self.crypt.encode_auth_token(user.id) } } except (NotFound, LoginError) as exp: return {"status": "error", "service": self.name, "key": "Forbidden", "msg": str(exp)} except Exception as exp: return {"status": "error", "service": self.name, "key": "InternalServerError", "msg": str(exp)} @rpc def identify(self, token): try: user_id = self.crypt.decode_auth_token(token) user = self.db.query(User).filter_by(id=user_id).first() if not user: raise NotFound("User does not exist.") return { "status": "success", "data": UserSchema().dump(user).data } except (LoginError, InvalidSignatureError) as exp: return {"status": "error", "service": self.name, "key": "Forbidden", "msg": str(exp)} except Exception as exp: return {"status": "error", "service": self.name, "key": "InternalServerError", "msg": str(exp)}
class CollegeService: name = 'college_service' db = DatabaseSession(DeclarativeBase) @rpc def ping(self): return 'alive' @rpc def process(self, name): id = str(uuid.uuid4()) temp_data = TempTable() temp_data.name = name temp_data.id = id self.db.add(temp_data) self.db.commit() temp_datax = self.db.query(TempTable).filter_by(id=id).first() return temp_datax.name @rpc def process_college(self, college_data): college = College() college.unitid = college_data['UNITID'] college.name = college_data['INSTNM'] college.address1 = college_data['ADDR'] college.city = college_data['CITY'] college.state = college_data['STABBR'] college.phone = college_data['GENTELE'] college.web_url = college_data['WEBADDR'] college.admissions_url = college_data['ADMINURL'] college.netprice_url = college_data['NPRICURL'] college.sector = college_data['SECTOR'] college.locale = college_data['LOCALE'] college.hbcu = college_data['HBCU'] college.latitude = college_data['LATITUDE'] college.longitude = college_data['LONGITUD'] #upsert statement = pg_insert(College).values( **college.as_dict()).on_conflict_do_update( constraint='college_pkey', set_=college.props_dict()) self.db.execute(statement) self.db.commit() return college.name
class ProductService: name = 'service_product' db = DatabaseSession(DeclarativeBase) event_dispatcher = EventDispatcher() @rpc def get_product(self, productId): product = self.db.query(Product).get(productId) if not product: raise ProductNotFound(f'Product Id:{productId} not found!') return ProductSchema(strict=True).dump(product) @rpc def create_product(self, product): p = Product(name=product['name'], description=product['description'], short_description=product['short_description'], reference=product['reference'], warehouse_id=product['warehouse_id']) self.db.add(p) self.db.commit() p = ProductSchema(strict=True).dump(p) self.event_dispatcher('product_created', {'product': p}) return product @rpc def get_warehouse(self, warehouseId): warehouse = self.db.query(Warehouse).get(warehouseId) if not warehouse: raise f'Warehouse Id:{warehouseId} not found!' return ProductSchema(strict=True).dump(warehouse) @rpc def create_warehouse(self, warehouse): w = Warehouse(name=warehouse['name']) self.db.add(w) self.db.commit() w = WarehouseSchema(strict=True).dump(w) self.event_dispatcher('warehouse_created', {'warehouse': w}) return warehouse
class ArticleService(AuthorMixin, ReviewMixin, ArticleMixin): name = "articles" tracer = Tracer() db_session = DatabaseSession(DeclarativeBase) event_dispatcher = EventDispatcher() @http("GET", "/healthcheck") def health_check_http(self, request): return json.dumps(self.health_check()) @rpc def health_check(self): return {"status": "ok"}
class ExampleService(object): name = "exampleservice" session = DatabaseSession(DeclBase) @dummy def write(self, value): obj = ExampleModel(data=value) self.session.add(obj) self.session.commit() return obj.id @dummy def read(self, id): return self.session.query(ExampleModel).get(id).data
class UsersService: name = "users" db = DatabaseSession(Base) @rpc def create_user(self, user_data): user = User(username=user_data["username"], email=user_data["email"], password=user_data["password"], project=user_data["project"], sa_token=user_data["sa_token"]) self.db.add(user) self.db.commit() return UserSchema().dump(user) @rpc def get_user(self, id): user = self.db.query(User).get(id) if not user: raise NotFound("User with id {0} not found".format(id)) return UserSchema().dump(user) @rpc def update_user(self, id, user_data): user = self.db.query(User).get(id) for key, value in user_data.items(): if key == "password": user.password = user.generate_hash(value) else: setattr(user, key, value) self.db.commit() return UserSchema().dump(user) @rpc def delete_user(self, id): user = self.db.query(User).get(id) self.db.delete(user) self.db.commit()
class CommandNewsService: name = 'command_stack' dispatcher = EventDispatcher() db = DatabaseSession(Base) @rpc def news_domain(self, data): try: data['id'] = str(uuid.uuid1()) news = NewsCommandModel(data) self.db.add(news) self.db.commit() self.dispatcher('news_created', data) return data.get('id') except Exception as e: self.db.rollback() logging.error(e)
class OrdersService: name = 'orders' log = StructlogDependency() dispatch = EventDispatcher() db = DatabaseSession(DeclarativeBase) carts_rpc = RpcProxy('carts') @rpc def health_check(self): self.log.info(f'orders.health:: start') response = 'Orders service is up and running!' self.log.info(f'orders.health:: response {response}') self.log.info(f'orders.health:: end') return response @rpc def create(self, cart_id): self.log.info(f'orders.create:: start') self.log.info(f'orders.create:: cart id {cart_id}') cart = self.carts_rpc.show(cart_id) order = Order( total_price=cart['total_price'], products=[ Product( serial_number=product['id'], title=product['title'], description=product['description'], price=product['price'], quantity=product['quantity'] ) for product in cart['products'] ] ) self.db.add(order) self.db.commit() order = OrderSchema().dump(order) self.log.info(f'orders.create: order {order}') payload = {'order': order, 'cart_id': cart_id} self.dispatch('order_created', payload) self.log.info(f'orders.create:: end') return order
class ContactsService: name = 'contacts' session = DatabaseSession(DeclarativeBase) dispatch = EventDispatcher() auto_crud = AutoCrudWithEvents( session, dispatch, 'contact', model_cls=Contact, get_method_name='get_contact', create_method_name='create_contact', update_method_name='update_contact', list_method_name='list_contacts', count_method_name='count_contacts', create_event_name='contact_created', update_event_name='contact_updated', )
class CommandStack: name = 'command_stack' dispatch = EventDispatcher() db = DatabaseSession(Base) @rpc def create_user(self, data): try: user = UsersCommandModel(id=data['id'], name=data['name'], email=data['email'], description=data['description'], permission=data['permission']) self.db.add(user) self.db.commit() data['id'] = user.id self.dispatch('user_created', data) return data except Exception as e: self.db.rollback() return e
class ExampleService(object): name = "exampleservice" session = DatabaseSession(dec_base) example_crud = AutoCrud('session', model_cls=example_model, list_method_name='_list_examplemodels', delete_method_name=None) @rpc def get_examplemodel(self, id_): """ Method should not be overwritten """ return "hello" @rpc def list_examplemodels(self, *args, **kwargs): """ Enhancing default method behaviour """ results = self._list_examplemodels(*args, **kwargs) for result in results: result['more'] = 'data' return results
class StudentService: name = 'student_service' db = DatabaseSession(DeclarativeBase) @rpc def ping(self): return 'alive' @rpc def process(self, name): id = str(uuid.uuid4()) temp_data = TempTable() temp_data.name = name temp_data.id = id self.db.add(temp_data) self.db.commit() temp_datax = self.db.query(TempTable).filter_by(id=id).first() return temp_datax.name