def __init__(self, verbose_name=None, name=None, auto=True, version=1, node=None, clock_seq=None, namespace=None, **kwargs):
kwargs['max_length'] = 36
self.auto = auto
self.version = version
if version==1:
self.node, self.clock_seq = node, clock_seq
elif version==3 or version==5:
self.namespace, self.name = namespace, name
StringField.__init__(self, verbose_name, name, **kwargs)
class Building(Document):
meta = {
"collection": "noc.buildings",
"allow_inheritance": False,
"indexes": ["adm_division", "data", "sort_order"]
}
# Administrative division
adm_division = PlainReferenceField(Division)
status = StringField(choices=[("P", "PROJECT"), ("B", "BUILDING"),
("R", "READY"), ("E", "EVICTED"),
("D", "DEMOLISHED")],
default="R")
## Total homes
homes = IntField()
## Maximal amount of floors
floors = IntField()
#
entrances = ListField(EmbeddedDocumentField(Entrance))
#
has_cellar = BooleanField()
has_attic = BooleanField()
#
postal_code = StringField()
# Type
is_administrative = BooleanField(default=False)
is_habitated = BooleanField(default=False)
#
data = DictField()
#
start_date = DateTimeField()
end_date = DateTimeField()
# Internal field for sorting
# Filled by primary address trigger
sort_order = StringField()
@classmethod
def update_floors(cls, sender, document, **kwargs):
"""
Update floors
"""
@property
def primary_address(self):
# Try primary address first
pa = Address.objects.filter(building=self.id, is_primary=True).first()
if pa:
return pa
# Fallback to first address found
return Address.objects.filter(building=self.id).first()
def fill_entrances(self,
first_entrance=1,
first_home=1,
n_entrances=1,
first_floor=1,
last_floor=1,
homes_per_entrance=1):
e_home = first_home
for e in range(first_entrance, first_entrance + n_entrances):
self.entrances += [
Entrance(number=str(e),
first_floor=str(first_floor),
last_floor=str(last_floor),
first_home=str(e_home),
last_home=str(e_home + homes_per_entrance - 1))
]
e_home += homes_per_entrance
self.save()
class George_s(Document):
meta = {'collection': 'George'}
full_name = StringField(required=True)
tweet_text= StringField(required=True)
no_of_replies = StringField(required=True)
number_of_likes = StringField(required=True)
hashtags= StringField(required=True)
username = StringField(required=True)
no_of_retweets = StringField(required=True)
twitter_url= StringField(required=True)
call_to_action = StringField(required=True)
no_of_hashtags = StringField(required=True)
mentions= StringField(required=True)
tweet_time = StringField(required=True)
no_of_mentions = StringField(required=True)
sentiment = StringField(required=True)
class Hero(Document):
name = StringField(required=True)
description = StringField()
release_date = DateTimeField()
blizz_role = StringField()
bans = DictField()
can_tank = BooleanField(default=False)
can_solo_heal = BooleanField(default=False)
can_heal_ally = BooleanField(default=False)
can_heal_self = BooleanField(default=False)
can_shield_self = BooleanField(default=False)
can_shield_ally = BooleanField(default=False)
can_solo_lane = BooleanField(default=False)
has_aoe_heal = BooleanField(default=False)
has_dot_heal = BooleanField(default=False)
has_percent_heal = BooleanField(default=False)
has_aoe_damage = BooleanField(default=False)
has_dot_damage = BooleanField(default=False)
has_percent_damage = BooleanField(default=False)
has_waveclear = BooleanField(default=False)
has_global = BooleanField(default=False)
has_stun = BooleanField(default=False)
has_root = BooleanField(default=False)
has_slow = BooleanField(default=False)
has_silence = BooleanField(default=False)
has_blind = BooleanField(default=False)
has_sleep = BooleanField(default=False)
has_polymorph = BooleanField(default=False)
has_knockback = BooleanField(default=False)
has_stasis = BooleanField(default=False)
has_time_stop = BooleanField(default=False)
has_parry = BooleanField(default=False)
has_unrevealable = BooleanField(default=False)
has_reveal = BooleanField(default=False)
has_stealth_self = BooleanField(default=False)
has_stealth_ally = BooleanField(default=False)
has_evade_self = BooleanField(default=False)
has_evade_ally = BooleanField(default=False)
has_unstoppable_self = BooleanField(default=False)
has_unstoppable_ally = BooleanField(default=False)
has_protected_self = BooleanField(default=False)
has_protected_ally = BooleanField(default=False)
has_unkillable_self = BooleanField(default=False)
has_unkillable_ally = BooleanField(default=False)
has_invulnerable_self = BooleanField(default=False)
has_invulnerable_ally = BooleanField(default=False)
has_aa_speedup_ally = BooleanField(default=False)
has_aa_speedup_self = BooleanField(default=False)
has_move_speedup_ally = BooleanField(default=False)
has_move_speedup_self = BooleanField(default=False)
has_aa_dpsup_ally = BooleanField(default=False)
has_aa_dpsup_self = BooleanField(default=False)
has_crits_ally = BooleanField(default=False)
has_crits_self = BooleanField(default=False)
has_ability_dpsup_ally = BooleanField(default=False)
has_ability_dpsup_self = BooleanField(default=False)
def __repr__(self):
return '{}'.format(self.name)
def get_hero_popularity(self):
popularity = {'players': 0, 'total_level': 0}
for player_hero in PlayerHero.objects(hero=self):
if player_hero.mode not in popularity:
popularity[player_hero.mode] = {
'wins': 0,
'losses': 0,
'bans': self.bans[player_hero.mode]
}
popularity[player_hero.mode][
'losses'] += player_hero.games_played - player_hero.games_won
popularity[player_hero.mode]['wins'] += player_hero.games_won
popularity['players'] += 1
popularity['total_level'] += player_hero.level
return popularity
def get_hero_popularity_for_date_range(self,
start_date,
end_date=None,
min_level=1,
mode=None):
from server.db.replay import Replay
popularity = {}
replays_by_result = Replay.get_replays_by_result_for_hero_mode_and_date_range(
self, start_date, end_date, mode, min_level)
for result, replays in replays_by_result.items():
for replay in replays:
if replay.mode not in popularity:
popularity[replay.mode] = {
'wins': 0,
'losses': 0,
'bans': 0
}
popularity[replay.mode][result] += 1
return popularity
def get_talents_details(self):
return {}
def get_hero_details(self):
hero_details = {
'talents': self.get_talents_details(),
'popularity': self.get_hero_popularity()
}
return hero_details
class Block(EmbeddedDocument):
type = StringField(required=True)
data = DictField(required=True)
class ChildRegisteredAfter(Document):
meta = {'collection': 'test_child_after_reference'}
parent = ReferenceField(ParentWithRelationship)
name = StringField()
class Vendor(Document):
"""
Equipment vendor
"""
meta = {
"collection": "noc.vendors",
"strict": False,
"auto_create_index": False,
"json_collection": "inv.vendors",
"json_unique_fields": ["name", "code"],
}
# Short vendor name, included as first part of platform
name = StringField(unique=True)
# Full vendor name
full_name = StringField()
# Unique id
uuid = UUIDField(binary=True)
# List of vendor codes to be searched via .get_by_code()
code = ListField(StringField(), unique=True)
# Vendor's site
site = URLField(required=False)
# Object id in BI
bi_id = LongField(unique=True)
_id_cache = cachetools.TTLCache(1000, ttl=60)
_bi_id_cache = cachetools.TTLCache(1000, ttl=60)
_code_cache = cachetools.TTLCache(1000, ttl=60)
_ensure_cache = cachetools.TTLCache(1000, ttl=60)
def __str__(self):
return self.name
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_id_cache"),
lock=lambda _: id_lock)
def get_by_id(cls, id):
return Vendor.objects.filter(id=id).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_bi_id_cache"),
lock=lambda _: id_lock)
def get_by_bi_id(cls, id):
return Vendor.objects.filter(bi_id=id).first()
@classmethod
def _get_by_code(cls, code):
"""
Uncached version of get_by_code
:param code:
:return:
"""
code = code.upper()
return Vendor.objects.filter(code=code).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_code_cache"),
lock=lambda _: id_lock)
def get_by_code(cls, code):
return cls._get_by_code(code)
def clean(self):
# Convert code to list
if isinstance(self.code, six.string_types):
self.code = [self.code]
# Uppercase code
self.code = [c.upper() for c in self.code]
# Fill full name if not set
if not self.full_name:
self.full_name = self.name
#
super(Vendor, self).clean()
def on_save(self):
if not hasattr(self,
"_changed_fields") or "name" in self._changed_fields:
from .platform import Platform
for p in Platform.objects.filter(vendor=self.id):
p.save() # Rebuild full name
def to_json(self):
return to_json(
{
"name": self.name,
"$collection": self._meta["json_collection"],
"full_name": self.full_name,
"code": self.code,
"site": self.site,
"uuid": self.uuid,
},
order=["name", "uuid", "full_name", "code", "site"],
)
def get_json_path(self):
return "%s.json" % self.name
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_ensure_cache"),
lock=lambda _: id_lock)
def ensure_vendor(cls, code):
"""
Get or create vendor by code
:param code:
:return:
"""
while True:
vendor = Vendor._get_by_code(code)
if vendor:
return vendor
try:
vendor = Vendor(name=code,
full_name=code,
code=[code],
uuid=uuid.uuid4())
vendor.save()
return vendor
except NotUniqueError:
pass # Already created by concurrent process, reread
class UserModel(Document):
meta = {"collection": "Users"}
username = StringField(required=True, unique=True)
is_admin = BooleanField(default=False)
email = StringField(default="")
class HostDO(EmbeddedDocument):
ip = StringField(max_length=256)
hostname = StringField(max_length=256)
def __repr__(self):
return '<Host %r>' % self.hostname
class lti(Document):
user = StringField()
payload = DictField()
class OneTimeToken(Document):
user = StringField()
token = StringField()
class MntTask(Document):
"""全自动计划任务"""
TASK_TYPE_CHOICES = ((0, '例行任务'), (1, '快速任务-添加宝贝'), (2, '快速任务-修改限价'),
(3, '命令生成任务'), (4, '快速任务-加大/减小投入'))
STATUS_CHOICES = (('deactive', '未激活'), ('ready', '准备中'),
('allocated', '已分配'), ('doing', '执行中'),
('successed', '执行成功'), ('failed', '执行失败'), ('paused',
'优化暂停'))
shop_id = IntField(verbose_name="店铺ID", required=True)
campaign_id = IntField(verbose_name="推广计划ID", required=True)
create_time = DateTimeField(verbose_name="创建时间",
default=datetime.datetime.now)
task_type = IntField(verbose_name='任务类型',
default=0,
choices=TASK_TYPE_CHOICES)
mnt_type = IntField(verbose_name="监控类型",
choices=MNT_TYPE_CHOICES,
default=1)
start_time = DateTimeField(verbose_name="执行时间", default=None)
end_time = DateTimeField(verbose_name="结束时间", default=None)
status = StringField(verbose_name="任务执行时间",
default='ready',
choices=STATUS_CHOICES)
failed_count = IntField(verbose_name="任务失败次数", default=0)
opt_list = ListField(
verbose_name="任务执行操作列表", default=[]
) # 形如:[{'func':'add_keywords', 'args':'{}'},{'func':'optimize_keywords', 'args':'{}'}], 由json序列化
reporter = ObjectIdField(verbose_name="任务报告者", default=None)
meta = {
'db_alias': "mnt-db",
'collection': 'mnt_task',
'indexes': ['shop_id', 'campaign_id', 'task_type']
}
@property
def mnt_campaign(self):
"""获取当前任务对应的计划"""
if not hasattr(self, '_mnt_campaign'):
try:
mnt_camp = MntCampaign.objects.get(
shop_id=self.shop_id, campaign_id=self.campaign_id)
except DoesNotExist:
mnt_camp = None
self._mnt_campaign = mnt_camp
return self._mnt_campaign
def is_runnable(self, is_force=False): #
"""检查是否可以执行：
1.是否有api权限
2.对应的全自动计划，且全计划未暂停，自动计划是托管中
3.失败次数超过3次，且非强制执行
"""
dler = Downloader.objects.get(shop_id=self.shop_id)
if not dler.tapi: # api不可用
return False, 'not_callable'
if not self.mnt_campaign: # 托管计划不存在
return False, 'mnt_camp_not_found'
# return True, 'OK'
if self.task_type == 0: # 只检查例行任务，因为快速任务是用户手动触发的，需要立即执行
if not self.mnt_campaign.is_active: # 托管计划被暂停
return False, 'mnt_camp_not_active'
account = Account.objects.get(shop_id=self.shop_id)
if account.is_keep_stop:
return False, 'shop_banlance_is_less'
if self.failed_count >= 3 and (not is_force): # 后台执行失败超过3次
return False, 'failed_too_much'
return True, 'OK'
def save_log(self, check_desc):
try:
UploadRecord.objects.create(shop_id=self.shop_id,
campaign_id=self.campaign_id,
op_type=1,
data_type=113,
detail_list=[check_desc],
opter=3)
except Exception, e:
log.error(
'save mnt log error, shop_id=%s, camp_id=%s, desc=%s, e=%s' %
(self.shop_id, self.campaign_id, check_desc, e))
return
class Service(Document):
meta = {
"collection": "noc.services",
"strict": False,
"auto_create_index": False,
"indexes": ["subscriber", "managed_object", "parent", "order_id"],
}
profile = ReferenceField(ServiceProfile, required=True)
# Creation timestamp
ts = DateTimeField(default=datetime.datetime.now)
# Logical state of service
logical_status = StringField(
choices=[
("P", "Planned"),
("p", "Provisioning"),
("T", "Testing"),
("R", "Ready"),
("S", "Suspended"),
("r", "Removing"),
("C", "Closed"),
("U", "Unknown"),
],
default="U",
)
logical_status_start = DateTimeField()
# Parent service
parent = ReferenceField("self", required=False)
# Subscriber information
subscriber = ReferenceField(Subscriber)
description = StringField()
#
agreement_id = StringField()
# Order Fulfillment order id
order_id = StringField()
stage_id = StringField()
stage_name = StringField()
stage_start = DateTimeField()
# Billing contract number
account_id = StringField()
# Connection address
address = StringField()
# For port services
managed_object = ForeignKeyField(ManagedObject)
# NRI port id, converted by portmapper to native name
nri_port = StringField()
# CPE information
cpe_serial = StringField()
cpe_mac = StringField()
cpe_model = StringField()
cpe_group = StringField()
# Capabilities
caps = ListField(EmbeddedDocumentField(CapsItem))
# Integration with external NRI and TT systems
# Reference to remote system object has been imported from
remote_system = ReferenceField(RemoteSystem)
# Object id in remote system
remote_id = StringField()
# Object id in BI
bi_id = LongField(unique=True)
# Labels
labels = ListField(StringField())
effective_labels = ListField(StringField())
def __str__(self):
return str(self.id) if self.id else "new service"
def on_delete(self):
if self.nri_port:
self.unbind_interface()
def on_save(self):
if not hasattr(
self, "_changed_fields") or "nri_port" in self._changed_fields:
self.unbind_interface()
if not hasattr(self,
"_changed_fields") or "parent" in self._changed_fields:
self._refresh_managed_object()
def _refresh_managed_object(self):
from noc.sa.models.servicesummary import ServiceSummary
mo = self.get_managed_object()
if mo:
ServiceSummary.refresh_object(mo)
def unbind_interface(self):
from noc.inv.models.interface import Interface
Interface._get_collection().update({"service": self.id},
{"$unset": {
"service": ""
}})
self._refresh_managed_object()
def get_managed_object(self):
r = self
while r:
if r.managed_object:
return self.managed_object
r = r.parent
return None
def get_caps(self) -> Dict[str, Any]:
return CapsItem.get_caps(self.caps, self.profile.caps)
@classmethod
def can_set_label(cls, label):
if label.enable_service:
return True
return False
@classmethod
def can_expose_label(cls, label):
return False
class CustomWord(Document):
word = StringField(regex=f'^[a-z]{{{MIN_WORD_LENGTH},{MAX_WORD_LENGTH}}}$',
required=True)
uuid = UUIDField(unique=True, required=True, default=uuid.uuid4)
class Game(Document):
uuid = UUIDField(unique=True, required=True, default=uuid.uuid4)
word = StringField(regex=f'^[a-z]{{{MIN_WORD_LENGTH},{MAX_WORD_LENGTH}}}$',
required=True)
status = StringField(min_length=3,
max_length=16,
default=STATUS_IN_PROGRESS,
choices=STATUS_CHOICES)
updated_at = DateTimeField(default=datetime.datetime.utcnow)
letters = EmbeddedDocumentListField('LetterGuessed')
def __str__(self):
return (f'{self.uuid}->{self.word}->{self.status}')
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.updated_at = datetime.datetime.utcnow()
# update game status if needed
if not document.is_over:
if document.representation == document.word:
document.status = STATUS_WON
elif document.letters and document.last_letter.attempts_left == 0:
document.status = STATUS_LOST
@property
def word_length(self):
return len(self.word)
@property
def letters_guessed(self):
return {l.letter for l in self.letters}
@property
def is_over(self):
return self.status != STATUS_IN_PROGRESS
@property
def last_letter(self):
return self.letters[-1]
@property
def representation(self):
return ''.join(
map(lambda l: l if l in self.letters_guessed else '_', self.word))
def get_available_letters(self, letters_guessed=None):
if letters_guessed is None:
letters_guessed = self.letters_guessed
return ''.join(
map(lambda l: l
if l not in letters_guessed else '', string.ascii_lowercase))
def append_letter(self, letter, attempts_left, message):
letter = LetterGuessed(letter=letter,
attempts_left=attempts_left,
message=message)
self.letters.append(letter)
self.save()
return letter
class Division(Document):
meta = {
"collection": "noc.divisions",
"strict": False,
"auto_create_index": False,
"indexes": ["parent", "data", "name"],
}
# Division type
type = StringField(default="A", choices=[("A", "Administrative")])
#
parent = PlainReferenceField("self")
# Normalized name
name = StringField()
# street/town/city, etc
short_name = StringField()
#
is_active = BooleanField(default=True)
# Division level
level = IntField()
# Additional data
# Depends on importer
data = DictField()
#
start_date = DateTimeField()
end_date = DateTimeField()
#
tags = ListField(StringField())
def __str__(self):
if self.short_name:
return self.short_name
else:
return self.name
def get_children(self):
return Division.objects.filter(parent=self.id)
@classmethod
def get_top(cls, type="A"):
return Division.objects.filter(parent__exists=False, type=type)
def get_buildings(self):
from .building import Building
return Building.objects.filter(
adm_division=self.id).order_by("sort_order")
@classmethod
def update_levels(cls):
"""
Update divisions levels
"""
def _update(root, level):
if root.level != level:
root.level = level
root.save()
for c in root.get_children():
_update(c, level + 1)
for d in cls.get_top():
_update(d, 0)
@property
def full_path(self):
r = [smart_text(self)]
p = self.parent
while p:
r = [smart_text(p)] + r
p = p.parent
return " | ".join(r)
class ParentWithRelationship(Document):
meta = {'collection': 'test_parent_reference'}
before_child = ListField(ReferenceField("ChildRegisteredBefore"))
after_child = ListField(ReferenceField("ChildRegisteredAfter"))
name = StringField()
class InterfaceProfile(Document):
"""
Interface SLA profile and settings
"""
meta = {
"collection": "noc.interface_profiles",
"strict": False,
"auto_create_index": False
}
name = StringField(unique=True)
description = StringField()
style = ForeignKeyField(Style, required=False)
# Interface-level events processing
link_events = StringField(
required=True,
choices=[
("I", "Ignore Events"),
("L", "Log events, do not raise alarms"),
("A", "Raise alarms"),
],
default="A",
)
# Discovery settings
discovery_policy = StringField(
choices=[("I", "Ignore"), ("O", "Create new"), ("R", "Replace"),
("C", "Add to cloud")],
default="R",
)
# Collect mac addresses on interface
mac_discovery_policy = StringField(choices=[("d", "Disabled"),
("m", "Management VLAN"),
("e", "Enabled")],
default="d")
# Collect and keep interface status
status_discovery = BooleanField(default=False)
#
allow_lag_mismatch = BooleanField(default=False)
# Send up/down notifications
status_change_notification = ForeignKeyField(NotificationGroup,
required=False)
# Interface profile metrics
metrics = ListField(EmbeddedDocumentField(InterfaceProfileMetrics))
# Alarm weight
weight = IntField(default=0)
# User network interface
# MAC discovery can be restricted to UNI
is_uni = BooleanField(default=False)
# Allow automatic segmentation
allow_autosegmentation = BooleanField(default=False)
# Allow collecting metrics from subinterfaces
allow_subinterface_metrics = BooleanField(default=False)
# Validation policy
interface_validation_policy = PlainReferenceField(
InterfaceValidationPolicy)
# Integration with external NRI and TT systems
# Reference to remote system object has been imported from
remote_system = ReferenceField(RemoteSystem)
# Object id in remote system
remote_id = StringField()
# Object id in BI
bi_id = LongField(unique=True)
_id_cache = cachetools.TTLCache(maxsize=100, ttl=60)
_name_cache = cachetools.TTLCache(maxsize=100, ttl=60)
_bi_id_cache = cachetools.TTLCache(maxsize=100, ttl=60)
_default_cache = cachetools.TTLCache(maxsize=100, ttl=60)
_status_discovery_cache = cachetools.TTLCache(maxsize=100, ttl=60)
DEFAULT_PROFILE_NAME = "default"
def __str__(self):
return self.name
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_id_cache"),
lock=lambda _: id_lock)
def get_by_id(cls, id):
return InterfaceProfile.objects.filter(id=id).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_bi_id_cache"),
lock=lambda _: id_lock)
def get_by_bi_id(cls, id):
return InterfaceProfile.objects.filter(bi_id=id).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_name_cache"),
lock=lambda _: id_lock)
def get_by_name(cls, name):
return InterfaceProfile.objects.filter(name=name).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_default_cache"),
lock=lambda _: id_lock)
def get_default_profile(cls):
return InterfaceProfile.objects.filter(
name=cls.DEFAULT_PROFILE_NAME).first()
@classmethod
@cachetools.cachedmethod(operator.attrgetter("_status_discovery_cache"),
lock=lambda _: id_lock)
def get_with_status_discovery(cls):
"""
Get list of interface profile ids with status_discovery = True
:return:
"""
return list(x["_id"] for x in InterfaceProfile._get_collection().find(
{"status_discovery": True}, {"_id": 1}))
class ErroneousModel(Document):
meta = {'collection': 'test_colliding_objects_model'}
objects = ListField(StringField())
class Animal(Document):
name = StringField()
meta = {'allow_inheritance': True, 'indexes': ['name']}
class ManagementPolicy(EmbeddedDocument):
protocol = StringField(choices=[("cli", "CLI"), ("snmp",
"SNMP"), ("http",
"HTTP")])
def __init__(self, *args, **kwargs):
if 'default' not in kwargs:
kwargs['default'] = '{}'
StringField.__init__(self, *args, **kwargs)
class Story(Document):
uid = StringField(primary_key=True, max_length=91, min_length=26)
time = LongField(required=True)
blocks = ListField(EmbeddedDocumentField(Block), required=True)
version = StringField(required=True)
class Interface(Document):
"""
Interfaces
"""
meta = {
"collection":
"noc.interfaces",
"strict":
False,
"auto_create_index":
False,
"indexes": [
("managed_object", "name"),
"mac",
("managed_object", "ifindex"),
"service",
"aggregated_interface",
],
}
managed_object = ForeignKeyField(ManagedObject)
name = StringField() # Normalized via Profile.convert_interface_name
type = StringField(choices=[(x, x) for x in INTERFACE_TYPES])
description = StringField(required=False)
ifindex = IntField(required=False)
mac = StringField(required=False)
aggregated_interface = PlainReferenceField("self", required=False)
enabled_protocols = ListField(
StringField(choices=[(x, x) for x in INTERFACE_PROTOCOLS]), default=[])
profile = PlainReferenceField(InterfaceProfile,
default=InterfaceProfile.get_default_profile)
# profile locked on manual user change
profile_locked = BooleanField(required=False, default=False)
#
project = ForeignKeyField(Project)
state = ForeignKeyField(ResourceState)
vc_domain = ForeignKeyField(VCDomain)
# Current status
admin_status = BooleanField(required=False)
oper_status = BooleanField(required=False)
oper_status_change = DateTimeField(required=False,
default=datetime.datetime.now)
full_duplex = BooleanField(required=False)
in_speed = IntField(required=False) # Input speed, kbit/s
out_speed = IntField(required=False) # Output speed, kbit/s
bandwidth = IntField(required=False) # Configured bandwidth, kbit/s
# Coverage
coverage = PlainReferenceField(Coverage)
technologies = ListField(StringField())
# External NRI interface name
nri_name = StringField()
#
service = ReferenceField(Service)
PROFILE_LINK = "profile"
def __str__(self):
return "%s: %s" % (self.managed_object.name, self.name)
def iter_changed_datastream(self, changed_fields=None):
if config.datastream.enable_managedobject:
yield "managedobject", self.managed_object.id
def save(self, *args, **kwargs):
if not hasattr(self,
"_changed_fields") or "name" in self._changed_fields:
self.name = self.managed_object.get_profile(
).convert_interface_name(self.name)
if (not hasattr(self, "_changed_fields")
or "mac" in self._changed_fields) and self.mac:
self.mac = MACAddressParameter().clean(self.mac)
try:
super(Interface, self).save(*args, **kwargs)
except Exception as e:
raise ValueError("%s: %s" % (e.__doc__, e.message))
if not hasattr(self,
"_changed_fields") or "service" in self._changed_fields:
ServiceSummary.refresh_object(self.managed_object)
def on_delete(self):
from .macdb import MACDB
# Remove all subinterfaces
for si in self.subinterface_set.all():
si.delete()
# Unlink
link = self.link
if link:
self.unlink()
# Flush MACDB
MACDB.objects.filter(interface=self.id).delete()
@property
def link(self):
"""
Return Link instance or None
:return:
"""
if self.type == "aggregated":
q = {
"interfaces__in": [self.id] + [i.id for i in self.lag_members]
}
else:
q = {"interfaces": self.id}
return Link.objects.filter(**q).first()
@property
def is_linked(self):
"""
Check interface is linked
:returns: True if interface is linked, False otherwise
"""
if self.type == "aggregated":
q = {
"interfaces": {
"$in": [self.id] + [i.id for i in self.lag_members]
}
}
else:
q = {"interfaces": self.id}
return bool(Link._get_collection().with_options(
read_preference=ReadPreference.SECONDARY_PREFERRED).find_one(q))
def unlink(self):
"""
Remove existing link.
Raise ValueError if interface is not linked
"""
link = self.link
if link is None:
raise ValueError("Interface is not linked")
if link.is_ptp or link.is_lag:
link.delete()
else:
raise ValueError("Cannot unlink non p-t-p link")
def link_ptp(self, other, method=""):
"""
Create p-t-p link with other interface
Raise ValueError if either of interface already connected.
:param other: Other Iface for link
:param method: Linking method
:type other: Interface
:returns: Link instance
"""
def link_mismatched_lag(agg, phy):
"""
Try to link LAG to physical interface
:param agg:
:param phy:
:return:
"""
l_members = [i for i in agg.lag_members if i.oper_status]
if len(l_members) > 1:
raise ValueError("More then one active interface in LAG")
link = Link(interfaces=l_members + [phy], discovery_method=method)
link.save()
return link
# Try to check existing LAG
el = Link.objects.filter(interfaces=self.id).first()
if el and other not in el.interfaces:
el = None
if (self.is_linked or other.is_linked) and not el:
raise ValueError("Already linked")
if self.id == other.id:
raise ValueError("Cannot link with self")
if self.type in ("physical", "management"):
if other.type in ("physical", "management"):
# Refine LAG
if el:
left_ifaces = [
i for i in el.interfaces if i not in (self, other)
]
if left_ifaces:
el.interfaces = left_ifaces
el.save()
else:
el.delete()
#
link = Link(interfaces=[self, other], discovery_method=method)
link.save()
return link
elif other.type == "aggregated" and other.profile.allow_lag_mismatch:
return link_mismatched_lag(other, self)
else:
raise ValueError("Cannot connect %s interface to %s" %
(self.type, other.type))
elif self.type == "aggregated":
# LAG
if other.type == "aggregated":
# Check LAG size match
# Skip already linked members
l_members = [i for i in self.lag_members if not i.is_linked]
r_members = [i for i in other.lag_members if not i.is_linked]
if len(l_members) != len(r_members):
raise ValueError("LAG size mismatch")
# Create link
if l_members:
link = Link(interfaces=l_members + r_members,
discovery_method=method)
link.save()
return link
else:
return
elif self.profile.allow_lag_mismatch:
return link_mismatched_lag(self, other)
else:
raise ValueError("Cannot connect %s interface to %s" %
(self.type, other.type))
raise ValueError("Cannot link")
@classmethod
def get_interface(cls, s):
"""
Parse <managed object>@<interface> string
and return interface instance or None
"""
if "@" not in s:
raise ValueError("Invalid interface: %s" % s)
o, i = s.rsplit("@", 1)
# Get managed object
try:
mo = ManagedObject.objects.get(name=o)
except ManagedObject.DoesNotExist:
raise ValueError("Invalid manged object: %s" % o)
# Normalize interface name
i = mo.get_profile().convert_interface_name(i)
# Look for interface
iface = Interface.objects.filter(managed_object=mo.id, name=i).first()
return iface
@property
def subinterface_set(self):
from .subinterface import SubInterface
return SubInterface.objects.filter(interface=self.id)
@property
def lag_members(self):
if self.type != "aggregated":
raise ValueError(
"Cannot net LAG members for not-aggregated interface")
return Interface.objects.filter(aggregated_interface=self.id)
@property
def effective_vc_domain(self):
if self.type in ("null", "tunnel", "other", "unknown"):
return None
if self.vc_domain:
return self.vc_domain
if self.managed_object.vc_domain:
return self.managed_object.vc_domain
return VCDomain.get_default()
@property
def status(self):
"""
Returns interface status in form of
Up/100/Full
"""
def humanize_speed(speed):
if not speed:
return "-"
for t, n in [(1000000, "G"), (1000, "M"), (1, "k")]:
if speed >= t:
if speed // t * t == speed:
return "%d%s" % (speed // t, n)
else:
return "%.2f%s" % (float(speed) / t, n)
return str(speed)
s = [{True: "Up", False: "Down", None: "-"}[self.oper_status]]
# Speed
if self.oper_status:
if self.in_speed and self.in_speed == self.out_speed:
s += [humanize_speed(self.in_speed)]
else:
s += [
humanize_speed(self.in_speed),
humanize_speed(self.out_speed)
]
s += [{True: "Full", False: "Half", None: "-"}[self.full_duplex]]
else:
s += ["-", "-"]
return "/".join(s)
def set_oper_status(self, status):
"""
Set current oper status
"""
if self.oper_status == status:
return
now = datetime.datetime.now()
if self.oper_status != status and (not self.oper_status_change
or self.oper_status_change < now):
self.update(oper_status=status, oper_status_change=now)
if self.profile.status_change_notification:
logger.debug(
"Sending status change notification to %s",
self.profile.status_change_notification.name,
)
self.profile.status_change_notification.notify(
subject="[%s] Interface %s(%s) is %s" % (
self.managed_object.name,
self.name,
self.description or "",
"up" if status else "down",
),
body="Interface %s (%s) is %s" %
(self.name, self.description
or "", "up" if status else "down"),
)
@property
def parent(self):
"""
Returns aggregated interface for LAG or
self for non-aggregated interface
"""
if self.aggregated_interface:
return self.aggregated_interface
else:
return self
def get_profile(self):
if self.profile:
return self.profile
return InterfaceProfile.get_default_profile()
class Convention(BDocument):
label = StringField()
tariff = EmbeddedDocumentField(Tariff)
min = FloatField()
max = FloatField()
exceptions = EmbeddedDocumentListField(ConventionException)
class HostModel(DynamicDocument):
username = StringField()
levels = DictField()
blockchain = StringField()
registered_at = DateTimeField()
architect = StringField()
hoperator = StringField()
consensus_percent = FloatField()
referral_percent = FloatField()
dac_mode = IntField()
dacs = DictField()
chosts = DictField()
ahost = StringField()
non_active_chost = BooleanField()
need_switch = BooleanField()
fhosts_mode = IntField()
fhosts = DictField()
title = StringField()
purpose = StringField()
total_shares = IntField()
quote_amount = StringField()
root_token_contract = StringField()
root_token = StringField()
symbol = StringField()
precision = IntField()
to_pay = IntField()
payed = BooleanField()
cycle_start_id = IntField()
current_pool_id = IntField()
current_cycle_num = IntField()
current_pool_num = IntField()
parameters_setted = BooleanField()
activated = BooleanField()
priority_flag = BooleanField()
meta = StringField()
app = StringField()
meta = {
'collection':
'hosts',
'ordering': ['-registered_at'],
'indexes': [
'username', 'blockchain', 'ahost', 'activated', 'payed',
'parameters_setted'
'priority_flag'
'need_switch', 'non_active_chost', 'app'
],
'auto_create_index':
True,
'index_background':
True
}
class AWSImage(Document):
meta = {'collection': 'awsImage'}
extra = DictField()
name = StringField()
class SchemaElement(Document):
tag = StringField(required=True)
value = StringField(default=None)
options = DictField()
children = ListField(ReferenceField('SchemaElement'))
class Hashtags_trend(Document):
meta = {'collection': 'US_HASHTAGS_TREND_copy'}
full_name = StringField(required=True)
tweet_text= StringField(required=True)
no_of_replies = StringField(required=True)
number_of_likes = StringField(required=True)
hashtags= StringField(required=True)
username = StringField(required=True)
no_of_retweets = StringField(required=True)
twitter_url= StringField(required=True)
call_to_action = StringField(required=True)
no_of_hashtags = StringField(required=True)
mentions= StringField(required=True)
tweet_time = StringField(required=True)
no_of_mentions = StringField(required=True)
sentiment = StringField(required=True)
Country=StringField(required=True)
class Child(Parent):
meta = {'collection': 'test_child'}
baz = StringField()
loc = PointField()
def __init__(self, *args, **kwargs):
if 'default' not in kwargs:
kwargs['default'] = '{}'
StringField.__init__(self, *args, **kwargs)
class Tag(Document, DocumentHelperMixin):
# BIG DB migration 20141028
bigmig_migrated = BooleanField(default=False)
# END BIG DB migration
name = StringField(verbose_name=_(u'name'), unique=True)
slug = StringField(verbose_name=_(u'slug'))
language = StringField(verbose_name=_(u'language'), default='')
parents = ListField(ReferenceField('self', reverse_delete_rule=PULL),
default=list)
children = ListField(ReferenceField('self', reverse_delete_rule=PULL),
default=list)
# reverse_delete_rule=NULLIFY,
origin = GenericReferenceField(verbose_name=_(u'Origin'),
help_text=_(u'Initial origin from where '
u'the tag was created from, '
u'to eventually help '
u'defining other attributes.'))
duplicate_of = ReferenceField('Tag',
reverse_delete_rule=NULLIFY,
verbose_name=_(u'Duplicate of'),
help_text=_(u'Put a "master" tag here to '
u'help avoiding too much '
u'different tags (eg. singular '
u'and plurals) with the same '
u'meaning and loss of '
u'information.'))
meta = {
'indexes': [
'name',
]
}
# See the `WordRelation` class before working on this.
#
# antonyms = ListField(ReferenceField('self'), verbose_name=_(u'Antonyms'),
# help_text=_(u'Define an antonym tag to '
# u'help search connectable but.'))
def __unicode__(self):
return _(u'{0} {1}⚐ (#{2})').format(self.name, self.language, self.id)
def replace_duplicate_everywhere(self, duplicate_id, *args, **kwargs):
duplicate = self.__class__.objects.get(id=duplicate_id)
# This method is defined in nonrel.article to avoid an import loop.
self.replace_duplicate_in_articles(duplicate, *args, **kwargs)
#
# TODO: do the same for feeds, reads (, subscriptions?) …
#
pass
@classmethod
def signal_post_save_handler(cls,
sender,
document,
created=False,
**kwargs):
tag = document
if created:
if tag._db_name != settings.MONGODB_NAME_ARCHIVE:
# HEADS UP: this task is declared by
# the register_task_method call below.
tag_post_create_task.delay(tag.id) # NOQA
def post_create_task(self):
""" Method meant to be run from a celery task. """
if not self.slug:
self.slug = slugify(self.name)
self.save()
statsd.gauge('mongo.tags.counts.total', 1, delta=True)
@classmethod
def get_tags_set(cls, tags_names, origin=None):
tags = set()
for tag_name in tags_names:
tag_name = tag_name.lower()
try:
tag = cls.objects.get(name=tag_name)
except cls.DoesNotExist:
try:
tag = cls(name=tag_name, origin=origin).save()
except (NotUniqueError, DuplicateKeyError):
tag = cls.objects.get(name=tag_name)
tags.add(tag.duplicate_of or tag)
return tags
def save(self, *args, **kwargs):
""" This method will simply add the missing children/parents reverse
links of the current Tag. This is needed when modifying tags from
the Django admin, which doesn't know about the reverse-link
existence.
.. note:: sadly, we have no fast way to do the same for links
removal.
"""
super(Tag, self).save(*args, **kwargs)
for parent in self.parents:
if self in parent.children:
continue
try:
parent.add_child(self,
update_reverse_link=False,
full_reload=False)
except:
LOGGER.exception(
u'Exception while reverse-adding '
u'child %s to parent %s', self, parent)
for child in self.children:
if self in child.parents:
continue
try:
child.add_parent(self,
update_reverse_link=False,
full_reload=False)
except:
LOGGER.exception(
u'Exception while reverse-adding '
u'parent %s to child %s', self, child)
return self
def add_parent(self, parent, update_reverse_link=True, full_reload=True):
self.update(add_to_set__parents=parent)
if full_reload:
self.safe_reload()
if update_reverse_link:
parent.add_child(self, update_reverse_link=False)
def remove_parent(self,
parent,
update_reverse_link=True,
full_reload=True):
if update_reverse_link:
parent.remove_child(self, update_reverse_link=False)
self.update(pull__parents=parent)
if full_reload:
self.safe_reload()
def add_child(self, child, update_reverse_link=True, full_reload=True):
self.update(add_to_set__children=child)
if full_reload:
self.safe_reload()
if update_reverse_link:
child.add_parent(self, update_reverse_link=False)
def remove_child(self, child, update_reverse_link=True, full_reload=True):
if update_reverse_link:
child.remove_parent(self, update_reverse_link=False)
self.update(pull__children=child)
if full_reload:
self.safe_reload()
