ansible-framework.tar.gz

af/0000755000000000000000000000000013377750517010161 5ustar  rootrootaf/configs/0000755000000000000000000000000013407163344011577 5ustar  rootrootaf/configs/settings0000750000000000000000000000512513407163343013362 0ustar  rootroot#!/bin/bash
# Jocalinux (www.jocalinux.com.br)

# Change no fear! not much without fear :D
ROOTAF="/af"
USERSSH="root"
USERANS="root"
GRPANS="ansible"

############################################################
# (be or much) careful to change anything after this line! #
############################################################

# for all tools
DATA=$(date +%d%m%Y-%Hh%Mm%Ss)
CONFIGDIR="${ROOTAF}/configs"
SETTINGS="${CONFIGDIR}/settings"
LOGSDIR="${ROOTAF}/logs"
MODELS="${ROOTAF}/models"
TMPDIR="${ROOTAF}/tmp"
PLBKDIR="${ROOTAF}/playbooks"
TEMPLATES="${ROOTAF}/templates"
BACKUPSDIR="${ROOTAF}/backups"
USER=$(who am i | awk -F ' ' '{ print $1 }')

# Colours
EC="\033[m"   # End
RD="\033[31m" # Red
GR="\033[32m" # Green
YE="\033[33m" # Yellow
BL="\033[34m" # Blue
PL="\033[35m" # Purple
CY="\033[36m" # Cyan
GY="\033[37m" # Gray
WT="\033[38m" # White

# ansible-template
LOGSTMTE="${LOGSDIR}/ansible-template.log"

# ansible-sshkey
PUBKEY="${CONFIGDIR}/.ssh/id_rsa.pub"
LOGSSHKEY="${LOGSDIR}/ansible-sshkey.log"

# ansible-run
SSHTEST="true"
SHOWHOST="true" # Show or not the host list? 'true' for 'yes' anything else for 'no'.
SHOWTEST="true" # Show or not the host group list? 'true' for 'yes' anything else for 'no'.
FQDNTEST="true" # Test FQDN? 'true' for 'yes' anything else for 'no'.
LOGRUN="${LOGSDIR}/ansible-run.log"

# ansible-control
CTRLFILEDIR="${BACKUPSDIR}/control-file"
LOGCTRL="${LOGSDIR}/ansible-control.log"

# ansible-scheduler
HOSTS="hosts"
SCHDIR="${ROOTAF}/scheduler"

# Functions (more functions, as aways!)
CHECKBIN(){
for BIN in "sort" "cat" "ansible-playbook" "touch" "chmod" "chown" "chattr" "tar" "vi" "ls" "mkdir" "cp" "rm" "ssh-copy-id" "nmap"
do
	if [ -z $(which ${BIN}) ] ; then {
		echo
		echo -e "The command ${RD}${BIN}${EC} not found! Exiting..." 
		echo
		exit 1
	}
	fi
done

	# Define BIN vars
	SORT=$(which sort)
	ASCMD=$(which ansible-playbook)
	TOUCH=$(which touch)
	CHMOD=$(which chmod)
	CHOWN=$(which chown)
	CHATTR=$(which chattr)
	TAR=$(which tar)
	VI=$(which vi)
	LS=$(which ls)
	MKDIR=$(which mkdir)
	CP=$(which cp)
	RM=$(which rm)
	SSHCOPYID=$(which ssh-copy-id)
	CAT=$(which cat)
	
}


CHECKDIR(){
for DIR in ${ROOTAF} ${CONFIGDIR} ${LOGSDIR} ${TMPDIR} ${PLAYBOOKSDIR} ${TEMPLATES} ;
do
        if [ -d "${DIR}" ] ; then {
		echo . > /dev/null
        }
        else {
		echo
		echo -e $"${RD} ERROR:${EC} essential directory ${DIR} not found! Please, verify:${YE} ${SETTINGS} ${EC}"
                echo "${DATA} ; ${USER} ; error ; ${DIR} - essential directory not found! Please, verify!" >> ${LOGRUN}
		echo
		exit 1
        }
        fi
done
}

# Exec function
CHECKBIN
CHECKDIR

af/backups/0000755000000000000000000000000013325626552011603 5ustar  rootrootaf/backups/control-file/0000750000000000000000000000000013407162020014155 5ustar  rootrootaf/backups/templates/0000750000000000000000000000000013407162026013564 5ustar  rootrootaf/backups/templates/.playbooks0000640000000000000000000000064413371070341015573 0ustar  rootrootall
at
authorized-keys
autofs
bashrc
ca-agent
crond
ctmagent-install
ctmagent-uninstall
des-open-sat
des-rhel-sat
des-sap-sat
hml-open-sat
hml-rhel-sat
hml-sap-sat
hostname
hosts
ldap
limits
login
logrotate
motd
nsswitch
ntpd
packages
pam.d
passwd
prd-open-sat
prd-rhel-sat
prd-sap-sat
profile
puppet-agent
resolv
securetty
services
snmpd
sshd
sssd
sudoers
sysctl
tds
tibero-install
update
vsftpd
yum.repos
zabbix-agent
af/scripts/0000755000000000000000000000000013407163322011632 5ustar  rootrootaf/scripts/ansible-run0000750000000000000000000003244713407163253014007 0ustar  rootroot#!/bin/bash
# Created by Jocalinux (www.jocalinux.com.br)
# Any help? jocalinux@gmail.com

# Load vars in settings file
. /af/configs/settings

# Vars (or Constants?)
TMPFILE="${TMPDIR}/ansible-run_${DATA}"

# Caption Vars
HOSTNAME=$1
HOSTGRP=$1
CHECKEXPR=$(echo ${HOSTGRP} | awk -F '.' '{ print $1 }')
OPTION=$2
PLAYBOOK=$3

# Functions

# Check if README.md playbook exist
DESPLBK(){
if [ -f "${PLBKDIR}/${PLAYBOOK}/info/README.md" ] ; then {
	README=$(${CAT} ${PLBKDIR}/${PLAYBOOK}/info/README.md)
        echo -e $"${YE} ${PLAYBOOK} ${EC}"
        echo -e $"${GR} Description playbook:${EC} ${README}"
        echo "---------------------------------------------------------------------------------------------------------------------"
}
else {
        echo -e $"${YE} ${PLAYBOOK} ${EC}"
        echo -e $"${RD} Description playbook:${EC} README.md playbook not available! :("
        echo "---------------------------------------------------------------------------------------------------------------------"
}
fi
}

# Search and list all PLAYBOOK in: /git/playbooks
SRCPLBK(){
for PLAYBOOK in $(${LS} -l ${PLBKDIR} | awk -F ' ' '{ print $9 }' | sort | uniq) ; 
do
	echo -e $"${YE} ${PLAYBOOK} ${EC}"
done
}

# Check if PLAYBOOK is AVAILABLE for a host
PLBKAVA(){
if [ "${HOSTNAME}" != "" ] ; then {
	if [ -f "${TEMPLATES}/${HOSTNAME}/.playbooks" ] ; then {
		for PLAYBOOK in $(cat ${TEMPLATES}/${HOSTNAME}/.playbooks | ${SORT}) ;
		do
			if [ -f "${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml" ] ; then {
				echo -e $"${YE} ${PLAYBOOK} ${EC}"
			}
			else {
				echo -e $" This playbook exist in .playbooks file, but not available: ${RD}${PLAYBOOK}${EC}"
			}
			fi
		done
	}
	else {
		SRCPLBK
	}
	fi
}
else {
	SRCPLBK
}
fi
}

