Mucking with the calling scripts namespace (For a good reason, honest!)

[Larry Bates]

I would suggest following:

1) Change the config file into proper format for
ConfigParser module.

[server_001]
hostname=alpha
os=posix

[server_002]
hostname=beta
os=win

[client_001]
hostname=ichi
os=posix

[client_002]
hostname=ni
os=posix

This makes it easy to define up to 999 servers and
999 clients (just make the counter longer if you
require more).

2) Create classes to hold information/methods that
will work on each server/client.

class server:
    def __init__(self, server_id, name, os):
        self.id=server_id
        self.name=name
        self.os=os
        return

    def dosomething(self):
        #
        # Insert code here to do something on this
        # server.
        #
        return

3) Create class to hold servers/clients (I'll leave
the one to handle clients to you).

class servers:
    def __init__(self, INI):
        #
        # Create an index pointer for next method
        #
        self.next_index=0
        #
        # Create a list to hold server names
        #
        self.names=[]
        serverlist=[x for x in INI.sections if
INI.sections.beginswith('server')]
        serverlist.sort()  # If you want to keep them in order
        #
        # Loop over each server entry
        #
        for server_id in serverlist:
            name=INI.get(server_id, 'name')
            os=INI.get(server_id, 'os')
            self.append(id, name, os)

        return

    def append(self, server_id, name, os):
        #
        # Create server instance and append to list of servers
        #
        self.names.append(server_id)
        self.__dict__[name]=server(server_id, name, os)
        return

    def __iter__(self):
        return self

    def next(self):
        #
        # Try to get the next route
        #
        try: SERVER=self.names[self.next_index]
        except:
            self.next_index=0
            raise StopIteration
        #
        # Increment the index pointer for the next call
        #
        self.next_index+=1
        return SERVER

In your programt do something like:

import ConfigParser

INI=ConfigParser.ConfigParser()
INI.read(inifilepath)

SERVERS=servers(INI)

Now you can access

SERVERS.server_001.name
SERVERS.server_001.os

or call methods via

SERVERS.server_001.dosomething()

or you can easily loop over them

for SERVER in SERVERS:
    SERVER.dosomething()

or

print SERVERS.names

Code not tested, but I hope it helps.

Larry Bates
Syscon, Inc.



"Doug Rosser" <da_rosser at yahoo.com> wrote in message
news:e08cd05f.0408020727.15ce4356 at posting.google.com...
> I'm writing a fairly complicated test framework and keeping
> configuration data inside ini files that are parsed at runtime by the
> ConfigParser module.
>
> For example, there would be a section similar to the following
>
> [servers]
> server1:{'hostname':'alpha','os':'posix'}
> server2:{'hostname':'beta','os':'win'}
>
> [clients]
> client1:{'hostname':'ichi','os':'posix'}
> client2:{'hostname':'ni','os':'posix'}
>
> As I read the configuration file, I don't actually create instances,
> but use the data to check "what's out there" to make sure the physical
> network environment has the bits and pieces required to run a
> particular test. This is a sort of "go/no-go" resource check.
>
> Assuming that everything is correct with the physical network
> environment, I want my testers to be able to refer to these resources
> in their python scripts by the names in the ini file, like so:
>
> myTest.checkResources() # Read the config file and associate names
> with real
>                         # life instances
>
> server1.doSomething()   # Note how I have cleverly saved myself from
> declaring
>                         # "server1" because the module myTest has
> inserted
>                         # it into the right namespace :-)
>
> Down to business: How do I write a module that can insert these names
> into the calling script's namespace at runtime? Is this even possible
> in Python?
>
> da rosser
> -- We are the music makers, and we are the dreamers of dreams --