AHM - Ansible Host Manager

#!/usr/bin/python3

## @package ansiblehostmanager

#  AHM, Ansible Hosts Manager is a python 3 interface to manage the inventory file (hosts file) of ansible

#

#

from PyQt4 import QtGui, QtCore

import sys, re, traceback, os.path, time

import interface_ansible

## Special groups

ungrouped = "ungrouped"

alls = "all"

specials = [ungrouped,alls]

## Class derived from QListWidget

class MyQListWidget(QtGui.QListWidget):

    def __init__(self, parent=None, def_name=None):

        if def_name is None:

            (filename, line_number, function_name, text) = traceback.extract_stack()[-2]

            def_name = text[:text.find('=')].strip().lstrip("self.")

            self.defined_name = def_name

        super(MyQListWidget, self).__init__(parent)

        self.acceptfrom = []

        self.setDragDropMode(QtGui.QAbstractItemView.DragDrop)

        self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)

        #self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)

        self.setAcceptDrops(True)

        ### be careful #self.itemPressed.connect(self.item_Press)

        self.selectedItem = ""

        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.onrightclick)

    ## Implementation of right click

    # Will be used to delete objects

    def onrightclick(self, pos):

        self.emit(QtCore.SIGNAL("rightclick"), pos)

    def dragEnterEvent(self, event):

        if event.mimeData().hasUrls():

            event.accept()

        else:

            super(MyQListWidget, self).dragEnterEvent(event)

            event.accept()

    def dragMoveEvent(self, event):

        if event.mimeData().hasUrls():

            event.setDropAction(QtCore.Qt.CopyAction)

            event.accept()

        else:

            super(MyQListWidget, self).dragMoveEvent(event)

            event.accept()

    def dropEvent(self, event):

        if (event.source().defined_name in self.acceptfrom) or (event.source().defined_name == self.defined_name):

            if event.mimeData().hasUrls():

                event.setDropAction(QtCore.Qt.MoveAction)

                event.accept()

                links = []

                for url in event.mimeData().urls():

                    links.append(str(url.toLocalFile()))

                self.emit(QtCore.SIGNAL("dropped"), links)

            else:

                event.setDropAction(QtCore.Qt.MoveAction)

                super(MyQListWidget, self).dropEvent(event)

                self.emit(QtCore.SIGNAL("dropped"), event.source().defined_name)

                event.accept()

                # self.emit(QtCore.SIGNAL("inserted"))

    ## Catch events

    # Raise signal "modified" when child is removed.

    # This ensure that all the drag and drop events are finished so the lists are up to date

    def event(self, QEvent):

        res = super(MyQListWidget, self).event(QEvent)

        #Raise signal modified when QEvent.type = ChildRemoved

        if QEvent.type() == QtCore.QEvent.ChildRemoved :

            self.emit(QtCore.SIGNAL("modified"))

        return res

    ## Return all the items as a list

    def getallitems(self):

        items = []

        for index in range(self.count()):

            items.append(self.item(index))

        return items

## Class to manage all the data of the Ansible hosts file

class AnsibleHostFile(object):

    ## Constructor

    # Structure of the datas is the following:

    # hosts : list of all hosts names

    # groups : list of all groups names

    # cgroups : list of all cgroups (children groups) names

    # attributes : list of all attributes

    # grouphosts : dictionary with group name as key and list of hosts in that group as value

    # cgroupgroups : dictionary with cgroup name as key and list of groups or cgroups in that cgroup as value

    # groupattributes : dictionary with group or cgroup name as key and list of attributes for that group/cgroup

    # hostattributes : dictionary with host name as key and list of attributes for that host

    def __init__(self):

        self.hosts = []

        self.groups = []

        self.cgroups = []

        self.attributes = []

        self.grouphosts = {}

        self.cgroupgroups = {}

        self.groupattributes = {}

