Ejemplo n.º 1
0
 def testGetDict(self):
     host = Host('foo')
     host.set_address('foo2')
     self.assertEqual(host.get_dict(), {'hostname': 'foo',
                                        'address':  'foo2',
                                        'protocol': 'telnet',
                                        'port':     23})
Ejemplo n.º 2
0
    def testGetAll(self):
        self.assertEqual(self.host.get_all(), {'testarg': 1})
        self.testSetAll()
        self.assertEqual(self.host.get_all(), {'test1': 1, 'test2': 2})

        host = Host('localhost')
        self.assertEqual(host.get_all(), {})
Ejemplo n.º 3
0
    def testGetAll(self):
        self.assertEqual(self.host.get_all(), {'testarg': 1})
        self.testSetAll()
        self.assertEqual(self.host.get_all(), {'test1': 1, 'test2': 2})

        host = Host('localhost')
        self.assertEqual(host.get_all(), {})
Ejemplo n.º 4
0
 def testGetDict(self):
     host = Host('foo')
     host.set_address('foo2')
     self.assertEqual(host.get_dict(), {
         'hostname': 'foo',
         'address': 'foo2',
         'protocol': 'telnet',
         'port': 23
     })
Ejemplo n.º 5
0
 def __init__(self, name = 'fake'):
     self.function = lambda x: None
     self.name     = name
     self.failures = 0
     self.data     = {'pipe':   0,
                      'stdout': sys.stdout,
                      'host':   Host('foo')}
Ejemplo n.º 6
0
def run_command(rmq_channel, command, hosts, threads):
    """Execute command on remote host"""
    from Exscript import Account, Host
    from Exscript.util.start import start

    results = {}

    def do_something(thread, host, conn):
        #conn.execute('vtysh -c "%s"' % command)
        conn.execute(command)
        result = repr(conn.response)
        data = {
            host.address: {
                command: result
            },
        }
        body = json.dumps(data)
        rmq_channel.basic_publish(exchange='measure',
                                  routing_key="result",
                                  body=body)
        #conn.execute("exit")

    accounts = [Account("root", password="******")]

    hosts = [Host(h, default_protocol="ssh") for h in hosts]
    #TODO: open multiple ssh sessions
    start(accounts, hosts, do_something, max_threads=threads)
    return results
Ejemplo n.º 7
0
  def handle(self, *args, **options):
    if options['all'] and options['device_id']:
      print ("Error: --all and --deviceid detected. Use only one")
      return

    if options['all']:
      devices = Device.objects.all()

    if options['device_id']:
      try:
        devices = [ Device.objects.get(pk=int(options['device_id'])) ]
      except:
        raise CommandError('Device ID "%s" does not exist' % options['device_id'])

    for device in devices:
      found_credential = False
      for credential in Credential.objects.all():
        if credential.match_ip(device.access_ip):
          found_credential = True
          host = Host(device.protocol + device.access_ip)
          account = (Account(credential.username,
                        credential.password))

          if credential.enable_username and credential.enable_password:
            account.set_authorization_password(credential.enable_password)

          host.set_account(account)
          host.set('device', device)
          hosts.append(host)
          break
      if not found_credential:
       device.backup_status = "No credentials found." % device
       device.save()

    queue = Queue(max_threads = 5, verbose = -1, stderr=open(os.devnull, 'w'))
    queue.run(hosts, do_backup)
    queue.shutdown()

    for log in logger.get_logs():
      device = Device.objects.get(access_ip=log.get_name())
      if log.has_error():
        device.backup_status = log.get_error(False)
      else:
        device.backup_status = 'ok'
      device.backup_last_ran = now()
      device.save()
Ejemplo n.º 8
0
    def testConstructor(self):
        host = Host('localhost')
        self.assertEqual(host.get_protocol(), 'telnet')
        host = Host('localhost', default_protocol = 'foo')
        self.assertEqual(host.get_protocol(), 'foo')

        for url, result in urls:
            host = Host(url)
            uri  = Url.from_string(url)
            self.assertEqual(host.get_name(),    uri.hostname)
            self.assertEqual(host.get_address(), uri.hostname)
            self.assertEqual(host.get_uri(), str(uri))
