~ubuntu-branches/ubuntu/oneiric/command-not-found/oneiric

« back to all changes in this revision

Viewing changes to UnifiedDataExtractor/DebPackage.py

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt, Zygmunt Krynicki
  • Date: 2011-08-25 15:15:50 UTC
  • Revision ID: james.westby@ubuntu.com-20110825151550-m6gycva2g7fnn91m
Tags: 0.2.43ubuntu1
[ Zygmunt Krynicki ]
* lp:~zkrynicki/command-not-found/rework-locale-support:
  - improved gettext handling

Show diffs side-by-side

added added

removed removed

Lines of Context:
3
3
 
4
4
import warnings
5
5
warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
6
 
import apt, apt_inst, apt_pkg
7
 
import sys, os, subprocess
8
 
from gettext import gettext as _
 
6
 
 
7
import apt
 
8
import apt_inst
 
9
import apt_pkg
 
10
 
9
11
 
10
12
class GenericFileInfo(object):
11
 
    BASE_STICKY  = 8
12
 
    BASE_READ    = 4
13
 
    BASE_WRITE   = 2
14
 
    BASE_EXEC    = 1
15
 
 
16
 
    O_STICKY= BASE_STICKY << 0
17
 
    O_READ  = BASE_READ   << 0
18
 
    O_WRITE = BASE_WRITE  << 0
19
 
    O_EXEC  = BASE_EXEC   << 0
20
 
  
21
 
    G_STICKY= BASE_STICKY << 3
22
 
    G_READ  = BASE_READ   << 3
23
 
    G_WRITE = BASE_WRITE  << 3
24
 
    G_EXEC  = BASE_EXEC   << 3
25
 
  
26
 
    U_STICKY= BASE_STICKY << 6
27
 
    U_READ  = BASE_READ   << 6
28
 
    U_WRITE = BASE_WRITE  << 6
29
 
    U_EXEC  = BASE_EXEC   << 6
30
 
 
31
 
    STICKY = O_STICKY  | G_STICKY | U_STICKY
32
 
    READ   = O_READ    | G_READ   | U_READ
33
 
    WRITE  = O_WRITE   | G_WRITE  | U_WRITE
34
 
    EXEC   = O_EXEC    | G_EXEC   | U_EXEC
35
 
  
 
13
 
 
14
    BASE_STICKY = 8
 
15
    BASE_READ = 4
 
16
    BASE_WRITE = 2
 
17
    BASE_EXEC = 1
 
18
 
 
19
    O_STICKY = BASE_STICKY << 0
 
20
    O_READ = BASE_READ << 0
 
21
    O_WRITE = BASE_WRITE << 0
 
22
    O_EXEC = BASE_EXEC << 0
 
23
 
 
24
    G_STICKY = BASE_STICKY << 3
 
25
    G_READ = BASE_READ << 3
 
26
    G_WRITE = BASE_WRITE << 3
 
27
    G_EXEC = BASE_EXEC << 3
 
28
 
 
29
    U_STICKY = BASE_STICKY << 6
 
30
    U_READ = BASE_READ << 6
 
31
    U_WRITE = BASE_WRITE << 6
 
32
    U_EXEC = BASE_EXEC << 6
 
33
 
 
34
    STICKY = O_STICKY | G_STICKY | U_STICKY
 
35
    READ = O_READ | G_READ | U_READ
 
36
    WRITE = O_WRITE | G_WRITE | U_WRITE
 
37
    EXEC = O_EXEC | G_EXEC | U_EXEC
 
38
 
36
39
    def __init__(self, name, mode, uid, gid, size, mtime):
37
40
        self.name = name
38
41
        self.mode = mode
49
52
 
50
53
    def is_writable(self):
51
54
        return self.mode & self.WRITE
52
 
  
 
55
 
53
56
    def unix_mode(self):
54
57
        """ Returns a ls -l like mode string. """
55
58
        def mode_str(mode):
56
59
            out = ""
57
60
            if mode & self.BASE_EXEC:
58
 
                    out += 'x'
 
61
                out += 'x'
59
62
            else:
60
 
                    out += '-'
 
63
                out += '-'
61
64
            if mode & self.BASE_READ:
62
 
                    out += 'r'
 
65
                out += 'r'
63
66
            else:
64
 
                    out += '-'
 
67
                out += '-'
65
68
            if mode & self.BASE_WRITE:
66
 
                    out += 'w'
 
69
                out += 'w'
67
70
            else:
68
 
                    out += '-'
 
71
                out += '-'
69
72
            return out
70
 
    def kind_str(self):
71
 
        if isinstance(self, FileInfo) or isinstance(self, HardLinkInfo):
72
 
                return '-'
73
 
        elif isinstance(self, DirectoryInfo):
74
 
                return 'd'
75
 
        elif isinstance(self, SymbolicLinkInfo):
76
 
                return 'l'
77
 
        else:
78
 
                return '?'
 
73
 
 
74
        def kind_str():
 
75
            if isinstance(self, FileInfo) or isinstance(self, HardLinkInfo):
 
76
                return '-'
 
77
            elif isinstance(self, DirectoryInfo):
 
78
                return 'd'
 
79
            elif isinstance(self, SymbolicLinkInfo):
 
80
                return 'l'
 
81
            else:
 
82
                return '?'
 
83
 