# Message if playbook there are not available for a host
PLBKNOTAVA(){
echo
echo -e $"The${RD} ${PLAYBOOK}${EC} is not available for this host! :("
echo -e $"run:${GR} ansible-run ${HOSTNAME} play${EC} to see all playbooks available for this host. Or ..."
echo -e $"run:${GR} ansible-control ${HOSTNAME} edit${EC} to edit playbooks availables for a host. :)"
echo "${DATA} ; ${USER} ; warn ; ${HOSTNAME} ; the user selected a playbook (${PLAYBOOK}) not available for this host" >> ${LOGRUN}
echo
exit 1
}

# Functions and more functions! (sorry, I'm not a good programmer! But, I try! :D)
# Check if playbook selected with 'run' option is available for the host

ERRORFQDN(){
echo
echo -e $"This a valid FQDN?"
echo -e $"With ${GR}run${EC} OPTION: ${YE}server.mylocaldomain${EC}"
echo -e $"With ${GR}grp${EC} OPTION: ${YE}server?.mylocaldomain${EC}"
echo "${DATA} ; ${USER} ; error ; ${HOSTNAME} ; this is a not valid FQDN with OPTION '${OPTION}'" >> ${LOGRUN}
echo
exit 1
}

FQDN(){
if [ "${FQDNTEST}" == "true" ] ; then {

	# Validate FDQN
        if [[ ${HOSTNAME} =~ .*'.'.* ]] ; then {
        	FQDN1=$(echo ${HOSTNAME} | awk -F '.' '{ print $1 }')
                FQDN2=$(echo ${HOSTNAME} | awk -F '.' '{ print $2 }')
                if [[ ${FQDN1} == "" ]] \
                || [[ ${FQDN2} == "" ]] ; then {
                	ERRORFQDN
                }
                fi
        }
        else {
        	ERRORFQDN
        }
        fi
}
fi
}


CHECKPLBK(){
if [ "${HOSTNAME}" != "" ] ; then {

	# Checking FQDN
	FQDN

	# Checking if OPTION is 'run'
	if [ "${OPTION}" == "run" ] ; then {
		if [ -f "${TEMPLATES}/${HOSTNAME}/.playbooks" ] ; then {
			if [ "${PLAYBOOK}" == '' ] ; then {
				echo
				echo "Select a playbook!" 
				echo -e $"run: ${GR}ansible-run ${HOSTNAME} play${EC} to see all playbooks available"
				echo
				exit 1
			}
			else {
				AVAILABLE=$(cat ${TEMPLATES}/${HOSTNAME}/.playbooks | grep "${PLAYBOOK}")
				if [ "$?" -eq "0" ] ; then {
					if [ ${PLAYBOOK} == ${AVAILABLE} ] ; then {
						echo
						echo -e $"${GR}Init playbook ...${EC}"
						echo
					}
					else {
						PLBKNOTAVA
						exit 1
					}
					fi
				}
				else {
					PLBKNOTAVA
                                	exit 1
				}
				fi
			}
			fi
		}
		fi
	}
	fi
}
fi
}

# Create a temporary file to run a playbook
GENTEMPFILE(){
if [ "${OPTION}" == "run" ] ; then {
        HOST="${TMPDIR}/ansible-host-temp-${HOSTNAME}"
        echo "[${PLAYBOOK}_hosts]" > ${HOST}
        echo "${HOSTNAME}" >> ${HOST}
	if [ "${SHOWHOST}" == "true" ] ; then {
		cat ${HOST}
	}
	fi
}
else {
        if [ "${OPTION}" == "grp" ] ; then {
                GROUP="${TMPDIR}/ansible-group-temp_${DATA}"
                echo "[${PLAYBOOK}_hosts]" > ${GROUP}
                find ${TEMPLATES} -name "${HOSTGRP}" | awk -F '/' '{ print $4 }' >> ${GROUP}
		if [ "${SHOWHOST}" == "true" ] ; then {
			cat ${GROUP}
		}
        	fi
        }
        fi
}
fi

}

# Check if servername contain regular expression. You can't run ansible-run with regular expression and 'run' OPTION
CHECKHOST(){
if [[ ${HOSTNAME} =~ .*'['.* ]] \
        || [[ ${HOSTNAME} =~ .*']'.* ]] \
        || [[ ${HOSTNAME} =~ .*'[0-9]'.* ]] \
        || [[ ${HOSTNAME} =~ .*'[a-z]'.* ]] \
        || [[ ${HOSTNAME} =~ .*'[A-Z]'.* ]] \
        || [[ ${HOSTNAME} =~ .*'{'.* ]] \
        || [[ ${HOSTNAME} =~ .*'}'.* ]] \
        || [[ ${HOSTNAME} =~ .*'^'.* ]] \
        || [[ ${HOSTNAME} =~ .*'?'.* ]] \
        || [[ ${HOSTNAME} =~ .*'*'.* ]] ; then {
        echo
	echo -e $"To run ansible-run with regular expression, use '${YE}grp${EC}' option"
	echo "${DATA} ; ${USER} ; warn ; ${HOSTNAME} ; the user can not use regular expression with 'run' option" >> ${LOGRUN}
        echo
	exit 0
}
fi

}

# Only message to the script be more beautiful! :D
PREXECRUN(){
if [ "${SHOWTEST}" == "true" ] ; then {
	echo
	echo -e $"${GR}Check HOSTNAME...........${EC} Passed!"
	if [ "${SSHTEST}" == "true" ] ; then {
		echo -e $"${GR}Check SSH connection.....${EC} Passed!"
	}
	else {
		echo -e $"${YE}Check SSH connection.....${EC} Skipped!"
	}
	fi
	echo -e $"${GR}Check playbook syntax....${EC} Passed!"
	echo -e $"${CY}Running ....${EC}"
	echo
}
fi
}

# Similar the last function description. 
# Attention: for host groups, not check SSH connection because for delay to test every host!
PREXECGRP(){
if [ "${SHOWTEST}" == "true" ] ; then {
	echo
	echo -e $"${GR}Check hostname...........${EC} Passed!"
	echo -e $"${GR}Check SSH connection.....${EC} Attention: Not checked for host group!"
	echo -e $"${GR}Check playbook syntax....${EC} Passed!"
	echo -e $"${CY}Running ....${EC}"
	echo
}
fi
}

ANSRUNPLAYMSG(){
if [ "${PLAYBOOK}" == '' ] ; then {
	echo
        echo "Select a playbook!"
        echo -e $"run: ${GR}ansible-run ${HOSTNAME} play${EC} to see all playbooks available"
	echo "${DATA} ; ${USER} ; warn ; ${HOSTNAME} ; the user not selected any playbook" >> ${LOGRUN}
	echo
}
else {
	echo
	echo -e $"Playbook ${RD}${PLAYBOOK}${EC} not exist!"
	echo -e $"run: ${GR}ansible-run ${HOSTNAME} play${EC} to see all playbooks available"
	echo "${DATA} ; ${USER} ; warn ; ${HOSTNAME} ; the playbook '${PLAYBOOK}' selected not exist!" >> ${LOGRUN}
	echo
}
fi
}

# Message if the script found a syntax error
SYNTAXERROR(){
echo
echo -e $"Playbook: ${RD}${PLAYBOOK}${EC} syntax error!"
echo "${DATA} ; ${USER} ; error ; ${HOSTNAME} ; the playbook ${PLAYBOOK} has error in your syntax code!" >> ${LOGRUN}
echo
exit 1
}

