lib/python/Screens/NetworkSetup.py

   1 from Screen import Screen
   2 from Components.ActionMap import ActionMap
   3 from Components.ConfigList import ConfigListScreen
   4 from Components.config import config, getConfigListEntry
   5 from Components.Network import iNetwork
   6 from Components.Label import Label
   7 from Components.MenuList import MenuList
   8 from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigNothing
   9 from Components.PluginComponent import plugins
  10 from Plugins.Plugin import PluginDescriptor
  11
  12
  13 class NetworkAdapterSelection(Screen):
  14         def __init__(self, session):
  15                 Screen.__init__(self, session)
  16
  17                 self["adapterlist"] = MenuList([(self.getFriendlyName(x),x) for x in iNetwork.getAdapterList()])
  18
  19                 self["actions"] = ActionMap(["OkCancelActions"],
  20                 {
  21                         "ok": self.okbuttonClick ,
  22                         "cancel": self.close
  23                 })
  24
  25         def getFriendlyName(self, x):
  26                 # maybe this needs to be replaced by an external list.
  27                 friendlyNames = {
  28                         "eth0": _("Integrated Ethernet"),
  29                         "wlan0": _("Wireless")
  30                 }
  31
  32                 return friendlyNames.get(x, x) # when we have no friendly name, use adapter name
  33
  34         def okbuttonClick(self):
  35                 selection = self["adapterlist"].getCurrent()
  36                 if selection is not None:
  37                         self.session.open(AdapterSetup, selection[1])
  38
  39 class NameserverSetup(Screen, ConfigListScreen):
  40         def __init__(self, session):
  41                 Screen.__init__(self, session)
  42                 self.backupNameserverList = iNetwork.getNameserverList()[:]
  43                 print "backup-list:", self.backupNameserverList
  44
  45                 self["red"] = Label(_("Delete"))
  46                 self["green"] = Label(_("Add"))
  47
  48                 self.createConfig()
  49
  50                 self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
  51                 {
  52                         "ok": self.ok,
  53                         "cancel": self.cancel,
  54                         "green": self.add,
  55                         "red": self.remove
  56                 }, -2)
  57
  58                 self.list = []
  59                 ConfigListScreen.__init__(self, self.list)
  60                 self.createSetup()
  61
  62         def createConfig(self):
  63                 self.nameservers = iNetwork.getNameserverList()
  64                 self.nameserverEntries = []
  65
  66                 for nameserver in self.nameservers:
  67                         self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
  68
  69         def createSetup(self):
  70                 self.list = []
  71
  72                 #self.nameserverConfigEntries = []
  73                 for i in range(len(self.nameserverEntries)):
  74                         self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i]))
  75
  76                 self["config"].list = self.list
  77                 self["config"].l.setList(self.list)
  78
  79         def ok(self):
  80                 iNetwork.clearNameservers()
  81                 for nameserver in self.nameserverEntries:
  82                         iNetwork.addNameserver(nameserver.value)
  83                 iNetwork.writeNameserverConfig()
  84                 self.close()
  85
  86         def cancel(self):
  87                 iNetwork.clearNameservers()
  88                 print "backup-list:", self.backupNameserverList
  89                 for nameserver in self.backupNameserverList:
  90                         iNetwork.addNameserver(nameserver)
  91                 self.close()
  92
  93         def add(self):
  94                 iNetwork.addNameserver([0,0,0,0])
  95                 self.createConfig()
  96                 self.createSetup()
  97
  98         def remove(self):
  99                 print "currentIndex:", self["config"].getCurrentIndex()
 100
 101                 index = self["config"].getCurrentIndex()
 102                 if index < len(self.nameservers):
 103                         iNetwork.removeNameserver(self.nameservers[index])
 104                         self.createConfig()
 105                         self.createSetup()
 106
 107
 108 class AdapterSetup(Screen, ConfigListScreen):
 109         def __init__(self, session, iface):
 110                 Screen.__init__(self, session)
 111
 112                 self.iface = iface
 113
 114                 print iNetwork.getAdapterAttribute(self.iface, "dhcp")
 115                 self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp")))
 116                 self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=True))
 117                 self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")))
 118                 self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask")))
 119                 self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway")))
 120
 121                 self["iface"] = Label(iNetwork.getAdapterName(self.iface))
 122
 123                 self["actions"] = ActionMap(["SetupActions"],
 124                 {
 125                         "ok": self.ok,
 126                         "cancel": self.cancel,
 127                 }, -2)
 128
 129                 self.list = []
 130                 ConfigListScreen.__init__(self, self.list)
 131                 self.createSetup()
 132
 133                 self["introduction"] = Label(_("Press OK to activate the settings."))
 134
 135         def createSetup(self):
 136                 self.list = []
 137
 138                 self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
 139                 self.list.append(self.dhcpEntry)
 140                 if not self.dhcpConfigEntry.value:
 141                         self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
 142                         self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
 143                         self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry))
 144                         if self.hasGatewayConfigEntry.value:
 145                                 self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 146
 147                 self.extended = None
 148                 self.extendedSetup = None
 149                 for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
 150                         callFnc = p.__call__["ifaceSupported"](self.iface)
 151                         if callFnc is not None:
 152                                 self.extended = callFnc
 153                                 print p.__call__
 154                                 if p.__call__.has_key("configStrings"):
 155                                         self.configStrings = p.__call__["configStrings"]
 156                                 else:
 157                                         self.configStrings = None
 158
 159                                 if p.__call__.has_key("menuEntryName"):
 160                                         menuEntryName = p.__call__["menuEntryName"](self.iface)
 161                                 else:
 162                                         menuEntryName = _('Extended Setup...')
 163                                 self.extendedSetup = getConfigListEntry(menuEntryName, NoSave(ConfigNothing()))
 164                                 self.list.append(self.extendedSetup)
 165
 166                 self["config"].list = self.list
 167                 self["config"].l.setList(self.list)
 168
 169         def newConfig(self):
 170                 print self["config"].getCurrent()
 171                 if self["config"].getCurrent() == self.dhcpEntry:
 172                         self.createSetup()
 173
 174         def keyLeft(self):
 175                 ConfigListScreen.keyLeft(self)
 176                 self.createSetup()
 177
 178         def keyRight(self):
 179                 ConfigListScreen.keyRight(self)
 180                 self.createSetup()
 181
 182         def ok(self):
 183                 selection = self["config"].getCurrent()
 184                 if selection == self.extendedSetup:
 185                         self.extended(self.session, self.iface)
 186                 else:
 187                         iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
 188                         iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
 189                         iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
 190                         if self.hasGatewayConfigEntry.value:
 191                                 iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
 192                         else:
 193                                 iNetwork.removeAdapterAttribute(self.iface, "gateway")
 194
 195                         if self.extended is not None and self.configStrings is not None:
 196                                 iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
 197
 198                         iNetwork.deactivateNetworkConfig()
 199                         iNetwork.writeNetworkConfig()
 200                         iNetwork.activateNetworkConfig()
 201                         self.close()
 202
 203         def cancel(self):
 204                 iNetwork.getInterfaces()
 205                 self.close()