class MinionJobHistorySerializer(serializers.ModelSerializer):
"""
Serializer for Salt_return model
"""
jid = models.CharField()
full_ret = JSONField()
def transform_jid(self, obj, jid):
jid = jids.objects.get(jid=jid).load
details = dict(user=jid.get("user"), sls=jid.get("arg"))
return details
def transform_full_ret(self, obj, full_ret):
# full_ret should already be a dict
# full_ret = json.loads(full_ret)
details = dict(success=full_ret.get("success"),
time_stamp=full_ret.get("_stamp"))
return details
class Meta:
model = salt_returns
fields = (
"full_ret",
"jid",
)
class Shooting(models.Model):
STATUS_PREPARE = 'P'
STATUS_RUNNING = 'R'
STATUS_FINISHED = 'F'
STATUS_INTERRUPTED = 'I'
STATUS_CHOICES = (
(STATUS_PREPARE, 'Prepare'),
(STATUS_RUNNING, 'Running'),
(STATUS_FINISHED, 'Finished'),
(STATUS_INTERRUPTED, 'Interrupted'),
)
session_id = models.CharField(u"ID сессии",
max_length=32,
help_text=u"ID теста",
null=True,
blank=True,
unique=True)
start = models.IntegerField(u"Отметка времени начала стрельбы",
null=True,
blank=True)
finish = models.IntegerField(u"Отметка времени окончания стрельбы",
null=True,
blank=True)
planned_duration = models.IntegerField(u"Планируемая длительность теста",
null=True,
blank=True)
scenario = models.ForeignKey(Scenario, null=False, blank=False)
tank = models.ForeignKey(Tank, null=False, blank=False)
status = models.CharField(u"Статус стрельбы",
max_length=1,
choices=STATUS_CHOICES,
default=STATUS_PREPARE,
help_text=u"Статус стрельбы - Готовится, "
u"Выполняется, Закончен "
u"или Прерван.")
user = models.ForeignKey(User, null=True, blank=True)
alt_name = models.CharField(u"Имя пользователя",
max_length=128,
help_text=u"Нужно, если не указан токен "
u"и тест запускается в консоли",
null=True,
blank=True)
ticket_id = models.CharField(u"Тикет ID",
max_length=64,
help_text='',
null=True,
blank=True)
custom_data = JSONField(null=True,
default={},
decode_kwargs={},
encode_kwargs={},
db_index=False,
db_index_options={})
def __unicode__(self):
return "Shooting %s" % self.id
class AppUser(models.Model):
ref_id = models.CharField(max_length=100, blank=False, null=False, unique=True)
email = models.CharField(max_length=200, blank=True, null=True, db_index=True)
first_name = models.CharField(max_length=200, blank=True, null=True)
last_name = models.CharField(max_length=200, blank=True, null=True)
nick_name = models.CharField(max_length=200, blank=True, null=True)
time_offset = models.IntegerField(default=None, blank=True, null=True)
custom_data = JSONField(null=False, blank=False, default=json_default, db_index=True)
add_date = models.DateTimeField(blank=False, auto_now_add=True)
edit_date = models.DateTimeField(blank=False, auto_now=True)
@staticmethod
def setup(ref_id):
if not ref_id:
return None
try:
user = AppUser.objects.get(ref_id=ref_id)
if user.edit_date > timezone.now() - timedelta(days=1):
return user
except ObjectDoesNotExist:
user = AppUser()
user.ref_id = ref_id
#get fb profile data
try:
m = Messenger(settings.FB_MESSENGER_TOKEN)
profile = m.get_profile(ref_id)
except FacebookException:
profile = None
if profile:
user.first_name = profile.get('first_name', None)
user.last_name = profile.get('last_name', None)
user.custom_data['facebook_data'] = profile
if profile.get('timezone',None):
user.time_offset = profile.get('timezone')
try:
user.save()
except IntegrityError,inst:
#race condition
logger.error("DB Error:" % inst)
return AppUser.objects.get(ref_id=ref_id)
return user
class ReEditCourse(models.Model):
CourseId=models.CharField(max_length=100,primary_key=True)
title=models.CharField(max_length=200)
GroupName=models.CharField(max_length=200,null=True)
creator= models.ForeignKey(User,on_delete=models.CASCADE)
CreateDate=models.DateTimeField(default=timezone.now())
MakeDate=models.DateTimeField(null=True)
ProjectId=models.CharField(max_length=100,null=True)
FilePath=models.CharField(max_length=1024,null=True)
SlideVersion=models.CharField(max_length=100,null=True)
type=models.CharField(max_length=100,null=True)
TempletType=models.CharField(max_length=100,default="slide")
duration=models.IntegerField(null=True)
SourceCourseId=models.ForeignKey("ReEditCourse",null=True,on_delete=models.CASCADE)
EpisodeCount=models.IntegerField(null=True)
lecturer=models.ForeignKey("lecturer",null=True,on_delete=models.CASCADE)
PublishCategory = models.ManyToManyField("PublishCategory")
InternalCategory = models.ManyToManyField("InternalCategory")
progress=models.CharField(max_length=100,null=True)
KeyWords=models.CharField(max_length=1024,null=True)
note=models.CharField(max_length=200,null=True)
ExtendedData = JSONField(null=True)
subtitles = JSONField(null=True)
class MasterDetailsSerializer(serializers.ModelSerializer):
"""
serializer for master details
"""
config = JSONField()
mastertoken_set = MasterTokenInfoSerializer(many=True, read_only=True)
def transform_config(self, obj, config):
"""
transform config field in master model
"""
# config = json.loads(config)
if isinstance(config, dict):
details = dict(event_return=config.get("event_return", 'Unknown'),
worker_threads=config.get("worker_threads",
'Unknown'),
pillar_version=config.get("pillar_version",
'Unknown'),
mysql_db=config.get("mysql.db", 'Unknown'),
mysql_host=config.get("mysql.host", 'Unknown'),
postgresql_db=config.get("returner.pgjsonb.db",
'Unknown'),
postgresql_host=config.get("returner.pgjsonb.host",
'Unknown'),
rest_cherrypy=config.get("rest_cherrypy",
'Unknown'),
file_roots=config.get("file_roots", 'Unknown'),
transport=config.get("transport", 'Unknown'),
key_logfile=config.get("key_logfile", 'Unknown'),
renderer=config.get("renderer", 'Unknown'),
max_event_size=config.get("max_event_size",
'Unknown'),
loop_interval=config.get("loop_interval",
'Unknown'),
master_job_cache=config.get("master_job_cache",
'Unknown'),
log_file=config.get("log_file", 'Unknown'),
interface=config.get("interface", 'Unknown'))
else:
details = dict()
return details
class Meta:
model = Master
fields = ('id', 'hostname', 'netapi_port', 'auth_mode',
'mastertoken_set', 'config')
class MinionFilter(models.Model):
"""
Table used to store the filter parameters saved by user for future use
"""
SEARCH_TYPE = (
(1, 'Text'),
(2, 'Grains'),
(3, 'Both'),
)
MATCH_PARAMETERS = (
(1, "Contains"),
(2, "Does Not Contains"),
(3, "Starts With"),
(4, "Ends With"),
(5, "Is"),
)
SEARCH_FIELD = (
(1, "Node"),
(2, "Master"),
(3, "Target Group"),
(4, "IP Address"),
)
user = models.ForeignKey(User,
help_text="User which this filter belongs to.")
filter_name = models.CharField(max_length=30,
blank=False,
null=False,
help_text="Add a filter name.")
search_type = models.IntegerField(choices=SEARCH_TYPE, default=1)
match_parameters = models.IntegerField(choices=MATCH_PARAMETERS, default=1)
search_field = models.IntegerField(choices=SEARCH_FIELD, default=1)
search_text = models.CharField(max_length=30, blank=True, null=True)
search_grains = JSONField(default={}, blank=True)
created_at = models.DateTimeField(blank=True, null=True)
def __unicode__(self):
return self.filter_name
class Meta:
ordering = ['filter_name']
verbose_name_plural = "Minion Filter"
class Pillar(models.Model):
'''
Table for pillar Database. Stores the pillar data as message pack. Unpacked
data is expected to be a dictionary
'''
name = models.CharField(max_length=255, primary_key=True)
data = JSONField()
created_at = models.DateTimeField(blank=True, null=True, auto_now=True)
created_by = models.ForeignKey(User, related_name="+", null=True)
modified_at = models.DateTimeField(blank=True,
null=True,
auto_now_add=True)
modified_by = models.ForeignKey(User, related_name="+", null=True)
def __unicode__(self):
return self.name
def __str__(self):
return self.name
class PipelineTrack(models.Model):
pipeline_name = models.TextField(db_index=True, null=True)
item_content_type = models.ForeignKey(ContentType, related_name='+')
item_id = models.PositiveIntegerField(null=True, blank=True)
created_info = JSONField(default=dict)
trigger_from_name = models.TextField(db_index=True, null=True)
result_content_type = models.ForeignKey(ContentType,
null=True,
blank=True,
related_name='+')
result_id = models.PositiveIntegerField(null=True, blank=True)
created_date = models.DateTimeField(auto_now_add=True)
def get_item(self, key_attr):
print key_attr
item_id = getattr(self, key_attr + "_id")
item_ct = getattr(self, key_attr + "_content_type_id")
if not item_id or not item_ct:
return None
return model_ct_map[item_ct].objects.get(id=item_id)
item = cached_property(curry(get_item, key_attr="item"))
result = cached_property(curry(get_item, key_attr="result"))
class Meta(object):
index_together = [("item_content_type", "item_id")]
@classmethod
def by_objects(cls,
name,
item,
objects,
result=None,
trigger_from_name=None):
if not objects:
return None
data = dict(pipeline_name=name,
created_info=group_by(
objects, lambda obj: ct_model_map[obj.__class__],
lambda obj: obj.id).items(),
trigger_from_name=trigger_from_name)
data["item_content_type_id"], data["item_id"] = cls._get_generic_info(
item)
data["result_content_type_id"], data[
"result_id"] = cls._get_generic_info(result)
return cls(**data)
@classmethod
def _get_generic_info(cls, obj):
if isinstance(obj, models.Model):
return ct_model_map[obj.__class__], obj.id
elif isinstance(obj, type) and issubclass(obj, models.Model):
return ct_model_map[obj], None
return None, None
@classmethod
def _revert(cls, created_info):
for ct, ids in created_info:
try:
model = model_ct_map[ct]
except KeyError:
continue
objs_queryset = model.objects.filter(id__in=ids)
objs_queryset._raw_delete(objs_queryset.db)
def revert(self):
self._revert(self.created_info)
self.delete()
@classmethod
def revert_batch(cls, *trackers):
created_infos = defaultdict(list)
tracker_ids = [tracker.id for tracker in trackers]
for tracker in trackers:
for item_content_type_id, ids in tracker.created_info:
created_infos[item_content_type_id] += ids
if created_infos:
cls._revert(created_infos.items())
cls.objects.filter(id__in=tracker_ids).delete()
def keep_and_delete(self):
items = {}
for ct, ids in self.created_info:
model = model_ct_map[ct]
objs_queryset = model.objects.filter(id__in=ids)
items[model] = list(objs_queryset)
objs_queryset._raw_delete(objs_queryset.db)
self.old_data = items
PipelineTrack.objects.filter(id=self.id).update(reverted=True)
return self
def re_insert(self):
for model, data in self.old_data.iteritems():
if not data:
continue
model.objects.bulk_create(data)
class Master(models.Model):
"""
Table of masters.
"""
AUTH_TYPE = (
('pam', 'pam'),
('ldap', 'ldap'),
)
hostname = models.CharField(
max_length=45,
unique=True,
help_text="The salt master hostname ip address")
netapi_port = models.IntegerField()
auth_mode = models.CharField(max_length=5, choices=AUTH_TYPE)
created_at = models.DateTimeField(blank=True, null=True, auto_now=True)
created_by = models.ForeignKey(User, related_name="+", null=True)
modified_at = models.DateTimeField(blank=True,
null=True,
auto_now_add=True)
modified_by = models.ForeignKey(User, related_name="+", null=True)
config = JSONField(default={})
def __unicode__(self):
return self.hostname
def __str__(self):
return self.hostname
def save(self, *args, **kwargs):
"""
Override the save method with custom logic
"""
super(Master, self).save(*args, **kwargs)
class Meta:
ordering = ['hostname']
verbose_name_plural = "Master"
def api_request(self, method, path, body=None, extra_headers=None):
'''
Make a request to salt api for the given master
'''
headers = {
'Content-Type': 'application/json',
}
if extra_headers:
headers.update(extra_headers)
return request(self.hostname, self.netapi_port, method, path, body,
headers)
def api_post(self, body, extra_headers=None):
'''
Make a post request to salt api for the given master
'''
return self.api_request('POST', '/', body, extra_headers)
def sync_all_grains(self):
'''
Make an api call to saltutil.sync_grains
'''
data = {
'fun': 'saltutil.sync_grains',
'client': 'local_async',
'tgt': '*',
'expr_form': 'glob'
}
master_token = self.mastertoken_set.filter(~models.Q(
user__username="******"))[0]
return self.api_post(data, {'X-Auth-Token': master_token.token})
class CourseLog(models.Model):
course = models.ForeignKey("course",null=True,on_delete=models.CASCADE)
user=models.ForeignKey(User,on_delete=models.CASCADE)
type=models.CharField(max_length=100)
date=models.DateTimeField(default=timezone.now())
log = JSONField(null=True)