#        self.cgroupcgroups = {}

        self.hostattributes = {}

        for gr in specials:

            self.addgroup(gr)

    def reset(self):

        self.groups.clear()

        self.hosts.clear()

        self.attributes.clear()

        self.cgroups.clear()

        self.grouphosts.clear()

        self.groupattributes.clear()

        self.cgroupgroups.clear()

        self.hostattributes.clear()

        for gr in specials:

            self.addgroup(gr)

    ## Function to check integrity of data

    # It will check that same name is not use for host, group or cgroup and that members in cgroups are really defined as group or cgroup

    def check_integrity(self):

        message = ""

        for host in self.hosts:

            message += self.check_hostname(host)

        for group in self.groups:

            message += self.check_groupname(group)

        #groups in cgroupgroups have to be a group or cgroup

        for cgroup, groups in self.cgroupgroups.items():

            for group in groups:

                if group not in self.groups and group not in self.cgroups :

                    message += "\nError : group " + group + " appears in Cgroup "+cgroup+" but is not defined."

        return "\n".join(set(message.split('\n')))

    ## Check that host name is not already used as group or cgroup name

    def check_hostname(self,host):

        message = ""

        if host in self.groups:

            message += "\nDuplicate name : " + host + " defined as host and group"

        if host in self.cgroups:

            message += "\nDuplicate name : " + host + " defined as host and Cgroup"

        return message

    ## Check that group name is not already used as host or cgroup name

    def check_groupname(self,group):

        message = ""

        if group in self.hosts:

            message += "\nDuplicate name : " + group + " defined as host and group"

        if group in self.cgroups:

            message += "\nDuplicate name : " + group + " defined as group and Cgroup"

        return message

    ## Check that cgroup name is not already used as host or group name

    def check_cgroupname(self,cgroup):

        message = ""

        if cgroup in self.hosts:

            message += "\nDuplicate name : " + cgroup + " defined as host and group"

        if cgroup in self.groups:

            message += "\nDuplicate name : " + cgroup + " defined as group and Cgroup"

        return message

    ## Add host to the list of hosts

    def addhost(self, host):

        if host not in self.hosts:

            self.hosts.append(host)

    ## Return the list of hosts

    def gethosts(self):

        return self.hosts

    ## Return hostname if in hosts list or None if not

    def gethost(self, hostname):

        if hostname in self.hosts:

            return hostname

        else:

            return None

    ## Delete host from list of hosts and from group it was in

    def delhost(self, host):

        if host in self.hosts:

            self.hosts.remove(host)

        for group in self.grouphosts:

            self.delhosttogroup(host, group)

    ## Add new group in list of groups (and in grouphosts)

    def addgroup(self, group):

        if group not in self.groups:

            self.groups.append(group)

        if group not in self.grouphosts:

            grouphost = self.grouphosts.setdefault(group, [])

    ## Delete a group from groups list and from grouphosts and cgroupgroups

    def delgroup(self, group):

        if group in specials:

            return

        if group in self.groups:

            self.groups.remove(group)

        del self.grouphosts[group]

        for cgroup in self.cgroupgroups:

            self.delgrouptocgroup(group,cgroup)

    ## Return group if it exists or None if not

    def getgroup(self, group):

        if group in self.groups:

            return group

        else:

            return None

    ## Return all groups

    def getgroups(self):

        return self.groups

    ## Add new cgroup in list of cgroups (and in cgroupgroups)

    def addcgroup(self, cgroup):

        if cgroup not in self.cgroups:

            self.cgroups.append(cgroup)

        if cgroup not in self.cgroupgroups:

            cgroupgroups = self.cgroupgroups.setdefault(cgroup, [])

    ## Delete cgroup

    def delcgroup(self, cgroup):

        if cgroup in self.cgroups:

            self.cgroups.remove(cgroup)

        del self.cgroupgroups[cgroup]

    ## Return cgroup if it exists or None if not

    def getcgroup(self, cgroup):

        if cgroup in self.cgroups:

            return cgroup

        else:

            return None

    ## Return all cgroups

    def getcgroups(self):

        return self.cgroups

    ## Add attribute to the list of attributes

    def addattribute(self, attribute):

        if attribute not in self.attributes:

            self.attributes.append(attribute)

        #        self.attributes.update({attribute.name:attribute})

    ## Delete attribute

    def delattribute(self, attribute):

        if attribute in self.attributes:

            self.attributes.remove(attribute)

            for group in self.groupattributes:

                self.delattributetogroup(attribute,group)

                self.delattributetocgroup(attribute,group)

            for host in self.hostattributes:

                self.delattributetohost(attribute,host)

    ## Return all attributes

    def getattributes(self):

        return self.attributes

    ## Return all attributes

    def gethostsattributes(self):

        return self.attributes

    ## Return attribute if it exists or None if not

    def getattribute(self, attribute):

        if attribute in self.attributes:

            return attribute

        else:

            return None

    ## Add host to group

    def addhosttogroup(self, host, group):

        #self.addgroup(group)

        #self.addhost(host)

        grouphost = self.grouphosts.setdefault(group, [])

        if host not in grouphost:

            grouphost.append(host)

    ## Add group to host

    def addgrouptohost(self, group, host):

        self.addhosttogroup(host, group)

    ## Remove host from group

    def delhosttogroup(self, host, group):

        grouphost = self.grouphosts.setdefault(group, [])

        if host in grouphost:

            grouphost.remove(host)

    ## Add group to cgroup

    def addgrouptocgroup(self, group, cgroup):

        #self.addgroup(group)

        #self.addcgroup(cgroup)

        cgroupgroups = self.cgroupgroups.setdefault(cgroup, [])

        if group not in cgroupgroups:

            cgroupgroups.append(group)

    ## Remove group from cgroup

    def delgrouptocgroup(self, group, cgroup):

        cgroupgroups = self.cgroupgroups.setdefault(cgroup, [])

        if group in cgroupgroups:

            cgroupgroups.remove(group)

    ## Add attribute to host

    def addattributetohost(self, attribute, host):

        #self.addattribute(attribute)

        #self.addhost(host)

        attributes = self.hostattributes.setdefault(host, [])

        if attribute not in attributes:

            attributes.append(attribute)

            # self.hostattributes.update({host.name:attribute.name})

    ## Remove attribute from host

    def delattributetohost(self, attribute, host):

        hostattributes = self.hostattributes.setdefault(host, [])

        if attribute in hostattributes:

            hostattributes.remove(attribute)

    ## Add attribute to group

    def addattributetogroup(self, attribute, group):

        self.addattribute(attribute)

        #self.addgroup(group)

        groupattribute = self.groupattributes.setdefault(group, [])

        if attribute not in groupattribute:

            groupattribute.append(attribute)

            # self.groupattributes.update({group.name:attribute.name})

    ## Remove attribute from group

    def delattributetogroup(self, attribute, group):

        groupattributes = self.groupattributes.setdefault(group, [])

        if attribute in groupattributes:

            groupattributes.remove(attribute)

    ## Add attribute to cgroup

    def addattributetocgroup(self, attribute, cgroup):

        #self.addattribute(attribute)

        #self.addgroup(group)

        cgroupattribute = self.groupattributes.setdefault(cgroup, [])

        if attribute not in cgroupattribute:

            cgroupattribute.append(attribute)

            # self.groupattributes.update({group.name:attribute.name})

    ## Remove attribute from cgroup

    def delattributetocgroup(self, attribute, cgroup):

        cgroupattributes = self.groupattributes.setdefault(cgroup, [])

        if attribute in cgroupattributes:

            cgroupattributes.remove(attribute)

    ## Return dictionary with group name as key and hostname as value for the required host name

    def getgroupsforhost(self, hostname):

        subdict = dict((k, v) for k, v in self.grouphosts.items() if hostname in v)

        return subdict

    ## Return dictionary with cgroup name as key and group name as value for the required cgroup name

    def getgroupforcgroup(self, cgroup):

        subdict = dict((k, v) for k, v in self.cgroupgroups.items() if cgroup == k)

        return subdict

