def json_from_url(url):
    """ Simple function to load json object from url """

    from urllib2 import urlopen
    import json

    response = urlopen(url)
    data = response.read().decode("utf-8")
    return json.loads(data)

class Switch:
    """ Class construct for a switch """

    from urllib2 import urlopen

    def __init__(self,name):
        self.name = name

    def get_vendor(self):
        """ Acquire device vendor by portalAPI """

        apiJson = json_from_url( 'https://portal.tower-research.com/portal/api/v1/netdb/device/?username=netops-api' \
                                 '&amp=&api_key=343242343232525325343243reewffgfdgdfgd&limit=0&offset=0&name=%s' \
                                 '&site__dns_prefix=%s' % ( self.name.split(".")[0], self.name.split(".")[1] ) )
        try: return apiJson['objects'][0]['vendor']['name']
        except: return

    def get_model(self):
        """ Simple function to strip out model information from hostname """
        try: return self.name.split(".")[0].split("-")[0]
        except: return

    def get_version(self):
        """ Wrapper of get_version_eapi and get_version_scrape """

        vendor  = self.get_vendor()
        if vendor == 'Arista': return self.get_version_eapi()
        elif vendor == 'Cisco' or vendor == 'Metamako': return self.get_version_scrape()
        else: return

    def get_version_eapi(self):
        """Acquires version from Arista platform via eAPI"""

        import socket
        from jsonrpclib import Server
        import errno
        import ssl
        import xmlrpclib

        try:
            _create_unverified_https_context = ssl._create_unverified_context
        except AttributeError:
            # Legacy Python that doesn't verify HTTPS certificates by default
            pass
        else:
            # Handle target environment that doesn't support HTTPS verification
            ssl._create_default_https_context = _create_unverified_https_context

        username = "netops"
        password = "$isg00d"
        socket.setdefaulttimeout(5.0)
        connection = Server( "https://%s:%s@%s/command-api" % (username, password, self.name) )
        try: response = connection.runCmds( 1, ["show version"] )
        except socket.error as msg: return msg
        except xmlrpclib.ProtocolError as err: '%s %s' % ( str(err.errcode), str(err.errmsg) )
        else: return response[0]['version']

    def get_version_scrape(self):
        """Acquires version from Cisco/Metamko platform via screen scrape"""

        import pexpect
        import socket

        username = "test"
        password = "test"
        sshCommand = 'ssh -l %s %s -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no \"show version\"' % (username, self.name)
        socket.setdefaulttimeout(5.0)
        p = pexpect.spawn(sshCommand)

        connectStatus = p.expect(['[Pp]assword:', pexpect.TIMEOUT, pexpect.EOF])
        if connectStatus == 0:
            p.sendline(password)
            authSuccess = p.expect([pexpect.EOF, '[Pp]assword:'])
            if authSuccess == 0: showVersion = p.before
            if authSuccess == 1: return "[Error: Incorrect credentials]"
        if connectStatus == 1: return "[Error: Timeout]"
        if connectStatus == 2: return "[Error: EOF]"

        model = self.get_model()
        if '3064' in model.lower():
            try: return [each.split()[2] for each in showVersion.split("\n") if 'system:' in each][0]
            except IndexError: return "[Error: Index out of range]"
        if '4900' in model.lower():
            try: return showVersion.split("\n")[2].split()[10].strip(",")
            except IndexError: return "[Error: Index out of range]"
        if 'meta' in model.lower():
            try: return showVersion.split("\n")[5].split()[3]
            except IndexError: return "[Error: Index out of range]"
        else:
            try: return showVersion.split("\n")[2].split()[7].strip(",")
            except IndexError: return "[Error: Index out of range]"

def get_version_printer(switch_class):
    """ Simple printer for formatting of output """

    return '{0:50} {1:40}'.format( switch_class.name, switch_class.get_version() )


def get_devices_from_portal(vendors=[], models=[], sites=[], live=True):
    """ Function to pull devices down from portalAPI based off filters """

    netdbDevices = json_from_url( 'https://portal.tower-research.com/portal/api/v1/netdb/device/' \
                                    '?username=netops-api&amp=&api_key=' \
                                    '2127c497de605b24253cfc7ffd02f5524f85cf33&limit=0&offset=0' )

    netdbObjects = netdbDevices['objects']

    # Match filters against returned values
    if sites: netdbObjects = [device for device in netdbObjects if device['site']['dns_prefix'] in sites]
    if models: netdbObjects = [device for device in netdbObjects if device['name'].split("-")[0] in models]
    if vendors: netdbObjects = [device for device in netdbObjects if device['vendor']['name'] in vendors]
    if live == True: netdbObjects = [device for device in netdbObjects if device['status'] == 1]
    return [each['name'] + "." + each['site']['dns_prefix'] for each in netdbObjects]

def main():
    """ Main function to print output based off user input """

    from datetime import datetime
    from multiprocessing.dummy import Pool as ThreadPool

    start = datetime.now()

    if args:
        print "Default argument provided, excluding filters..."
        print

        switches = [Switch(arg) for arg in args]

    if not args:
        print "Sites... " + str(opts.sites)
        print "Models... " + str(opts.models)
        print "Vendors... " + str(opts.vendors)
        print
        print "Executing..."
        print

        switches = [Switch(each) for each in get_devices_from_portal(opts.vendors, opts.models, opts.sites)]

    pool = ThreadPool(100)
    output = pool.map(get_version_printer, switches)
    pool.close()
    pool.join()

    print '{0:50} {1:40}'.format( "Hostname", "Version/Error" )
    print '{0:50} {1:40}'.format( "-" * len("Hostname"), "-" * len("Version/Error") )

    for each in sorted( output, key=lambda site: site.split(".")[1] ): print each

    print
    print "Duration: " + str(datetime.now() - start)

if __name__ == '__main__':

    import optparse
    import sys

    usage = "Usage: getVersion.py [-s site1 -s site2] [-m model1 -m model2] [-v vendor1 -v vendor2] switch1 switch2 switch3"
    parser = optparse.OptionParser(usage=usage)
    parser.add_option('-s', '--sites',
                      default=[],
                      action='append',
                      dest='sites',
                      help='Perform operations on following sites')
    parser.add_option('-v', '--vendors',
                      dest='vendors',
                      default=[],
                      action='append',
                      help='Perform operations on following vendors')
    parser.add_option('-m', '--models',
                      dest='models',
                      default=[],
                      action='append',
                      help='Perform operations on following models. Models are identifed by text leading up to first hyphen')
    opts, args = parser.parse_args()

    opts.sites = list( set(opts.sites) )
    opts.vendors = list( set(opts.vendors) )
    opts.models = list( set(opts.models) )

    main()