Products.ZenModel.OperatingSystem

36 37 totalSwap = 0L 38 uname = "" 39 40 _properties = Software._properties + ( 41 {'id':'totalSwap', 'type':'long', 'mode':'w'}, 42 {'id':'uname', 'type':'string', 'mode':''}, 43 ) 44 45 _relations = Software._relations + ( 46 ("interfaces", ToManyCont(ToOne, 47 "Products.ZenModel.IpInterface", "os")), 48 ("routes", ToManyCont(ToOne, "Products.ZenModel.IpRouteEntry", "os")), 49 ("ipservices", ToManyCont(ToOne, "Products.ZenModel.IpService", "os")), 50 ("winservices", ToManyCont(ToOne, 51 "Products.ZenModel.WinService", "os")), 52 ("processes", ToManyCont(ToOne, "Products.ZenModel.OSProcess", "os")), 53 ("filesystems", ToManyCont(ToOne, 54 "Products.ZenModel.FileSystem", "os")), 55 ("software", ToManyCont(ToOne, "Products.ZenModel.Software", "os")), 56 ) 57 58 security = ClassSecurityInfo() 59 60 routeTypeMap = ('other', 'invalid', 'direct', 'indirect') 61 routeProtoMap = ('other', 'local', 'netmgmt', 'icmp', 62 'egp', 'ggp', 'hello', 'rip', 'is-is', 'es-is', 63 'ciscoIgrp', 'bbnSpfIgrp', 'ospf', 'bgp') 64 65 factory_type_information = ( 66 { 67 'id' : 'Device', 68 'meta_type' : 'Device', 69 'description' : """Base class for all devices""", 70 'icon' : 'Device_icon.gif', 71 'product' : 'ZenModel', 72 'factory' : 'manage_addDevice', 73 'immediate_view' : '../deviceOsDetail', 74 'actions' : () 75 }, 76 ) 77 78

79 - def __init__(self):

80 id = "os" 81 Software.__init__(self, id) 82 self._delObject("os") # OperatingSystem is a software

83 # but doens't have os relationship 84 85

86 - def totalSwapString(self):

87 return self.totalSwap and convToUnits(self.totalSwap) or 'Unknown'

88

89 - def traceRoute(self, target, ippath):

90 """ 91 Trace the route to the target from this device using our routing 92 table and return an array of IP address strings showing the route. 93 94 If the route is not traversable (ie a gap in the routing table), 95 then return the incomplete path with a final value of None. 96 97 @parameter target: destination IP to find 98 @type target: DMD device object 99 @parameter ippath: used to store intermediate results in calls. Call with [] 100 @type ippath: array-like object used for 101 @return: IP addresses to target device 102 @rtype: array of strings 103 """ 104 log.debug("traceRoute from device %s to target %s", 105 self.getDeviceName(), target) 106 # Try to find a specific route to the target device 107 nextdev = None 108 for route in sorted(self.getRouteObjs(),key=lambda route:route.routemask,reverse=True): 109 ip = route.getNextHopIp() 110 log.debug("Route %s next hop %s", route.getTarget(), ip) 111 # Have a host-route 112 if ip == target.getManageIp(): 113 ippath.append(ip) 114 return ippath 115 116 # Have a net-route 117 if route.matchTarget(target.getManageIp()): 118 if route.routetype == 'direct': 119 nextdev = target 120 break 121 nextdev = route.getNextHopDevice() 122 break 123 else: 124 # No routes matched -- try the default route (if any) 125 log.debug("Device %s default route", self.getDeviceName()) 126 ip = "" 127 default = self.routes._getOb("0.0.0.0_0", None) 128 if default: 129 ip = default.getNextHopIp() 130 nextdev = default.getNextHopDevice() 131 132 if target == nextdev or ip == "0.0.0.0": 133 ippath.append(target.id) 134 return ippath 135 136 if nextdev: 137 # Look for a bizarre case where we find a loop 138 if nextdev.manageIp not in ippath: 139 ippath.append(ip) 140 return nextdev.traceRoute(target, ippath) 141 142 # Oops! No route! 143 log.debug("Unable to trace to %s, gap at %s", target.id, 144 self.getDeviceName()) 145 ippath.append(None) 146 return ippath

147 148

149 - def getRouteObjs(self):

150 """Return our real route objects. 151 """ 152 return filter(lambda r: r.target(), self.routes())

153 154

155 - def device(self):