79
84
        return "%s%s%s%s" % (kind_str(self), mode_str(self.mode >> 6 & 7), mode_str(self.mode >> 3 & 7), mode_str(self.mode & 7))
80
85
 
 
86
 
81
87
class FileInfo(GenericFileInfo):
 
88
 
82
89
    def __init__(self, name, mode, uid, gid, size, mtime):
83
90
        GenericFileInfo.__init__(self, name, mode, uid, gid, size, mtime)
84
91
 
 
92
 
85
93
class DirectoryInfo(GenericFileInfo):
 
94
 
86
95
    def __init__(self, name, mode, uid, gid, size, mtime):
87
96
        GenericFileInfo.__init__(self, name, mode, uid, gid, size, mtime)
88
97
 
 
98
 
89
99
class LinkInfo(GenericFileInfo):
90
 
    (SOFT,HARD) = range(2)
 
100
 
 
101
    (SOFT, HARD) = range(2)
 
102
 
91
103
    def __init__(self, name, target, mode, uid, gid, size, mtime):
92
104
        GenericFileInfo.__init__(self, name, mode, uid, gid, size, mtime)
93
105
        self.target = target
 
106
 
94
107
    def get_link_type(self):
95
108
        raise NotImplemented
96
109
 
 
110
 
97
111
class SymbolicLinkInfo(LinkInfo):
 
112
 
98
113
    def __init__(self, name, target, mode, uid, gid, size, mtime):
99
114
        LinkInfo.__init__(self, name, target, mode, uid, gid, size, mtime)
 
115
 
100
116
    def get_link_type(self):
101
117
        return self.SOFT
102
118
 
 
119
 
103
120
class HardLinkInfo(LinkInfo):
 
121
 
104
122
    def __init__(self, name, target, mode, uid, gid, size, mtime):
105
123
        LinkInfo.__init__(self, name, target, mode, uid, gid, size, mtime)
 
124
 
106
125
    def get_link_type(self):
107
126
        return self.HARD
108
127
 
 
128
 
109
129
class DeviceInfo(GenericFileInfo):
110
 
    (CHAR,BLOCK) = range(2)
 
130
 
 
131
    (CHAR, BLOCK) = range(2)
 
132
 
111
133
    def __init__(self, name, mode, uid, gid, size, mtime, major, minor):
112
134
        GenericFileInfo.__init__(self, name, mode, uid, gid, size, mtime)
113
135
        self.major = major
114
136
        self.minor = minor
 
137
 
115
138
    def get_device_type(self):
116
139
        pass
117
140
 
 
141
 
118
142
class CharDeviceInfo(DeviceInfo):
 
143
 
119
144
    def __init__(self, name, mode, uid, gid, size, mtime, major, minor):
120
145
        DeviceInfo.__init__(self, name, mode, uid, gid, size, mtime, major, minor)
 
146
 
121
147
    def get_device_type(self):
122
148
        return self.CHAR
123
149
 
 
150
 
124
151
class BlockDeviceInfo(DeviceInfo):
 
152
 
125
153
    def __init__(self, name, mode, uid, gid, size, mtime, major, minor):
126
154
        DeviceInfo.__init__(self, name, mode, uid, gid, size, mtime, major, minor)
 
155
 
127
156
    def get_device_type(self):
128
157
        return self.BLOCK
129
158
 
 
159
 
130
160
class FifoInfo(GenericFileInfo):
131
161
    def __init__(self, name, mode, uid, gid, size, mtime):
132
162
        GenericFileInfo.__init__(self, name, mode, uid, gid, size, mtime)
133
163
 
 
164
 
134
165
def load(filename):
135
166
    return DebPackage(filename)
136
167
 
137
 
class DebPackage:
 
168
 
 
169
class DebPackage(object):
 
170
 
138
171
    def __init__(self, filename):
139
172
        self.filename = filename
140
173
        self._sections = apt_pkg.ParseSection(self.getControlFile("control"))
 
174
 
141
175
    arch = property(lambda self: self._sections["Architecture"], None, None, "Architecture the package is compiled for")
 
176
 
142
177
    name = property(lambda self: self._sections["Package"], None, None, "Cannonical package name")
 
178
 
143
179
    def getControlFile(self, name):
144
180
        """ Returns the contents of given file in debian/ or None if it does not exits """
145
181
        return apt_inst.debExtractControl(file(self.filename), name)
146
 
    def __get_items(self):
 
182
 
 
183
    @property
 
184
    def items(self):
147
185
        """ Return the list of items in the package.
148
186
        Each file is represented by an instance of  FileInfo """
149
187
        items = []
 
188
 
150
189
        def extract_cb(kind, name, target, mode, uid, gid, size, mtime, major, minor):
151
190
            if kind == "FILE":
152
191
                items.append(FileInfo(name, mode, uid, gid, size, mtime))
159
198
            elif kind == "FIFO":
160
199
                items.append(FifoInfo(name, mode, uid, gid, size, mtime))
161
200
            else:
162
 
                    print "unsupported kind: %s" % kind
 
201
                print "unsupported kind: %s" % kind
163
202
        try:
164
203
            apt_inst.debExtract(open(self.filename), extract_cb, "data.tar.gz")
165
204
        except:
166
205
            apt_inst.debExtract(open(self.filename), extract_cb, "data.tar.bz2")
167
206
        return items
168
 
    items = property(__get_items)