# How to use this fuck**** script?
USEANSRUN(){
BANNER="Ansible Framework v1.0 (Created by Joca! 'jocalinux@gmail.com')"
echo 
echo -e $"#${CY} ${BANNER} ${EC}"
echo 
echo -e $"Usage: ansible-run ${CY}<server>${EC} [${GR}run${EC}|${GR}grp${EC}|${GR}des${EC}|${GR}play${EC}] ${YE}{playbook}${EC}"
echo
echo -e $"${GR} run  ${EC}: Execute a playbook for a only server" 
echo -e $"${GR} grp  ${EC}: Execute a playbook for a host group" 
echo -e $"${GR} des  ${EC}: Playbook description" 
echo -e $"${GR} play ${EC}: Playbooks availables" 
echo
echo $"Available playbooks:"
echo
}

# Redundant this ... I will write a better code in the future! (I hope)
CHECKANSBIN(){
if [ -z $(which ansible-playbook) ] ; then {
	echo
	echo -e $"The ansible-playbook ${RD}not installed!${EC} You need install this package!"
	echo
	exit 1
}
fi
}

# Fix bugs and more bugs :'(
CLEAN_ALL(){
unset HOSTNAME
unset HOSTGRP
unset OPTION
unset PLAYBOOK
}

# Select Playbook
case "$2" in
	run)
		# Started ansible-run with 'run' OPTION for host
		echo "${DATA} ; ${USER} ; info ; ${HOSTNAME} ; started ansible-run with 'run' option and playbook '${PLAYBOOK}' selected!" >> ${LOGRUN}
		
		# Check if HOSTNAME contain regular expression
		CHECKHOST

		# Check if server/host have access to the ansible playbook
		CHECKPLBK

		# Check if playbook exist
		if [ -f "${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml" ] ; then {

			# Create a temporary file with hosts
			GENTEMPFILE

			# Check nmap-ncat package
			if [ -z $(which nmap) ] ; then {
				echo
				echo -e $"The package nmap-ncat ${RD}not installed!${EC} You need install this package!"
				echo "${DATA} ; ${USER} ; error ; ${HOSTNAME} ; nmap not installed!" >> ${LOGRUN}
				echo
				exit 1
			}
			fi

			# Check SSH connection with nmap-ncat
			if [ "${SSHTEST}" == "true" ] ; then {
				SSHCHECK=$($(which nmap) -p22 ${HOSTNAME} | grep 22/tcp | awk -F ' ' '{ print $2 }')
			}
			else {
				SSHCHECK="open"
			}	
			fi

			# If SSHCHECK is 'open'
			if [ "${SSHCHECK}" != "open" ] ; then {
				echo
				echo -e $"${HOSTNAME} ${RD}SSH - not connected! Check your ssh connection! :(${EC}"
				echo "${DATA} ; ${USER} ; error ; ${HOSTNAME} ; ssh not connected! Please, verify!" >> ${LOGRUN}
				echo
				exit 1
			} 
			else {
				# Check ansible-playbook package
				CHECKANSBIN

				# Check playbook syntax
                		${ASCMD} -i ${HOST} ${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml --syntax-check
				if [ "$?" -eq "0" ] ; then {
					PREXECRUN

					# If syntax check OK, run the playbook
					${ASCMD} -i ${HOST} ${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml
					echo "${DATA} ; ${USER} ; info ; ${HOSTNAME} ; starting run ${PLAYBOOK} after all tests!" >> ${LOGRUN}
					CLEAN_ALL

				} 
				else {
					# Show syntax error message
					SYNTAXERROR
					CLEAN_ALL
				}
				fi
			}
			fi

			# Delete temporary file created by 'GENTEMPFILE' function
                	rm -f ${HOST}
		}
		else {
			# Show PLAYBOOK
			ANSRUNPLAYMSG
			CLEAN_ALL
		}
		fi
	;;
	grp)

	# Valide HOSTGRP name
        if [ "${FQDNTEST}" == "true" ] ; then {

              	# Validate FQDN for a HOSTGRP
               	if [[ ${HOSTGRP} =~ .*'.'.* ]] ; then {
                       	FQDN1=$(echo ${HOSTGRP} | awk -F '.' '{ print $1 }')
                       	FQDN2=$(echo ${HOSTGRP} | awk -F '.' '{ print $2 }')
                       	if [[ ${FQDN1} == "" ]] \
			|| [[ ${FQDN2} == "" ]] ; then {
                               	ERRORFQDN
                       	}
                       	fi
               	}	
               	else {
                       	ERRORFQDN
               	}
               	fi
        }
        fi

	# Check regular expression
	if [[ ${CHECKEXPR} =~ .*'['.* ]] \
        || [[ ${CHECKEXPR} =~ .*']'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'[0-9]'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'[a-z]'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'[A-Z]'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'{'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'}'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'^'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'?'.* ]] \
        || [[ ${CHECKEXPR} =~ .*'*'.* ]] ; then {

		# generate a temp file to run a playbook
		if [ -f "${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml" ] ; then {
			GENTEMPFILE

			# Check ansible-playbook package
			CHECKANSBIN

                	${ASCMD} -i ${GROUP} ${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml --syntax-check
			if [ "$?" -eq "0" ] ; then {
                        	PREXECGRP
                                ${ASCMD} -i ${GROUP} ${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml
				for HOSTGRP in $(cat ${GROUP}) ; 
				do
					# There are some bugs with the contains clause that I could not fix (yet!)
					if [[ ${HOSTGRP} =~ .*'['.* ]] \
					|| [[ ${HOSTGRP} =~ .*']'.* ]] ; then {
						echo . > /dev/null
					}
					else {
						# My monitor is very small! This is a terrible thing! :P
						PART1="${DATA} ; ${USER} ; info ;"
						PART2="starting run ${PLAYBOOK} for ${HOSTGRP} with 'grp'"
						PART3="option after some tests! (not check ssh connection)"
						echo "${PART1} ${PART2} ${PART3}" >> ${LOGRUN}
					}
					fi
				done
				CLEAN_ALL
                       	} 
			else {
				SYNTAXERROR
				CLEAN_ALL
			}
			fi

			# Delete temporary file created by 'GENTEMPFILE' function
                	rm -f ${GROUP}
		}
		else {
			ANSRUNPLAYMSG
			CLEAN_ALL
		}
		fi
	}
	else {
		echo
		echo -e $"Sorry, this (${CY}${HOSTGRP}${EC}) does not look like a regular expression!"
		echo "${DATA} ; ${USER} ; warn ; the expression '${HOSTGRP}' does not look like a regular expression!" >> ${LOGRUN}
		echo -e $"Your expression contains ${WT}'*', '?'${EC} ${RD}after${EC} the first dot(.) or any special character for example?"
		echo -e $"Attention: For security reasons, you ${RD}can not${EC} specify any special character after the first dot(.)"
		echo -e $"You can try some like this: ${WT}servername${YE}?${EC}${WT}.global.corp${EC} - understand?"
		echo -e $"Where ${YE}?${EC} represents any single character"
		echo
	}
	fi
	;;
	des)
		# Checking FQDN
		FQDN

		# Playbook exist?
		if [ -f "${PLBKDIR}/${PLAYBOOK}/${PLAYBOOK}.yml" ] ; then {
			DESPLBK		
			CLEAN_ALL
		}
		else {
			ANSRUNPLAYMSG
			CLEAN_ALL
                }
                fi
    	;;
	play)
		# Checking FQDN
		FQDN

		# Search and list PLAYBOOK
		echo
		echo -e $" Playbooks availables for: ${YE}${HOSTNAME}${EC}"
		echo
		PLBKAVA
		CLEAN_ALL
		echo
	;;
	*)
	USEANSRUN
	PLBKAVA
	CLEAN_ALL
	echo