Ejemplo n.º 9
0
    def testToHosts(self):
        from Exscript.util.cast import to_hosts
        self.assertRaises(TypeError, to_hosts, None)

        result = to_hosts([])
        self.assertIsInstance(result, list)
        self.assertEqual(len(result), 0)

        result = to_hosts('localhost')
        self.assertIsInstance(result, list)
        self.assertEqual(len(result), 1)
        self.assertIsInstance(result[0], Host)

        result = to_hosts(Host('localhost'))
        self.assertIsInstance(result, list)
        self.assertEqual(len(result), 1)
        self.assertIsInstance(result[0], Host)

        hosts = ['localhost', Host('1.2.3.4')]
        result = to_hosts(hosts)
        self.assertIsInstance(result, list)
        self.assertEqual(len(result), 2)
        self.assertIsInstance(result[0], Host)
        self.assertIsInstance(result[1], Host)
Ejemplo n.º 10
0
 def testToHost(self):
     from Exscript.util.cast import to_host
     self.assertIsInstance(to_host('localhost'), Host)
     self.assertIsInstance(to_host(Host('localhost')), Host)
     self.assertRaises(TypeError, to_host, None)
Ejemplo n.º 11
0
        raise Exception("unsupported os: " + repr(conn.guess_os()))

    # autoinit() automatically executes commands to make the remote
    # system behave more script-friendly. The specific commands depend
    # on the detected operating system, i.e. on what guess_os() returns.
    conn.autoinit()

    # Execute a simple command.
    conn.execute("show ip int brie")
    print "myvariable is", conn.get_host().get("myvariable")


def two(job, host, conn):
    conn.autoinit()
    conn.execute("show interface POS1/0")


accounts = get_accounts_from_file("accounts.cfg")

# Start on one host.
host = Host("localhost")
host.set("myvariable", "foobar")
start(accounts, host, one)

# Start on many hosts. In this case, the accounts from accounts.cfg
# are only used if the host url does not contain a username and password.
# The "max_threads" keyword indicates the maximum number of concurrent
# connections.
hosts = get_hosts_from_file("hostlist.txt")
start(accounts, hosts, two, max_threads=2)
Ejemplo n.º 12
0
 def testGetUri(self):
     for url, result in urls:
         host = Host(url)
         uri = Url.from_string(url)
         self.assertEqual(host.get_uri().split('&').sort(),
                          str(uri).split('&').sort())
Ejemplo n.º 13
0
    def testConstructor(self):
        host = Host('localhost')
        self.assertEqual(host.get_protocol(), 'telnet')
        host = Host('localhost', default_protocol='foo')
        self.assertEqual(host.get_protocol(), 'foo')

        for url, result in urls:
            host = Host(url)
            uri = Url.from_string(url)
            self.assertEqual(host.get_name(), uri.hostname)
            self.assertEqual(host.get_address(), uri.hostname)
            self.assertEqual(host.get_uri().split('&').sort(),
                             str(uri).split('&').sort())
Ejemplo n.º 14
0
 def setUp(self):
     self.host = Host('localhost')
     self.host.set_all(dict(testarg=1))
Ejemplo n.º 15
0
    from Exscript import Host

    basedir = os.path.dirname(os.path.dirname(__file__))
    prov_dir = os.path.join(basedir, 'providers')
    xsd_file = os.path.join(basedir, 'xsl', 'model.xsd')
    xslt_file = os.path.join(prov_dir, 'ios', 'xsl', 'generic.xsl')
    xml = etree.parse(sys.argv[1])
    proc_xml = xml.find('processor[@type="xslt"]')
    fs_dir = os.path.expandvars(xml.findtext('file-store/basedir'))
    proc_xml.find('xsl-dir').text = basedir
    print 'Assuming file store is in', fs_dir

    class FakeProvider(object):
        store = FileStore(fs_dir)

    prov = FakeProvider()

    p = XsltProcessor(basedir, proc_xml)
    p.debug = True
    host = Host('m4docirom1ea.do-a-11.de.ipmb.dtag.de')
    host.set('path', 'ipmb/pe/m4docirom1ea.do-a-11.de.ipmb.dtag.de')
    host.set('country', 'mycountry')
    host.set('city', 'mycity')
    p.start(prov,
            host,
            object,
            xslt=xslt_file,
            xsd=xsd_file,
            input='show_version.xml',
            output='not-used.xml')
