RoundupDownloader/RoundupDownloader.py at master · mbidewell/RoundupDownloader · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
from lxml import etree

import argparse
import os


BASE_URL="http://ivyroundup.googlecode.com/svn/trunk/repo"

class IvyModule:
    @staticmethod
    def get_module(moduledef):
        mod = IvyModule(moduledef[1].text, moduledef[0].text)
        for sp in moduledef[2].xpath("./*/span"):
            mod.add_version(sp.text, sp.getparent().get("href"))

	return mod

    def __init__(self, org, name):
        self.org = org
        self.name = name;
        self.versions = {}

    def add_version(self, version, url):
        self.versions[version] = BASE_URL + url

    def get_org(self):
        return self.org

    def get_name(self):
        return self.name

    def get_versions(self):
        return self.versions

class IvyRepository:
    def __init__(self):
        self.repo = {}

    def add_org_module(self, org, module):
        if not org in self.repo:
            self.repo[org] = [module]
        else:
            self.repo[org].append(module)

    def get_modules(self):
        return list(self.repo.values())

    def search(self, criteria):
        if criteria["org"] in self.repo:
            modules = self.repo[criteria["org"]]
            if "module" in criteria:
                for m in modules:
                    if m.get_name() == criteria["module"]:
                        if "version" in criteria:
                            if criteria["version"] in m.get_versions():
                                return m
                        else:
                            return m

            else:
                return modules


def dump_ivy_object(obj):
    if isinstance(obj, IvyModule):
        print "Organization: %s" % obj.get_org()
        print "Name: %s" % obj.get_name()
        print "Versions: "
        for ver in obj.get_versions().keys():
            print "\t%s => %s" % (ver, obj.get_versions()[ver])
    elif type(obj) == type([]):
        for o in obj:
            dump_ivy_object(o)
            print "=========================="


def initialize_ivyloader():
    global ivy_repo
    xslt = etree.XSLT(etree.parse(BASE_URL+"/xsl/modules.xsl"))
    xml = etree.parse(BASE_URL+"/modules.xml")
    html = xslt(xml)

    rows = html.xpath("//table/tbody/tr");

    ivy_repo = IvyRepository()

    for row in rows:
        tdlist = list(row)
        module = IvyModule.get_module(tdlist)
        ivy_repo.add_org_module(tdlist[1].text, module)

def list_to_dict(keys, values):
    dct = {}
    for i in xrange(len(keys)):
        if i < len(values):
            dct[keys[i]] = values[i]
    return dct

def do_ivy_retrieve(ivydep):
    ivytmplfile = etree.parse("ivy.template.xml")
    ivyfile = "ivy.%d.xml" % os.getpid()
    depChild = ivytmplfile.getroot().find("dependencies")
    dep = etree.Element("dependency")

    for key in ivydep.keys():
        dep.set(key, ivydep[key])

    depChild.append(dep)

    with open(ivyfile, "w") as f:
        f.write(etree.tostring(ivytmplfile.getroot(), pretty_print=True))

    os.system("ant -Divy.dep.file=%s -f build.template.xml ivy.fetch" % ivyfile)

    os.remove(ivyfile)

def main():
    parser = argparse.ArgumentParser(description='Search and download from IvyRoundup')
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("--find", "-f", nargs='+',
			help="Search for ivy component.  At least one of org, module, version required" )
    group.add_argument("--retrieve", "-r", nargs=3,  help="Resolve ivy component")
    group.add_argument("--install", "-i", nargs=3, help="Install ivy component")
    group.add_argument("--list", "-l", action="store_true", help="List all ivy components")
    args = parser.parse_args()

    print args

    if args.find != None:
        result = ivy_repo.search(list_to_dict(["org", "module", "version"], args.find))
        if result != None:
            dump_ivy_object(result)
    elif args.list:
        dump_ivy_object(ivy_repo.get_modules())
    elif args.retrieve:
        do_ivy_retrieve(list_to_dict(["org", "name", "rev"], args.retrieve))


ivy_repo = None

if __name__ == "__main__":
    initialize_ivyloader()
    main()