def connec_to_database(path, set_as_default_db=False):
database = ThreadSafeDatabase(path)
inited = False
try:
database.open()
except DatabasePathException:
create_db(database)
inited = True
if set_as_default_db:
Model.database = database
return database, inited
def __init__(self, filename=None):
"""
:param filename:
:return:
"""
self.db = Database(filename)
if self.db.exists():
self._open_db()
self.db.reindex()
else:
self.db.create()
def get_data(cls, eventid, key):
"""get data."""
cdb = ThreadSafeDatabase(cls._DATABASE)
return_data = None
if cdb.exists():
cdb.open()
cdb.reindex()
try:
print eventid
record_dict = cdb.get('eventid', eventid, with_doc=True, with_storage=True)
print record_dict
record = record_dict['doc']
return_data = record[key]
print record
except RecordNotFound:
print "Record not Found"
return_data = None
except:
print "Error"
return_data = None
finally:
cdb.close()
return return_data
def setup_db(self, data, *args, **kwargs):
if self.db is None:
codernitydb = cherrypy.config.get('codernitydb')
if codernitydb:
path = codernitydb['dir']
else:
path = cherrypy.config['codernitydb.dir']
db = Database(path)
if db.exists():
db.open()
else:
db.create()
# add indexes etc...
self.db = db
def setup_db(self, data, *args, **kwargs):
if self.db is None:
codernitydb = cherrypy.config.get('codernitydb')
if codernitydb:
path = codernitydb['dir']
else:
path = cherrypy.config['codernitydb.dir']
db = Database(path)
if db.exists():
db.open()
else:
db.create()
# add indexes etc...
self.db = db
def insert_data(cls, eventid, key, value):
"""insert data."""
cdb = ThreadSafeDatabase(cls._DATABASE)
status = False
if cdb.exists():
cdb.open()
cdb.reindex()
try:
record_dict = cdb.get('eventid', eventid, with_doc=True, with_storage=False)
record = record_dict['doc']
cdb.update({key: value, "server": record['server'], "eventid": eventid, '_id': record['_id'], '_rev': record['_rev']})
status = True
except RecordNotFound:
status = False
except:
status = False
finally:
cdb.close()
return status
def delete_data(cls, eventid):
"""delete data."""
cdb = ThreadSafeDatabase(cls._DATABASE)
status = False
if cdb.exists():
cdb.open()
cdb.reindex()
try:
record_dict = cdb.get('eventid', eventid, with_doc=True, with_storage=True)
record = record_dict['doc']
cdb.delete({'_id': record['_id'], '_rev': record['_rev']})
status = True
except RecordNotFound:
print "Record not Found"
status = False
except:
print "Error"
status = False
finally:
cdb.close()
return status
class DBObject(object):
def __init__(self, filename=None):
"""
:param filename:
:return:
"""
self.db = Database(filename)
if self.db.exists():
self._open_db()
self.db.reindex()
else:
self.db.create()
def _open_db(self):
try:
self.db.open()
except DatabaseConflict:
pass
def save(self, info=None):
"""
:param info:
:return:
"""
if info is None:
raise MissingPropertyException("info must not be None!")
self._open_db()
self.db.insert(info)
def reindex(self):
"""
Does a reindex of the database.
:return:
"""
self._open_db()
self.db.reindex()
def list_all(self):
return self.db.all("id")
#!/usr/bin/env python
from CodernityDB.database import Database
from CodernityDB.hash_index import HashIndex
from CodernityDB.database_thread_safe import ThreadSafeDatabase
from CodernityDB.database import RecordNotFound
import time
cdb = ThreadSafeDatabase('database')
#db = Database('database')
if cdb.exists():
cdb.open()
cdb.reindex()
else:
#from database_indexes import UserIndex, MessageAllIndex, MessageUserIndex, FollowerRel1Index, FollowerRel2Index, UserIDIndex, FollowerIndex
print("no database pressent")
quit()
print cdb.count(cdb.all, 'eventid')
insert_dict = {"eventid": "123" , "port": "0", "server": "127.0.0.1" }
cdb.insert(insert_dict)
try:
print "tesit"
rv = cdb.get('eventid', '123', with_doc=True, with_storage=True)
# rv= user['doc']['pw_hash']
except RecordNotFound:
rv = None
else:
#time.sleep(20)
def getport(self, eventid):
"""get port or insert data."""
cdb = ThreadSafeDatabase(self._DATABASE)
if cdb.exists():
cdb.open()
cdb.reindex()
try:
print eventid
record_dict = cdb.get('eventid', eventid, with_doc=True, with_storage=True)
record = record_dict['doc']
cdb.close()
return record['port']
except RecordNotFound:
print "Record not Found"
self.dict['eventid'] = eventid
cdb.insert(self.dict)
cdb.close()
return None
else:
cdb.create()
cdb.add_index(CustomEventidIndex(cdb.path, "eventid"))
self.dict['eventid'] = eventid
cdb.insert(self.dict)
cdb.close()
return None
def runCouchPotato(options, base_path, args, data_dir = None, log_dir = None, Env = None, desktop = None):
try:
locale.setlocale(locale.LC_ALL, "")
encoding = locale.getpreferredencoding()
except (locale.Error, IOError):
encoding = None
# for OSes that are poorly configured I'll just force UTF-8
if not encoding or encoding in ('ANSI_X3.4-1968', 'US-ASCII', 'ASCII'):
encoding = 'UTF-8'
Env.set('encoding', encoding)
# Do db stuff
db_path = toUnicode(os.path.join(data_dir, 'database'))
# Check if database exists
db = ThreadSafeDatabase(db_path)
db_exists = db.exists()
if db_exists:
# Backup before start and cleanup old backups
backup_path = toUnicode(os.path.join(data_dir, 'db_backup'))
backup_count = 5
existing_backups = []
if not os.path.isdir(backup_path): os.makedirs(backup_path)
for root, dirs, files in scandir.walk(backup_path):
for backup_file in files:
ints = re.findall('\d+', backup_file)
# Delete non zip files
if len(ints) != 1:
os.remove(os.path.join(backup_path, backup_file))
else:
existing_backups.append((int(ints[0]), backup_file))
# Remove all but the last 5
for eb in existing_backups[:-backup_count]:
os.remove(os.path.join(backup_path, eb[1]))
# Create new backup
new_backup = toUnicode(os.path.join(backup_path, '%s.tar.gz' % int(time.time())))
zipf = tarfile.open(new_backup, 'w:gz')
for root, dirs, files in scandir.walk(db_path):
for zfilename in files:
zipf.add(os.path.join(root, zfilename), arcname = 'database/%s' % os.path.join(root[len(db_path) + 1:], zfilename))
zipf.close()
# Open last
db.open()
else:
db.create()
# Register environment settings
Env.set('app_dir', toUnicode(base_path))
Env.set('data_dir', toUnicode(data_dir))
Env.set('log_path', toUnicode(os.path.join(log_dir, 'CouchPotato.log')))
Env.set('db', db)
Env.set('cache_dir', toUnicode(os.path.join(data_dir, 'cache')))
Env.set('cache', FileSystemCache(toUnicode(os.path.join(Env.get('cache_dir'), 'python'))))
Env.set('console_log', options.console_log)
Env.set('quiet', options.quiet)
Env.set('desktop', desktop)
Env.set('daemonized', options.daemon)
Env.set('args', args)
Env.set('options', options)
# Determine debug
debug = options.debug or Env.setting('debug', default = False, type = 'bool')
Env.set('debug', debug)
# Development
development = Env.setting('development', default = False, type = 'bool')
Env.set('dev', development)
# Disable logging for some modules
for logger_name in ['enzyme', 'guessit', 'subliminal', 'apscheduler', 'tornado', 'requests']:
logging.getLogger(logger_name).setLevel(logging.ERROR)
for logger_name in ['gntp']:
logging.getLogger(logger_name).setLevel(logging.WARNING)
# Use reloader
reloader = debug is True and development and not Env.get('desktop') and not options.daemon
# Logger
logger = logging.getLogger()
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s', '%m-%d %H:%M:%S')
level = logging.DEBUG if debug else logging.INFO
logger.setLevel(level)
logging.addLevelName(19, 'INFO')
# To screen
if (debug or options.console_log) and not options.quiet and not options.daemon:
hdlr = logging.StreamHandler(sys.stderr)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
# To file
hdlr2 = handlers.RotatingFileHandler(Env.get('log_path'), 'a', 500000, 10, encoding = Env.get('encoding'))
hdlr2.setFormatter(formatter)
logger.addHandler(hdlr2)
# Start logging & enable colors
# noinspection PyUnresolvedReferences
import color_logs
from couchpotato.core.logger import CPLog
log = CPLog(__name__)
log.debug('Started with options %s', options)
def customwarn(message, category, filename, lineno, file = None, line = None):
log.warning('%s %s %s line:%s', (category, message, filename, lineno))
warnings.showwarning = customwarn
# Create app
from couchpotato import WebHandler
web_base = ('/' + Env.setting('url_base').lstrip('/') + '/') if Env.setting('url_base') else '/'
Env.set('web_base', web_base)
api_key = Env.setting('api_key')
if not api_key:
api_key = uuid4().hex
Env.setting('api_key', value = api_key)
api_base = r'%sapi/%s/' % (web_base, api_key)
Env.set('api_base', api_base)
# Basic config
host = Env.setting('host', default = '0.0.0.0')
# app.debug = development
config = {
'use_reloader': reloader,
'port': tryInt(Env.setting('port', default = 5050)),
'host': host if host and len(host) > 0 else '0.0.0.0',
'ssl_cert': Env.setting('ssl_cert', default = None),
'ssl_key': Env.setting('ssl_key', default = None),
}
# Load the app
application = Application(
[],
log_function = lambda x: None,
debug = config['use_reloader'],
gzip = True,
cookie_secret = api_key,
login_url = '%slogin/' % web_base,
)
Env.set('app', application)
# Request handlers
application.add_handlers(".*$", [
(r'%snonblock/(.*)(/?)' % api_base, NonBlockHandler),
# API handlers
(r'%s(.*)(/?)' % api_base, ApiHandler), # Main API handler
(r'%sgetkey(/?)' % web_base, KeyHandler), # Get API key
(r'%s' % api_base, RedirectHandler, {"url": web_base + 'docs/'}), # API docs
# Login handlers
(r'%slogin(/?)' % web_base, LoginHandler),
(r'%slogout(/?)' % web_base, LogoutHandler),
# Catch all webhandlers
(r'%s(.*)(/?)' % web_base, WebHandler),
(r'(.*)', WebHandler),
])
# Static paths
static_path = '%sstatic/' % web_base
for dir_name in ['fonts', 'images', 'scripts', 'style']:
application.add_handlers(".*$", [
('%s%s/(.*)' % (static_path, dir_name), StaticFileHandler, {'path': toUnicode(os.path.join(base_path, 'couchpotato', 'static', dir_name))})
])
Env.set('static_path', static_path)
# Load configs & plugins
loader = Env.get('loader')
loader.preload(root = toUnicode(base_path))
loader.run()
# Fill database with needed stuff
fireEvent('database.setup')
if not db_exists:
fireEvent('app.initialize', in_order = True)
fireEvent('app.migrate')
# Go go go!
from tornado.ioloop import IOLoop
loop = IOLoop.current()
# Some logging and fire load event
try: log.info('Starting server on port %(port)s', config)
except: pass
fireEventAsync('app.load')
if config['ssl_cert'] and config['ssl_key']:
server = HTTPServer(application, no_keep_alive = True, ssl_options = {
'certfile': config['ssl_cert'],
'keyfile': config['ssl_key'],
})
else:
server = HTTPServer(application, no_keep_alive = True)
try_restart = True
restart_tries = 5
while try_restart:
try:
server.listen(config['port'], config['host'])
loop.start()
except Exception as e:
log.error('Failed starting: %s', traceback.format_exc())
try:
nr, msg = e
if nr == 48:
log.info('Port (%s) needed for CouchPotato is already in use, try %s more time after few seconds', (config.get('port'), restart_tries))
time.sleep(1)
restart_tries -= 1
if restart_tries > 0:
continue
else:
return
except:
pass
raise
try_restart = False