156 """Return our Device object for DeviceResultInt. 157 """ 158 return self.getPrimaryParent()

159

160 - def deleteDeviceComponents(self, context, componentNames=[], REQUEST=None):

161 """Delete device components""" 162 if not componentNames: return self() 163 if isinstance(componentNames, basestring): 164 componentNames = (componentNames,) 165 for componentName in componentNames: 166 dc = context._getOb(componentName, False) 167 if dc: dc.manage_deleteComponent() 168 if REQUEST: 169 return self.callZenScreen(REQUEST)

170

171 - def unlockDeviceComponents(self, context, componentNames=[], REQUEST=None):

172 """Unlock device components""" 173 if not componentNames: return self() 174 if isinstance(componentNames, basestring): 175 componentNames = (componentNames,) 176 for componentName in componentNames: 177 dc = context._getOb(componentName) 178 dc.unlock() 179 if REQUEST: 180 return self.callZenScreen(REQUEST)

181

182 - def lockDeviceComponentsFromDeletion(self, context, componentNames=[], 183 sendEventWhenBlocked=None, REQUEST=None):

184 """Lock device components from deletion""" 185 if not componentNames: return self() 186 if isinstance(componentNames, basestring): 187 componentNames = (componentNames,) 188 for componentName in componentNames: 189 dc = context._getOb(componentName) 190 dc.lockFromDeletion(sendEventWhenBlocked) 191 if REQUEST: 192 return self.callZenScreen(REQUEST)

193

194 - def lockDeviceComponentsFromUpdates(self, context, componentNames=[], 195 sendEventWhenBlocked=None, REQUEST=None):

196 """Lock device components from updates""" 197 if not componentNames: return self() 198 if isinstance(componentNames, basestring): 199 componentNames = (componentNames,) 200 for componentName in componentNames: 201 dc = context._getOb(componentName, False) 202 if dc: dc.lockFromUpdates(sendEventWhenBlocked) 203 if REQUEST: 204 return self.callZenScreen(REQUEST)

205 206

207 - def addIpInterface(self, newId, userCreated, REQUEST=None):

208 """Add IpInterfaces. 209 """ 210 manage_addIpInterface(self.interfaces, newId, userCreated) 211 if REQUEST: 212 messaging.IMessageSender(self).sendToBrowser( 213 'Interface Created', 214 'IP Interface %s was created.' % newId 215 ) 216 REQUEST['RESPONSE'].redirect( 217 self.interfaces._getOb(newId).absolute_url()) 218 self._p_changed = True 219 return self.callZenScreen(REQUEST)

220

221 - def deleteIpInterfaces(self, componentNames=[], REQUEST=None):

222 """Delete IpInterfaces""" 223 self.deleteDeviceComponents(self.interfaces, componentNames, REQUEST) 224 if REQUEST: 225 messaging.IMessageSender(self).sendToBrowser( 226 'Interfaces Deleted', 227 'IP Interfaces %s was created.' % (', '.join(componentNames)) 228 ) 229 REQUEST['RESPONSE'].redirect(self.absolute_url()) 230 return self.callZenScreen(REQUEST)

231

232 - def setComponentMonitored(self, context, componentNames=[], 233 monitored=True, REQUEST=None):

234 """ 235 Set monitored status for selected components. 236 """ 237 if isinstance(context, basestring): 238 context = getattr(self, context) 239 if not componentNames: return self() 240 if isinstance(componentNames, basestring): 241 componentNames = (componentNames,) 242 monitored = bool(monitored) 243 for componentName in componentNames: 244 comp = context._getOb(componentName, False) 245 if comp and comp.monitored() != monitored: 246 comp.monitor = monitored 247 if isinstance(comp, (Service, OSProcess)): 248 comp.setAqProperty('zMonitor', monitored, 'boolean') 249 comp.index_object() 250 if REQUEST: 251 verb = monitored and "Enabled" or "Disabled" 252 messaging.IMessageSender(self).sendToBrowser( 253 'Monitoring %s' % verb, 254 'Monitoring was %s on %s.' % (verb.lower(), 255 ', '.join(componentNames)) 256 ) 257 return self.callZenScreen(REQUEST)

258

259 - def unlockIpInterfaces(self, componentNames=[], REQUEST=None):

