def execute_networkports(changeplan):
changed_networkports = NetworkPort.objects.filter(version=changeplan)
for changed_networkport in changed_networkports:
try:
live = ChangePlan.objects.get(id=0)
live_networkport = versioned_object(changed_networkport, live, NetworkPort.IDENTITY_FIELDS)
if live_networkport is None:
live_asset = add_asset(changed_networkport.asset, live)
NetworkPort.objects.create(
asset=live_asset,
label=changed_networkport.label,
mac_address=changed_networkport.mac_address,
connection=add_network_conn(changed_networkport.connection, live),
version=live
)
else:
live_networkport.label = changed_networkport.label
live_networkport.mac_address = changed_networkport.mac_address
if changed_networkport.connection:
live_networkport.connection = add_network_conn(changed_networkport.connection, live)
else:
live_networkport.connection = None
live_networkport.save()
except Exception as e:
pass
def execute_assets(changeplan):
changed_assets = Asset.objects.filter(version=changeplan).order_by('itmodel__type')
for changed_asset in changed_assets:
try:
live = ChangePlan.objects.get(id=0)
live_asset = versioned_object(changed_asset, live, Asset.IDENTITY_FIELDS)
if live_asset is None:
live_asset = versioned_object(changed_asset, live, ['hostname'])
if live_asset is None:
Asset.objects.create(
version=live,
hostname=changed_asset.hostname,
site=changed_asset.site,
rack=add_rack(changed_asset.rack, live) if not changed_asset.site.offline else None,
rack_position=changed_asset.rack_position if not changed_asset.site.offline and changed_asset.itmodel.type != ITModel.Type.BLADE else None,
itmodel=changed_asset.itmodel,
owner=changed_asset.owner,
comment=changed_asset.comment,
display_color=changed_asset.display_color if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None,
cpu=changed_asset.cpu if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None,
memory=changed_asset.memory if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None,
storage=changed_asset.storage if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None,
blade_chassis=add_asset(changed_asset.blade_chassis, live, Asset.IDENTITY_FIELDS)\
if changed_asset.itmodel.type == ITModel.Type.BLADE or changed_asset.itmodel.type == ITModel.Type.CHASSIS else None,
slot=changed_asset.slot if changed_asset.itmodel.type == ITModel.Type.CHASSIS else None
)
else:
live_asset.asset_number = changed_asset.asset_number
live_asset.hostname = changed_asset.hostname
live_asset.site = changed_asset.site
live_asset.rack = add_rack(changed_asset.rack, live) if not changed_asset.site.offline else None
live_asset.rack_position = changed_asset.rack_position if not changed_asset.site.offline and changed_asset.itmodel.type != ITModel.Type.BLADE else None
live_asset.itmodel = changed_asset.itmodel
live_asset.owner = changed_asset.owner
live_asset.comment = changed_asset.comment
live_asset.display_color = changed_asset.display_color if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None
live_asset.cpu = changed_asset.cpu if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None
live_asset.memory = changed_asset.memory if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None
live_asset.storage = changed_asset.storage if changed_asset.itmodel.type != ITModel.Type.CHASSIS else None
live_asset.blade_chassis = add_asset(changed_asset.blade_chassis, live, Asset.IDENTITY_FIELDS)\
if changed_asset.itmodel.type == ITModel.Type.BLADE else None
live_asset.slot = changed_asset.slot if changed_asset.itmodel.type == ITModel.Type.BLADE else None
live_asset.save()
except Exception as e:
pass
def decommission_asset(asset_id, view, user, version):
try:
asset = Asset.objects.get(id=asset_id)
change_plan = ChangePlan.objects.create(
owner=user,
name='_DECOMMISSION_' + str(asset.id),
executed=version.executed,
executed_at=version.executed_at,
auto_created=True,
parent=version
)
# Freeze Asset - Copy all data to new change plan
# Requires resetting of all foreign keys
old_rack = Rack.objects.get(id=asset.rack.id) if asset.rack else None
old_asset = Asset.objects.get(id=asset.id)
asset = add_asset(asset, change_plan)
rack = asset.rack
asset.commissioned = None
asset.decommissioned_by = user
asset.decommissioned_timestamp = now()
asset.save()
if old_rack:
for a in old_rack.asset_set.exclude(id=old_asset.id):
add_asset(a, change_plan)
if rack:
for pdu in old_rack.pdu_set.filter(version=version):
new_pdu = rack.pdu_set.get(position=pdu.position)
for power in pdu.powered_set.filter(asset=old_asset):
power.id = None
power.pdu = new_pdu
power.asset = asset
power.version = change_plan
power.save()
def loop_ports(old_asset, recurse):
for port in old_asset.networkport_set.all():
old_port = NetworkPort.objects.get(id=port.id)
other = old_port.connection
port = add_network_conn(port, change_plan)
if other:
if recurse:
loop_ports(other.asset, False)
other = add_network_conn(other, change_plan)
other.connection = port
port.connection = other
other.save()
port.save()
loop_ports(old_asset, True)
log_decommission(user, old_asset)
for blade in old_asset.blade_set.all():
blade.delete()
if old_asset.version == version:
old_asset.delete()
return asset
except Asset.DoesNotExist:
raise serializers.ValidationError(
'Asset does not exist.'
)
except ChangePlan.DoesNotExist:
raise serializers.ValidationError(
'Change Plan does not exist.'
)
def after_import_row(self, row, row_result, **kwargs):
if row_result.import_type == 'skip':
return
try:
my_asset = Asset.objects.get(id=row_result.object_id)
except:
return # skip
my_asset = add_asset(my_asset, self.version)
if not my_asset.site.offline and not my_asset.itmodel.type == ITModel.Type.BLADE:
my_rack = my_asset.rack
special = []
for i in range(1, min(3, my_asset.itmodel.power_ports + 1)):
pc = row['power_port_connection_' + str(i)]
if len(pc) > 0:
try:
split = re.search(r"\d", pc).start()
position = pc[:split]
plug = int(pc[split:])
special.append({
'pdu_id':
PDU.objects.get(rack=my_rack, position=position),
'plug':
plug
})
except AttributeError:
raise ValidationError('power_port_connection_' +
str(i) +
" formatted incorrectly")
except PDU.DoesNotExist:
raise ValidationError(
pc + " does not exit on the specified rack")
current = []
powered_set = my_asset.powered_set
if 2 <= len(special) < my_asset.itmodel.power_ports and \
powered_set.exists() and powered_set.first().pdu.rack == my_asset.rack:
special_simple = [
port['pdu_id'].position + str(port['plug'])
for port in special
]
current = [{
'pdu_id': port['pdu'],
'plug': port['plug_number'],
'position': port['pdu__position']
} for port in powered_set.order_by('order').values(
'pdu', 'plug_number', 'pdu__position')]
for port in current:
simple = port['position'] + str(port['plug'])
if simple in special_simple:
current.remove(port)
my_asset.powered_set.all().delete()
create_ports = False
net_port = my_asset.networkport_set.first()
if net_port and net_port.label.itmodel != my_asset.itmodel:
for port in my_asset.networkport_set.all():
port.delete()
create_ports = True
if row_result.import_type == "new" or create_ports:
ports = [{
"label": port,
"mac_address": None,
"connection": None
} for port in NetworkPortLabel.objects.filter(
itmodel=my_asset.itmodel).values_list('name', flat=True)]
else:
ports = None
my_asset.version = self.version
create_asset_extra(my_asset, self.version, special + current,
ports)
if my_asset.itmodel.type == ITModel.Type.BLADE:
my_asset.rack = my_asset.blade_chassis.rack
my_asset.save()
if my_asset.site.offline:
for port in my_asset.networkport_set.all():
port.connection = None
port.save()
def clean(self, value, row=None, *args, **kwargs):
if value:
version = ChangePlan.objects.get(id=row['version'])
chassis = newest_object(Asset, version, asset_number=value)
return add_asset(chassis, version)
return None
def clean(self, value, row=None, *args, **kwargs):
version = ChangePlan.objects.get(id=row['version'])
asset = newest_object(Asset, version, hostname=row['src_hostname'])
return add_asset(asset, version, ['hostname'])
def update(self, request, *args,
**kwargs): # todo the logic in this looks fishy..
# Do you need to update data's id or is that done already? what about version?
# Does the new asset get added to the new version? What about its network ports?
# Make sure that network ports are not deleted in the offline case but connections are wiped
version = ChangePlan.objects.get(id=get_version(request))
asset = self.get_object()
asset_ver = asset.version
request.data['power_connections'] = request.data.get(
'power_connections', [])
request.data['network_ports'] = request.data.get('network_ports', [])
request.data['power_connections'] = [
entry for entry in request.data['power_connections'] if entry
]
site = Site.objects.get(id=request.data['location']['site'])
check_asset_perm(request.user.username, site.abbr)
check_asset_perm(request.user.username, asset.site.abbr)
if version != asset_ver:
data = request.data
if not site.offline:
rack = versioned_object(asset.rack, version,
Rack.IDENTITY_FIELDS)
if not rack:
rack = add_rack(asset.rack, version)
old_pdus = {
port['id']: port['position']
for port in asset.rack.pdu_set.order_by('position').values(
'id', 'position')
}
new_pdus = {
port['position']: port['id']
for port in rack.pdu_set.order_by('position').values(
'id', 'position')
}
data['location']['rack'] = rack.id
for i, port in enumerate(request.data['power_connections']):
data['power_connections'][i]['pdu_id'] = new_pdus[old_pdus[
int(port['pdu_id'])]]
for i, port in enumerate(request.data['network_ports']):
if port['connection'] is not None:
versioned_conn = add_network_conn(
NetworkPort.objects.get(id=port['connection']),
version)
data['network_ports'][i][
'connection'] = versioned_conn.id
else:
request.data['power_connections'] = []
if request.data['location']['tag'] == 'chassis-mount':
chassis = Asset.objects.get(
id=request.data['location']['asset'])
request.data['location']['asset'] = add_asset(
chassis, version, Asset.IDENTITY_FIELDS).id
pass
serializer = AssetSerializer(data=data,
context={
'request': request,
'version': version.id
})
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data, status=HTTP_200_OK)
else:
return super(AssetUpdate, self).update(request, *args, **kwargs)