#    def getcgroupforcgroup(self, cgroup):

#        subdict = dict((k, v) for k, v in self.cgroupcgroups.items() if cgroup == k)

#        return subdict

    ## Return dictionary with group name as key and attribute as value for the required attribute

    def getgroupforattribute(self, attribute):

        subdict1 = dict((k, v) for k, v in self.groupattributes.items() if attribute in v)

        #need to filter group (and not cgroup)

        subdict = dict((k, v) for k, v in subdict1.items() if k in self.groups)

        return subdict

    ## Return dictionary with cgroup name as key and attribute as value for the required attribute

    def getcgroupforattribute(self, attribute):

        subdict1 = dict((k, v) for k, v in self.groupattributes.items() if attribute in v)

        #need to filter cgroup (and not group)

        subdict = dict((k, v) for k, v in subdict1.items() if k in self.cgroups)

        return subdict

    ## Return dictionary with host name as key and attribute as value for the required host name

    def getattributesforhost(self, hostname):

        subdict = dict((k, v) for k, v in self.hostattributes.items() if hostname == k)

        return subdict

    ## Return dictionary with host name as key and attribute as value for the required attribute

    def gethostsforattribute(self, attributename):

        subdict = dict((k, v) for k, v in self.hostattributes.items() if attributename in v)

        return subdict

    ## Return dictionary with group name as key and attribute as value for required the group name

    def getattributesforgroup(self,groupname):

        subdict = dict((k, v) for k, v in self.groupattributes.items() if groupname == k)

        return subdict

    ## Return dictionary with group name as key and host name as value for required the group name

    def gethostsforgroup(self, groupname):

        subdict = dict((k, v) for k, v in self.grouphosts.items() if groupname == k)

        return subdict

    ## Return a sorted list

    def get_items(self,liste):

        #return liste.items()

        return sorted(liste.items())

    ## Function to generate the ansible host file

    # It will first check the integrity of the date and eventually include some warnings

    # then it will list all ungroupped hosts

    # then attributes for group "all"

    # then groups in alphabetical order

    # then cgroups in alphabetical order

    def export_ansible(self):

        self.update_ungroupped()

        export = "# Ansible host file generated by the Ansible Hosts Manager \n"

        check_integrity_msg = self.check_integrity()

        if check_integrity_msg is not "":

            export += "\n#Check integrity result:"

            export += check_integrity_msg.replace("\n","\n#")+"\n\n"

        # We start by ungrouped and follow by all then the rest

        group = self.grouphosts.setdefault(ungrouped, [])

        for host in group:

            export += host + " "

            attributes = self.hostattributes.setdefault(host, [])

            for attribute in sorted(attributes):

                export += " " + attribute

            export += "\n"

        listattr = ""

        # Variable for group all

        attributes = self.groupattributes.setdefault(alls, [])

        if group is not None:

            for attribute in attributes:

                listattr += attribute+"\n"

            if listattr != "":

                        export += "\n[" + alls + ":vars]\n"+listattr

        # All groups and groups vars (attributes)

        for group in self.get_items(self.grouphosts):

            #if group[0] == alls:

            #    if group[0] in self.groupattributes:

            #        for attribute in sorted(self.groupattributes[group[0]]):

            #            listattr += attribute+"\n"

            #        if listattr != "":

            #            export += "\n[" + group[0] + ":vars]\n"+listattr

            if group[0] not in specials:

                export += "\n[" + group[0] + "]\n"

                for host in group[1]:

                    export += host

                    attributes = self.hostattributes.setdefault(host, [])

                    for attribute in sorted(attributes):

                        export += " " + attribute

                    export += "\n"

                listattr = ""

                if group[0] in self.groupattributes:

                    for attribute in sorted(self.groupattributes[group[0]]):

                        listattr += attribute+"\n"

                    if listattr != "":

                        export += "\n[" + group[0] + ":vars]\n"+listattr

        # All cgroups and vars

        for cgroup in self.get_items(self.cgroupgroups):

            export += "\n[" + cgroup[0] + ":children]\n"

            for group in cgroup[1]:

                export += group + "\n"

                #attributes = self.hostattributes.setdefault(group, [])

                #for attribute in sorted(attributes):

                #    export += " ------------------------------ " + attribute

                #export += "\n"

            listattr = ""

            if cgroup[0] in self.groupattributes:

                for attribute in sorted(self.groupattributes[cgroup[0]]):

                    listattr += attribute+"\n"

                if listattr != "":

                    export += "\n[" + cgroup[0] + ":vars]\n"+listattr

        return export

    ## Function to manage the list of "ungroupped" hosts.

    # It will search for the presence of any host in the grouphost list

    # and put hosts which are not in a group in the "ungroupped" group

    def update_ungroupped(self):

        for host in self.gethosts():

            for group in self.getgroupsforhost(host):

                # If host is in a group (not ungroupped) then remove it from ungroupped

                if group != ungrouped:

                    self.delhosttogroup(host,ungrouped)

                    break

            else:

                self.addhosttogroup(host,ungrouped)

