Пример #1
0
def list_users():
    try:
        access_token = request.args.get('accessToken')
        helper = DatabaseHelper()
        return helper.list_users(access_token)
    except Exception as e:
        return "API Error\n" + e.message
Пример #2
0
def delete_project(id):
    try:
        access_token = request.args.get('accessToken')
        helper = DatabaseHelper()
        return helper.delete_project(id, access_token)
    except Exception as e:
        return "API Error\n" + e.message
Пример #3
0
def login():
    try:
        email = request.data.get("email")
        password = request.data.get("password")
        helper = DatabaseHelper()
        return helper.login(email, password)
    except Exception as e:
        return "API Error\n" + e.message
Пример #4
0
def register():
    try:
        email = request.data.get("email")
        password = request.data.get("password")
        firstname = request.data.get("firstname")
        lastname = request.data.get("lastname")
        helper = DatabaseHelper()
        return helper.register(email, password, firstname, lastname)
    except Exception as e:
        return "API Error\n" + e.message
Пример #5
0
def create_project():
    try:
        owner_id = request.data.get("owner_id")
        name = request.data.get("name")
        description = request.data.get("description")
        due_date = request.data.get("due_date")
        helper = DatabaseHelper()
        return helper.create_project(owner_id, name, description, due_date)
    except Exception as e:
        return "API Error\n" + e.message
 def test_saveMember(self):
     self.helper = DatabaseHelper()
     self.config = self.helper.getConfig()
     self.helper.start_tests()
     self.helper.setup_clean_db()
     self.helper.execute_instruction("""
         insert into projects
           (projectname, startdate, enddate, description, currency)
         values
           ('test', '2012-06-04', '2013-07-03', 'a simple test', 'GBP')""")
     self.helper.execute_instruction("""
         insert into projects
           (projectname, startdate, enddate, description, currency)
         values
           ('test 2', '2012-06-04', '2013-07-03', 'another simple test', 'GBP')""")
     with session_scope() as session:
         self.assertEqual(session.query(Household).count(), 0)
         house1 = Household(hhid=40, householdname='Test', pid=2, dateofcollection=datetime.date(2012,6,4))
         session.add(house1)
     add_house_hold_member_logic = AddHouseHoldMemberLogic(40, 2)
     assert add_house_hold_member_logic.saveMember('Male', "10", "2004", False, "", "", "")
     r = AddHouseHoldMemberLogic(40, 2, 'm10')
     m = r.getExistingMember()
     self.assertEqual(m.headofhousehold, 'No')
     self.assertEqual(m.sex, 'Male')
     assert r.saveMember('Female', "12", "2002", False, "", "", "")
     m2 = r.getExistingMember()
     self.assertEqual(m2.personid, 'f12')
     self.assertEqual(m2.headofhousehold, 'No')
     self.helper.end_tests()
    def setUp(self):
        self.helper = DatabaseHelper()
        self.config = self.helper.getConfig()
        self.helper.start_tests()
        self.helper.setup_clean_db()

        self.helper.execute_instruction("""
            insert into projects
              (projectname, startdate, enddate, description, currency)
            values
              ('test', '2012-06-04', '2013-07-03', 'a simple test', 'GBP')""")
        self.helper.execute_instruction("""
            insert into projects
              (projectname, startdate, enddate, description, currency)
            values
              ('test 2', '2012-06-04', '2013-07-03', 'another simple test', 'GBP')""")
        with session_scope() as session:
            self.assertEqual(session.query(Household).count(), 0)
            q = household.search(session, 1, '', '')
            self.assertEqual(q.count(), 0)
            house1 = Household(hhid=40, householdname='Test', pid=2, dateofcollection=datetime.date(2012,6,4))
            house2 = Household(hhid=55, householdname='A Test 2', pid=2, dateofcollection=datetime.date(2012,6,4))
            house3 = Household(hhid=42, householdname='Test 3', pid=3, dateofcollection=datetime.date(2012,6,4))
            session.add(house1)
            session.add(house2)
            session.add(house3)
            household.addMember(session, house2, 'm4', '2010', 'No', 'Male', '', '', '', '')
            c = Householdcharacteristic(characteristic='Test', charvalue='a', hhid=42, pid=3)
            session.add(c)
Пример #8
0
	def __init__(self, config):
		
		self.config = config
		
		self.cm = CameraManager()
		self.builder = gtk.Builder()
		self.builder.add_from_file('win_main.xml')
		self.dbh = DatabaseHelper()
		self._init_controls()
		self._connect_events()
Пример #9
0
class TestSQLAlchemy(unittest.TestCase):
    """
    In order to use these tests you need to have a config file named
    test_openihm.cfg in the directory you are running the tests from
    (i.e. the src directory).

        [database]
        superuser = root
        superuser_password = s00pers3cur3
        database = test_openihm
        user = openihm
        password = ihm2012

    This should contain database credentials for a database that exists
    in mysql for testing.  This database will be toyed around with a lot.
    Obviously avoid pointing it at a database you care about...

    """

    def setUp(self):
        self.helper = DatabaseHelper()
        self.config = self.helper.getConfig()
        self.helper.start_tests()

    def tearDown(self):
        # drop the database
        self.helper.end_tests()

    def test_connection_string(self):
        self.helper.setup_clean_db()
        cs = self.helper.real_config.sqlalchemy_connection_string()
        engine = create_engine(cs, echo=True)
        Session = sessionmaker(bind=engine)
        session = Session()
        self.assertEqual(session.query(SetupFoodsCrops).count(), 0)
        crop = SetupFoodsCrops('test', 'category', 10, 'kg')
        session.add(crop)
        self.assertEqual(session.query(SetupFoodsCrops).count(), 1)
        session.commit()

    def test_alchemy_wrapper(self):
        self.helper.setup_clean_db()
        with session_scope() as session:
            self.assertEqual(session.query(SetupFoodsCrops).count(), 0)