Ejemplo n.º 16
0
class HostTest(unittest.TestCase):
    CORRELATE = Host

    def setUp(self):
        self.host = Host('localhost')
        self.host.set_all(dict(testarg=1))

    def testConstructor(self):
        host = Host('localhost')
        self.assertEqual(host.get_protocol(), 'telnet')
        host = Host('localhost', default_protocol='foo')
        self.assertEqual(host.get_protocol(), 'foo')

        for url, result in urls:
            host = Host(url)
            uri = Url.from_string(url)
            self.assertEqual(host.get_name(), uri.hostname)
            self.assertEqual(host.get_address(), uri.hostname)
            self.assertEqual(host.get_uri().split('&').sort(),
                             str(uri).split('&').sort())

    def testSetUri(self):
        for url, result in urls:
            self.host.set_uri(url)
            uri = Url.from_string(url)
            self.assertEqual(self.host.get_name(), uri.hostname)
            self.assertEqual(self.host.get_address(), uri.hostname)

    def testGetUri(self):
        for url, result in urls:
            host = Host(url)
            uri = Url.from_string(url)
            self.assertEqual(host.get_uri().split('&').sort(),
                             str(uri).split('&').sort())

    def testGetDict(self):
        host = Host('foo')
        host.set_address('foo2')
        self.assertEqual(host.get_dict(), {
            'hostname': 'foo',
            'address': 'foo2',
            'protocol': 'telnet',
            'port': 23
        })

    def testSetAddress(self):
        self.host.set_protocol('dummy')
        self.host.set_address('test.org')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(), 'localhost')
        self.assertEqual(self.host.get_address(), 'test.org')

        self.host.set_address('001.002.003.004')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(), 'localhost')
        self.assertEqual(self.host.get_address(), '1.2.3.4')

    def testGetAddress(self):
        self.assertEqual(self.host.get_address(), 'localhost')
        # Additional tests are in testSetAddress().

    def testSetName(self):
        self.assertEqual(self.host.get_name(), 'localhost')
        self.host.set_protocol('dummy')
        self.host.set_name('test.org')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(), 'test.org')
        self.assertEqual(self.host.get_address(), 'localhost')
        self.host.set_name('testhost')
        self.assertEqual(self.host.get_name(), 'testhost')

    def testGetName(self):
        pass  # Tested in testSetName().

    def testSetProtocol(self):
        self.assertEqual(self.host.get_protocol(), 'telnet')
        self.host.set_protocol('dummy')
        self.assertEqual(self.host.get_protocol(), 'dummy')

    def testGetProtocol(self):
        pass  # Tested in testSetProtocol().

    def testSetOption(self):
        self.assertRaises(TypeError, self.host.set_option, 'test', True)
        self.assertEqual(self.host.get_options(), {})
        self.assertEqual(self.host.get_option('verify_fingerprint'), None)
        self.assertEqual(self.host.get_option('verify_fingerprint', False),
                         False)
        self.host.set_option('verify_fingerprint', True)
        self.assertEqual(self.host.get_option('verify_fingerprint'), True)
        self.assertEqual(self.host.get_options(), {'verify_fingerprint': True})

    def testGetOption(self):
        pass  # Tested in testSetOption().

    def testGetOptions(self):
        pass  # Tested in testSetOption().

    def testSetTcpPort(self):
        self.assertEqual(self.host.get_tcp_port(), 23)
        self.host.set_protocol('ssh')
        self.assertEqual(self.host.get_tcp_port(), 23)
        self.host.set_tcp_port(123)
        self.assertEqual(self.host.get_tcp_port(), 123)

    def testGetTcpPort(self):
        pass  # Tested in testSetTcpPort().

    def testSetAccount(self):
        account = Account('test')
        self.assertEqual(self.host.get_account(), None)
        self.host.set_account(account)
        self.assertEqual(self.host.get_account(), account)

    def testGetAccount(self):
        pass  # Tested in testSetAccount().

    def testSet(self):
        self.assertEqual(self.host.get('test'), None)
        self.host.set('test', 3)
        self.assertEqual(self.host.get('test'), 3)

    def testSetAll(self):
        self.testSet()
        self.host.set_all({'test1': 1, 'test2': 2})
        self.assertEqual(self.host.get('test'), None)
        self.assertEqual(self.host.get('test1'), 1)
        self.assertEqual(self.host.get('test2'), 2)

    def testGetAll(self):
        self.assertEqual(self.host.get_all(), {'testarg': 1})
        self.testSetAll()
        self.assertEqual(self.host.get_all(), {'test1': 1, 'test2': 2})

        host = Host('localhost')
        self.assertEqual(host.get_all(), {})

    def testAppend(self):
        self.assertEqual(self.host.get('test'), None)
        self.host.append('test', 3)
        self.assertEqual(self.host.get('test'), [3])
        self.host.append('test', 4)
        self.assertEqual(self.host.get('test'), [3, 4])

    def testSetDefault(self):
        self.testSet()
        self.assertEqual(self.host.get('test'), 3)
        self.assertEqual(self.host.get('test2'), None)
        self.host.set_default('test', 5)
        self.host.set_default('test2', 1)
        self.assertEqual(self.host.get('test'), 3)
        self.assertEqual(self.host.get('test2'), 1)

    def testHasKey(self):
        self.testSet()
        self.assertTrue(self.host.has_key('test'))
        self.assertFalse(self.host.has_key('test2'))

    def testGet(self):
        self.testSet()
        self.assertEqual(self.host.get('test'), 3)
        self.assertEqual(self.host.get('test2'), None)
        self.assertEqual(self.host.get('test', 1), 3)
        self.assertEqual(self.host.get('test2', 1), 1)