esac
af/scripts/check-packages.sh0000750000000000000000000000112613321535557015025 0ustar  rootroot#!/bin/bash
# Created by Jocalinux
# Do you need a help? jocalinux@gmail.com

check-packages(){
for packages in git ansible ansible-playbook nmap cat awk date ;
do
	check=`whereis ${packages} | awk -F ' ' '{ print $2 }'`
	if [ "${check}" == '' ] ; then {
		echo -e $"Binary not installed: \033[31m${packages}\033[m"
		echo -e $"Try: \033[33myum install ${packages}\033[m (or 'yum search ${packages}')"
		echo "----------------------------------------------------------------------------"
	}
	else {
		echo -e $"Binary is installed: \033[32m${check}\033[m"
	}
	fi
done
}

# Exec func
check-packages
af/scripts/ansible-sshkey0000750000000000000000000000275013407163300014474 0ustar  rootroot#!/bin/bash
# Created by Jocalinux (www.jocalinux.com.br)
# Do you need a help? jocalinux@gmail.com

# Load vars in /git/configs/settings
. /af/configs/settings

# Var
HOSTNAME=$1

# Functions
# Copy id_rsa.pub for a host
COPYSSH(){
	echo
	echo -e "Copying SSH key for: ${GR}${HOSTNAME}${EC} ..."
	${SSHCOPYID} -f -i ${PUBKEY} -o StrictHostKeyChecking=no ${USERSSH}@${HOSTNAME} > /dev/null
	if [ "$?" == "0" ] ; then {
		echo -e "Copy SSH key for ${YE}${HOSTNAME}:${EC} [ ${GR}OK${EC} ]"
		echo "${DATA} ; ${USER} ; info ; Copy SSH for ${HOSTNAME} - OK" >> ${LOGSSHKEY}
		echo
	}
	else {
		echo -e "Copy SSH key for ${YE}${HOSTNAME}:${EC} [ ${RD}NOT OK${EC} ]"
		echo "${DATA} ; ${USER} ; error ; Copy SSH for ${HOSTNAME} - NOT OK" >> ${LOGSSHKEY}
		echo
		exit 1
	}
	fi
}

# Check if id_rsa.pub exist
CHECKDIRPUB(){
	if [ -f ${PUBKEY} ] ; then {
		COPYSSH
	}
	else {
		echo
		echo -e "${YE}id_rsa.pub${EC} defined in ${GR}'/git/configs/settings'${EC} file ${RD}NOT FOUND!${EC} Please, check out!"
		echo -e "If you do not have a ${YE}id_rsa.pub${EC} you can run: ${GR}'ssh-keygen -t rsa'${EC} command as root or sudo user."
		echo
		echo "${DATA} ; ${USER} ; warn ; The id_rsa.pub defined in settings file not found!" >> ${LOGSSHKEY}
		exit 1
	}
	fi
}

case "$2" in
	copy)
		CHECKDIRPUB
   	;;
	*)
	BANNER="Ansible Framework v1.0 (Created by Joca! 'jocalinux@gmail.com')"
	echo
        echo -e $"#${CY} ${BANNER} ${EC}"
	echo
    	echo -e $"Usage: ansible-sshkey ${CY}<hostname>${EC} ${GR}copy${EC}"
	echo
esac
af/scripts/create-symlinks.sh0000750000000000000000000000160113325444336015302 0ustar  rootroot#!/bin/bash
# Created by Jocalinux
# Do you need a help? jocalinux@gmail.com

create-symlinks(){
for script in ansible-run ansible-sshkey ansible-template ansible-control ;
do
	# Check scripts
	if [ -f "/af/scripts/${script}" ] ; then {
		# Remove symlinks
		rm=`whereis rm | awk -F ' ' '{ print $2 }'`
		${rm} -f /usr/bin/${script}
	
		# Create symlinks
		sym=`whereis ln | awk -F ' ' '{ print $2 }'`
		${sym} -s /af/scripts/${script} /usr/bin/${script}
		if [ $? == "0" ] ; then {
			echo -e $"Created symlink: \033[32m/usr/bin/${script}\033[m"
			whereis ${script}
			echo "------------------------------------------------------"
		}
		else {
			echo -e $"Failure to create a symlink for: \033[32m/usr/bin/${script}\033[m"
		}
		fi
	}
	else {
		echo -e $"The script: \033[31m/af/scripts/${script}\033[m not exist! Aborting script ...:("
		exit 1
	}
	fi

	  
done
}

# Exec func
create-symlinks
af/scripts/ansible-control0000710000000000000000000003551113407163256014655 0ustar  rootroot#!/bin/bash
# Created by Jocalinux
# Any help? jocalinux@gmail.com

# Load settings
. /af/configs/settings

# Vars
HOSTNAME=$1

# Functions
# Check if directory backup for playbook control file exist
CHECKDIRBKP(){
if [ -d "${CTRLFILEDIR}/${HOSTNAME}" ] ; then {
	echo . > /dev/null
}
else {
	echo
	echo -e " The backup directory to playbook control file ${RD}not exist!${EC}"
	echo "${DATA} ; ${USER} ; warn ; The directory backup for playbook control file not exist!" >> ${LOGCTRL}
	CTRLDIRBKP="x"
	while ! [[ ${CTRLDIRBKP} = [YyNn] ]]; 
        do
        echo
        echo -e " Do you would like create a directory for ${CY}backup${EC} of playbook control file? [Y/y/N/n]"
        echo -e " ${GR}Y/y${EC} - for create a ${YE}DIRECTORY${EC} backup"
        echo -e " ${RD}N/n${EC} - for do not create a ${YE}DIRECTORY${EC} backup"
        echo
        echo -e " What do you to do?"
        read CTRLDIRBKP
        done
        	if [ ${CTRLDIRBKP} == "N" ] || [ ${CTRLDIRBKP} == "n" ] ; then {
			echo -e "The ansible-control need the directory ${YE}${CTRLFILEDIR}/${HOSTNAME}${EC} to work! ${RD}Aborting...${EC}"
			echo "${DATA} ; ${USER} ; error ; The ansible-control need the directory ${CTRLFILEDIR}/${HOSTNAME} to work! Aborting..." >> ${LOGCTRL}
			echo
			exit 1
               	}
		else {
                	${MKDIR} -p ${CTRLFILEDIR}/${HOSTNAME}
			if [ "$?" -eq "0" ] ; then {
				echo
				echo -e "The ansible-control can not create the directory: ${RD}${CTRLFILEDIR}/${HOSTNAME}${EC}! Aborting..."
				echo "${DATA} ; ${USER} ; error ; The ansible-control can not create the directory ${CTRLFILEDIR}/${HOSTNAME}! Aborting..." >> ${LOGCTRL}
				echo 
				exit 1
			}
			fi
			${CHMOD} g+w ${CTRLFILEDIR}/${HOSTNAME}
			if [ "$?" -eq "0" ] ; then {
                                echo
                                echo -e "The ansible-control can not change permissions for the directory: ${RD}${CTRLFILEDIR}/${HOSTNAME}${EC}"
				echo "${DATA} ; ${USER} ; error ; The ansible-control can not change permissions for the directory ${CTRLFILEDIR}/${HOSTNAME}! Aborting..." >> ${LOGCTRL}
                                echo 
                                exit 1
                        }
                        fi
			${CHOWN} ${ANSUSER}.${GRPANS} ${CTRLFILEDIR}/${HOSTNAME} 
			if [ "$?" -eq "0" ] ; then {
                                echo
                                echo -e "The ansible-control can not change owner/group (${USERANS}:${GRPANS}) of the directory: ${RD}${CTRLFILEDIR}/${HOSTNAME}${EC}"
				echo "${DATA} ; ${USER} ; error ; The ansible-control can not change owner/group (${USERANS}:${GRPANS}) of the directory: ${CTRLFILEDIR}/${HOSTNAME}! Aborting..." >> ${LOGCTRL}
                                echo 
                                exit 1
                        }
                        fi
			ansible-control ${HOSTNAME} bkp
		}
                fi
	echo
}
fi
}