260 """Unlock IpInterfaces""" 261 self.unlockDeviceComponents(self.interfaces, componentNames, REQUEST) 262 if REQUEST: 263 messaging.IMessageSender(self).sendToBrowser( 264 'Interfaces Unlocked', 265 'Interfaces %s were unlocked.' % (', '.join(componentNames)) 266 ) 267 REQUEST['RESPONSE'].redirect(self.absolute_url()) 268 return self.callZenScreen(REQUEST)

269

270 - def lockIpInterfacesFromDeletion(self, componentNames=[], 271 sendEventWhenBlocked=None, REQUEST=None):

272 """Lock IpInterfaces from deletion""" 273 self.lockDeviceComponentsFromDeletion(self.interfaces, componentNames, 274 sendEventWhenBlocked, REQUEST) 275 if REQUEST: 276 messaging.IMessageSender(self).sendToBrowser( 277 'Interfaces Locked', 278 'Interfaces %s were locked from deletion.' % ( 279 ', '.join(componentNames)) 280 ) 281 REQUEST['RESPONSE'].redirect(self.absolute_url()) 282 return self.callZenScreen(REQUEST)

283

284 - def lockIpInterfacesFromUpdates(self, componentNames=[], 285 sendEventWhenBlocked=None, REQUEST=None):

286 """Lock IpInterfaces from updates""" 287 self.lockDeviceComponentsFromUpdates(self.interfaces, componentNames, 288 sendEventWhenBlocked, REQUEST) 289 if REQUEST: 290 messaging.IMessageSender(self).sendToBrowser( 291 'Interfaces Locked', 292 'Interfaces %s were locked from updates and deletion.' % ( 293 ', '.join(componentNames)) 294 ) 295 REQUEST['RESPONSE'].redirect(self.absolute_url()) 296 return self.callZenScreen(REQUEST)

297

298 - def addWinService(self, newClassName, userCreated, REQUEST=None):

299 """Add an WinService. 300 """ 301 org = self.dmd.Services 302 wsc = org.unrestrictedTraverse(newClassName) 303 if wsc is not None: 304 ws = manage_addWinService(self.winservices, 305 wsc.id, 306 wsc.description, 307 userCreated=userCreated) 308 self._p_changed = True 309 elif REQUEST: 310 messaging.IMessageSender(self).sendToBrowser( 311 'No Such WinService', 312 'Could not find a WinService named %s.' % (newClassName), 313 priority=messaging.WARNING 314 ) 315 return self.callZenScreen(REQUEST) 316 317 if REQUEST: 318 messaging.IMessageSender(self).sendToBrowser( 319 'WinService Added', 320 'WinService %s was added.' % (newClassName) 321 ) 322 REQUEST['RESPONSE'].redirect(ws.absolute_url()) 323 return self.callZenScreen(REQUEST)

324

325 - def deleteWinServices(self, componentNames=[], REQUEST=None):

326 """Delete WinServices""" 327 self.deleteDeviceComponents(self.winservices, componentNames, REQUEST) 328 if REQUEST: 329 messaging.IMessageSender(self).sendToBrowser( 330 'WinServices Deleted', 331 'WinServices %s were deleted.' % (', '.join(componentNames)) 332 ) 333 REQUEST['RESPONSE'].redirect(self.absolute_url()) 334 return self.callZenScreen(REQUEST)

335

336 - def unlockWinServices(self, componentNames=[], REQUEST=None):

337 """Unlock WinServices""" 338 self.unlockDeviceComponents(self.winservices, componentNames, REQUEST) 339 if REQUEST: 340 messaging.IMessageSender(self).sendToBrowser( 341 'WinServices Unlocked', 342 'WinServices %s were unlocked.' % (', '.join(componentNames)) 343 ) 344 REQUEST['RESPONSE'].redirect(self.absolute_url()) 345 return self.callZenScreen(REQUEST)

346

347 - def lockWinServicesFromDeletion(self, componentNames=[], 348 sendEventWhenBlocked=None, REQUEST=None):

349 """Lock WinServices from deletion""" 350 self.lockDeviceComponentsFromDeletion(self.winservices, componentNames, 351 sendEventWhenBlocked, REQUEST) 352 if REQUEST: 353 messaging.IMessageSender(self).sendToBrowser( 354 'WinServices Locked', 355 'WinServices %s were locked from deletion.' % ( 356 ', '.join(componentNames)) 357 ) 358 REQUEST['RESPONSE'].redirect(self.absolute_url()) 359 return self.callZenScreen(REQUEST)

360

361 - def lockWinServicesFromUpdates(self, componentNames=[], 362 sendEventWhenBlocked=None, REQUEST=None):

