示例#1
0
class ConfigWin:
    # variables de clase
    objPropiedades = None
    objRegistro = None

    def __init__(self):

        #Init Glade Builder
        builder = gtk.Builder()
        ficherin = os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), 'indicador-proxy.glade')
        builder.add_from_file(ficherin)
        
        #Connect signals to builder
        self.window = builder.get_object('window1')
        builder.connect_signals(self)

        # Get components from builder
        self.servidor = builder.get_object('te_servidor')
        self.puerto   = builder.get_object('te_puerto')
        self.aut      = builder.get_object('cb_aut')
        self.usuario  = builder.get_object('te_usuario')
        self.clave    = builder.get_object('te_clave')
        self.clave    = builder.get_object('te_clave')
        self.apt      = builder.get_object('cb_apt')
        self.excep    = builder.get_object('te_excep')
        self.git      = builder.get_object('cb_git')
        self.docker   = builder.get_object('cb_docker')

        # fichero de configuración
        self.objPropiedades = Propiedades()
        # acceso al registro
        self.objRegistro = Registro()

        # muestra la configuracion. Rellenamos los campos
        self.servidor.set_text(self.objRegistro.getHost())
        self.puerto.set_text(self.objRegistro.getPort())
        self.usuario.set_text(self.objRegistro.getUser())
        self.clave.set_text(self.objRegistro.getPassword())
        self.excep.set_text(self.objRegistro.getIgnoreList())
        self.aut.set_active(self.objRegistro.getAuthentication())
        
        a=self.objPropiedades.lee("proxy_apt")
        b=self.objPropiedades.lee("proxy_git")
        c=self.objPropiedades.lee("proxy_docker")
        self.apt.set_active(False)
        self.git.set_active(False)
        self.docker.set_active(False)
        if (a == "True"):
            self.apt.set_active(True)

        if (b == "True"):
            self.git.set_active(True)

        if (c == "True"):
            self.docker.set_active(True)


    def show(self):
        self.window.show()

    def b_aceptar_clicked(self, button):
        self.objRegistro.setIgnoreList(self.excep.get_text())
        self.objRegistro.setHost(self.servidor.get_text())
        self.objRegistro.setPort(self.puerto.get_text())
        self.objRegistro.setAuthentication(self.aut.get_active())
        self.objRegistro.setUser(self.usuario.get_text())
        self.objRegistro.setPassword(self.clave.get_text())

        value = self.apt.get_active()
        self.objPropiedades.escribe("proxy_apt", str(value))
        value = self.git.get_active()
        self.objPropiedades.escribe("proxy_git", str(value))
        value = self.docker.get_active()
        self.objPropiedades.escribe("proxy_docker", str(value))


        self.window.destroy()

    def b_cancelar_clicked(self, button):
        self.window.destroy()

    def cb_aut_toggled(self, button):
        value = button.get_active()
        self.usuario.set_sensitive(value)
        self.clave.set_sensitive(value)

    def cb_apt_toggled(self, button):
        value = button.get_active()

    def cb_git_toggled(self, button):
        value = button.get_active()

    def cb_docker_toggled(self, button):
        value = button.get_active()