Ejemplo n.º 17
0
class HostTest(unittest.TestCase):
    CORRELATE = Host

    def setUp(self):
        self.host = Host('localhost')
        self.host.set_all(dict(testarg = 1))

    def testConstructor(self):
        host = Host('localhost')
        self.assertEqual(host.get_protocol(), 'telnet')
        host = Host('localhost', default_protocol = 'foo')
        self.assertEqual(host.get_protocol(), 'foo')

        for url, result in urls:
            host = Host(url)
            uri  = Url.from_string(url)
            self.assertEqual(host.get_name(),    uri.hostname)
            self.assertEqual(host.get_address(), uri.hostname)
            self.assertEqual(host.get_uri(), str(uri))

    def testSetUri(self):
        for url, result in urls:
            self.host.set_uri(url)
            uri = Url.from_string(url)
            self.assertEqual(self.host.get_name(),    uri.hostname)
            self.assertEqual(self.host.get_address(), uri.hostname)

    def testGetUri(self):
        for url, result in urls:
            host = Host(url)
            uri  = Url.from_string(url)
            self.assertEqual(host.get_uri(), str(uri))

    def testGetDict(self):
        host = Host('foo')
        host.set_address('foo2')
        self.assertEqual(host.get_dict(), {'hostname': 'foo',
                                           'address':  'foo2',
                                           'protocol': 'telnet',
                                           'port':     23})

    def testSetAddress(self):
        self.host.set_protocol('dummy')
        self.host.set_address('test.org')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(),     'localhost')
        self.assertEqual(self.host.get_address(),  'test.org')

        self.host.set_address('001.002.003.004')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(),     'localhost')
        self.assertEqual(self.host.get_address(),  '1.2.3.4')

    def testGetAddress(self):
        self.assertEqual(self.host.get_address(), 'localhost')
        # Additional tests are in testSetAddress().

    def testSetName(self):
        self.assertEqual(self.host.get_name(), 'localhost')
        self.host.set_protocol('dummy')
        self.host.set_name('test.org')
        self.assertEqual(self.host.get_protocol(), 'dummy')
        self.assertEqual(self.host.get_name(),     'test.org')
        self.assertEqual(self.host.get_address(),  'localhost')
        self.host.set_name('testhost')
        self.assertEqual(self.host.get_name(), 'testhost')

    def testGetName(self):
        pass # Tested in testSetName().

    def testSetProtocol(self):
        self.assertEqual(self.host.get_protocol(), 'telnet')
        self.host.set_protocol('dummy')
        self.assertEqual(self.host.get_protocol(), 'dummy')

    def testGetProtocol(self):
        pass # Tested in testSetProtocol().

    def testSetOption(self):
        self.assertRaises(TypeError, self.host.set_option, 'test', True)
        self.assertEqual(self.host.get_options(), {})
        self.assertEqual(self.host.get_option('verify_fingerprint'), None)
        self.assertEqual(self.host.get_option('verify_fingerprint', False), False)
        self.host.set_option('verify_fingerprint', True)
        self.assertEqual(self.host.get_option('verify_fingerprint'), True)
        self.assertEqual(self.host.get_options(), {'verify_fingerprint': True})

    def testGetOption(self):
        pass # Tested in testSetOption().

    def testGetOptions(self):
        pass # Tested in testSetOption().

    def testSetTcpPort(self):
        self.assertEqual(self.host.get_tcp_port(), 23)
        self.host.set_protocol('ssh')
        self.assertEqual(self.host.get_tcp_port(), 23)
        self.host.set_tcp_port(123)
        self.assertEqual(self.host.get_tcp_port(), 123)

    def testGetTcpPort(self):
        pass # Tested in testSetTcpPort().

    def testSetAccount(self):
        account = Account('test')
        self.assertEqual(self.host.get_account(), None)
        self.host.set_account(account)
        self.assertEqual(self.host.get_account(), account)

    def testGetAccount(self):
        pass # Tested in testSetAccount().

    def testSet(self):
        self.assertEqual(self.host.get('test'), None)
        self.host.set('test', 3)
        self.assertEqual(self.host.get('test'), 3)

    def testSetAll(self):
        self.testSet()
        self.host.set_all({'test1': 1, 'test2': 2})
        self.assertEqual(self.host.get('test'),  None)
        self.assertEqual(self.host.get('test1'), 1)
        self.assertEqual(self.host.get('test2'), 2)

    def testGetAll(self):
        self.assertEqual(self.host.get_all(), {'testarg': 1})
        self.testSetAll()
        self.assertEqual(self.host.get_all(), {'test1': 1, 'test2': 2})

        host = Host('localhost')
        self.assertEqual(host.get_all(), {})

    def testAppend(self):
        self.assertEqual(self.host.get('test'), None)
        self.host.append('test', 3)
        self.assertEqual(self.host.get('test'), [3])
        self.host.append('test', 4)
        self.assertEqual(self.host.get('test'), [3, 4])

    def testSetDefault(self):
        self.testSet()
        self.assertEqual(self.host.get('test'),  3)
        self.assertEqual(self.host.get('test2'), None)
        self.host.set_default('test',  5)
        self.host.set_default('test2', 1)
        self.assertEqual(self.host.get('test'),  3)
        self.assertEqual(self.host.get('test2'), 1)

    def testHasKey(self):
        self.testSet()
        self.assert_(self.host.has_key('test'))
        self.failIf(self.host.has_key('test2'))

    def testGet(self):
        self.testSet()
        self.assertEqual(self.host.get('test'),     3)
        self.assertEqual(self.host.get('test2'),    None)
        self.assertEqual(self.host.get('test',  1), 3)
        self.assertEqual(self.host.get('test2', 1), 1)