363 """Lock WinServices from updates""" 364 self.lockDeviceComponentsFromUpdates(self.winservices, componentNames, 365 sendEventWhenBlocked, REQUEST) 366 if REQUEST: 367 messaging.IMessageSender(self).sendToBrowser( 368 'WinServices Locked', 369 'WinServices %s were locked from updates and deletion.' % ( 370 ', '.join(componentNames)) 371 ) 372 REQUEST['RESPONSE'].redirect(self.absolute_url()) 373 return self.callZenScreen(REQUEST)

374

375 - def getSubOSProcessClassesGen(self, REQUEST=None):

376 """Get OS Process 377 """ 378 return self.getDmdRoot('Processes').getSubOSProcessClassesGen()

379

380 - def addOSProcess(self, newClassName, userCreated, REQUEST=None):

381 """Add an OSProcess. 382 """ 383 osp = manage_addOSProcess(self.processes, newClassName, userCreated) 384 self._p_changed = True 385 if REQUEST: 386 messaging.IMessageSender(self).sendToBrowser( 387 'Process Created', 388 'OS process %s was created.' % newClassName 389 ) 390 REQUEST['RESPONSE'].redirect(osp.absolute_url())

391

392 - def deleteOSProcesses(self, componentNames=[], REQUEST=None):

393 """Delete OSProcesses""" 394 self.deleteDeviceComponents(self.processes, componentNames, REQUEST) 395 if REQUEST: 396 messaging.IMessageSender(self).sendToBrowser( 397 'Processes Deleted', 398 'OS processes %s were deleted.' % (', '.join(componentNames)) 399 ) 400 REQUEST['RESPONSE'].redirect(self.absolute_url()) 401 return self.callZenScreen(REQUEST)

402

403 - def unlockOSProcesses(self, componentNames=[], REQUEST=None):

404 """Unlock OSProcesses""" 405 self.unlockDeviceComponents(self.processes, componentNames, REQUEST) 406 if REQUEST: 407 messaging.IMessageSender(self).sendToBrowser( 408 'Processes Unlocked', 409 'OS Processes %s were unlocked.' % (', '.join(componentNames)) 410 ) 411 REQUEST['RESPONSE'].redirect(self.absolute_url()) 412 return self.callZenScreen(REQUEST)

413

414 - def lockOSProcessesFromDeletion(self, componentNames=[], 415 sendEventWhenBlocked=None, REQUEST=None):

416 """Lock OSProcesses from deletion""" 417 self.lockDeviceComponentsFromDeletion(self.processes, componentNames, 418 sendEventWhenBlocked, REQUEST) 419 if REQUEST: 420 messaging.IMessageSender(self).sendToBrowser( 421 'Processes Locked', 422 'OS processes %s were locked from deletion.' % ( 423 ', '.join(componentNames)) 424 ) 425 REQUEST['RESPONSE'].redirect(self.absolute_url()) 426 return self.callZenScreen(REQUEST)

427

428 - def lockOSProcessesFromUpdates(self, componentNames=[], 429 sendEventWhenBlocked=None, REQUEST=None):

430 """Lock OSProcesses from updates""" 431 self.lockDeviceComponentsFromUpdates(self.processes, componentNames, 432 sendEventWhenBlocked, REQUEST) 433 if REQUEST: 434 messaging.IMessageSender(self).sendToBrowser( 435 'Processes Locked', 436 'OS processes %s were locked from updates and deletion.' % ( 437 ', '.join(componentNames)) 438 ) 439 REQUEST['RESPONSE'].redirect(self.absolute_url()) 440 return self.callZenScreen(REQUEST)

441

442 - def addIpService(self, newClassName, protocol, userCreated, REQUEST=None):

443 """Add IpServices. 444 """ 445 org = self.dmd.Services 446 ipsc = org.unrestrictedTraverse(newClassName) 447 if ipsc is not None: 448 ips = manage_addIpService(self.ipservices, 449 ipsc.id, 450 protocol, 451 ipsc.port, 452 userCreated=userCreated) 453 self._p_changed = True 454 elif REQUEST: 455 messaging.IMessageSender(self).sendToBrowser( 456 'No Such WinService', 457 'Could not find an IP Service named %s.' % (newClassName), 458 priority=messaging.WARNING 459 ) 460 return self.callZenScreen(REQUEST) 461 462 if REQUEST: 463 messaging.IMessageSender(self).sendToBrowser( 464 'IP Service Added', 465 'IP Service %s was added.' % (newClassName) 466 ) 467 REQUEST['RESPONSE'].redirect(ips.absolute_url()) 468 return self.callZenScreen(REQUEST)

