def create_interface(self, vip):
     try:
         vip=vip.split("/",1)[0]
         Shell.run('ifconfig lo:1 %s netmask 255.255.255.255 up' % (vip))
         logging.debug("Assigned VIP to the loopback interface")
     except Exception as ex:
           logging.error(ex)

 def clear_interface(self, vip):
     try:
        vip=vip.split("/",1)[0]
        Shell.run('ifconfig lo:1 %s netmask 255.255.255.255 down' % (vip))
        logging.debug("Removed VIP from loopback interface due to all backend failures")
     except Exception as ex:
            logging.error(ex)

def is_ambari_installed():
	sh = Shell()
	output = sh.run('which ambari-server')
	if len(output[0]) == 0:
		return False
	else:
		return True

 def __init__(self, basename):
     self.print_backtrace = True
     self.reader = 0
     self.logger = None
     Shell.__init__(self, basename)
     self.register_commands(self, self.NOCARD_COMMANDS)
     self.set_prompt("(No card) ")

    def post(self):
    	sh = Shell()

    	for line in request.form['code'].split('\n'):
    		retval = sh.push(line)

        return {'retval': retval.strip() }

 def namespace_init(self, daemon):
     output = Shell.run('ip netns list')
     for line in output.split():
         if line == 'ns-' + daemon:
             return False
     Shell.run('ip netns add ns-%s' % daemon)
     return True

    def test_chaining(self):
        sh = Shell(has_input=True)
        output = sh.run('cat -u').write('Hello, world!').output()
        self.assertEqual(output, ['Hello, world!'])

        output = shell('cat -u', has_input=True).write('Hello, world!').output()
        self.assertEqual(output, ['Hello, world!'])

    def test__handle_output_norecord(self):
        sh = Shell(record_output=False, record_errors=False)
        self.assertEqual(sh._stdout, '')
        self.assertEqual(sh._stderr, '')

        sh._handle_output('another.txt\n', 'Error: Please supply an arg.')
        self.assertEqual(sh._stdout, '')
        self.assertEqual(sh._stderr, '')

def is_hdp_select_installed():
	sh = Shell()
	output = sh.run('which hdp-select')
	
	if len(output[0]) == 0:
		return False
	else:
		return True

 def output(self):
   for ok in self.messages['ok']:
     print(Shell.color(ok, 'white', 'green'))
     
   for warning in self.messages['warning']:
     print(Shell.color(warning, 'yellow', 'black'))
     
   for error in self.messages['error']:
     print(Shell.color(error, 'white', 'red'))

 def run(self):
     shell = Shell()
     print(self.three_level_dir_repr(), end='')
     command = input().strip()
     while(command != 'exit'):
         ret_msg = shell.process_command(command)
         print(ret_msg)
         print(self.three_level_dir_repr(), end='')
         command = input().strip()

 def _get_master_ifname(self, daemon, ifname_instance):
     output = Shell.run('ip netns exec ns-%s ethtool -S %s' %
                        (daemon, ifname_instance))
     m = re.search(r'peer_ifindex: (\d+)', output)
     ifindex = m.group(1)
     output = Shell.run('ip link list')
     expr = '^' + ifindex + ': (\w+): '
     regex = re.compile(expr, re.MULTILINE)
     m = regex.search(output)
     return m.group(1)

def install_nifi():

	logger.info('Attempting to install NiFi to the cluster')
	if not is_ambari_installed():
		logger.error('Ambari must be installed to install NiFi as well.')
		raise EnvironmentError('You must install the demo on the same node as the Ambari server. Install Ambari here or move to another node with Ambari installed before continuing')
	
	
	if not is_hdp_select_installed():
		installed = install_hdp_select()
		if not installed:
			logger.error('hdp-select must be installed to install NiFi')
			raise EnvironmentError('hdp-select could not be installed. Please install it manually and then re-run the setup.')

	conf = config.read_config('service-installer.conf')
	cmds = json.loads(conf['NIFI']['install-commands'])
	
	sh = Shell()
	logger.info('Getting HDP Version')
	version = sh.run(cmds[0])
	logger.info('HDP Version: ' + version[0])
	fixed_copy = cmds[2].replace('$VERSION', str(version[0])).replace('\n', '')
	fixed_remove = cmds[1].replace('$VERSION', str(version[0])).replace('\n', '')
	logger.info('NiFi Clean Command: ' + fixed_copy)
	logger.info('NiFi Copy Command: ' + fixed_remove)
	remove = sh.run(fixed_remove)
	copy = sh.run(fixed_copy)
	logger.info('Attempting to restart Ambari...')
	restart = sh.run(cmds[3])

	print("Please open the Ambari Interface and manually deploy the NiFi Service.")
	raw_input("Press enter twice to continue...")
	raw_input("Press enter once to continue...")
	
