teleceptorcmd

#!/usr/bin/env python
"""
Authors: Victor Szczepanski
         Evan Salazar
         Cyrille Gindreau
"""

import runpy
import sys
import os
import atexit
import shutil
import platform
import json
import time
import requests
from os import fdopen, remove
from subprocess import call
from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL
from sqlalchemy.engine import reflection
from sqlalchemy.schema import (
    MetaData,
    Table,
    DropTable,
    ForeignKeyConstraint,
    DropConstraint,
)
import teleceptor
from teleceptor import models, testFixtures, server, sessionManager, USE_ELASTICSEARCH, WEBROOT, SQLDATA, USE_SQL_ALWAYS, USEPG

Stdin = '/dev/null'
Stdout = '/dev/null'
Stderr = '/dev/null'


def delpid():
    os.remove(self.pidfile)


def runserver(*args):
    """
    do the UNIX double-fork magic, see Stevens' "Advanced
    Programming in the UNIX Environment" for details (ISBN 0201563177)
    http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
    """
    server.runserver(server.get_cp_config())


def btcmote(*args):
    btcmotecmd = os.path.join(teleceptor.__path__[0], 'softSensors', 'BitcoinSensor', 'BTCMote.py')
    print btcmotecmd
    runpy.run_path(btcmotecmd, None, '__main__')


def apiTest(*args):
    print "Running api test."
    runpy.run_path('unittests/apiTests.py', None, '__main__')


def poller(*args):
    pollercmd = os.path.join(teleceptor.__path__[0], 'basestation', 'poller.py')
    print pollercmd
    runpy.run_path(pollercmd, None, '__main__')


def serialPoller(*args):
    sys.argv = ["something here "]
    if len(args[0]) is not 1:
        print "Please enter the name of the USB device you are trying to connect to. Read the documentation to find out how to find your device name."
    serialpollercmd = os.path.join(teleceptor.__path__[0], 'basestation', 'serialPoller.py')
    print serialpollercmd
    runpy.run_path(serialpollercmd, {"DEVICENAME": args[0]}, '__main__')


def tcpPoller(*args):
    tcppollercmd = os.path.join(teleceptor.__path__[0], 'basestation', 'tcpPoller.py')
    print tcppollercmd
    runpy.run_path(tcppollercmd, None, '__main__')


def copyConfig(*args):
    if platform.system() == 'Windows':
        appdata = os.path.join(os.getenv("APPDATA"), "teleceptor")
    else:
        appdata = os.path.join(os.getenv("HOME"), ".config", "teleceptor")

    # Check if file exists
    if os.path.exists(os.path.join(appdata, 'config.json')):
        print "Config Exists at: " + str(os.path.join(appdata, 'config.json'))
        return

    if not os.path.exists(appdata):
        os.makedirs(appdata)

    fromfile = os.path.join(teleceptor.PATH, 'config', "defaults.json")
    tofile = os.path.join(appdata, "config.json")
    shutil.copy2(fromfile, tofile)

    print "Config installed at:" + str(tofile)


def displayVersion(*args):
    print "teleceptor Version: " + teleceptor.__version__


def rebuild(*args):

    print 'This command will wipe your database and start fresh.  Are you sure you want to continue?'
    user_resp = None
    user_resp = raw_input('(Y/n) ').rstrip()
    while user_resp not in ['Y', 'n']:
        print 'Did not understand your response.  Please enter \'Y\' or \'n\'.'
        print 'This command will wipe your database and start fresh.  Are you sure you want to continue?'
        user_resp = raw_input('(Y/n) ').rstrip()

    if user_resp == 'n':
        sys.exit(0)

    assert user_resp == 'Y', 'Something Bad Happened!'

    if teleceptor.USEPG:
        rebuild_postgres()
    else:
        rebuild_sqlite()

    print "Runing setup."
    setup()


def rebuild_sqlite():
    """
    Handles rebuilding sqlite db.
    """
    print("Deleting " + str(teleceptor.DBFILE) + " ...")
    try:
        os.remove(teleceptor.DBFILE)
        print teleceptor.DBFILE + " deleted."
    except OSError:
        print('base_station.db does not exist.  Creating new db.')


def rebuild_postgres():
    """
    Handles rebuilding postgres db. Drops all tables in the postgres db.

    The following receipe is taken from Atlassian for dropping all tables even if there are cyclical dependencies.
    See https://bitbucket.org/zzzeek/sqlalchemy/wiki/UsageRecipes/DropEverything
    """

    # Get a connection to the postgres db
    dboptions = {}
    dboptions['drivername'] = 'postgres'
    dboptions['host'] = teleceptor.PGSQLDBHOST
    dboptions['port'] = teleceptor.PGSQLDBPORT
    dboptions['username'] = teleceptor.PGSQLDBUSERNAME
    dboptions['password'] = teleceptor.PASSWORD
    dboptions['database'] = teleceptor.PGSQLDBNAME
    dbURL = URL(**dboptions)
    engine = create_engine(dbURL)

    print("Dropping all tables from " + str(dbURL) + " ...")

    conn = engine.connect()

    # the transaction only applies if the DB supports
    # transactional DDL, i.e. Postgresql, MS SQL Server
    trans = conn.begin()

    inspector = reflection.Inspector.from_engine(engine)

    # gather all data first before dropping anything.
    # some DBs lock after things have been dropped in
    # a transaction.

    metadata = MetaData()

    tbs = []
    all_fks = []

    for table_name in inspector.get_table_names():
        fks = []
        for fk in inspector.get_foreign_keys(table_name):
            if not fk['name']:
                continue
            fks.append(
                ForeignKeyConstraint((), (), name=fk['name'])
            )
        t = Table(table_name, metadata, *fks)
        tbs.append(t)
        all_fks.extend(fks)

    for fkc in all_fks:
        conn.execute(DropConstraint(fkc))

    for table in tbs:
        conn.execute(DropTable(table))

    trans.commit()
    print("Done dropping tables for " + str(dbURL))


