def check_services(self):
"""
Checks the status of required services
:returns: status of the services
:rtype: bool
"""
logging = LogHandler(System().get_watcher_log_dir())
# Checking the API
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((self.system.get_grid_ip(), self.system.get_api_port()))
if result == 0:
api_status = True
logging.logger("Status of API: ACTIVE", 4, module)
else:
api_status = False
logging.logger("Status of API: INACTIVE", 4, module)
# Checking the LOCAL_NET
if ServiceManager().get_service_status("pimotics-local-net"):
local_net_status = True
logging.logger("Status of LOCAL_NET: ACTIVE", 4, module)
else:
local_net_status = False
logging.logger("Status of LOCAL_NET: INACTIVE", 4, module)
# Output result
if api_status and local_net_status:
return True
else:
return False
def __init__(self, description, name=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class User
self._name = name
self.description = description
def __init__(self, user_id, distributed_on, valid_until, api_token=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class ApiToken
self._user_id = user_id # foreign key to user object
self._api_token = api_token
self.distributed_on = distributed_on
self.valid_until = valid_until
def __init__(self, pin_number, pin_type, bus_address, identifier=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class User
self._id = identifier
self.pin_number = pin_number
self.pin_type = pin_type
self.bus_address = bus_address
def __init__(self, pin_id, name, type, room_name, identifier=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class Sensor
self._id = identifier
self._pi_pin = pin_id
self._room_name = room_name
self.name = name
self.type = type
def __init__(self):
"""
constructor for MySQLDB
"""
self.module = __name__
self.settings = System().get_config_file()
self.logger = LogHandler(System().get_model_log_dir())
# init db
self.db = MySQLdb.connect(host="localhost",
user=self.settings['pimotics']['cluster']['config']['mysql']['user'],
passwd=self.settings['pimotics']['cluster']['config']['mysql']['password'],
db=self.settings['pimotics']['cluster']['config']['mysql']['database'])
def __init__(self, username, password, name, surname, email, user_access, admin_access, identifier=None,
joined_on=datetime.datetime.now()):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class User
self._id = identifier
self.username = username
self.password = password
self.name = name
self.surname = surname
self.email = email
self.joined_on = joined_on
self.user_access = user_access
self.admin_access = admin_access
class User(object):
"""
User class
"""
def __init__(self, username, password, name, surname, email, user_access, admin_access, identifier=None,
joined_on=datetime.datetime.now()):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class User
self._id = identifier
self.username = username
self.password = password
self.name = name
self.surname = surname
self.email = email
self.joined_on = joined_on
self.user_access = user_access
self.admin_access = admin_access
@property
def id(self):
"""
Creates a READ ONLY 'id' property
:returns: id
:rtype: int
"""
return self._id
def save(self):
"""
Save/update the object to the persistent backend. It will also invalidate certain caches.
:raises PiMoticUserNotFoundExceptionsException
"""
db = MySQLDB()
if self.id:
if self._exists():
db.execute_query("UPDATE `User` SET `password`='{0}',"
"`name`='{1}',`surname`='{2}',`e-mail`='{3}',"
"`user_access`={4}, `admin_access`={5} WHERE `id`={6};"
.format(self.password, self.name, self.surname,
self.email, self.user_access, self.admin_access, self.id)
)
db.commit()
else:
raise UserNotFoundException("Object User with name '{0}' not found in persistent database".format(self.name),
self.module)
else:
self.logger.logger("Inserting new User into DB", 4, self.module)
db.execute_query("INSERT INTO `User` (`username`, `password`, `name`, `surname`, `e-mail`, `joined_on`"
", `user_access`, `admin_access`) VALUES ('{0}', '{1}', '{2}', '{3}', '{4}', now(), "
"{5}, {6});".format(self.username, self.password, self.name, self.surname, self.email,
self.user_access, self.admin_access))
db.commit()
def serialize(self):
"""
Returns the object in a dict/json style
:returns: a serialized object
:rtype: dict
"""
return {
"id": self.id,
"username": self.username,
"password": self.password,
"name": self.name,
"surname": self.surname,
"e-mail": self.email,
"joined_on": self.joined_on,
"user_access": self.user_access,
"admin_access": self.admin_access
}
def delete(self):
"""
Deletes the object from the persistent backend. It will also invalidate certain caches.
:raises UserNotFoundException
"""
db = MySQLDB()
if self._exists():
mysql_check = self._select()
if mysql_check:
db.execute_query("DELETE FROM `User` WHERE `id`={0};".format(self.id))
db.commit()
else:
raise UserNotFoundException("Object User with name '{0}' not found in the persistent backend"
.format(self.name), self.module)
else:
raise UserNotFoundException("Object User with name '{0}' is a new object, "
"and can't be deleted from the persistent database"
.format(self.name), self.module)
def _select(self):
"""
Selects the object from the persistent backend.
:returns: mysql database result
:rtype: tuple
"""
db = MySQLDB()
mysql_check = db.execute_query("SELECT * FROM `User` WHERE `id`={0};".format(self.id)).fetchall()
return mysql_check
def _exists(self):
"""
Checks if the object exists in the persistent backend
:returns: if the local objects exists in the backend
:rtype: bool
"""
mysql_exists = self._select()
if len(mysql_exists) == 1:
return True
else:
return False
def discard(self):
"""
Discard the local object/changes and get object from persistent backend.
It will also invalidate certain caches.
"""
# get object
if self._exists():
mysql_user = self._select()
# reset attributes
self._id = mysql_user[0][0]
self.username = mysql_user[0][1]
self.password = mysql_user[0][2]
self.name = mysql_user[0][3]
self.surname = mysql_user[0][4]
self.email = mysql_user[0][5]
self.joined_on = mysql_user[0][6]
self.user_access = mysql_user[0][7]
self.admin_access = mysql_user[0][8]
else:
raise UserNotFoundException("Object User with name '{0}' not found in the persistent backend"
.format(self.name), self.module)
class MySQLDB:
"""
initiates MySQLDB server connection
"""
def __init__(self):
"""
constructor for MySQLDB
"""
self.module = __name__
self.settings = System().get_config_file()
self.logger = LogHandler(System().get_model_log_dir())
# init db
self.db = MySQLdb.connect(host="localhost",
user=self.settings['pimotics']['cluster']['config']['mysql']['user'],
passwd=self.settings['pimotics']['cluster']['config']['mysql']['password'],
db=self.settings['pimotics']['cluster']['config']['mysql']['database'])
def execute_query(self, mysql_query):
"""
Execute a database query
:param mysql_query: a mysql database query
:type mysql_query: str
:returns: result from a mysql database
:rtype: tuple
:raises PiMoticsException
"""
self.logger.logger("Executing DB query", 4, self.module)
try:
# init cursor
cur = self.db.cursor()
# execute query
cur.execute(mysql_query)
return cur
except MySQLdb.Error as e:
raise MySqlException("A MySQL unexpected Error occurred: {0}".format(e[1]), self.module)
def commit(self):
"""
Perform a mysql database commit
"""
# commit if insert
self.db.commit()
def __del__(self):
"""
Close the database connection when garbage collector is passing
"""
self.logger.logger("Closing DB connection", 4, self.module)
self.db.close()
class Sensor(object):
"""
Sensor class
"""
def __init__(self, pin_id, name, type, room_name, identifier=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class Sensor
self._id = identifier
self._pi_pin = pin_id
self._room_name = room_name
self.name = name
self.type = type
@property
def id(self):
"""
Creates a READ ONLY 'id' property
:returns: identifier of PiPin
:rtype: int
"""
return self._id
@property
def pi_pin(self): # @TODO: link to class
"""
Foreign key to PiPin object through pin_id.
:returns: PiPin object
:rtype: PiPin
"""
return self._id
def save(self): # @TODO: save
"""
Save/update the object to the persistent backend. It will also invalidate certain caches.
"""
db = MySQLDB()
if self._exists():
db.execute_query("UPDATE `PI_pin` SET `pin_number`='{0}', WHERE `id`={1};"
.format(self.pin_number, self.id)
)
db.commit()
else:
self.logger.logger("Inserting new PiPin into DB", 4, self.module)
db.execute_query("INSERT INTO `PI_pin`(`pin_number`) VALUES ('{0}');"
.format(self.pin_number))
db.commit()
def serialize(self): # @TODO: serialize
"""
Returns the object in a dict/json style
:returns: a serialized object
:rtype: dict
"""
return {
"id": self.id,
"pin_number": self.pin_number
}
def delete(self): # @TODO: delete
"""
Deletes the object from the persistent backend. It will also invalidate certain caches.
:raises SensorNotFoundException
"""
db = MySQLDB()
if self._exists():
mysql_check = self._select()
if mysql_check:
db.execute_query("DELETE FROM `PI_pin` WHERE `id`='{0}';".format(self.id))
db.commit()
else:
raise SensorNotFoundException("Object PiPin with id '{0}' not found in the persistent database"
.format(self.id), self.module)
else:
raise SensorNotFoundException("Object PiPin with id '{0}' is a new object, "
"and can't be deleted from the persistent database"
.format(self.id), self.module)
def _select(self): # @TODO: _select
"""
Selects the object from the persistent backend.
:returns: mysql database result
:rtype: tuple
"""
db = MySQLDB()
mysql_check = db.execute_query("SELECT * FROM `PI_pin` WHERE `id`='{0}';".format(self.id)).fetchall()
return mysql_check
def _exists(self): # @TODO: _exists
"""
Checks if the object exists in the persistent backend
:returns: if the local objects exists in the backend
:rtype: bool
"""
mysql_exists = self._select()
if len(mysql_exists) == 1:
return True
else:
return False
def discard(self): # @TODO: discard
"""
Discard the local object/changes and get object from persistent backend.
It will also invalidate certain caches.
"""
# get object
if self._exists():
mysql_user = self._select()
# reset attributes
self._id = mysql_user[0][0]
self.pin_number = mysql_user[0][1]
else:
raise SensorNotFoundException("Object PiPin with id '{0}' not found in the persistent database"
.format(self.id), self.module)
class ApiToken(object):
"""
ApiToken class
"""
def __init__(self, user_id, distributed_on, valid_until, api_token=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class ApiToken
self._user_id = user_id # foreign key to user object
self._api_token = api_token
self.distributed_on = distributed_on
self.valid_until = valid_until
@property
def api_token(self):
"""
Creates a READ ONLY 'api_token' property
:returns: api_token
:rtype: str
"""
return self._api_token
@property
def user(self):
"""
Foreign key to user object through user_id.
:returns: a User object that is connected to this ApiToken
:rtype: User
"""
return UserList().get_by_id(self._user_id)
def save(self):
"""
Save/update the object to the persistent backend. It will also invalidate certain caches.
:raises ApiTokenNotFoundException
"""
db = MySQLDB()
if self.api_token:
if self._exists():
db.execute_query("UPDATE `API_Token` SET "
"`user_id`={0},`distributed_on`='{1}',`valid_until`='{2}' WHERE `api_token`='{3}';"
.format(self.user_id, self.distributed_on, self.valid_until, self.api_token)
)
db.commit()
else:
raise ApiTokenNotFoundException("Object ApiToken with api_token '{0}' "
"not found in the persistent backend".format(self.api_token),
self.module)
else:
self.logger.logger("Inserting new ApiToken into DB", 4, self.module)
db.execute_query("INSERT INTO `API_Token` (`user_id`, `api_token`, `distributed_on`, `valid_until`) VALUES "
"({0}, '{1}', '{2}', '{3}';"
.format(self.user_id, self._api_token, self.distributed_on, self.valid_until)
)
db.commit()
def serialize(self):
"""
Returns the object in a dict/json style
:returns: a serialized object
:rtype: dict
"""
return {
"user": self.user.serialize(),
"api_token": self.api_token,
"distributed_on": self.distributed_on,
"valid_until": self.valid_until
}
def delete(self):
"""
Deletes the object from the persistent backend. It will also invalidate certain caches.
:raises ApiTokenNotFoundException
"""
db = MySQLDB()
if self._exists():
mysql_check = self._select()
if mysql_check:
db.execute_query("DELETE FROM `API_Token` WHERE `api_token`='{0}';".format(self.api_token))
db.commit()
else:
raise ApiTokenNotFoundException(
"Object ApiToken with api_token '{0}' not found in the persistent database"
.format(self.api_token), self.module)
else:
raise ApiTokenNotFoundException(
"Object ApiToken with api_token '{0}' is a new object, "
"and can't be deleted from the persistent database"
.format(self.api_token), self.module)
def _select(self):
"""
Selects the object from the persistent backend.
:returns: mysql database result
:rtype: tuple
"""
db = MySQLDB()
mysql_check = db.execute_query("SELECT * FROM `API_Token` WHERE `api_token`='{0}';".format(self.api_token))\
.fetchall()
return mysql_check
def _exists(self):
"""
Checks if the object exists in the persistent backend
:returns: if the local objects exists in the backend
:rtype: bool
"""
mysql_exists = self._select()
if len(mysql_exists) == 1:
return True
else:
return False
def discard(self):
"""
Discard the local object/changes and get object from persistent backend. It will also invalidate certain caches.
"""
# get object
if self._exists():
mysql_user = self._select()
# reset attributes
self.user_id = mysql_user[0][0]
self._api_token = mysql_user[0][1]
self.distributed_on = mysql_user[0][2]
self.valid_until = mysql_user[0][3]
else:
raise ApiTokenNotFoundException("Object ApiToken with api_token '{0}' not found in the persistent database"
.format(self.api_token), self.module)
# Output result
if api_status and local_net_status:
return True
else:
return False
if __name__ == "__main__":
"""
Executes the watcher, checks the services and controls the PiMotics core watcher
"""
service_mode = sys.argv[1]
watcher = Watcher()
module = "main-watcher"
logging = LogHandler(System().get_webapps_log_dir())
logging.logger("Started watcher ...", 3, module)
if service_mode == "check":
amount_tries = 0
max_tries = 10
logging.logger("Checking services ...", 3, module)
while True:
if not watcher.check_services():
if max_tries > amount_tries:
logging.logger("One of the PiMotics services is down! Checking again in a few...", 2, module)
max_tries += 1
time.sleep(5)
else:
logging.logger("Some PiMotics services are down! Max tries have been exceeded, shutting down ...",
class Room(object):
"""
Room class
"""
def __init__(self, description, name=None):
self.module = __name__
self.logger = LogHandler(System().get_core_log_dir())
# properties of Class User
self._name = name
self.description = description
@property
def name(self):
"""
Creates a READ ONLY 'name' property
:returns: name
:rtype: str
"""
return self._name
def save(self):
"""
Save/update the object to the persistent backend. It will also invalidate certain caches.
"""
db = MySQLDB()
if self._exists():
db.execute_query("UPDATE `Room` SET `description`='{0}', WHERE `name`={1};"
.format(self.description, self.name)
)
db.commit()
else:
self.logger.logger("Inserting new Room into DB", 4, self.module)
db.execute_query("INSERT INTO `Room`(`name`, `description`) VALUES ('{0}', '{1}');"
.format(self.name, self.description))
db.commit()
def serialize(self):
"""
Returns the object in a dict/json style
:returns: a serialized object
:rtype: dict
"""
return {
"name": self.name,
"description": self.description
}
def delete(self):
"""
Deletes the object from the persistent backend. It will also invalidate certain caches.
:raises RoomNotFoundException
"""
db = MySQLDB()
if self._exists():
mysql_check = self._select()
if mysql_check:
db.execute_query("DELETE FROM `Room` WHERE `name`='{0}';".format(self.name))
db.commit()
else:
raise RoomNotFoundException("Object Room with name '{0}' not found in the persistent database"
.format(self.name), self.module)
else:
raise RoomNotFoundException("Object Room with name '{0}' is a new object, "
"and can't be deleted from the persistent database"
.format(self.name), self.module)
def _select(self):
"""
Selects the object from the persistent backend.
:returns: mysql database result
:rtype: tuple
"""
db = MySQLDB()
mysql_check = db.execute_query("SELECT * FROM `Room` WHERE `name`='{0}';".format(self.name)).fetchall()
return mysql_check
def _exists(self):
"""
Checks if the object exists in the persistent backend
:returns: if the local objects exists in the backend
:rtype: bool
"""
mysql_exists = self._select()
if len(mysql_exists) == 1:
return True
else:
return False
def discard(self):
"""
Discard the local object/changes and get object from persistent backend.
It will also invalidate certain caches.
:raises RoomNotFoundException
"""
# get object
if self._exists():
mysql_user = self._select()
# reset attributes
self._name = mysql_user[0][0]
self.description = mysql_user[0][1]
else:
raise RoomNotFoundException("Object Room with name '{0}' not found in the persistent database"
.format(self.name), self.module)