469

470 - def deleteIpServices(self, componentNames=[], REQUEST=None):

471 """Delete IpServices""" 472 self.deleteDeviceComponents(self.ipservices, componentNames, REQUEST) 473 if REQUEST: 474 messaging.IMessageSender(self).sendToBrowser( 475 'IP Services Deleted', 476 'IP Services %s were deleted.' % (', '.join(componentNames)) 477 ) 478 REQUEST['RESPONSE'].redirect(self.absolute_url()) 479 return self.callZenScreen(REQUEST)

480

481 - def unlockIpServices(self, componentNames=[], REQUEST=None):

482 """Unlock IpServices""" 483 self.unlockDeviceComponents(self.ipservices, componentNames, REQUEST) 484 if REQUEST: 485 messaging.IMessageSender(self).sendToBrowser( 486 'IpServices Unlocked', 487 'IP Services %s were unlocked.' % (', '.join(componentNames)) 488 ) 489 REQUEST['RESPONSE'].redirect(self.absolute_url()) 490 return self.callZenScreen(REQUEST)

491

492 - def lockIpServicesFromDeletion(self, componentNames=[], 493 sendEventWhenBlocked=None, REQUEST=None):

494 """Lock IpServices from deletion""" 495 self.lockDeviceComponentsFromDeletion(self.ipservices, componentNames, 496 sendEventWhenBlocked, REQUEST) 497 if REQUEST: 498 messaging.IMessageSender(self).sendToBrowser( 499 'Services Locked', 500 'IP services %s were locked from deletion.' % ( 501 ', '.join(componentNames)) 502 ) 503 REQUEST['RESPONSE'].redirect(self.absolute_url()) 504 return self.callZenScreen(REQUEST)

505

506 - def lockIpServicesFromUpdates(self, componentNames=[], 507 sendEventWhenBlocked=None, REQUEST=None):

508 """Lock IpServices from updates""" 509 self.lockDeviceComponentsFromUpdates(self.ipservices, componentNames, 510 sendEventWhenBlocked, REQUEST) 511 if REQUEST: 512 messaging.IMessageSender(self).sendToBrowser( 513 'Services Locked', 514 'IP services %s were locked from updates and deletion.' % ( 515 ', '.join(componentNames)) 516 ) 517 REQUEST['RESPONSE'].redirect(self.absolute_url()) 518 return self.callZenScreen(REQUEST)

519

520 - def addFileSystem(self, newId, userCreated, REQUEST=None):

521 """Add a FileSystem. 522 """ 523 fsid = prepId(newId) 524 manage_addFileSystem(self.filesystems, newId, userCreated) 525 self._p_changed = True 526 if REQUEST: 527 messaging.IMessageSender(self).sendToBrowser( 528 'Filesystem Added', 529 'Filesystem %s was added.' % newId 530 ) 531 REQUEST['RESPONSE'].redirect( 532 self.filesystems._getOb(fsid).absolute_url()) 533 return self.callZenScreen(REQUEST)

534

535 - def deleteFileSystems(self, componentNames=[], REQUEST=None):

536 """Delete FileSystems""" 537 self.deleteDeviceComponents(self.filesystems, componentNames, REQUEST) 538 if REQUEST: 539 messaging.IMessageSender(self).sendToBrowser( 540 'Filesystems Deleted', 541 'Filesystems %s were deleted.' % (', '.join(componentNames)) 542 ) 543 REQUEST['RESPONSE'].redirect(self.absolute_url()) 544 return self.callZenScreen(REQUEST)

545

546 - def unlockFileSystems(self, componentNames=[], REQUEST=None):

547 """Unlock FileSystems""" 548 self.unlockDeviceComponents(self.filesystems, componentNames, REQUEST) 549 if REQUEST: 550 messaging.IMessageSender(self).sendToBrowser( 551 'Filesystems Unlocked', 552 'Filesystems %s were unlocked.' % (', '.join(componentNames)) 553 ) 554 REQUEST['RESPONSE'].redirect(self.absolute_url()) 555 return self.callZenScreen(REQUEST)

556

557 - def lockFileSystemsFromDeletion(self, componentNames=[], 558 sendEventWhenBlocked=None, REQUEST=None):

