class SearchBase(BaseStatsModel):
type_name = 'search'
stats_class = SearchStats
data_fields = ['search_engine', 'search_term']
search_engine = StringType(default='')
search_term = StringType(default='')
class VMImport(Model):
name = StringType(serialized_name='NAME', required=True)
os = StringType(serialized_name='OS', required=True)
launch_server = StringType(serialized_name='LAUNCH_SERVER', required=True)
userid = IntType(serialized_name='USERID', required=True)
product_specification_lcuuid = UUIDType(
serialized_name='PRODUCT_SPECIFICATION_LCUUID', required=True)
domain = UUIDType(required=True, serialized_name='DOMAIN')
class BackupChargeAdd(Model):
"""Backup Charge add structure
"""
name = StringType(required=True, serialized_name='NAME')
userid = IntType(required=True, serialized_name='USERID')
start_time = StringType(required=True, serialized_name='START_TIME')
size = IntType(required=True, serialized_name='SIZE')
domain = UUIDType(serialized_name='DOMAIN', required=True)
charge_mode = IntType(required=True, serialized_name='CHARGE_MODE')
price = IntType(required=True, serialized_name='PRICE')
class Parent(Model):
id = StringType()
gender = StringType()
name = StringType()
class Options:
roles = {
'public': blacklist("id", "gender"),
'gender': blacklist("gender")
}
class HostAdd(Model):
"""Host add model structure
"""
_instance_types = ['VM', 'NSP']
instance_types = string_enum(*_instance_types)
instance_types_dict = dict(zip(_instance_types, [1, 3]))
_hypervisor_types = ['XEN', 'VMWARE', 'KVM']
hypervisor_types = string_enum(*_hypervisor_types)
hypervisor_types_dict = dict(zip(_hypervisor_types, [1, 2, 3]))
_nic_types = ['GIGABIT', 'XGIGABIT']
nic_types = string_enum(*_nic_types)
nic_types_dict = dict(zip(_nic_types, [1, 2]))
ip = IPv4Type(required=True, serialized_name='IP')
user_name = StringType(required=True, serialized_name='USER_NAME')
user_passwd = StringType(required=True, serialized_name='USER_PASSWD')
instance_type = StringType(required=True,
serialized_name='INSTANCE_TYPE',
choices=_instance_types)
rack_name = StringType(required=True, serialized_name='RACK_NAME')
hypervisor_type = StringType(required=True,
serialized_name='HYPERVISOR_TYPE',
choices=_hypervisor_types)
nic_type = StringType(required=True,
serialized_name='NIC_TYPE',
choices=_nic_types)
uplink_ip = IPv4Type(serialized_name='UPLINK_IP')
uplink_netmask = IPv4Type(serialized_name='UPLINK_NETMASK')
uplink_gateway = IPv4Type(serialized_name='UPLINK_GATEWAY')
misc = StringType(serialized_name='MISC')
brand = StringType(serialized_name='BRAND')
model = StringType(serialized_name='MODEL')
storage_link_ip = IPv4Type(serialized_name='STORAGE_LINK_IP')
class SourceBase(BaseStatsModel):
use_indexes = False
type_name = 'source'
stats_class = SourceStats
data_fields = ['source']
source = StringType(required=True)
class UrlBase(BaseStatsModel):
type_name = 'url'
stats_class = UrlStats
data_fields = ['url', 'title', 'checksum']
index_fields = ['checksum']
url = URLType(required=True)
title = StringType(default='')
checksum = SHA1Type()
def _add_checksum(self, query):
query = query or {}
if 'url' in query:
query['checksum'] = get_checksum(query['url'])
def validate_checksum(self, data, value):
checksum = get_checksum(data['url'])
data['checksum'] = checksum
return checksum
def find(self, query=None, *args, **kwargs):
self._add_checksum(query)
return super(UrlBase, self).find(query, *args, **kwargs)
def find_one(self, query=None, *args, **kwargs):
self._add_checksum(query)
return super(UrlBase, self).find_one(query, *args, **kwargs)
class OutsideShares(BaseModel):
collection_name = 'outside_shares'
indexes = [{
'index': [('site', 1), ('checksum', 1), ('source', 1)],
'args': {
'unique': True
}
}]
site = IntType(required=True)
url = URLType(required=True)
checksum = SHA1Type()
source = StringType(required=True)
shares = IntType()
data_fields = ['url', 'checksum', 'source']
def _add_checksum(self, query):
query = query or {}
if 'url' in query:
query['checksum'] = get_checksum(query['url'])
def validate_checksum(self, data, value):
checksum = get_checksum(data['url'])
data['checksum'] = checksum
return checksum
def find(self, query=None, *args, **kwargs):
self._add_checksum(query)
return super(OutsideShares, self).find(query, *args, **kwargs)
def find_one(self, query=None, *args, **kwargs):
self._add_checksum(query)
return super(OutsideShares, self).find_one(query, *args, **kwargs)
def get_totals(self, site_id, group_fields=None, limit=None):
match = {'site': site_id}
group = {'_id': {}, 'shares': {'$sum': '$shares'}}
sort = {'shares': -1}
if group_fields is None:
group_fields = self.data_fields
for field in group_fields:
group['_id'][field] = '$%s' % field
pipeline = [{'$match': match}, {'$group': group}, {'$sort': sort}]
if limit is not None:
pipeline.append({'$limit': limit})
result = list(self.collection.aggregate(pipeline))
return self._replace_id(result)
def get_totals_without_group(self, site_id):
totals = self.get_totals(site_id, group_fields=[])
if not totals:
return {'shares': 0}
return totals[0]
def set_counter(self, site, url, source, value):
checksum = get_checksum(url)
query = dict(site=site, url=url, checksum=checksum, source=source)
self.set(query, {'shares': value}, upsert=True)
class CountryBase(BaseStatsModel):
use_indexes = False
type_name = 'country'
stats_class = CountryStats
data_fields = ['country']
country = StringType(required=True)
class DomainBase(BaseStatsModel):
use_indexes = False
type_name = 'domain'
stats_class = DomainStats
data_fields = ['domain']
domain = StringType(default='')
def __new__(mcs, name, bases, attrs):
all_attrs = {}
for base in reversed(bases):
all_attrs.update(dict(inspect.getmembers(base)))
all_attrs.update(attrs)
type_name = all_attrs['type_name']
stats_class = all_attrs['stats_class']
has_granularity = all_attrs['has_granularity']
if type_name:
attrs['type'] = StringType(required=True,
default=all_attrs['type_name'])
if stats_class:
attrs['totals'] = ModelType(stats_class)
if has_granularity:
attrs['values'] = DictType(ModelType(stats_class))
new_class = super(StatsModelMetaClass,
mcs).__new__(mcs, name, bases, attrs)
index_fields = getattr(new_class, 'index_fields',
new_class.data_fields)
indexes = deepcopy(new_class.indexes)
index = indexes[0]['index']
# add specific fields to index
for field in index_fields:
index_entry = (field, 1)
if index_entry not in index:
index.append(index_entry)
new_class.indexes = indexes
return new_class
class Response(DashbaseResponse):
request = ModelType(Request) # type: Request
totalDocs = LongType()
numDocs = LongType()
numHits = LongType()
numDocsProcessed = LongType()
numHitsProcessed = LongType()
latencyInMillis = LongType()
timeProcessedTo = LongType(default=0)
isTimedOut = BooleanType(default=False)
startId = StringType()
endId = StringType()
error = StringType()
debugMap = DictType(BaseType)
hits = ListType(ModelType(Hit)) # type: list[Hit]
aggregations = DictType(BaseType)
schema = DictType(StringType)
class GrandParent(Parent):
age = IntType()
family_secret = StringType()
class Options:
roles = {
'grandchildren': whitelist("age"),
'public': blacklist("id", "family_secret")
}
class PyagexecStorage(Model):
pool_name = StringType(required=True, serialized_name='POOL_NAME')
uuid = UUIDType(serialized_name='UUID')
total_size = IntType(required=True, serialized_name='TOTAL_SIZE')
used_size = IntType(required=True, serialized_name='USED_SIZE')
def validate_used_size(self, data, value):
if data['total_size'] < value or value < 0:
raise ValidationError('0 <= used_size <= total_size')
return value
class StorageAdd(Model):
"""Storage add model structure
"""
_backends = ['CEPH_RBD']
backends = string_enum(*_backends)
backends_dict = dict(zip(_backends, [1]))
_types = ['CAPACITY', 'PERFORMANCE']
types = string_enum(*_types)
name = StringType(required=True, serialized_name='NAME')
uuid = UUIDType(serialized_name='UUID')
disk_total = IntType(required=True, serialized_name='DISK_TOTAL')
disk_used = IntType(required=True, serialized_name='DISK_USED')
backend = StringType(required=True,
serialized_name='BACKEND',
choices=_backends)
hosts = ListType(IPv4Type, serialized_name='HOSTS', default=[])
type = StringType(required=True, serialized_name='TYPE', choices=_types)
domain = UUIDType(serialized_name='DOMAIN', required=True)
class Request(Model):
startTimeInMillis = LongType(serialize_when_none=False)
endTimeInMillis = LongType(serialize_when_none=False)
endGlobalId = LongType(serialize_when_none=False)
startGlobalId = LongType(serialize_when_none=False)
numResults = LongType(default=10)
tableNames = ListType(StringType, default=["*"])
excludeTableNames = ListType(StringType, default=[])
query = DictType(BaseType, serialize_when_none=False)
aggregations = DictType(BaseType, serialize_when_none=False)
fields = ListType(StringType, default=[])
useApproximation = BooleanType(default=False)
ctx = StringType(serialize_when_none=False)
fetchSchema = BooleanType(default=False)
timeoutMillis = LongType(default=0x7fffffff)
disableHighlight = BooleanType(default=False)
startId = StringType(serialize_when_none=False)
endId = StringType(serialize_when_none=False)
debugMode = LongType(serialize_when_none=False)
def set_query(self, query=None):
if not query:
query = "*"
self.query = {"queryType": "string", "queryStr": query}
class User(with_metaclass(ORMMeta, BaseModel, UserMixin)):
_uniques = ['email']
firstname = StringType()
lastname = StringType()
email = StringType(required=True)
password = StringType()
active = BooleanType(default=True)
confirmed_at = DateTimeType()
last_login_at = DateTimeType(default=datetime.datetime.now)
current_login_at = DateTimeType(default=datetime.datetime.now)
registered_at = DateTimeType()
last_login_ip = StringType()
current_login_ip = StringType()
login_count = IntType()
sort_on = IntType()
roles = ListType(ModelType(Role), default=[])
class Question(Model):
question_id = StringType(required=True)
type = StringType(default="text")
class Payload(Model):
fields = DictType(ListType(StringType))
stored = StringType()
entities = ListType(ModelType(Entity)) # type: Entity
class Child(Parent):
bio = StringType()
class Parent(Model):
name = StringType(required=True)
class User(Model):
name = StringType(required=True)
bio = StringType(required=True)
class Player(Model):
name = StringType()
class User(Model):
username = StringType()
class User(Model):
username = StringType(deserialize_from='name')
class Parent(Model):
id = StringType()
name = StringType()
class Options:
roles = {'public': blacklist("id")}
class Player(Model):
name = StringType(required=True)
class ClusterInfo(Model):
metrics = ModelType(ClusterMetricInfo) # type: ClusterMetricInfo
info = DictType(ListType(StringType()))
class ClusterOverviewResponse(DashbaseResponse):
clusterPrefix = StringType()
overview = DictType(ModelType(ClusterInfo)) # type: dict[str, ClusterInfo]
class User(Model):
name = StringType(default=u'Doggy')