## Class to manage the graphic interface

class ImageViewer(QtGui.QMainWindow, interface_ansible.Ui_MainWindow):

    def __init__(self, parent=None):

        super(ImageViewer, self).__init__(parent)

        self.ansible = AnsibleHostFile()

        self.setupUi(self)

        # Define connectors

        self.tabs.currentChanged.connect(self.ontabchange)

        self.actionload_hostsfile.triggered.connect(self.load_hostsfile)

        self.Loadhostfile.clicked.connect(self.load_hostsfile)

        self.actionSauver.triggered.connect(self.save_hostsfile)

        self.Savehostfile.clicked.connect(self.save_hostsfile)

        self.actionQuitter.triggered.connect(self.quit)

        # Tab Hosts

        QtCore.QObject.connect(self.addhost, QtCore.SIGNAL("clicked()"), self.clic_addnewhost)

        QtCore.QObject.connect(self.hosttoadd, QtCore.SIGNAL("returnPressed()"), self.clic_addnewhost)

        self.hostslist.itemSelectionChanged.connect(self.update_listhostgroups)

        QtCore.QObject.connect(self.hostgroupslist, QtCore.SIGNAL("dropped"), self.add_group_to_host)

        QtCore.QObject.connect(self.availablegroupslist, QtCore.SIGNAL("dropped"), self.remove_group_to_host)

        QtCore.QObject.connect(self.hostattributeslist, QtCore.SIGNAL("dropped"), self.add_attribute_to_host)

        QtCore.QObject.connect(self.availableattributeslist, QtCore.SIGNAL("dropped"), self.remove_attribute_to_host)

        QtCore.QObject.connect(self.hostslist, QtCore.SIGNAL("rightclick"), self.delhost)

        # Tab Groups

        QtCore.QObject.connect(self.addgroup, QtCore.SIGNAL("clicked()"), self.clic_addnewgroup)

        QtCore.QObject.connect(self.grouptoadd, QtCore.SIGNAL("returnPressed()"), self.clic_addnewgroup)

        self.groupslist.itemSelectionChanged.connect(self.update_listgrouphosts)

        #QtCore.QObject.connect(self.grouphostslist, QtCore.SIGNAL("dropped"), self.add_host_to_group)

        QtCore.QObject.connect(self.grouphostslist, QtCore.SIGNAL("modified"), self.reload_grouphosts)

        QtCore.QObject.connect(self.availablehostslist_2, QtCore.SIGNAL("modified"), self.reload_grouphosts)

        #QtCore.QObject.connect(self.availablehostslist_2, QtCore.SIGNAL("dropped"), self.remove_host_to_group)

        QtCore.QObject.connect(self.groupslist, QtCore.SIGNAL("rightclick"), self.delgroup)

        QtCore.QObject.connect(self.groupattributeslist, QtCore.SIGNAL("dropped"), self.add_attribute_to_group)

        QtCore.QObject.connect(self.availableattributeslist_2, QtCore.SIGNAL("dropped"), self.remove_attribute_to_group)

        # Tab cgroups

        QtCore.QObject.connect(self.addcgroup, QtCore.SIGNAL("clicked()"), self.clic_addnewcgroup)

        QtCore.QObject.connect(self.cgrouptoadd, QtCore.SIGNAL("returnPressed()"), self.clic_addnewcgroup)

        self.cgroupslist.itemSelectionChanged.connect(self.update_listcgroupgroups)

        #QtCore.QObject.connect(self.groupcgroupslist, QtCore.SIGNAL("dropped"), self.add_group_to_cgroup)

        QtCore.QObject.connect(self.groupcgroupslist, QtCore.SIGNAL("modified"), self.reload_cgroupgroups)

        QtCore.QObject.connect(self.availablegroupslist_2, QtCore.SIGNAL("modified"), self.reload_cgroupgroups)

        #QtCore.QObject.connect(self.availablegroupslist_2, QtCore.SIGNAL("dropped"), self.remove_group_to_cgroup)

        QtCore.QObject.connect(self.cgroupslist, QtCore.SIGNAL("rightclick"), self.delcgroup)

        QtCore.QObject.connect(self.cgroupattributeslist, QtCore.SIGNAL("dropped"), self.add_attribute_to_cgroup)

        QtCore.QObject.connect(self.availableattributeslist_3, QtCore.SIGNAL("dropped"), self.remove_attribute_to_cgroup)

        # Tab attributes

        QtCore.QObject.connect(self.addattribute, QtCore.SIGNAL("clicked()"), self.addnewattribute)

        QtCore.QObject.connect(self.attributetoadd, QtCore.SIGNAL("returnPressed()"), self.addnewattribute)

        self.attributeslist.itemSelectionChanged.connect(self.update_listattributegroup)

        QtCore.QObject.connect(self.attributehostslist, QtCore.SIGNAL("dropped"), self.add_host_to_attribute)

        QtCore.QObject.connect(self.availablehostslist_3, QtCore.SIGNAL("dropped"), self.remove_host_to_attribute)

        QtCore.QObject.connect(self.attributegroupslist, QtCore.SIGNAL("dropped"), self.add_group_to_attribute)

        QtCore.QObject.connect(self.availablegroupslist_3, QtCore.SIGNAL("dropped"), self.remove_group_to_attribute)

        QtCore.QObject.connect(self.attributecgroupslist, QtCore.SIGNAL("dropped"), self.add_cgroup_to_attribute)

        QtCore.QObject.connect(self.availablecgroupslist, QtCore.SIGNAL("dropped"), self.remove_cgroup_to_attribute)

        QtCore.QObject.connect(self.attributeslist, QtCore.SIGNAL("rightclick"), self.delattribute)

        ## This to define the list between which drag and drop is authorized

        self.hostgroupslist.acceptfrom = ["availablegroupslist"]

        self.availablegroupslist.acceptfrom = ["hostgroupslist"]

        self.groupattributeslist.acceptfrom = ["availableattributeslist_2"]

        self.availableattributeslist_2.acceptfrom = ["groupattributeslist"]

        self.hostattributeslist.acceptfrom = ["availableattributeslist"]

        self.availableattributeslist.acceptfrom = ["hostattributeslist"]

        self.grouphostslist.acceptfrom = ["availablehostslist_2"]

        self.availablehostslist_2.acceptfrom = ["grouphostslist"]

        self.groupcgroupslist.acceptfrom = ["availablegroupslist_2"]

        self.availablegroupslist_2.acceptfrom = ["groupcgroupslist"]

        self.cgroupattributeslist.acceptfrom = ["availableattributeslist_3"]

        self.availableattributeslist_3.acceptfrom = ["cgroupattributeslist"]

        self.attributegroupslist.acceptfrom = ["availablegroupslist_3"]

        self.availablegroupslist_3.acceptfrom = ["attributegroupslist"]

        self.attributecgroupslist.acceptfrom =["availablecgroupslist"]

        self.availablecgroupslist.acceptfrom = ["attributecgroupslist"]

        self.attributehostslist.acceptfrom = ["availablehostslist_3"]

        self.availablehostslist_3.acceptfrom = ["attributehostslist"]

        ## Set the current tab to host view

        self.tabs.setCurrentIndex(0)

    def quit(self):

        print("bye bye")

        sys.exit(0)

    def save_hostsfile(self):

        filename = QtGui.QFileDialog.getOpenFileName(self, 'File to save')

        if filename != "":

            if os.path.isfile(filename):

                warn_msg = "File exists. Do you want to overwrite ?"

                reply = QtGui.QMessageBox.question(self, 'Message',warn_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

                if reply == QtGui.QMessageBox.No:

                    return

            file = open(filename, 'w')

            result = self.ansible.export_ansible()

            file.write(result)

            file.close()

    ## On tab change event catcher

    # will update lists of the new tab to get modification made previously

    # will generate the new hosts file when tab "view hosts file" is activated

    def ontabchange(self,i):

        if i == 0:

            self.update_liststabhosts()

        elif i == 1:

            self.update_liststabgroups()

        elif i == 2:

            self.update_liststabcgroups()

        elif i == 3:

            self.update_liststabattributes()

        elif i == 4:

            result = self.ansible.export_ansible()

            self.textEdit.setText(result)

            #QtGui.QMessageBox.information(self,

            #      "Tab Index Changed!",

            #      "Current Tab Index: %d" % i ) #changed!

    ## Delete a host

    # will ask for confirmation

    def delhost(self, pos):

        menu = QtGui.QMenu(self)

        texte = ""

        for host in self.hostslist.selectedItems():

            texte += host.text() + " "

        delAction = menu.addAction("Delete " + texte)

        action = menu.exec_(self.hostslist.mapToGlobal(pos))

        if action == delAction:

            for hostname in self.hostslist.selectedItems():

                warn_msg = "Are you sure you want to delete host " + hostname.text() + " ?"

                reply = QtGui.QMessageBox.question(self, 'Message', warn_msg, QtGui.QMessageBox.Yes,

                                                   QtGui.QMessageBox.No)

                if reply == QtGui.QMessageBox.Yes:

                    self.ansible.delhost(hostname.text())

        self.update_listallhosts()

    ## Delete a group

    # will ask for confirmation

    def delgroup(self, pos):

        menu = QtGui.QMenu(self)

        texte = ""

        for group in self.groupslist.selectedItems():

            if group.text() in specials:

                return

            texte += group.text() + " "

        delAction = menu.addAction("Delete " + texte)

        action = menu.exec_(self.groupslist.mapToGlobal(pos))

        if action == delAction:

            for groupname in self.groupslist.selectedItems():

                # hostname = self.hostslist.selectedItem.text()

                # host=host(hostname)

                warn_msg = "Are you sure you want to delete group "+groupname.text()+" ?"

                reply = QtGui.QMessageBox.question(self, 'Message', warn_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

                if reply == QtGui.QMessageBox.Yes:

                    self.ansible.delgroup(groupname.text())

        self.update_listallgroups()

    ## Delete a cgroup

    # will ask for confirmation

    def delcgroup(self, pos):

        menu = QtGui.QMenu(self)

        texte = ""

        for cgroup in self.cgroupslist.selectedItems():

            texte += cgroup.text() + " "

        delAction = menu.addAction("Delete " + texte)

        action = menu.exec_(self.cgroupslist.mapToGlobal(pos))

        if action == delAction:

            for cgroupname in self.cgroupslist.selectedItems():

                warn_msg = "Are you sure you want to delete Cgroup " + cgroupname.text() + " ?"

                reply = QtGui.QMessageBox.question(self, 'Message', warn_msg, QtGui.QMessageBox.Yes,

                                                   QtGui.QMessageBox.No)

                if reply == QtGui.QMessageBox.Yes:

                    self.ansible.delcgroup(cgroupname.text())

        self.update_listallcgroups()

    ## Delete an attribute

    # will ask for confirmation

    def delattribute(self,pos):

        menu = QtGui.QMenu(self)

        texte = ""

        for attribute in self.attributeslist.selectedItems():

            texte += attribute.text() + " "

        delAction = menu.addAction("Delete " + texte)

        action = menu.exec_(self.attributeslist.mapToGlobal(pos))

        if action == delAction:

            for attributename in self.attributeslist.selectedItems():

                warn_msg = "Are you sure you want to delete attribute " + attributename.text() + " ?"

                reply = QtGui.QMessageBox.question(self, 'Message', warn_msg, QtGui.QMessageBox.Yes,

                                                   QtGui.QMessageBox.No)

                if reply == QtGui.QMessageBox.Yes:

                    self.ansible.delattribute(attributename.text())

        self.update_listallattributes()

    ## function to load a hosts file

    def load_hostsfile(self):

        self.ansible.reset()

        filename = QtGui.QFileDialog.getOpenFileName(self,'File to open')

        #filename = "hosts"

        file = open(filename, 'r')

        current_group = ungrouped

        cgroup = False

        vargroup = False

        while 1:

            line = file.readline()

            if not line:

                break

            line = line.strip(" \t\n\r")

            if len(line) > 1:

                # Pass comments and empty lines

                if line[0] == "#":

                    pass

                elif line == '':

                    pass

                # Detect groups

                elif line[0] == "[":

                    # Get name of group (part between []

                    newgroupname = re.search('^\[(.*)\]', line).group(1)

                    # Search for cgroup

                    lcgroup = re.search('(.*):children', newgroupname)

                    if lcgroup is None:

                        cgroup = False

                        groupvar = re.search('(.*):vars', newgroupname)

                        if groupvar is None:

                            self.ansible.addgroup(newgroupname)

                            vargroup = False