Ejemplo n.º 18
0
# This script is not meant to provide a fully automated test, it's
# merely a hack/starting point for investigating memory consumption
# manually. The behavior also depends heavily on the version of meliae.
from meliae import scanner, loader
from Exscript import Account, Host

hostlist = [Host(str(i)) for i in range(1, 10000)]
#accountlist = [Account(str(i)) for i in range(1, 10000)]

scanner.dump_all_objects('test.dump')
om = loader.load('test.dump')
print om.summarize()
Ejemplo n.º 19
0
 def testGetUri(self):
     for url, result in urls:
         host = Host(url)
         uri  = Url.from_string(url)
         self.assertEqual(host.get_uri(), str(uri))
Ejemplo n.º 20
0
    # You can add a safehold based on the guess_os() method.
    if conn.guess_os() != 'ios':
        raise Exception('unsupported os: ' + repr(conn.guess_os()))

    # autoinit() automatically executes commands to make the remote
    # system behave more script-friendly. The specific commands depend
    # on the detected operating system, i.e. on what guess_os() returns.
    conn.autoinit()

    # Execute a simple command.
    conn.execute('show ip int brie')
    print "myvariable is", conn.get_host().get('myvariable')

def two(job, host, conn):
    conn.autoinit()
    conn.execute('show interface POS1/0')

accounts = get_accounts_from_file('accounts.cfg')