def setup(*args):
    if not teleceptor.USEPG:
        print "Creating new base_station.db file..."
        if not os.path.exists(os.path.dirname(teleceptor.DBFILE)):
            os.makedirs(os.path.dirname(teleceptor.DBFILE))
        open(teleceptor.DBFILE, 'a').close()
        print teleceptor.DBFILE + " created."
        dbURL = 'sqlite:///' + teleceptor.DBFILE
    else:
        dboptions = {}
        dboptions['drivername'] = 'postgres'
        dboptions['host'] = teleceptor.PGSQLDBHOST
        dboptions['port'] = teleceptor.PGSQLDBPORT
        dboptions['username'] = teleceptor.PGSQLDBUSERNAME
        dboptions['password'] = teleceptor.PASSWORD
        dboptions['database'] = teleceptor.PGSQLDBNAME
        dbURL = URL(**dboptions)

    db = create_engine(dbURL)

    print "Initializing database tables..."
    models.Base.metadata.create_all(db)

    if USE_ELASTICSEARCH:
        # TODO: Use index and doc from config
        conf = json.load(open(os.path.join(teleceptor.PATH, 'config', 'es_template.json')))
        r = requests.put(teleceptor.ELASTICSEARCH_URI+'/_template/teleceptor', json=conf)
        print r

    print "Run teleceptorcmd loadfixtures for example data"


def loadfixtures(*args):
    print "Loading fixtures..."
    testFixtures.main()


def shell(*args):
    import IPython
    print "Starting IPython Shell"
    session = sessionManager.createSession()
    IPython.embed()


def minorVersion(*args):
    print "Current version: {}".format(teleceptor.__version__)
    version = teleceptor.__version__.split('.')
    version[2] = str(int(version[2]) + 1)
    version = ".".join(version)
    saveVersion(version)


def majorVersion(*args):
    print "Current version: {}".format(teleceptor.__version__)
    version = teleceptor.__version__.split('.')
    version[1] = str(int(version[1]) + 1)
    version[2] = "0"
    version = ".".join(version)
    saveVersion(version)


def saveVersion(version):
    newTime = time.time()
    print "New version is: {}".format(version)
    newFile = ""
    with open('teleceptor/version.py', 'r') as versionFile:
        for line in versionFile:
            if line.startswith("__version__"):
                line = "__version__ = '{}'\n".format(version)
            if line.startswith("__buildDate__"):
                line = "__buildDate__ = {}\n".format(newTime)
            newFile += line
    f = open('teleceptor/version.py', 'w+')
    for i in newFile:
        f.write(i)
    f.close()
    with open('package.json') as package:
        data = json.load(package)
        data['version'] = version
        data['buildDate'] = newTime
    os.remove('package.json')
    with open('package.json', 'w') as package:
        json.dump(data, package, indent=2, sort_keys=True)


if __name__ == "__main__":
    cmds = {
        'runserver': [runserver, "Start the server"],
        'copyconfig': [copyConfig, "Copy default config to home"],
        'rebuild': [rebuild, "Rebuild the database and datafiles"],
        'setup': [setup, "Build the database"],
        'btcmote': [btcmote, "Example sensor that collects BTC informaiotn"],
        'poller': [poller, "General poller"],
        'serialpoller': [serialPoller, "Serial poller"],
        'tcppoller': [tcpPoller, "TCP poller (Hosts are added in config.json)"],
        'loadfixtures': [loadfixtures, "Load test database data"],
        'version': [displayVersion, "Display version"],
        'shell': [shell, "Ipython shell"],
        'apitest': [apiTest, "Run tests against the api."],
        'minorversion': [minorVersion, "Increment the minor version number"],
        'majorversion': [majorVersion, "Increment the major version number"]
    }

    args = sys.argv
    print args
    if len(args) > 1 and args[1].lower() in cmds:

        if len(args) > 2 and args[2] == "-d":
            print "Starting process %s as daemon..." % args[1].lower()
            pidfilename = "/tmp/teleceptor-" + args[1].lower() + '.pid'
            try:
                pid = os.fork()
                if pid > 0:
                    # exit first parent
                    sys.exit(0)
            except OSError, e:
                sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
                sys.exit(1)

            # decouple from parent environment
            os.chdir("/")
            os.setsid()
            os.umask(0)

            # do second fork
            try:
                pid = os.fork()
                if pid > 0:
                    # exit from second parent
                    sys.exit(0)
            except OSError, e:
                sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
                sys.exit(1)

            print "pid: %s" % os.getpid()
            # redirect standard file descriptors

            sys.stdout.flush()
            sys.stderr.flush()
            si = file(Stdin, 'r')
            so = file(Stdout, 'a+')
            se = file(Stderr, 'a+', 0)
            os.dup2(si.fileno(), sys.stdin.fileno())
            os.dup2(so.fileno(), sys.stdout.fileno())
            os.dup2(se.fileno(), sys.stderr.fileno())

            # write pidfile
            atexit.register(delpid)
            pid = str(os.getpid())
            file(pidfilename, 'w+').write("%s\n" % pid)

        cmds[args[1].lower()][0](args[2:])
        print "Done!"

    else:
        print "Please enter a valid command"
        print "Commands Are:"
        for c in sorted(cmds):
            print "    %s : %s" % (c, cmds[c][1])