def format_fields(self, data, process_func=None):
fields = self.get_schema().get_fields()
params = {}
for key, value in data.items():
if process_func and callable(process_func):
key, value = process_func(key, value)
if value is not None and value != '':
if key in fields:
type = fields[key].type
if type in ('dictfield', 'listfield'):
params[key] = load_json(value)
elif type == 'booleanfield':
params[key] = load_json(value.lower())
elif type == 'integerfield':
params[key] = int(value)
elif type == 'floatfield':
params[key] = float(value)
if key not in params:
params[key] = value
else:
params[key] = None
return params
def parse_value(self, type, value):
if isinstance(value, type):
return value
if type == int:
return int(value)
if type == float:
return float(value)
if type == str:
return str(value)
if type == bool:
return load_json(value.lower())
if type == list:
return [x.strip() for x in value.split(',')]
if type == dict:
return load_json(value)
def get(cls, data, decrypt=True, user=None):
if decrypt:
message = Cipher.get('command_api',
user=user).decrypt(data['package'], False)
data = load_json(message)
message = getattr(sys.modules[__name__], data['type'])(user=user)
message.load(data)
return message
def get_service(self, name, restart=True, create=True):
if not self.client:
return None
service_file = self._service_file(name)
services = self.get_spec('services')
for dependent in dependents(services, [name]):
if dependent != name:
dependent_data = self.get_service(dependent,
restart=restart,
create=create)
if not dependent_data:
return None
service_spec = self.get_service_spec(name)
if os.path.isfile(service_file):
data = load_json(load_file(service_file))
service = self._service_container(data['id'])
if not service and create:
service_id = self.start_service(name, **service_spec)
service = self._service_container(service_id)
if service:
if service.status != 'running':
if create or restart:
self.print("{} {}".format(
self.notice_color('Restarting Zimagi service'),
self.key_color(name)))
service.start()
success, service = self._check_service(name, service)
if not success:
self._service_error(name, service)
else:
return None
data['service'] = service
data['ports'] = {}
for port_name, port_list in service.attrs['NetworkSettings'][
'Ports'].items():
if port_list:
for port in port_list:
if port['HostIp'] == '0.0.0.0':
data['ports'][port_name] = int(
port['HostPort'])
break
return data
elif create:
raise ServiceError(
"Zimagi could not initialize and load service {}".format(
name))
elif create:
self.start_service(name, **service_spec)
return self.get_service(name)
return None
def dict(cls, name, default=None):
if not default:
default = {}
value = cls.value(name, default, default_on_empty=True)
if isinstance(value, str):
value = load_json(value)
return value
def list(cls, name, default=None):
if not default:
default = []
value = cls.value(name, None, default_on_empty=True)
if not value:
return default
if isinstance(value, str):
value = load_json(value)
return value
def decode(self, bytestring, **options):
base_url = options.get('base_url')
try:
data = load_json(bytestring.decode('utf-8'))
except ValueError as exc:
raise CommandParseError("Malformed JSON. {}".format(exc))
document = self._convert_to_document(data, base_url)
if isinstance(document, schema.Object):
document = schema.Document(content = dict(document))
elif not (isinstance(document, schema.Document) or isinstance(document, schema.Error)):
raise CommandParseError('Top level node should be a document or error.')
return document
def follow_task(self,
key,
message_callback=None,
status_check_interval=1000,
sleep_secs=0.01):
if self.task_connection():
status = self.get_task_status(key)
if status:
return status
subscription = self._task_connection.pubsub(
ignore_subscribe_messages=True)
subscription.subscribe(channel_message_key(key))
status_check_index = 0
while True:
message = subscription.get_message()
if message:
if message['type'] == 'message':
if message['data'] == self.TASK_EXIT_TOKEN:
break
if callable(message_callback):
message_callback(load_json(message['data']))
if status_check_index > status_check_interval:
if self.get_task_status(key):
break
else:
status_check_index = 0
time.sleep(sleep_secs)
status_check_index += 1
subscription.close()
return self.get_task_status(key)
return None
def to_internal_value(self, data):
return load_json(data)
def boolean(cls, name, default=False):
return load_json(cls.value(name, str(default)).lower())