Пример #10
0
    def __init__(self):
        self.ah_obj = AtlasHelper()
        self.awshelper_obj = aws_helper.AwsHelper()
        self.module = "chef_module"
        self.db_obj = DatabaseHelper()
        self.environment_groups = self.ah_obj.get_atlas_config_data("global_config_data", "environment_groups")
        self.memcache_var = memcache.Client([self.ah_obj.get_atlas_config_data("global_config_data",
                                                                    'memcache_server_location')
                                        ], debug=0)
        self.environment_subnets_details = self.awshelper_obj.get_environment_subnets_details()

        try:
            base_path = self.ah_obj.get_atlas_config_data("chef_module", 'chef-base-path')
            self.api = chef.autoconfigure(base_path)
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "__init__()", exp_object, exc_type, exc_obj, exc_tb)
Пример #11
0
class MainWindow:
	
	controls = [
		'win_main', 'btn_config_events', 'btn_recognize_face', 'lst_events',
		'cmb_cameras', 'btn_view_camera', 'txt_port', 'btn_start_server', 
		'lst_cameras', 'tr_vw_col_date', 'tr_vw_col_event', 'tr_vw_events'
	]
	
	def __init__(self, config):
		
		self.config = config
		
		self.cm = CameraManager()
		self.builder = gtk.Builder()
		self.builder.add_from_file('win_main.xml')
		self.dbh = DatabaseHelper()
		self._init_controls()
		self._connect_events()
		
		
	def _init_controls(self):
		
		for c in self.controls:
			self.__dict__[c] = self.builder.get_object(c)
			
		cell = gtk.CellRendererText()
		self.cmb_cameras.pack_start(cell, True)
		self.cmb_cameras.add_attribute(cell, "text", 0)
		self._fill_cameras()
		cell = gtk.CellRendererText()
		self.tr_vw_col_date.pack_start(cell, True)
		self.tr_vw_col_date.add_attribute(cell, 'text', 0)
		cell = gtk.CellRendererText()
		self.tr_vw_col_event.pack_start(cell, True)
		self.tr_vw_col_event.add_attribute(cell, 'text', 1)
		self._fill_events()
		
		
	def _fill_cameras(self):
		self.cmb_cameras.get_model().clear()
		for cam in self.cm.get_cameras():
			self.cmb_cameras.append_text(cam.device_path)
			
		self.cmb_cameras.set_active(0)

	def _connect_events(self):
		self.win_main.connect('delete_event', self._win_main_delete_event)
		self.btn_view_camera.connect('clicked', self._view_camera)
		self.btn_start_server.connect('clicked', self._start_server)
		
		
	def _fill_events(self, *args):
		self.lst_events.clear()
		
		for a in self.dbh.get_activities():
			row = time.strftime('%d/%m/%Y', time.localtime(a[1])), a[2]
			self.lst_events.append(row)
		
		
	def _start_server(self, *args):
		port = self.txt_port.get_text()
		print 'Servidor iniciado en puerto', port
		
		proc = Process(target = MainWindow._start_monitor_server, args = (port,))
		proc.start()
		
	def _win_main_delete_event(self, *args):
		gtk.main_quit()
		
	
	def _view_camera(self, *args):
		
		device = self.cmb_cameras.get_active_text()
		
		proc = Process(target = MainWindow._start_camera_monitor, 
			args = (device,) )
			
		proc.start()
	
	@staticmethod
	def _start_monitor_server(port):
		
		os.popen(' '.join(('python', 'monitor_server.py', '-p', port)))
	
	@staticmethod
	def _start_camera_monitor(device):
		
		os.popen(' '.join(('python', 'camera_manager.py', '-d', device, '-f')))
		
	
	def main(self):
		self.win_main.show_all()
		gtk.main()
Пример #12
0
import paho.mqtt.client as mqtt  #import the client1
from database_helper import DatabaseHelper
import paho.mqtt.client as mqtt
import re

username = "******"
password = "******"

database_helper = DatabaseHelper("employeerecords.db")


def start_record(args):
    return database_helper.start_record(*args)


def stop_record(args):
    return database_helper.stop_record()


def delete_employee(args):
    return database_helper.delete_employee(args)


def show_list(args):
    return database_helper.show_list(*args)


def update_employee(args):
    return database_helper.update_employee(*args)

Пример #13
0
from flask import Flask
from database_helper import DatabaseHelper
app = Flask(__name__)
db_instance = DatabaseHelper()


@app.route('/api/tasks', methods=["GET"])
def get():
    db_instance.get_a_todo()


@app.route('/api/tasks/bystatus/<status>', methods=["GET"])
def get_by_status(status):
    db_instance.get_a_todo_by_status(status)


@app.route('/api/tasks/byid/<id>', methods=["GET"])
def get_a_todo_by_id(id):
    db_instance.get_a_todo_by_id(id)