# Start on one host.
host = Host('localhost')
host.set('myvariable', 'foobar')
start(accounts, host1, one)

# Start on many hosts. In this case, the accounts from accounts.cfg
# are only used if the host url does not contain a username and password.
# The "max_threads" keyword indicates the maximum number of concurrent
# connections.
hosts = get_hosts_from_file('hostlist.txt')
start(accounts, hosts, two, max_threads = 2)
Ejemplo n.º 21
0
 def setUp(self):
     self.host = Host('localhost')
     self.host.set_all(dict(testarg = 1))
Ejemplo n.º 22
0
 def __get_host_from_row(self, row):
     assert row is not None
     tbl_h = self._table_map['host']
     host  = Host(row[tbl_h.c.name])
     host.set_address(row[tbl_h.c.address])
     host.set_protocol(row[tbl_h.c.protocol])
     host.set_tcp_port(row[tbl_h.c.tcp_port])
     host.set('path',     row[tbl_h.c.path])
     host.set('country',  row[tbl_h.c.country])
     host.set('city',     row[tbl_h.c.city])
     host.set('os',       row[tbl_h.c.os])
     host.set('duration', row[tbl_h.c.duration])
     host.set('deleted',  row[tbl_h.c.deleted])
     return host
Ejemplo n.º 23
0
        raise Exception('unsupported os: ' + repr(conn.guess_os()))

    # autoinit() automatically executes commands to make the remote
    # system behave more script-friendly. The specific commands depend
    # on the detected operating system, i.e. on what guess_os() returns.
    conn.autoinit()

    # Execute a simple command.
    conn.execute('show ip int brie')
    print "myvariable is", conn.get_host().get('myvariable')


def two(conn):
    conn.autoinit()
    conn.execute('show interface POS1/0')


accounts = get_accounts_from_file('accounts.cfg')

# Start on one host.
host = Host('localhost')
host.set('myvariable', 'foobar')
start(accounts, host1, one)

# Start on many hosts. In this case, the accounts from accounts.cfg
# are only used if the host url does not contain a username and password.
# The "max_threads" keyword indicates the maximum number of concurrent
# connections.
hosts = get_hosts_from_file('hostlist.txt')
start(accounts, hosts, two, max_threads=2)
Ejemplo n.º 24
0
    import sys
    from FileStore import FileStore
    from Exscript import Host

    basedir   = os.path.dirname(os.path.dirname(__file__))
    prov_dir  = os.path.join(basedir, 'providers')
    xsd_file  = os.path.join(basedir, 'xsl', 'model.xsd')
    xslt_file = os.path.join(prov_dir, 'ios', 'xsl', 'generic.xsl')
    xml       = etree.parse(sys.argv[1])
    proc_xml  = xml.find('processor[@type="xslt"]')
    fs_dir    = os.path.expandvars(xml.findtext('file-store/basedir'))
    proc_xml.find('xsl-dir').text = basedir
    print 'Assuming file store is in', fs_dir
    class FakeProvider(object):
        store = FileStore(fs_dir)
    prov = FakeProvider()

    p       = XsltProcessor(basedir, proc_xml)
    p.debug = True
    host    = Host('m4docirom1ea.do-a-11.de.ipmb.dtag.de')
    host.set('path',    'ipmb/pe/m4docirom1ea.do-a-11.de.ipmb.dtag.de')
    host.set('country', 'mycountry')
    host.set('city',    'mycity')
    p.start(prov,
            host,
            object,
            xslt   = xslt_file,
            xsd    = xsd_file,
            input  = 'show_version.xml',
            output = 'not-used.xml')
Ejemplo n.º 25
0
 def __get_host_from_row(self, row):
     assert row is not None
     tbl_h = self._table_map['host']
     host = Host(row[tbl_h.c.name])
     host.set_address(row[tbl_h.c.address])
     host.set_protocol(row[tbl_h.c.protocol])
     host.set_tcp_port(row[tbl_h.c.tcp_port])
     host.set('path', row[tbl_h.c.path])
     host.set('country', row[tbl_h.c.country])
     host.set('city', row[tbl_h.c.city])
     host.set('os', row[tbl_h.c.os])
     host.set('duration', row[tbl_h.c.duration])
     host.set('deleted', row[tbl_h.c.deleted])
     return host