logging.info("\n")
logging.info("** starting new OMS migration: "+str(datetime.datetime.now())+" **")
""" establish multiple database connections (for old and new handbook db)
(loosely) following recipe at: http://elixir.ematia.de/trac/wiki/Recipes/MultipleDatabases
"""
old_engine = create_engine("mysql://*****:*****@localhost:3306/dbo")
old_session = scoped_session(sessionmaker(autoflush=True, bind=old_engine))
old_metadata = metadata
old_metadata.bind = old_engine
new_engine = create_engine("mysql://*****:*****@localhost:3306/newhandbook")
new_session = scoped_session(sessionmaker(autoflush=True, bind=new_engine))
new_metadata = ThreadLocalMetaData()
new_metadata.bind = new_engine
""" MODEL DATA """
# old
class Distributorship(Entity):
""" dbo/distributorship """
using_options(metadata=old_metadata, session=old_session, tablename="distributorship", autoload=True)
class DistributorshipUserInRole(Entity):
""" dbo/distributorshipuserinrole """
using_options(metadata=old_metadata, session=old_session, tablename="distributorshipuserinrole", autoload=True)
class DistributorshipZipCode(Entity):
""" dbo/distributorzipcode """
import os
precdir = os.path.realpath(os.curdir)
os.chdir(os.path.dirname(__file__))
import ConfigParser
config = ConfigParser.RawConfigParser()
config.optionxform = str
config.read("../../etc/bgp-ranking.conf")
login = config.get('mysql','login')
password = config.get('mysql','password')
host = config.get('mysql','hostname')
dbname = config.get('mysql','dbname_whois')
os.chdir(precdir)
whois_engine = create_engine( 'mysql://' + login + ':' + password + '@' + host + '/' + dbname )
WhoisSession = scoped_session(sessionmaker(bind=whois_engine))
whois_metadata = ThreadLocalMetaData()
whois_metadata.bind = whois_engine
import re
INET6_ADDRSTRLEN = 46
class Assignations(Entity):
"""
Ip assignations
"""
block = Field(Unicode(INET6_ADDRSTRLEN), default=unicode(''))
whois = Field(UnicodeText, required=True)
pre_options = Field(UnicodeText, default=unicode(''))
post_options = Field(UnicodeText, default=unicode(''))
keepalive_options = Field(UnicodeText, default=unicode(''))
port = Field(Integer, default=43)
from sqlalchemy.engine.url import URL
from elixir import Unicode, DateTime, String, Integer, UnicodeText, Text, Boolean, Float
from elixir import Entity, Field, using_options, using_table_options
from elixir import OneToMany, ManyToOne, ManyToMany, OneToOne
from elixir import setup_all, entities, create_all
from elixir.options import using_table_options_handler #using_table_options() can only work inside Entity-inherited class.
from sqlalchemy import UniqueConstraint, create_engine
from sqlalchemy.schema import ThreadLocalMetaData
from sqlalchemy.orm import scoped_session, sessionmaker
from datetime import datetime
from pymodule.db import ElixirDB
__session__ = scoped_session(sessionmaker(autoflush=False, autocommit=True))
__metadata__ = ThreadLocalMetaData()
class README(Entity):
#2008-08-07
title = Field(String(2000))
description = Field(String(60000))
created_by = Field(String(128))
updated_by = Field(String(128))
date_created = Field(DateTime, default=datetime.now)
date_updated = Field(DateTime)
using_options(tablename='readme',
metadata=__metadata__,
session=__session__)
using_table_options(mysql_engine='InnoDB')
# -*- coding: utf-8 -*-
from contextlib import closing
from datetime import timedelta, date
from bcrypt import hashpw, gensalt
from flask import current_app
from itsdangerous import TimedJSONWebSignatureSerializer
from sqlalchemy import Column, String
from sqlalchemy.ext.declarative import declarative_base, DeferredReflection
from sqlalchemy.orm import backref, relationship
from sqlalchemy.schema import ThreadLocalMetaData
base = declarative_base(cls=DeferredReflection, metadata=ThreadLocalMetaData())
class user(base):
__tablename__ = 'users'
password_ = Column('password', String(length=255), nullable=False)
@property
def password(self):
return self.password_
@password.setter
def password(self, value):
self.password_ = hashpw(value.encode('utf-8'), gensalt(10))
# The token TTL is 86,400 seconds (1 day).
def get_token(self, expires_in=86400):
import os
precdir = os.path.realpath(os.curdir)
os.chdir(os.path.dirname(__file__))
import ConfigParser
config = ConfigParser.RawConfigParser()
config.optionxform = str
config.read("../../etc/bgp-ranking.conf")
login = config.get('mysql','login')
password = config.get('mysql','password')
host = config.get('mysql','hostname')
dbname = config.get('mysql','dbname_ranking')
os.chdir(precdir)
ranking_engine = create_engine( 'mysql://' + login + ':' + password + '@' + host + '/' + dbname, pool_size = 50, pool_recycle=3600, max_overflow=30 )
RankingSession = scoped_session(sessionmaker(bind=ranking_engine))
ranking_metadata = ThreadLocalMetaData()
ranking_metadata.bind = ranking_engine
import datetime
INET6_ADDRSTRLEN = 46
class IPs(Entity):
"""
Table which contains the IPs
"""
ip = Field(Unicode(INET6_ADDRSTRLEN), primary_key=True)
ip_descriptions = OneToMany('IPsDescriptions')
using_options(metadata=ranking_metadata, session=RankingSession, tablename='IPs')
def __repr__(self):
# -*- coding: utf-8 -*- from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.pool import NullPool from sqlalchemy.schema import ThreadLocalMetaData from settings import SQLALCHEMY engine = create_engine(SQLALCHEMY, convert_unicode=True, echo=False, poolclass=NullPool, strategy='threadlocal') base = declarative_base(bind=engine, metadata=ThreadLocalMetaData()) session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine, expire_on_commit=True))
if isinstance(d[column.name], date):
d[column.name] = d[column.name].isoformat()
return d
mysql = {}
mysql['engine'] = create_engine(
URL(**dictionary['MYSQL']),
convert_unicode=True,
echo=False,
pool_recycle=15,
pool_size=25,
pool_timeout=15,
strategy='threadlocal',
)
mysql['base'] = declarative_base(
bind=mysql['engine'], metadata=ThreadLocalMetaData()
)
mysql['base'].to_dictionary = to_dictionary
mysql['session'] = scoped_session(sessionmaker(
autocommit=False,
autoflush=False,
bind=mysql['engine'],
expire_on_commit=True
))
postgresql = {}
postgresql['engine'] = create_engine(
URL(**dictionary['POSTGRESQL']),
convert_unicode=True,
echo=False,
pool_recycle=15,
from sqlalchemy.schema import ThreadLocalMetaData
from elixir import *
import os, os.path
db_server = 'localhost'
db_user = '******'
db_pass = '******'
db_name = 'quran'
db_prefix = 'db_'
db_mysql_path = 'mysql://%s:%s@%s/%s' %(db_user, db_pass, db_server, db_name)
db_sqlite_path = "sqlite:///"+os.path.expanduser("~/python-modules/quran_quize/db.db")
b_engine = create_engine(db_mysql_path)
b_session = scoped_session(sessionmaker(autoflush=True))
b_metadata = ThreadLocalMetaData()
__metadata__ = b_metadata
__session__ = b_session
b_metadata.bind = b_engine
b_session.bind = b_engine
class users(Entity):
using_options(tablename = db_prefix+'users')
fb_id = Field(Unicode(100))
fb_user_name = Field(UnicodeText)
fb_full_name = Field(UnicodeText)
fb_gender = Field(Unicode(10))
fb_locale = Field(Unicode(5))
access_token = Field(UnicodeText)