# Search playbooks created
SRCPLAYBOOKS(){
for PLAYBOOK in $(${LS} -l ${PLBKDIR} | awk -F ' ' '{ print $9 }' | sort | uniq) ;
do
	echo "${PLAYBOOK}" >> "${TEMPLATES}/${HOSTNAME}/.playbooks"
done
}

# Check if playbook control exist
CTRLFILE(){
if [ -d "${TEMPLATES}/${HOSTNAME}" ] ; then {
	if [ -f "${TEMPLATES}/${HOSTNAME}/.playbooks" ] ; then {
		CHECK="true"
	}
	else {
		CHECK="false"
	}
	fi
}
else {
	CHECK="false"
	echo
	echo -e " The directory template for host ${YE}${HOSTNAME}${EC} not exist! Please, verify!"
	echo "${DATA} ; ${USER} ; error ; The directory template for host ${HOSTNAME} not exist! Aborting..." >> ${LOGCTRL}
	echo
	exit 1
}
fi

}

# Case selection
case "$2" in
	add)
		CTRLFILE
		if [ "${CHECK}" == "true" ] ; then {
			echo
			echo -e " The playbook control file exist! Nothing to do ..."
			echo -e " Run: ${GR}ansible-control <servername> edit${EC} to edit this file."
			echo
		}
		else {
			# Create .playbooks file
			${TOUCH} ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				TOUCHFILE="OK"
                        }
                        fi

			# Change permissions for .playbooks
			${CHMOD} 640 ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				CHGPERM="OK"
                        }
                        fi

			# Change onwer/group for .playbooks
			${CHOWN} ${USERANS}.${GRPANS} ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				CHGOWN="OK"
                        }
                        fi

			# Populate the file with playbooks in /git/playbooks
			SRCPLAYBOOKS

			# Lock the file
			${CHATTR} +i ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				LOCKFILE="OK"
			}
			fi

			if [ "${TOUCHFILE}" == "OK" ] && [ "${CHGPERM}" == "OK" ] && [ "${CHGOWN}"  == "OK" ]  && [ "${LOCKFILE}" == "OK" ] ; then {
					echo
					echo -e " The playbook control file for host ${CY}${HOSTNAME}${EC} has ${GR}been created!${EC}"
					echo "${DATA} ; ${USER} ; info ; The playbook control file for host ${HOSTNAME} has been created!" >> ${LOGCTRL}
					echo
			}
			else {
				echo
				echo -e " The playbook control file for host ${CY}${HOSTNAME}${EC} has ${RD}not created!${EC} Verify!"
				echo "${DATA} ; ${USER} ; error ; The playbook control file for host ${HOSTNAME} has not created! Verify!" >> ${LOGCTRL}
				echo
			}
			fi
		
		}
		fi
		exit 0
    	;;
	del)

		# Check directory backup
		CHECKDIRBKP

		# Check file
		CTRLFILE

		# Delete file
		if [ "${CHECK}" == "true" ] ; then {
                        ${CHATTR} -i ${TEMPLATES}/${HOSTNAME}/.playbooks
			cd ${TEMPLATES}/${HOSTNAME}/
			${TAR} -cf ${CTRLFILEDIR}/${HOSTNAME}/${HOSTNAME}_${DATA}.playbooks.gz .playbooks
			if [ $? -eq "0" ] ; then {
				echo
				echo -e " The safety copy has been created in: ${YE}${CTRLFILEDIR}/${HOSTNAME}/${HOSTNAME}_${DATA}.playbooks.gz${EC}"
				rm -f ${TEMPLATES}/${HOSTNAME}/.playbooks
				if [ $? -eq "0" ] ; then {
					echo -e " The playbook control file ${TEMPLATES}/${HOSTNAME}/.playbooks ${GR}has been deleted!${EC}"
					echo "${DATA} ; ${USER} ; info ; The playbook control file for host ${HOSTNAME} has been deleted!" >> ${LOGCTRL}
					echo
				}
				else {
					echo -e " The playbook control file ${TEMPLATES}/${HOSTNAME}/.playbooks ${RD}can not be deleted!${EC} Aborting..."
					echo "${DATA} ; ${USER} ; error ; The playbook control file for host ${HOSTNAME} can not be deleted!" >> ${LOGCTRL}
					echo
					exit 1
				}
				fi
			}
			else {
				echo
				echo -e " The safety copy ${RD}can not${EC} be created in '${CTRLFILEDIR}/${HOSTNAME}/' directory! Aborting..."
				echo "${DATA} ; ${USER} ; error ; The safety copy can not be created n '${CTRLFILEDIR}/${HOSTNAME}/' directory!" >> ${LOGCTRL}
				echo
				exit 1
			}
			fi
                }
                else {
			echo
                	echo -e " The playbook control file for ${HOSTNAME} ${RD}not exist!${EC} Aborting..."
			echo "${DATA} ; ${USER} ; error ; The playbook control file for ${HOSTNAME} not exist! Aborting..." >> ${LOGCTRL}
                       	echo
			exit 1
                }
                fi
    	;;
	bkp)
	 	# Check directory backup
                CHECKDIRBKP

                # Check file
                CTRLFILE

                # Backup file
                if [ "${CHECK}" == "true" ] ; then {
                        ${CHATTR} -i ${TEMPLATES}/${HOSTNAME}/.playbooks
                        cd ${TEMPLATES}/${HOSTNAME}
                        ${TAR} -cf ${CTRLFILEDIR}/${HOSTNAME}/${HOSTNAME}_${DATA}.playbooks.gz .playbooks
                        if [ $? -eq "0" ] ; then {
			    ${CHATTR} +i ${TEMPLATES}/${HOSTNAME}/.playbooks
                            echo
                            echo -e " The safety copy has been ${GR}created${EC} in: ${YE}${CTRLFILEDIR}/${HOSTNAME}/${HOSTNAME}_${DATA}.playbooks.gz${EC}"
			    echo "${DATA} ; ${USER} ; info ; The safety copy has been created in: ${CTRLFILEDIR}/${HOSTNAME}/${HOSTNAME}_${DATA}.playbooks.gz" >> ${LOGCTRL}
			    echo
			}
			else {
				${CHATTR} +i ${TEMPLATES}/${HOSTNAME}/.playbooks
                        	echo -e " The safety copy ${RD}can not${EC} be created in '${CTRLFILEDIR}/${HOSTNAME}' directory! Aborting..."
				echo "${DATA} ; ${USER} ; error ; The safety copy ${RD}can not${EC} be created in '${CTRLFILEDIR}/${HOSTNAME}' directory! Aborting..." >> ${LOGCTRL}
                        	echo
                        	exit 1
                	}
                	fi
		}
		else {
			echo
                        echo -e " The playbook control file for ${HOSTNAME} ${RD}not exist!${EC} Aborting..."
			echo "${DATA} ; ${USER} ; error ; The playbook control file for ${HOSTNAME} not exist! Aborting..." >> ${LOGCTRL}
                        echo
                        exit 1
		}
		fi
	;;
	res)
		# Check if directory backup exist
		CHECKDIRBKP

		echo
                ${LS} -l ${CTRLFILEDIR}/${HOSTNAME} | grep "${HOSTNAME}_" | awk -F ' ' '{ print $9 }'
                echo
                echo -e "Select file for restore ${YE}(ex.: servername_<date>-<time>.playbooks.gz)${EC}:"
                read OPTION
                if [ -f "${CTRLFILEDIR}/${HOSTNAME}/${OPTION}" ] ; then {
                        if [ -d "${TEMPLATES}/${HOSTNAME}" ] ; then {

				# Need re-check if .playbooks exist
				if [ -f "${TEMPLATES}/${HOSTNAME}/.playbooks" ] ; then {
					
					# Unlock file
					${CHATTR} -i ${TEMPLATES}/${HOSTNAME}/.playbooks
					if [ "$?" -eq "0" ] ; then {
						UNLOCK="OK"
					}
					fi
					
					# Extract file
					${TAR} -xf ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} -C ${TEMPLATES}/${HOSTNAME}
					if [ "$?" -eq "0" ] ; then {
                                                EXTRACT="OK"
                                        }
                                        fi

					# Lock restored file again
					${CHATTR} +i ${TEMPLATES}/${HOSTNAME}/.playbooks
					if [ "$?" -eq "0" ] ; then {
                                                LOCKFILE="OK"
                                        }
                                        fi
					
					# Check results

					if [ "${UNLOCK}" == "OK" ] && [ "${EXTRACT}" == "OK" ] && [ "${LOCKFILE}" == "OK" ] ; then {
						echo
                                		echo -e " The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} ${GR}has restored!${EC}"
					        echo "${DATA} ; ${USER} ; info ; The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} has restored!" >> ${LOGCTRL}	
						echo
					}
					else {
						echo
                                                echo -e " The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} ${RD}not restored!${EC}"
						echo "${DATA} ; ${USER} ; error ; The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} not restored!" >> ${LOGCTRL}
                                                echo
					}
					fi


				}
				# If .playbooks not exist when the user run ansible-control with 'res' option
				else {
					${TAR} -xf ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} -C ${TEMPLATES}/${HOSTNAME}
					if [ "$?" -eq "0" ] ; then {
						echo
                                                echo -e " The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} ${GR}has restored!${EC}"
                                                echo "${DATA} ; ${USER} ; info ; The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} has restored!" >> ${LOGCTRL} 
                                                echo
					}
					else {
						echo
                                                echo -e " The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} ${RD}not restored!${EC}"
                                                echo "${DATA} ; ${USER} ; error ; The ${CTRLFILEDIR}/${HOSTNAME}/${OPTION} not restored!" >> ${LOGCTRL}
                                                echo
					}
					fi
				}
				fi
				
                        }
                        else {
				echo -e " The backup of playbook control file ${RD}not found!${EC}"
				echo "${DATA} ; ${USER} ; error ; The backup of playbook control file not found!" >> ${LOGCTRL}
                                echo
                        }
                        fi
                }
                else {
                        echo
                        echo -e " The file (${YE}${OPTION}${EC}) selected for restore ${RD}not exist!${EC} re-run the command!"
			echo "${DATA} ; ${USER} ; warn ; The file (${OPTION}) selected for restore not exist! re-run the command!" >> ${LOGCTRL}
                        echo
                }
                fi
                echo
	;;
	edit)
	 	# Check directory backup
                CHECKDIRBKP

                # Check file
                CTRLFILE

                # Backup file
                if [ "${CHECK}" == "true" ] ; then {
			
			# Routine for backup
			BKP="x"
			while ! [[ ${BKP} = [YyNn] ]]; 
			do
				echo
				echo -e " Do you would like to do a ${CY}backup${EC} of playbook control file? [Y/y/N/n]"
				echo -e " ${GR}Y/y${EC} - for create a backup"
				echo -e " ${RD}N/n${EC} - for do not create a backup"
				echo
				echo -e " What do you to do?"
				read BKP
			done
			if [ ${BKP} == "Y" ] || [ ${BKP} == "y" ] ; then {
				ansible-control ${HOSTNAME} bkp
			}
			fi

			# Unlock file for edit
                        ${CHATTR} -i ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				UNLOCK="OK"
			}
			fi

			# Edit file
                        ${VI} ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				EDIT="OK"

			}
			fi

			# Lock file again
			${CHATTR} +i ${TEMPLATES}/${HOSTNAME}/.playbooks
			if [ $? -eq "0" ] ; then {
				LOCK="OK"
			}
			fi
			
			# Check results
			if [ "${UNLOCK}" == "OK" ] && [ "${EDIT}" == "OK" ] && [ "${LOCK}" == "OK" ] ; then {
				echo -e " The file ${YE}${TEMPLATES}/${HOSTNAME}/.playbooks${EC} has been edited by ${GR}${USER}${EC}"
				echo "${DATA} ; ${USER} ; info ; The file ${TEMPLATES}/${HOSTNAME}/.playbooks has been edited" >> ${LOGCTRL}
				echo
			}
			else {
				echo -e " There are some ${RD}error${EC} in edit option"
				echo "${DATA} ; ${USER} ; error ; The file ${TEMPLATES}/${HOSTNAME}/.playbooks has been edited" >> ${LOGCTRL}
				echo
			}
			fi
		}
		else {
			echo
                        echo -e " The playbook control file for ${HOSTNAME} ${RD}not exist!${EC} Aborting..."
                        echo " ${DATA} ; ${USER} ; error ; The playbook control file for ${HOSTNAME} not exist! Aborting..." >> ${LOGCTRL}
                        echo
                        exit 1
		}
		fi
	;;
	*)
	BANNER="Ansible Framework v1.0 (Created by Joca! 'jocalinux@gmail.com')"
	echo
        echo -e $"#${CY} ${BANNER} ${EC}"
	echo
    	echo -e $" Usage: ansible-control ${CY}<server>${EC} {${GR}add${EC}|${GR}del${EC}|${GR}bkp${EC}|${GR}res${EC}|${GR}edit${EC}}"
	echo
	echo -e "${GR} add:${EC}${WT}  ansible-control <server> add  ${EC} - to add a playbook control file"
	echo -e "${GR} del:${EC}${WT}  ansible-control <server> del  ${EC} - to delete a playbook control file"
	echo -e "${GR} bkp:${EC}${WT}  ansible-control <server> bkp  ${EC} - to create a backup of a playbook control file if exist"
	echo -e "${GR} res:${EC}${WT}  ansible-control <server> res  ${EC} - to restore a backup of a playbook control file if exist"
	echo -e "${GR} edit:${EC}${WT} ansible-control <server> edit ${EC} - to edit a playbook control file"
	echo