#	 We've copied the necessary files. Once that completes we need to add it to Ambari
	logger.info('Waiting for user to install service in Ambari to continue')
	print('Checking to make sure service is installed')
	ambari = config.read_config('global.conf')['AMBARI']
	installed = check_ambari_service_installed('NIFI', ambari)
	logger.info('NiFi installed successfully')
	cont = ''
	if not installed:
		print('Unable to contact Ambari Server. Unsure whether or not Zeppelin was installed')
		while not (cont == 'y' or cont == 'n'):
			cont = raw_input('Continue attempt to set up NiFi for demo?(y/n)')
			if not (cont == 'y' or cont == 'n'):
				print('Please enter "y" or "n"')
	else:
		cont = 'y'
	
	if cont == 'n':
		return False
	elif cont == 'y':
		return True

    def test__handle_output_simple(self):
        sh = Shell()
        self.assertEqual(sh._stdout, '')
        self.assertEqual(sh._stderr, '')

        sh._handle_output('another.txt\n', None)
        self.assertEqual(sh._stdout, 'another.txt\n')
        self.assertEqual(sh._stderr, '')

        sh._handle_output('something.txt\n', 'Error: Please supply an arg.\n')
        self.assertEqual(sh._stdout, 'another.txt\nsomething.txt\n')
        self.assertEqual(sh._stderr, 'Error: Please supply an arg.\n')

def is_hdp_select_installed():
  '''Checks if ``hdp-select`` is installed.
  
  Returns:
    bool: True if installed (available as shell command), False if not installed'''
  sh = Shell()
  output = sh.run('which hdp-select')
  
  if len(output[0]) == 0:
    return False
  else:
    return True

def is_ambari_installed():
  '''Determines whether or not ``ambari-server`` is available (In order to start/stop/restart Ambari)
  
  Returns:
    bool: True is ``ambari-server`` is available as a shell command. False otherwise.
  
  '''
  sh = Shell()
  output = sh.run('which ambari-server')
  if len(output[0]) == 0:
    return False
  else:
    return True

	def main_loop(self):
		while(self.__location <> "quit"):
			try:
				gesture = self.show(self.__location)
				if gesture[0] != "!":
					self.__history.append(gesture)
				page = self(gesture)
				if page is not None: self.__location = page
			except KeyboardInterrupt:
				break
			except Exception, e:
				Shell.show_message(`e`, 1)
				raise

def teardown(pod_namespace, pod_name, docker_id):
    manager = LxcManager()
    short_id = docker_id[0:12]

    api = ContrailVRouterApi()

    uid, podName = getDockerPod(docker_id)
    vmi, _ = vrouter_interface_by_name(podName)
    if vmi is not None:
        api.delete_port(vmi)

    manager.clear_interfaces(short_id)
    Shell.run('ip netns delete %s' % short_id)

    def interface_find_peer_name(self, nsname):
        ifname_instance = Shell.run(
            'ip netns exec %s ip link show eth0 | '
            'awk \'/eth0/{split($2, array, \":\"); print array[1];}\'' %
            nsname)
        logging.debug('instance interface %s' % ifname_instance)

        # Get ifindex of ifname_instance
        ns_ifindex = Shell.run('ip netns exec %s ethtool -S eth0 | '
                               'grep peer_ifindex | awk \'{print $2}\''
                               % (nsname))

        ifname = ifindex2name(int(ns_ifindex))
        return ifname

    def interface_update(self, daemon, vmi, ifname_instance):
        """
        1. Make sure that the interface exists in the name space.
        2. Update the mac address.
        """
        output = Shell.run('ip netns exec ns-%s ip link list' % daemon)
        if not self._interface_list_contains(output, ifname_instance):
            ifname_master = self.create_interface('ns-%s' % daemon, ifname_instance)
        else:
            ifname_master = self._get_master_ifname(daemon, ifname_instance)

        mac = vmi.virtual_machine_interface_mac_addresses.mac_address[0]
        Shell.run('ip netns exec ns-%s ifconfig %s hw ether %s' %
                  (daemon, ifname_instance, mac))
        return ifname_master