@app.route('/api/tasks/delete/<id>', methods=["DELETE"])
def delete(id):
    db_instance.delete_a_to_do(id)


@app.route('/api/tasks/post', methods=["POST"])
def post():
    db_instance.add_a_todo()

Пример #14
0
class TestModelHouseHold(unittest.TestCase):
    """
    In order to use these tests you need to have a config file named
    test_openihm.cfg in the directory you are running the tests from
    (i.e. the src directory).

        [database]
        superuser = root
        superuser_password = s00pers3cur3
        database = test_openihm
        user = openihm
        password = ihm2012

    This should contain database credentials for a database that exists
    in mysql for testing.  This database will be toyed around with a lot.
    Obviously avoid pointing it at a database you care about...

    """

    def setUp(self):
        self.helper = DatabaseHelper()
        self.config = self.helper.getConfig()
        self.helper.start_tests()
        self.helper.setup_clean_db()

        self.helper.execute_instruction("""
            insert into projects
              (projectname, startdate, enddate, description, currency)
            values
              ('test', '2012-06-04', '2013-07-03', 'a simple test', 'GBP')""")
        self.helper.execute_instruction("""
            insert into projects
              (projectname, startdate, enddate, description, currency)
            values
              ('test 2', '2012-06-04', '2013-07-03', 'another simple test', 'GBP')""")
        with session_scope() as session:
            self.assertEqual(session.query(Household).count(), 0)
            q = household.search(session, 1, '', '')
            self.assertEqual(q.count(), 0)
            house1 = Household(hhid=40, householdname='Test', pid=2, dateofcollection=datetime.date(2012,6,4))
            house2 = Household(hhid=55, householdname='A Test 2', pid=2, dateofcollection=datetime.date(2012,6,4))
            house3 = Household(hhid=42, householdname='Test 3', pid=3, dateofcollection=datetime.date(2012,6,4))
            session.add(house1)
            session.add(house2)
            session.add(house3)
            c = Householdcharacteristic(characteristic='Test', charvalue='a', hhid=42, pid=3)
            session.add(c)

    def tearDown(self):
        # drop the database
        self.helper.end_tests()

    def test_household_search(self):
        # a) no effective paramaters
        with session_scope() as session:
            q = household.search(session, 1, '', '')
            self.assertEqual(q.count(), 0)
            q = household.search(session, 2, '', '')
            self.assertEqual(q.count(), 2)
            q = household.search(session, 3, '', '')
            self.assertEqual(q.count(), 1)
            # g) ensure different projects don't clash - gets tested implicitly

    def test_number(self):
        # b) just number
        with session_scope() as session:
            q = household.search(session, 2, name='', number='55')
            self.assertEqual(q.count(), 1)
            q = household.search(session, 2, '', '33')
            self.assertEqual(q.count(), 0)

    def test_name(self):
        # c) just name
        with session_scope() as session:
            q = household.search(session, 3, 'Test 3', '')
            self.assertEqual(q.count(), 1)

    def test_both(self):
        # d) both
        with session_scope() as session:
            q = household.search(session, 2, 'Test', '40')
            self.assertEqual(q.count(), 2)
            q2 = household.search(session, 2, 'A Test', '55')
            self.assertEqual(q2.count(), 1)
            q2 = household.search(session, 2, 'A Test 2', '40')
            self.assertEqual(q2.count(), 2)
            q2 = household.search(session, 2, 'Not', '55')
            self.assertEqual(q2.count(), 1)

    def test_like(self):
        # e) like works
        with session_scope() as session:
            q = household.search(session, 2, 'Test', '')
            self.assertEqual(q.count(), 2)
            q2 = household.search(session, 2, 'A test', '')
            self.assertEqual(q2.count(), 1)
            q2 = household.search(session, 2, 'A Test 2', '')
            self.assertEqual(q2.count(), 1)
            q2 = household.search(session, 2, 'Not', '')
            self.assertEqual(q2.count(), 0)

    def test_results(self):
        # f) count and results work as expected.
        with session_scope() as session:
            q = household.search(session, 2, '', '')
            self.assertEqual(q.count(), 2)
            l = [ (h.hhid, h.householdname) for h in q ]
            self.assertEqual(l, [(40, 'Test'), (55, 'A Test 2')])

    def test_remove(self):
        with session_scope() as session:
            household.remove_house(session, 2, [55])
            q = household.search(session, 2, 'Test', '')
            self.assertEqual(q.count(), 1)

    def test_remove_project_scope(self):
        # ensure we don't accidentally delete houses from
        # different projects.
        with session_scope() as session:
            household.remove_house(session, 2, [55, 40, 42])
            q = household.search(session, 2, '', '')
            self.assertEqual(q.count(), 0)
            q = household.search(session, 3, '', '')
            self.assertEqual(q.count(), 1)

    def test_add_member(self):
        with session_scope() as session:
            house = Household(hhid=40, pid=2)
            household.addMember(session, house, 'm4', '2010', 'No', 'Male', '', '', '', '')
            # ensure that it deals with twins okay.
            household.addMember(session, house, 'm4', '2010', 'No', 'Male', '', '', '', '')
            # FIXME: ought to deal with removing and adding members okay.

    def test_eager_loading(self):
        with session_scope() as session:
            p = session.query(Project).options(joinedload('houses')).filter(Project.projectname == 'test').one()
            self.assertEqual(len(p.houses), 2)