esac

af/scripts/ansible-template0000750000000000000000000002426613407163321015012 0ustar  rootroot#!/bin/bash
# Created by Jocalinux
# Any help? jocalinux@gmail.com
# www.jocalinux.com.br

# Load settings
. /af/configs/settings

# Vars
HOSTNAME=$1
HOSTGRP=$1
OPTION=$2
MODEL=$3

# Functions
SRCMODELS(){
for MODELS in $(ls -l ${MODELS}/ | awk -F ' ' '{ print $9 }') ;
do
        echo -e $"${YE} ${MODELS} ${EC}"
done
}


BACKUP(){
	cd ${TEMPLATES}/${HOSTNAME}
	${TAR} -cf ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz * 
}

PERMISSIONS(){

	# Extract backup file
	${TAR} -xf ${BACKUPSDIR}/templates/${OPTION} -C ${TEMPLATES}/${HOSTNAME}/
	if [ $? -eq "0" ] ; then { 
		STP1="OK" 
	} 
	fi

	# Change owner for root user and ansible group
	${CHOWN} ${USERANS}.${GRPANS} ${TEMPLATES}/${HOSTNAME}
	if [ $? -eq "0" ] ; then { 
		STP2="OK" 
	} 
	fi

	# Change permissions for ansible group
	${CHMOD} g+r ${TEMPLATES}/${HOSTNAME} ${TEMPLATES}/${HOSTNAME}/*
	if [ $? -eq "0" ] ; then { 
		STP3="OK" 
	} 
	fi

	# Result extract backup file
	if [ "${STP1}" == "OK" ] ; then {
		echo -e " ${GR}OK${EC}     - Extract backup file!"
	}
	else {
		echo -e " ${RD}NOT OK${EC} - Extract backup file!"
	}
	fi

	# Result change owner and group
	if [ "${STP2}" == "OK" ] ; then {
		echo -e " ${GR}OK${EC}     - Change owner and group!"
	}
	else {
        	echo -e " ${RD}NOT OK${EC} - Change owner and group!"
	}
	fi

	# Result permissions
	if [ "${STP3}" == "OK" ] ; then {
		echo -e " ${GR}OK${EC}     - Add write permission for ansible group!"
	}
	else {
        	echo -e " ${RD}NOT OK${EC} - Add write permission for ansible group!"
	}
	fi

	# Register logs
	if [ "${STP1}" == "OK" ] && [ "${STP2}" == "OK" ] && [ "${STP3}" == "OK" ] ; then {
		echo
		echo -e " ${GR}The restore (${OPTION}) has sucessfully!${EC}"
		echo "${DATA} ; ${USER} ; info ; The restore (${OPTION}) has sucessfully!" >> ${LOGSTMTE}
		
	}
	else {
		echo
		echo -e " The ansible template ${RD}can not${EC} restore the file: ${RD}${OPTION}${EC}"
		echo "${DATA} ; ${USER} ; error ; The ansible template can not restore the file: ${OPTION}" >> ${LOGSTMTE}
		echo
		exit 1
	}
	fi
}

# Case selection
case "$2" in
	add)
		if [ -d "${TEMPLATES}/${HOSTNAME}" ] ; then {
			echo
			echo -e "The template directory server ${YE}${TEMPLATES}/${HOSTNAME}${EC} exist!"
			echo "${DATA} ; ${USER} ; warn ; The template directory server '${TEMPLATES}/${HOSTNAME}' exist" >> ${LOGSTMTE}
			echo
			exit 1
		}
		else {
			if [ -z "${MODEL}" ] ; then {
				echo
				echo -e "The model template${RD} not selected!${EC}"
				echo
				echo -e "Run:${GR} ansible-template <server> add <model>${EC}"
				echo
				echo "Available templates:"
				echo
				SRCMODELS
				echo
			}
			else {

				if [ -d "${MODELS}/${MODEL}" ] ; then {
					# Create Directory
					${MKDIR} -p ${TEMPLATES}/${HOSTNAME}
					if [ $? -eq "0" ] ; then {
						CREATEDIR="OK"
					}
					fi

					# Copy files
					${CP} -pfR ${MODELS}/${MODEL}/* ${TEMPLATES}/${HOSTNAME}
					if [ $? -eq "0" ] ; then {
                                                CPFILES="OK"
                                        }
                                        fi

					# Change owner
					${CHOWN} ${USERANS}.${GRPANS} ${TEMPLATES}/${HOSTNAME}
					if [ $? -eq "0" ] ; then {
                                                CHGOWNER="OK"
                                        }
                                        fi

					# Change mod
					${CHMOD} g+r ${TEMPLATES}/${HOSTNAME} ${TEMPLATES}/${HOSTNAME}/*
					if [ $? -eq "0" ] ; then {
                                                CHGMOD="OK"
                                        }
                                        fi

					# Check steps
					if [ "${CREATEDIR}" == "OK" ] \
						&& [ "${CPFILES}" == "OK" ] \
						&& [ "${CHGOWNER}" == "OK" ] \
						&& [ "${CHGMOD}" == "OK" ] ; then { 
							echo
							echo -e "${CY}Added${EC} a new structure server! ${GR}(${HOSTNAME}) :) - OK${EC}"
							echo "${DATA} ; ${USER} ; info ; Added a new structure server! (${HOSTNAME}) :) - OK" >> ${LOGSTMTE}
							echo
					}
					else {
						echo
						echo -e "There are any ${RD}error${EC} to add a new structure server for ${CY}${HOSTNAME}${EC} :("
						echo "${DATA} ; ${USER} ; error ; There are any error to add a new structure server for ${CY}${HOSTNAME}${EC}" >> ${LOGSTMTE}
						echo
						exit 1
					}
					fi
					exit 0
				}
				else {
					echo
					echo -e "The model ${YE}${MODEL}${EC} template${RD} not exist!${EC}"
					echo "${DATA} ; ${USER} ; warn ; The model ${MODEL} template not exist!" >> ${LOGSTMTE}
					echo
					echo -e "Run:${GR} ansible-template <server> add <model>${EC}"
                               		echo
					echo "Available templates:"
					echo
					SRCMODELS
					echo
				}
				fi
			}
			fi
		}
		fi
    	;;
	del)
		
		if [ -d "${TEMPLATES}/${HOSTNAME}" ] ; then {
			
			# If .playbooks exist
			if [ -f "${TEMPLATES}/${HOSTNAME}/.playbooks" ] ; then {
				${CHATTR} -i ${TEMPLATES}/${HOSTNAME}/.playbooks
				echo
                        	cd ${TEMPLATES}/${HOSTNAME}
                       	 	${TAR} -cf ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz * .playbooks
				if [ $? -eq "0" ] ; then {
                        		echo -e "The ${TEMPLATES}/${HOSTNAME} has been saved in:${YE} ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz${EC}"
                        		${RM} -rf ${TEMPLATES}/${HOSTNAME}
					if [ $? -eq "0" ] ; then {
                        			echo -e "Deleted the old directory server template!${GR} (${HOSTNAME}) :) - OK${EC}"
                        			echo "${DATA} ; ${USER} ; info ; Deleted the old directory server template for ${HOSTNAME}" >> ${LOGSTMTE}
						echo
                        			exit 0
					}
					else {
						echo -e "The ansible-template can not delete the old directory server template for ${HOSTNAME}"
						echo "${DATA} ; ${USER} ; error ; The ansible-template can not delete the old directory server template for ${HOSTNAME}" >> ${LOGSTMTE}
					}
					fi
				}
				else {
					echo
					echo -e "The ansible-template ${RD}can${EC} not a safety copy before delete the template directory! Aborting..."
					echo "${DATA} ; ${USER} ; error ; The ansible-template can not a safety copy before delete the template directory! Aborting..." >> ${LOGSTMTE}
				}
				fi
			}
			else {
				echo
                        	cd ${TEMPLATES}/${HOSTNAME}
                        	${TAR} -cf ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz *
				if [ $? -eq "0" ] ; then {
					echo -e "The ${TEMPLATES}/${HOSTNAME} has been saved in:${YE} ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz${EC}"
                        		${RM} -rf ${TEMPLATES}/${HOSTNAME}
					if [ $? -eq "0" ] ; then {
                        			echo -e "Deleted the old directory server template! ${GR}(${HOSTNAME}) :) - OK${EC}"
                        			echo "${DATA} ; ${USER} ; info ; Deleted the old directory server template for ${HOSTNAME}" >> ${LOGSTMTE}
                        			echo
                        			exit 0
					}
					else {
						echo -e "The ansible-template can not delete the old directory server template for ${HOSTNAME}"
						echo "${DATA} ; ${USER} ; error ; The ansible-template can not delete the old directory server template for ${HOSTNAME}" >> ${LOGSTMTE}
					}
					fi
				}
				fi
			}
			fi
			
		}
		else {
			echo
                        echo -e "The template directory server ${RD}${TEMPLATES}/${HOSTNAME}${EC} do not exist!"
			echo "${DATA} ; ${USER} ; warn ; The template directory server '${TEMPLATES}/${HOSTNAME}${EC}' do not exist!" >> ${LOGSTMTE}
                        echo
			exit 1
		}
		fi
    	;;
	bkp)
		if [ -d "${TEMPLATES}/${HOSTNAME}" ] ; then {
			cd ${TEMPLATES}/${HOSTNAME}
                        ${TAR} -cf ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz *
			if [ $? -eq "0" ] ; then {
                        	echo
                        	echo -e "The ${TEMPLATES}/${HOSTNAME} has been saved in: ${GR}${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz${EC}"
				echo "${DATA} ; ${USER} ; info ; The ${TEMPLATES}/${HOSTNAME} has been saved in: ${BACKUPSDIR}/templates/${HOSTNAME}-${DATA}.gz" >> ${LOGSTMTE}
                        	echo
                        	exit 0
			}
			else {
				echo
				echo -e "The ansible-template ${RD}can not${EC} copy of ${TEMPLATES}/${HOSTNAME}! Aborting..."
				echo "${DATA} ; ${USER} ; error ; The ansible-template can not copy of ${TEMPLATES}/${HOSTNAME}! Aborting..." >> ${LOGSTMTE}
				echo
				exit 1
			}
			fi
                }
                else {
                        echo
                        echo -e "The template directory server ${TEMPLATES}/${HOSTNAME} do not exist!"
			echo "${DATA} ; ${USER} ; warn ; The template directory server ${TEMPLATES}/${HOSTNAME} do not exist!" >> ${LOGSTMTE}
        		echo
                        exit 1
                }
                fi		
	;;
	res)
		echo
                ${LS} -l ${BACKUPSDIR}/templates/ | grep "${HOSTNAME}-" | awk -F ' ' '{ print $9 }'
                echo
		echo -e "Select file for restore${YE} (ex.: servername-<date>-<time>.gz)${EC}:"
		read OPTION
		if [ -f "${BACKUPSDIR}/templates/${OPTION}" ] ; then {
			if [ -d "${TEMPLATES}/$1" ] ; then {
				echo
				PERMISSIONS
			}
			else {
				${MKDIR} -p ${TEMPLATES}/${HOSTNAME}
				echo
				PERMISSIONS
			}
			fi
		}
		else {
			echo
                       	echo -e "The selected file (${OPTION}) for restore ${RD}not exist!${EC} re-run the command!"
			echo "${DATA} ; ${USER} ; warn ; The selected file (${OPTION}) for restore not exist! re-run the command!" >> ${LOGSTMTE}
                       	echo
		}
		fi
                echo
	;;
	*)
	BANNER="Ansible Framework v1.0 (Created by Joca! 'jocalinux@gmail.com')"
	echo
	echo -e $"#${CY} ${BANNER} ${EC}"
	echo
    	echo -e $" Usage: ansible-template ${CY}<server>${EC} {${GR}add${EC}|${GR}del${EC}|${GR}bkp${EC}|${GR}res${EC}}"
	echo
	echo -e "${GR} add:${EC}${WT} ansible-template <server> add${EC} ${YE}<model>${EC} - to add a new template directory based on a model"
	echo -e "${GR} del:${EC}${WT} ansible-template <server> del        ${EC} - to delete the template directory server if exist"
	echo -e "${GR} bkp:${EC}${WT} ansible-template <server> bkp        ${EC} - to create a backup of the template directory server if exist"
	echo -e "${GR} res:${EC}${WT} ansible-template <server> res        ${EC} - to restore a backup file of the template directory server"
	echo
	echo " Models availables:"
	echo
	SRCMODELS
	echo

esac

af/tmp/0000775000000000000000000000000013407162604010747 5ustar  rootrootaf/templates/0000775000000000000000000000000013407162553012150 5ustar  rootrootaf/templates/server-test.mydomain.com/0000755000000000000000000000000013407162570017021 5ustar  rootrootaf/templates/server-test.mydomain.com/hostname0000644000000000000000000000003113407162570020554 0ustar  rootroot{{ inventory_hostname }}
af/playbooks/0000755000000000000000000000000013407162373012153 5ustar  rootrootaf/playbooks/hostname/0000755000000000000000000000000013407162443013767 5ustar  rootrootaf/playbooks/hostname/roles/0000755000000000000000000000000013326136435015115 5ustar  rootrootaf/playbooks/hostname/roles/hostname/0000755000000000000000000000000013313247711016727 5ustar  rootrootaf/playbooks/hostname/roles/hostname/tasks/0000755000000000000000000000000013407162465020062 5ustar  rootrootaf/playbooks/hostname/roles/hostname/tasks/main.yml0000644000000000000000000000066313407162465021536 0ustar  rootroot---
# Jocalinux 
# Ensure the /root/backups directory
- file:
    path: /root/backups
    state: directory
    mode: 0700

# Create a backup
- name: backup original /etc/hostname file
  copy: remote_src=yes src=/etc/hostname dest=/root/backups/hostname.original backup=yes
  ignore_errors: yes

# Copy the new hostname file
- name: copy /etc/hostname
  template: src=/git/templates/{{ inventory_hostname }}/hostname dest=/etc/hostname
af/playbooks/hostname/hosts/0000775000000000000000000000000013377755644015152 5ustar  rootrootaf/playbooks/hostname/hosts/sabesp0000664000000000000000000000005313377040475016335 0ustar  rootroot[hostname_hosts]
corp2597.ti.sabesp.com.br
af/playbooks/hostname/hostname.yml0000644000000000000000000000017213407162442016327 0ustar  rootroot---
# Jocalinux 
- name: configure /etc/hostname file
  hosts: hostname_hosts
  remote_user: root
  roles:
    - hostname
af/playbooks/hostname/group_vars/0000755000000000000000000000000013407162422016153 5ustar  rootrootaf/playbooks/hostname/group_vars/all0000644000000000000000000000007613407162422016651 0ustar  rootroot---
# Jocalinux 
# Ansible role: hostname
file: /etc/hostname
af/models/0000755000000000000000000000000013407162061011425 5ustar  rootrootaf/models/rhel74/0000755000000000000000000000000013407162201012526 5ustar  rootrootaf/models/rhel74/hostname0000644000000000000000000000003113326135775014301 0ustar  rootroot{{ inventory_hostname }}
af/logs/0000755000000000000000000000000013407162041011104 5ustar  rootroot