559 """Lock FileSystems from deletion""" 560 self.lockDeviceComponentsFromDeletion(self.filesystems, componentNames, 561 sendEventWhenBlocked, REQUEST) 562 if REQUEST: 563 messaging.IMessageSender(self).sendToBrowser( 564 'Filesystems Locked', 565 'Filesystems %s were locked from deletion.' % ( 566 ', '.join(componentNames)) 567 ) 568 REQUEST['RESPONSE'].redirect(self.absolute_url()) 569 return self.callZenScreen(REQUEST)

570

571 - def lockFileSystemsFromUpdates(self, componentNames=[], 572 sendEventWhenBlocked=None, REQUEST=None):

573 """Lock FileSystems from updates""" 574 self.lockDeviceComponentsFromUpdates(self.filesystems, componentNames, 575 sendEventWhenBlocked, REQUEST) 576 if REQUEST: 577 messaging.IMessageSender(self).sendToBrowser( 578 'Filesystems Locked', 579 'Filesystems %s were locked from updates and deletion.' % ( 580 ', '.join(componentNames)) 581 ) 582 REQUEST['RESPONSE'].redirect(self.absolute_url()) 583 return self.callZenScreen(REQUEST)

584

585 - def addIpRouteEntry(self, dest, routemask, nexthopid, interface, 586 routeproto, routetype, userCreated, REQUEST=None):

587 """Add an IpRouteEntry. 588 """ 589 manage_addIpRouteEntry(self.routes, 590 dest, 591 routemask, 592 nexthopid, 593 interface, 594 routeproto, 595 routetype, 596 userCreated=userCreated) 597 self._p_changed = True 598 if REQUEST: 599 messaging.IMessageSender(self).sendToBrowser( 600 'Route Created', 601 'IP route entry was created.' 602 ) 603 REQUEST['RESPONSE'].redirect(self.absolute_url()) 604 return self.callZenScreen(REQUEST)

605

606 - def deleteIpRouteEntries(self, componentNames=[], REQUEST=None):

607 """Delete IpRouteEntries""" 608 self.deleteDeviceComponents(self.routes, componentNames, REQUEST) 609 if REQUEST: 610 messaging.IMessageSender(self).sendToBrowser( 611 'Routes Deleted', 612 'IP route entries %s were deleted.' % (', '.join(componentNames)) 613 ) 614 REQUEST['RESPONSE'].redirect(self.absolute_url()) 615 return self.callZenScreen(REQUEST)

616

617 - def unlockIpRouteEntries(self, componentNames=[], REQUEST=None):

618 """Unlock IpRouteEntries""" 619 self.unlockDeviceComponents(self.routes, componentNames, REQUEST) 620 if REQUEST: 621 messaging.IMessageSender(self).sendToBrowser( 622 'Routes Unlocked', 623 'IP route entries %s were unlocked.' % ( 624 ', '.join(componentNames)) 625 ) 626 REQUEST['RESPONSE'].redirect(self.absolute_url()) 627 return self.callZenScreen(REQUEST)

628

629 - def lockIpRouteEntriesFromDeletion(self, componentNames=[], 630 sendEventWhenBlocked=None, REQUEST=None):

631 """Lock IpRouteEntries from deletion""" 632 self.lockDeviceComponentsFromDeletion(self.routes, componentNames, 633 sendEventWhenBlocked, REQUEST) 634 if REQUEST: 635 messaging.IMessageSender(self).sendToBrowser( 636 'Routes Locked', 637 'IP route entries %s were locked from deletion.' % ( 638 ', '.join(componentNames)) 639 ) 640 REQUEST['RESPONSE'].redirect(self.absolute_url()) 641 return self.callZenScreen(REQUEST)

642

643 - def lockIpRouteEntriesFromUpdates(self, componentNames=[], 644 sendEventWhenBlocked=None, REQUEST=None):

645 """Lock IpRouteEntries from updates""" 646 self.lockDeviceComponentsFromUpdates(self.routes, componentNames, 647 sendEventWhenBlocked, REQUEST) 648 if REQUEST: 649 messaging.IMessageSender(self).sendToBrowser( 650 'Routes Locked', 651 'IP route entries %s were locked from updates and deletion.' % ( 652 ', '.join(componentNames)) 653 ) 654 REQUEST['RESPONSE'].redirect(self.absolute_url()) 655 return self.callZenScreen(REQUEST)

Source Code for Module Products.ZenModel.OperatingSystem