def create(self, table, fields, types):
sql = MiniDBMS.CREATE % (
table, MiniDBMS.sql_structure_generator(fields, types))
Log._(sql, Log.ORDINARY)
state = self._execute(sql)
self._commit()
return state
def update(self, table, fields, data):
sql = MiniDBMS.UPDATE % (
table, MiniDBMS.sql_assignment_generator(fields, data))
Log._(sql, Log.ORDINARY)
state = self._execute(sql)
self._commit()
return state
def sql_structure_generator(cls, fields, types):
structures = [
MiniDBMS.DECLARATION % (f, t) for f, t in zip(fields, types)
]
structure = MiniDBMS.SUBSEPARAOR.join(structures)
Log._(structure, Log.VORBOSE)
return structure
def insert(self, table, data):
sql = MiniDBMS.INSERT % (table,
MiniDBMS.sql_placeholder_generator(
max([len(d) for d in data])))
Log._(sql, Log.ORDINARY)
state = self._batch_execute(sql, data)
self._commit()
return state
def sql_assignment_generator(
cls, fields, data
): #todo: more perfecter(correct value format according to filed type of each field)
assignments = [
MiniDBMS.ASSIGNMENT % (f, d) for f, d in zip(fields, data)
]
assignment = MiniDBMS.SEPARATOR.join(assignments)
Log._(assignment, Log.VORBOSE)
return assignment
def _execute(self, sql):
state = True
try:
Log._(sql, Log.VORBOSE)
self.__cursor.execute(sql)
except: #todo: refined
state = False
Log._('crash', Log.SERIOUS)
Log.exception()
finally:
pass
return state
def router(self, data_or_skt, addr):
Log._('%s from %s' % (data_or_skt, addr), Log.VORBOSE)
method = lambda _: _
dick = ':)'
try:
data_or_skt.__class__.__name__.index('socket')
except ValueError: #todo: udp pure string data
method, dick = data_or_skt.split('#')
Log._(method, Log.ORDINARY)
method = getattr(self, method)
else: #todo: tcp socket object, maybe queues or new threads are needed here for detail handling
pass
finally:
method(dick, addr)
def launch_vm(openstack, *args): #todo: just apply to floating-ip
image_name, flavor_name, network_name, keypair_name, ssh_key_folder, vm_name = args
image = openstack.compute.find_image(image_name)
flavor = openstack.compute.find_flavor(flavor_name)
network = openstack.network.find_network(network_name)
keypair = openstack.compute.find_keypair(keypair_name) or make_keypair(
openstack, keypair_name, ssh_key_folder)
vm = openstack.compute.create_server(name=vm_name,
image_id=image.id,
flavor_id=flavor.id,
networks=[{
'uuid': network.id
}],
key_name=keypair.name)
vm = openstack.compute.wait_for_server(vm)
Log._('ssh -i {key} root@{ip}'.format(key=FS.join_path(
ssh_key_folder, keypair_name),
ip=vm.access_ipv4))
def sql_placeholder_generator(cls, count):
placeholder = MiniDBMS.SUBSEPARAOR.join([MiniDBMS.PLACEHOLDER] * count)
Log._(placeholder, Log.VORBOSE)
return placeholder
def create(self):
host = socket.gethostbyname(socket.gethostname())
Log._(host, Log.ORDINARY)
self.__skt.bind((host, Listener.PORT))
self.__cmd.create()
def exit(self, reason, addr):
Log._(reason, Log.SERIOUS)
Listener.GO = False