Пример #15
0
	# Opciones de la linea de comandos
	parser = OptionParser()
	
	parser.add_option('-d', '--device', dest='device', default=None, help='Ruta de dispositivo correspondiente a una camara web')
	
	parser.add_option('-f', '--face', dest='face', default=False, action='store_true', help='Indica si se detectaran imagenes en la camara')

	options = parser.parse_args()[0]
	
	if options.device:
		
		manager = CameraManager()
		
		camera = manager.get_camera(options.device)
		
		dbh = DatabaseHelper()
		
		camera.init()
			
		keep_running = True
		
		def mouse_callback(event, x, y, flags, params):
			global keep_running
			if event == highgui.CV_EVENT_LBUTTONDOWN:
				keep_running = False
					
		wname = 'Monitor de Camara[ {0} ]'.format(options.device)

		highgui.cvNamedWindow(wname, 1)
		highgui.cvSetMouseCallback(wname, mouse_callback, ())
		
class TestDatabaseInitialiser(unittest.TestCase):
    """
    In order to use these tests you need to have a config file named
    test_openihm.cfg in the directory you are running the tests from
    (i.e. the src directory).

        [database]
        superuser = root
        superuser_password = s00pers3cur3
        database = test_openihm
        user = openihm
        password = ihm2012

    This should contain database credentials for a database that exists
    in mysql for testing.  This database will be toyed around with a lot.
    Obviously avoid pointing it at a database you care about...

    """

    def setUp(self):
        self.helper = DatabaseHelper()
        self.config = self.helper.getConfig()
        self.helper.start_tests()

    def tearDown(self):
        # drop the database
        self.helper.end_tests()

    def test___init__(self):
        database_initialiser = DatabaseInitialiser(self.config)
        # FIXME: this test is probably bogus
        # we're really just checking we manage to create the
        # object okay.
        expected = "latest update on 2012-05-16"
        self.assertEqual(expected, database_initialiser.latestupdatestring)

    def test_createDatabase(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_db_file('openihmdb_mysql.sql')
        assert database_initialiser.createDatabase()

    @unittest.expectedFailure
    def test_cropsExist(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.helper.setup_db_file('openihmdb_mysql_fix59.sql')
        # FIXME: push some data into the relevant table.
        #self._execute_instruction('insert into setup_foods_crops values (%s)')
        assert database_initialiser.cropsExist()

    def test_databaseUpToDate(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        assert database_initialiser.databaseUpToDate()

    def test_databaseUpToDate_needupdate(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.make_db_outofdate()
        assert not database_initialiser.databaseUpToDate()

    def test_databaseUpToDate_fresh_db(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.helper.execute_instruction('delete from dbupdate')
        assert database_initialiser.databaseUpToDate()

    def make_db_outofdate(self):
        updatestr = "latest update on %s" % (date.min.isoformat())
        self.helper.execute_instruction(
            "update dbupdate set lastupdate = %s", [updatestr])

    def test_initialiseDB(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.assertEqual({
            'mysqlstarted': True,
            'dbinstalled': True,
            'dbuptodate': True}, database_initialiser.initialiseDB())

    def test_insertStartupCrops(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.helper.setup_db_file('openihmdb_mysql_fix59.sql')
        assert database_initialiser.insertStartupCrops()

    def test_setupStartupCrops(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.helper.setup_db_file('openihmdb_mysql_fix59.sql')
        assert database_initialiser.setupStartupCrops()

    def test_updateDatabase(self):
        # NOTE: it might be worth adding a test that compares the new
        # database to the updated database to check they match.
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        # this isn't much of a check...
        # our coverage isn't very good.
        assert database_initialiser.updateDatabase()

    def test_updateDatabase_needs_update(self):
        database_initialiser = DatabaseInitialiser(self.config)
        self.helper.setup_clean_db()
        self.make_db_outofdate()
        self.helper.setup_db_file('openihmdb_mysql_update.sql')
        assert database_initialiser.updateDatabase()
Пример #17
0
def main():
    controller = Controller(View(), Model())
    controller.start()
    DatabaseHelper.close()
Пример #18
0
class TestDatabase(unittest.TestCase):
    """
    In order to use these tests you need to have a config file named
    test_openihm.cfg in the directory you are running the tests from
    (i.e. the src directory).

        [database]
        superuser = root
        superuser_password = s00pers3cur3
        database = test_openihm
        user = openihm
        password = ihm2012

    This should contain database credentials for a database that exists
    in mysql for testing.  This database will be toyed around with a lot.
    Obviously avoid pointing it at a database you care about...

    """

    def setUp(self):
        self.helper = DatabaseHelper()
        self.config = self.helper.getConfig()
        self.helper.start_tests()

    def tearDown(self):
        # drop the database
        self.helper.end_tests()

    def test___init__(self):
        database = Database()
        self.assertEqual(self.config.dbinfo(), database.config)

    def test_close(self):
        database = Database()
        database.open()
        database.close()

    @unittest.expectedFailure
    def test_databaseExists(self):
        database = Database()
        assert database.databaseExists()

    @unittest.expectedFailure
    def test_databaseServerRunning(self):
        database = Database()
        assert database.databaseServerRunning()

    def test_execDefinitionQuery(self):
        self.helper.setup_clean_db()
        database = Database()
        database.open()
        database.execDefinitionQuery('create table simples (test int)')
        database.close()
        # and just to prove it's there to put something into.
        database.open()
        database.execUpdateQuery('insert into simples values (3)')
        database.close()

    def test_execSelectQuery(self):
        self.helper.setup_clean_db()
        self.helper.execute_instruction("""
            insert into projects
                (projectname, startdate, enddate, description, currency)
            values
                ('test', 2012-06-04, 2013-07-03, 'a simple test', 'GBP')""")
        database = Database()
        query = 'select * from projects'
        database.open()
        self.assertEqual([(2, u'test', None, None, u'a simple test', u'GBP')],
                        database.execSelectQuery(query))
        database.close()

    def test_execUpdateQuery(self):
        self.helper.setup_clean_db()
        database = Database()
        database.open()
        database.execUpdateQuery("""
            insert into projects
                (projectname, startdate, enddate, description, currency)
            values
                ('test', 2012-06-04, 2013-07-03, 'a simple test', 'GBP')""")
        query = 'select * from projects'
        # FIXME: the None's look hinky.
        self.assertEqual([(2, u'test', None, None, u'a simple test', u'GBP')],
                        database.execSelectQuery(query))
        database.close()

    def test_open(self):
        database = Database()
        database.open()
Пример #19
0
 def setUp(self):
     self.helper = DatabaseHelper()
     self.config = self.helper.getConfig()
     self.helper.start_tests()
Пример #20
0
from config_reader import ConfigReader
from database_helper import DatabaseHelper
from json import loads
from flask import Flask, jsonify, request

app = Flask('CountriesREST')
cr = ConfigReader()
host, dbname, user, password = cr.get_database_config()
db = DatabaseHelper(host, dbname, user, password)


@app.route('/countries', methods=['GET'])
def get_countries():
    result = db.execute_select('SELECT id, name, continent FROM public.countries')
    return db.transform_dataset_into_json(result)


@app.route('/countries/<id>', methods=['GET'])
def get_country(id):
    script = 'SELECT id, name, continent FROM public.countries WHERE id = {}'.format(id)
    result = db.execute_select(script)
    return db.transform_row_into_json(result)


@app.route('/countries/<id>', methods=['DELETE'])
def delete_country(id):
    script = 'DELETE FROM public.countries WHERE id = {}'.format(id)
    db.execute_script(script)
    message = 'Country {} was deleted!'.format(id)
    dic = {'message': message}
    return jsonify(dic)
Пример #21
0
class DBInterface(object):
    def __init__(self, model):
        self.database = DatabaseHelper()
        self.model = model

    def __get_filters(self, query, columns, values):
        if not isinstance(columns, list) and not isinstance(values, list):
            return query.filter(columns == values)
        else:
            assert (isinstance(columns, list) and isinstance(values, list))
            assert (columns.__len__() == values.__len__())

            for (column, value) in zip(columns, values):
                query = query.filter(column == value)
            return query

    def __get_update_query(self, query, columns, values):
        if not isinstance(columns, list) and not isinstance(values, list):
            return query.update({columns: values})
        else:
            assert (isinstance(columns, list) and isinstance(values, list))
            assert (columns.__len__() == values.__len__())

            index = 0
            obj = {}
            for column in columns:
                obj[column] = values[index]
                index += 1
            query = query.update(obj)
            return query

    def select_all(self):
        session = self.database.get_session()
        result = session.query(self.model).all()
        return result

    def select(self, columns, values):
        session = self.database.get_session()
        query = session.query(self.model)
        return self.__get_filters(query, columns, values).all()

    def delete(self, columns, values):
        session = self.database.get_session()
        result = self.select(columns, values)

        assert result

        if isinstance(result, list):
            # Many objects
            for obj in result:
                try:
                    session.delete(obj)
                    session.commit()
                    return True
                except NoResultFound:
                    print("Object NOT FOUND")
        else:
            # One object
            try:
                session.delete(result)
                session.commit()
                return True
            except NoResultFound:
                session.rollback()
                print("Object NOT FOUND")

    def update(self, columnsFind, valuesFind, columnsNew, valuesNew):
        session = self.database.get_session()
        query = session.query(self.model)
        query = self.__get_filters(query, columnsFind, valuesFind)

        assert query
        query = self.__get_update_query(query, columnsNew, valuesNew)

        if not query:
            print("Object NOT FOUND")
        else:
            v = View()
            v.print_and_getch("PRESS ANY KEY TO COMMIT")
            session.commit()
            return True

    def insert(self, obj):
        session = self.database.get_session()
        try:
            session.add(obj)
            session.commit()
            return True
        except BaseException as exception:
            session.rollback()
            print(exception)
 def setUp(self):
     self.helper = DatabaseHelper()
     self.helper.start_tests()
    class TestMySQLMixin(unittest.TestCase):
        """
        In order to use these tests you need to have a config file named
        test_openihm.cfg in the directory you are running the tests from
        (i.e. the src directory).

            [database]
            superuser = root
            superuser_password = s00pers3cur3
            database = test_openihm
            user = openihm
            password = ihm2012

        This should contain database credentials for a database that exists
        in mysql for testing.  This database will be toyed around with a lot.
        Obviously avoid pointing it at a database you care about...

        """

        def setUp(self):
            self.helper = DatabaseHelper()
            self.helper.start_tests()

        def tearDown(self):
            # drop the database
            self.helper.end_tests()

        def test_executeMultipleResultsQueries(self):
            self.helper.setup_clean_db()
            mixin = MySQLMixin()
            queries = [
            """
                insert into projects
                    (projectname, description, currency)
                values
                    ('test', 'a simple test', 'GBP')""",
            """
                insert into projects
                    (projectname, description, currency)
                values
                    ('test2', 'simple test', 'AUS')""",
            ]
            mixin.executeMultipleUpdateQueries(queries)
            exp = [
                [(u'test', None, None, u'a simple test', u'GBP')],
                [(u'test2', None, None, u'simple test', u'AUS')]
            ]
            s_queries = [
            """
            select projectname, startdate, enddate, description, currency
            from projects limit 1
            """,
            """
            select projectname, startdate, enddate, description, currency
            from projects limit 1 offset 1
            """,
            ]
            self.assertEqual(exp, mixin.executeMultipleResultsQueries(s_queries))

        def test_executeMultipleUpdateQueries(self):
            self.helper.setup_clean_db()
            my_sql_mixin = MySQLMixin()
            queries = [
            """
                insert into projects
                    (projectname, description, currency)
                values
                    ('test', 'a simple test', 'GBP')""",
            """
                insert into projects
                    (projectname, description, currency)
                values
                    ('test2', 'simple test', 'AUS')""",
            ]
            my_sql_mixin.executeMultipleUpdateQueries(queries)
            expected = [
                (u'test', None, None, u'a simple test', u'GBP'),
                (u'test2', None, None, u'simple test', u'AUS')
            ]
            query = """
            select projectname, startdate, enddate, description, currency
            from projects
            """
            self.assertEqual(expected, my_sql_mixin.executeResultsQuery(query))

        def test_executeResultsQuery(self):
            self.helper.setup_clean_db()
            my_sql_mixin = MySQLMixin()
            my_sql_mixin.executeUpdateQuery("""
                insert into projects
                    (projectname, description, currency)
                values
                    ('test', 'a simple test', 'GBP')""")
            expected = [(2, u'test', None, None, u'a simple test', u'GBP')]
            query = 'select * from projects'
            self.assertEqual(expected, my_sql_mixin.executeResultsQuery(query))

        def test_executeUpdateQueryWithParams(self):
            self.helper.setup_clean_db()
            my_sql_mixin = MySQLMixin()
            p = ['test3', '2012-06-04', 'description', 'LIR']
            my_sql_mixin.executeUpdateQuery("""
                insert into projects
                    (projectname, startdate, enddate, description, currency)
                values
                    (%s, %s, '2013-07-03', %s, %s)""", p)
            expected = [(2, u'test3', datetime.date(2012, 6, 4),
                        datetime.date(2013, 7, 3), u'description', u'LIR')]
            query = 'select * from projects'
            self.assertEqual(expected, my_sql_mixin.executeResultsQuery(query))

        def test_executeUpdateQuery(self):
            self.helper.setup_clean_db()
            my_sql_mixin = MySQLMixin()
            my_sql_mixin.executeUpdateQuery("""
                insert into projects
                    (projectname, description, currency)
                values
                    ('test', 'a simple test', 'GBP')""")
            expected = [(2, u'test', None, None, u'a simple test', u'GBP')]
            query = 'select * from projects'
            self.assertEqual(expected, my_sql_mixin.executeResultsQuery(query))
Пример #24
0
 def __init__(self, model):
     self.database = DatabaseHelper()
     self.model = model
Пример #25
0
class ChefHelper:

    def __init__(self):
        self.ah_obj = AtlasHelper()
        self.awshelper_obj = aws_helper.AwsHelper()
        self.module = "chef_module"
        self.db_obj = DatabaseHelper()
        self.environment_groups = self.ah_obj.get_atlas_config_data("global_config_data", "environment_groups")
        self.memcache_var = memcache.Client([self.ah_obj.get_atlas_config_data("global_config_data",
                                                                    'memcache_server_location')
                                        ], debug=0)
        self.environment_subnets_details = self.awshelper_obj.get_environment_subnets_details()

        try:
            base_path = self.ah_obj.get_atlas_config_data("chef_module", 'chef-base-path')
            self.api = chef.autoconfigure(base_path)
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "__init__()", exp_object, exc_type, exc_obj, exc_tb)

    def get_databag_list(self, databag=''):
        #returns a list of all available data bags on the chef_server
        data_bag_list = []
        try:
            data_bags = DataBag(databag,self.api)
            for items in data_bags.list(self.api):
                data_bag_list.append(items)
            if not data_bag_list:
                raise Exception, "No Data bags items found"
            else:
                return data_bag_list
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "get_databag_list()", exp_object, exc_type, exc_obj, exc_tb)
            return []


    def cache_databag_attributes_foritem(self, databag, item):
        """
        Fetch databag attributes from chef server using databag name and item name and cache it locally.
        """
        try:
            databag_attributes_foritem = self.get_databag_attribute_foritem(databag, item)
            self.memcache_var.set("cpdeployment_databag_attrs", databag_attributes_foritem,600) 
            if databag_attributes_foritem is None:
                raise Exception("Databag attributes cannot be obtained from Chef server. Please make sure data is obtained and populate the cache !!!")
            if databag_attributes_foritem is not None:
                self.memcache_var.set("global_cpdeployment_databag_attributes", databag_attributes_foritem ,86400)
            self.memcache_var.disconnect_all()
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "cache_databag_attributes_foritem()", exp_object, exc_type, exc_obj, exc_tb)
            self.memcache_var.disconnect_all()
            return

      
    def get_chefdbag_attributes_foritem(self, databag, item):
        """
        Check in short term cache if not fetch results from global cache
        """
        db_attribute_dict = self.memcache_var.get('cpdeployment_databag_attrs')
        if db_attribute_dict is None:
            db_attribute_dict = self.memcache_var.get('global_cpdeployment_databag_attrs')
            if db_attribute_dict is not None:
                self.memcache_var.set("cpdeployment_databag_attrs", db_attribute_dict, 600)
                self.memcache_var.disconnect_all()
                with threading.Lock():
                    thread = threading.Thread(target=self.cache_databag_attributes_foritem, args=(databag, item))
                    thread.start()
        return db_attribute_dict
       

    def get_databag_attribute_foritem(self, databag, item):
        try:
            data_bag = DataBag(databag,self.api)
            data_bag_item = data_bag[item]
            chef_databags = self.ah_obj.get_atlas_config_data("chef_module", 'chef_databags')[0]
            chef_databags_info = self.ah_obj.get_atlas_config_data("chef_module", 'chef_databags')[1]
            key_list = []
            for index in chef_databags:
                if databag in chef_databags_info.keys():
                    for item_index in chef_databags_info[databag]['items'].keys():
                        if item == item_index:
                            key_list = chef_databags_info[databag]['items'][item]['keys']

            data_bag_attr = {}
            data_bag_attr.fromkeys(data_bag_item.keys(), None)
            for d_item_key, d_item_values in data_bag_item.iteritems():

                if type(d_item_values)== unicode:
                    if d_item_key in key_list:
                        data_bag_attr[d_item_key] = {}
                        data_bag_attr[d_item_key] = d_item_values
                        break;
                elif type(d_item_values) == dict:
                    data_bag_attr[d_item_key] = {}

                    for key in key_list:
                        data_bag_attr[d_item_key][key] = self.ah_obj.get_nested_attribute_values(d_item_values, key)

            return data_bag_attr
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "get_databag_attributes()", exp_object, exc_type, exc_obj, exc_tb)
            return []

    def cache_chef_node_attributes(self):
        """
        Fetch node attributes from chef server and cache it locally.
        """
        try:
            chef_node_attributes_dict = self.get_node_attrs_from_chef()
            if chef_node_attributes_dict is None:
                raise Exception("Chef node attributes not available from the Chef server. Please make sure the data is available and populate the cache.")
            if chef_node_attributes_dict is not None:
                self.memcache_var.set("global_chef_node_attributes_cache", chef_node_attributes_dict,86400)
            self.memcache_var.disconnect_all()
            self.memcache_var.set("chef_node_attr_caches", chef_node_attributes_dict,2*60*60)
            self.memcache_var.disconnect_all()
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "cache_chef_node_attributes()", exp_object, exc_type, exc_obj, exc_tb)
            self.memcache_var.disconnect_all()
            return
    
    def get_node_attributes(self):
        node_attribute_dict = self.memcache_var.get('chef_node_attr_caches')
        if node_attribute_dict is None:
            node_attribute_dict = self.memcache_var.get('global_chef_node_attributes_cache')
            self.memcache_var.disconnect_all()
            if node_attribute_dict is not None:
                self.memcache_var.set('chef_node_attr_caches', node_attribute_dict, 600)
                with threading.Lock():
                    thread = threading.Thread(target=self.cache_chef_node_attributes)
                    thread.start()
        return node_attribute_dict


    def get_node_attrs_from_chef(self):
        try:
            env_subnets_dict = {}
            node_attribute_dict = {}
            for organization in self.awshelper_obj.get_organizations():
                node_attribute_dict = defaultdict(dict)
                node_list = Node.list(self.api)
                for environment in self.awshelper_obj.get_environments(organization):
                    for region in self.awshelper_obj.get_regions():
                        vpc_list = self.awshelper_obj.get_vpc_in_region(region)
                        if vpc_list:
                            for vpc in self.awshelper_obj.get_vpc_in_region(region):
                                env_subnets_dict = self.awshelper_obj.get_env_subnets(organization, region, vpc)
                for node in node_list:
                    node_obj = Node(node, api=self.api)
                    node_split = self.ah_obj.split_string(node, ["."])
                    if node_split is None or len(node_split)<=1:
                        pass
                    else:
                        node_subnet = self.ah_obj.split_string(node, ['.'])[1]
                        for key_tuple, environment in env_subnets_dict.iteritems():
                            if node_subnet in key_tuple:
                                environment = env_subnets_dict[key_tuple]
                                attribute_list = node_obj.attributes
                                if 'ec2' in attribute_list:
                                    if 'instance_id' in node_obj.attributes.get_dotted('ec2'):
                                        instance_id = node_obj.attributes.get_dotted('ec2.instance_id')
                                        node_attribute_dict[instance_id]['node'] = node
                                if 'os' in attribute_list:
                                    node_attribute_dict[instance_id]['os']=node_obj['os']
                                if 'os_version' in attribute_list:
                                    node_attribute_dict[instance_id]['os_version'] = node_obj['os_version']
                                if 'platform' in attribute_list:
                                    node_attribute_dict[instance_id]['platform'] = node_obj['platform']
                                if 'platform_version' in attribute_list:
                                    node_attribute_dict[instance_id]['platform_version'] = node_obj['platform_version']
                                if 'uptime' in attribute_list:
                                    node_attribute_dict[instance_id]['uptime'] = node_obj['uptime']
                                if 'idletime' in attribute_list:
                                    node_attribute_dict[instance_id]['idletime'] = node_obj['idletime']
            return dict(node_attribute_dict)
        except Exception as exp_object:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.ah_obj.print_exception("chef_helper.py", "get_node_attrs_from_chef1()", exp_object, exc_type, exc_obj, exc_tb)
            return {}

    def map_node_databag_attributes(self, node_attributes, databag_attributes, environment):
        tabs_info_dict = {}
        for instance_id, details in node_attributes.iteritems():
            tabs_info_dict[instance_id] = {'chef_information':{}}
            tabs_info_dict[instance_id]['chef_information'] = details
            for node_attr, node_attr_value in details.iteritems():
                tabs_info_dict[instance_id]['chef_information'][node_attr]=node_attr_value
            if databag_attributes.has_key(details['node']):
                for key, value in databag_attributes.iteritems():
                    if details['node'] == key:
                        for attribute, attribute_value in value.iteritems():
                            tabs_info_dict[instance_id]['chef_information'][attribute] = attribute_value           
        return tabs_info_dict

    def get_values_for_attribute(self, environment, region, vpc, subnet, stack, attribute, details):
        attribute_value_dict = {}
        if attribute == "owner":
            ownership_records = self.db_obj.get_stack_ownership_details(environment, region, vpc, subnet, stack)
            if ownership_records is not None:
                attribute_value_dict["owner"] = ownership_records.owner
                attribute_value_dict["start_time"] = int(ownership_records.start_time.strftime("%s")) * 1000
            else:
                attribute_value_dict["owner"] = "none"
        if attribute == "dbhost" or attribute == "email_override" or attribute == "branch":
            attribute_record = self.db_obj.get_stack_attribute_value(environment, region, vpc, subnet, stack, attribute)
            if attribute_record is not None:
                attribute_value_dict[attribute] = attribute_record.attribute_value
            else:
                custportal_dbag_attrs = self.memcache_var.get('cpdeployment_databag_attrs');
                if custportal_dbag_attrs is not None:
                    for keys, values in custportal_dbag_attrs.iteritems():
                        custportal_dbag_attrs_subnet = keys.split(".")[1]
                        if custportal_dbag_attrs_subnet == subnet and stack in details['stack']:
                            if attribute == "dbhost":
                                if values['AWS_DB_HOST']:
                                    attribute_value_dict["dbhost"] = values['AWS_DB_HOST']
                                else:
                                    attribute_value_dict["dbhost"] = "none"
                            if attribute == "email_override":
                                if values['EMAIL_OVERRIDE'] and values['EMAIL_OVERRIDE'] is not None:
                                    attribute_value_dict["email_override"] = values['EMAIL_OVERRIDE'] 
                                if values['EMAIL_OVERRIDE'] == "none":
                                    pass 
                            if attribute == "branch":
                                if values["branch"]:
                                    attribute_value_dict["branch"] = values['branch']
                                else:
                                  "none"
        return attribute_value_dict


    def stack_attribute_values(self, request, environment, region_vpc_dict):
        """
        Get attributes and values for each stack.
        """
        stack_attribute_dict = collections.defaultdict(dict)
        awsmodule_obj = AwsModule(request, environment)
        (stack_attr_list, stack_attr_details) = stack_attributes = self.ah_obj.get_atlas_config_data(self.module, 'stack_attributes')
        application_subnets = awsmodule_obj.get_information(environment, application_subnets='true')
        apps_in_environment = awsmodule_obj.get_information(environment, apps_in_environment='true')
        if application_subnets is not None and apps_in_environment is not None:
            for region, vpc_list in region_vpc_dict.iteritems():
                stack_attribute_dict[region] = {}
                if vpc_list is not None:
                    for vpc in vpc_list:
                        stack_attribute_dict[region][vpc] = {}
                        for subnet in application_subnets:
                            stack_attribute_dict[region][vpc][subnet] = {}
                            for stack in apps_in_environment:
                                stack_attribute_dict[region][vpc][subnet][stack] = {}
                                for attribute in stack_attr_list:
                                    details = stack_attr_details[attribute]
                                    stack_attribute_dict[region][vpc][subnet][stack].update(self.get_values_for_attribute(environment, region, vpc, subnet, stack, attribute, details))                
        return dict(stack_attribute_dict)

    def get_stack_attribute_values(self, request, environment, region_vpc_dict):
        """
        Get stack attribute values for environment or environment groups.
        """
        stack_attribute_dict = {}
        stack_attribute_dict = self.stack_attribute_values(request, environment, region_vpc_dict)

        return stack_attribute_dict

    def get_stack_attributes(self, environment):
        """
        Get stack attributes from config file.
        """
        stack_attribute_list = []
        stack_attributes_dict = self.ah_obj.get_atlas_config_data('chef_module', 'stack_attributes')[1]
        for attribute, details in stack_attributes_dict.iteritems():
            stack_attribute_list.append((attribute, details['editable']))
        return(stack_attribute_list, stack_attributes_dict)