示例#2
0
class IndicadorProxy:
    configWin = None
    objRegistro = None
    objPropiedades = None
    strCmd = ""
    ficheros = []
    usarSudo = False
      
    def __init__(self):
        # fichero de propiedades
        self.objPropiedades = Propiedades()

        # acceso al registro dconf
        self.objRegistro = Registro()

        # leer el estado del proxy
        estado_proxy=self.objRegistro.getStatus()
        print("[INFO]:  Estado del proxy: " + estado_proxy)

        #limpiando ficheros (aunque puede que aquí no sea suficiente)
        os.system("bash -c 'rm *.temp 2>/dev/null 1> /dev/null '")

        # configuración del icono
        self.ind = appindicator.Indicator.new("indicador-proxy", "estado del proxy", appindicator.IndicatorCategory.APPLICATION_STATUS)
        base_dir=os.path.abspath(os.path.dirname(sys.argv[0]))
        print "[INFO]:  directorio: ", base_dir

        self.ind.set_icon(os.path.join(base_dir,'ind-con-proxy.png'))
        self.ind.set_attention_icon (os.path.join(base_dir,'ind-sin-proxy.png'))
        self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
        if estado_proxy == "none":
            self.ind.set_status(appindicator.IndicatorStatus.ATTENTION)

        # establece el menú de la aplicación
        self.menu_setup(estado_proxy)
        self.ind.set_menu(self.menu)

    def menu_setup(self, estado_proxy):
        self.menu = gtk.Menu()

        self.menu_activar = gtk.MenuItem("Usar proxy")
        self.menu_activar.connect("activate", self.activa_proxy)
        self.menu.append(self.menu_activar)
        self.menu_desactivar = gtk.MenuItem("Sin proxy")
        self.menu_desactivar.connect("activate", self.desactiva_proxy)
        self.menu.append(self.menu_desactivar)

        if estado_proxy == "none":	
            self.menu_activar.show()
        else:
            self.menu_desactivar.show()

        self.blanco_item = gtk.MenuItem()
        self.blanco_item.show()
        self.menu.append(self.blanco_item)

        self.menu_configurar = gtk.MenuItem("Configurar")
        self.menu_configurar.connect("activate", self.configurar)

        self.menu.append(self.menu_configurar)
        self.menu_configurar.show()

        # self.menu_prueba = gtk.MenuItem("Prueba")
        # self.menu_prueba.connect("activate", self.prueba)
        # self.menu.append(self.menu_prueba)
        # self.menu_prueba.show()

        self.blanco_item = gtk.MenuItem()
        self.blanco_item.show()
        self.menu.append(self.blanco_item)

        self.quit_item = gtk.MenuItem("Quit")
        self.quit_item.connect("activate", self.quit)
        self.quit_item.show()
        self.menu.append(self.quit_item)

    def quit(self, widget):
        sys.exit(0)

    def  activa_proxy(self, widget):
        print("[DEBUG]: Activar proxy")

        self.ficheros = []
        self.usarSudo = False  #de momento false durante la ejecución ya se verá
        # leer información del registro
        servidor = self.objRegistro.getHost()
        puerto   = self.objRegistro.getPort()
        usuario  = None
        clave    = None
        if self.objRegistro.getAuthentication() == "True":
            usuario  = self.objRegistro.getUser()
            clave    = self.objRegistro.getPassword()
        noproxy  = self.objRegistro.getIgnoreList()



        # estableciendo proxy para aplicaciones de consola (.bashrc)                
        self.pon_proxy_bashrc(servidor, puerto, usuario, clave, noproxy)

        
        if (self.objPropiedades.lee("proxy_apt") == "True"):
            # Establece el proxy para 'apt-conf'
            self.pon_proxy_apt_conf(servidor, puerto, usuario, clave, noproxy)

        if (self.objPropiedades.lee("proxy_git") == "True"):
            # Establece el proxy para 'git'
            self.pon_proxy_git(servidor, puerto, usuario, clave)

        if (self.objPropiedades.lee("proxy_docker") == "True" ):
            # Establece el proxy para 'docker'
            self.pon_proxy_docker(servidor, puerto, usuario, clave, noproxy)

        # escribe las modificaciones en los ficheros si todo está OK
        if (self.modifica_ficheros()):
            # activa en el registro el proxy
            self.objRegistro.setStatus('manual')
            # modificando menu e icono
            self.menu_activar.hide()
            self.menu_desactivar.show()
            self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
       
    def desactiva_proxy(self, widget):
        self.ficheros = []
        self.usarSudo = False  #de momento false durante la ejecución ya se verá

        # Desactivando el proxy para las aplicaciones de consola (.bashrc)
        self.quita_proxy_bashrc()      
        self.quita_proxy_apt_conf()    
        self.quita_proxy_git()         
        self.quita_proxy_docker()      

        # escribe las modificaciones en los ficheros si todo está OK
        if (self.modifica_ficheros()):
            # Desactivando el proxy en el registro
            self.objRegistro.setStatus('none')
            # modificando menu e icono
            self.menu_activar.show()
            self.menu_desactivar.hide()
            self.ind.set_status(appindicator.IndicatorStatus.ATTENTION)

    #solicita clave para copiar ficheros del sitema
    # devuelve true si todo está ok sino devuelve False
    def modifica_ficheros(self):
        var=0

        comando= "bash -c '"
        if len(self.ficheros)>0:
            if self.usarSudo:
                comando =  "gksudo -m 'Se requiere su contraseña para realizar los cambios en el sistema' -- bash -c '"

            s = len(self.ficheros)
            for c in xrange(0,s,2):
                comando += "cp " + self.ficheros[c+1] + ' ' + self.ficheros[c] + "; "
            comando += "'"

            var = os.system(comando)
            s = len(self.ficheros)
            for c in xrange(0,s,2):
                os.remove(self.ficheros[c+1])

        retorno= True
        if (var != 0):
            retorno=False

        return retorno

    # Opción al seleccionar 'configurar'
    def configurar(self, widget):
        if self.configWin is None:
            self.configWin = ConfigWin()
        else:
            self.configWin.__init__()
        self.configWin.show()

    # Opción que se lanza al seleccionar el menú prueba
    def prueba(self, widget):
        print ("[DEBUG]  Prueba")
       
    # Activa el proxy en el fichero ~/.bashrc
    def pon_proxy_bashrc(self, proxy, puerto, usuario, clave, noproxy):
        home = expanduser("~")
        f = home+"/.bashrc"
        print "[DEBUG]: establecer proxy en ", f
        try:
            fichero = open(f, "a")
            if (usuario):
                fichero.write("export HTTP_PROXY=\"http://%s:%s@%s:%s\"\n" % (usuario, clave, proxy, puerto))
                fichero.write("export HTTPS_PROXY=\"https://%s:%s@%s:%s\"\n" % (usuario, clave, proxy, puerto))
                fichero.write("export FTP_PROXY=\"ftp://%s:%s@%s:%s\"\n" % (usuario, clave, proxy, puerto))
            else:
                fichero.write("export HTTP_PROXY=\"http://%s:%s\"\n" % (proxy, puerto))
                fichero.write("export HTTPS_PROXY=\"https://%s:%s\"\n" % (proxy, puerto))
                fichero.write("export FTP_PROXY=\"ftp://%s:%s\"\n" % (proxy, puerto))

            fichero.write("export NO_PROXY=\"%s\"\n" % (noproxy))
            fichero.close()
        except Exception, e:
            print "[ERROR]:  except en pon_proxy_bashrc: %s" % e
            pass