← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/packages.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mfrom: (0.9.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080622211713-fpo2zrq3s5dfecxg
Tags: 1.7.0-3
Simplify /etc/moin/wikilist format: "USER URL" (drop unneeded middle
CONFIG_DIR that was wrongly advertised as DATA_DIR).  Make
moin-mass-migrate handle both formats and warn about deprecation of
the old one.

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/packages.py
2
2
"""
3
3
    MoinMoin - Package Installer
4
4
 
5
 
    @copyright: 2005 by MoinMoin:AlexanderSchremmer
 
5
    @copyright: 2005 MoinMoin:AlexanderSchremmer,
 
6
                2007 MoinMoin:ReimarBauer
6
7
    @license: GNU GPL, see COPYING for details.
7
8
"""
8
9
 
9
 
import os
10
 
import sys
 
10
import os, sys
11
11
import zipfile
12
12
 
13
 
from MoinMoin import config, wikiutil, caching
 
13
from MoinMoin import config, wikiutil, caching, user
14
14
from MoinMoin.Page import Page
15
15
from MoinMoin.PageEditor import PageEditor
 
16
from MoinMoin.logfile import editlog, eventlog
16
17
 
17
18
MOIN_PACKAGE_FILE = 'MOIN_PACKAGE'
18
19
MAX_VERSION = 1
19
20
 
 
21
 
20
22
# Exceptions
21
23
class PackageException(Exception):
22
24
    """ Raised if the package is broken. """
38
40
class ScriptExit(Exception):
39
41
    """ Raised by the script commands when the script should quit. """
40
42
 
 
43
def event_logfile(self, pagename, pagefile):
 
44
    # add event log entry
 
45
    eventtype = 'SAVENEW'
 
46
    mtime_usecs = wikiutil.timestamp2version(os.path.getmtime(pagefile))
 
47
    elog = eventlog.EventLog(self.request)
 
48
    elog.add(self.request, eventtype, {'pagename': pagename}, 1, mtime_usecs)
 
49
 
 
50
def edit_logfile_append(self, pagename, pagefile, rev, action, logname='edit-log', comment=u'', author=u"Scripting Subsystem"):
 
51
    glog = editlog.EditLog(self.request, uid_override=author)
 
52
    pagelog = Page(self.request, pagename).getPagePath(logname, use_underlay=0, isfile=1)
 
53
    llog = editlog.EditLog(self.request, filename=pagelog,
 
54
                               uid_override=author)
 
55
    mtime_usecs = wikiutil.timestamp2version(os.path.getmtime(pagefile))
 
56
    host = '::1'
 
57
    extra = u''
 
58
    glog.add(self.request, mtime_usecs, rev, action, pagename, host, comment)
 
59
    llog.add(self.request, mtime_usecs, rev, action, pagename, host, extra, comment)
 
60
    event_logfile(self, pagename, pagefile)
 
61
 
41
62
# Parsing and (un)quoting for script files
42
 
def packLine(list, separator="|"):
43
 
    """ Packs a list into a string that is separated by `separator`. """
44
 
    return '|'.join([x.replace('\\', '\\\\').replace(separator, '\\' + separator) for x in list])
 
63
def packLine(items, separator="|"):
 
64
    """ Packs a list of items into a string that is separated by `separator`. """
 
65
    return '|'.join([item.replace('\\', '\\\\').replace(separator, '\\' + separator) for item in items])
45
66
 
46
67
def unpackLine(string, separator="|"):
47
68
    """ Unpacks a string that was packed by packLine. """
91
112
        self.themename = None
92
113
        self.ignoreExceptions = False
93
114
        self.goto = 0
94
 
        
 
115
 
95
116
        #Satisfy pylint
96
117
        self.msg = getattr(self, "msg", "")
97
118
        self.request = getattr(self, "request", None)
98
119
 
 
120
    def do_addattachment(self, zipname, filename, pagename, author=u"Scripting Subsystem", comment=u""):
 
121
        """
 
122
        Installs an attachment
 
123
 
 
124
        @param pagename: Page where the file is attached. Or in 2.0, the file itself.
 
125
        @param zipname: Filename of the attachment from the zip file
 
126
        @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0)
 
127
        """
 
128
        if self.request.user.may.write(pagename):
 
129
            _ = self.request.getText
 
130
 
 
131
            attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1)
 
132
            filename = wikiutil.taintfilename(filename)
 
133
            zipname = wikiutil.taintfilename(zipname)
 
134
            target = os.path.join(attachments, filename)
 
135
            page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author)
 
136
            rev = page.current_rev()
 
137
            path = page.getPagePath(check_create=0)
 
138
            if not os.path.exists(target):
 
139
                self._extractToFile(zipname, target)
 
140
                if os.path.exists(target):
 
141
                    os.chmod(target, config.umask )
 
142
                    action = 'ATTNEW'
 
143
                    edit_logfile_append(self, pagename, path, rev, action, logname='edit-log',
 
144
                                       comment=u'%(filename)s' % {"filename": filename}, author=author)
 
145
                self.msg += u"%(filename)s attached \n" % {"filename": filename}
 
146
            else:
 
147
                self.msg += u"%(filename)s not attached \n" % {"filename": filename}
 
148
        else:
 
149
            self.msg += u"action add attachment: not enough rights - nothing done \n"
 
150
 
 
151
    def do_delattachment(self, filename, pagename, author=u"Scripting Subsystem", comment=u""):
 
152
        """
 
153
        Removes an attachment
 
154
 
 
155
        @param pagename: Page where the file is attached. Or in 2.0, the file itself.
 
156
        @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0)
 
157
        """
 
158
        if self.request.user.may.write(pagename):
 
159
            _ = self.request.getText
 
160
 
 
161
            attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1)
 
162
            filename = wikiutil.taintfilename(filename)
 
163
            target = os.path.join(attachments, filename)
 
164
            page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author)
 
165
            rev = page.current_rev()
 
166
            path = page.getPagePath(check_create=0)
 
167
            if os.path.exists(target):
 
168
                os.remove(target)
 
169
                action = 'ATTDEL'
 
170
                edit_logfile_append(self, pagename, path, rev, action, logname='edit-log',
 
171
                                    comment=u'%(filename)s' % {"filename": filename}, author=author)
 
172
                self.msg += u"%(filename)s removed \n" % {"filename": filename}
 
173
            else:
 
174
                self.msg += u"%(filename)s does not exist \n" % {"filename": filename}
 
175
        else:
 
176
            self.msg += u"action delete attachment: not enough rights - nothing done \n"
 
177
 
99
178
    def do_print(self, *param):
100
179
        """ Prints the parameters into output of the script. """
101
180
        self.msg += '; '.join(param) + "\n"
119
198
        @param lines: lines to ignore
120
199
        """
121
200
        _ = self.request.getText
122
 
        
 
201
 
123
202
        from MoinMoin.version import release
124
203
        version_int = [int(x) for x in version.split(".")]
125
204
        release = [int(x) for x in release.split(".")]
156
235
                                  wikiutil.taintfilename(target))
157
236
        theme_dir = os.path.dirname(theme_file)
158
237
        if not os.path.exists(theme_dir):
159
 
            os.makedirs(theme_dir, 0777 & config.umask)
 
238
            os.makedirs(theme_dir)
160
239
        self._extractToFile(filename, theme_file)
161
240
 
162
241
    def do_installplugin(self, filename, visibility, ptype, target):
200
279
                raise RuntimeScriptException(_("Installation of '%(filename)s' failed.") % {
201
280
                    'filename': filename} + "\n" + package.msg)
202
281
        else:
203
 
            raise RuntimeScriptException(_('The file %s is not a MoinMoin package file.' % filename))
 
282
            raise RuntimeScriptException(_('The file %s is not a MoinMoin package file.') % filename)
204
283
 
205
284
        self.msg += package.msg
206
285
 
207
 
    def do_addrevision(self, filename, pagename, author=u"Scripting Subsystem", comment=u"", trivial = u"No"):
 
286
    def do_addrevision(self, filename, pagename, author=u"Scripting Subsystem", comment=u"", trivial=u"No"):
208
287
        """ Adds a revision to a page.
209
288
 
210
289
        @param filename: name of the file in this package
213
292
        @param comment:  comment related to this revision (optional)
214
293
        @param trivial:  boolean, if it is a trivial edit
215
294
        """
216
 
        _ = self.request.getText
217
 
        trivial = str2boolean(trivial)
218
 
 
219
 
        page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author)
220
 
        try:
221
 
            page.saveText(self.extract_file(filename).decode("utf-8"), 0, trivial=trivial, comment=comment)
222
 
        except PageEditor.Unchanged:
223
 
            pass
224
 
 
225
 
        page.clean_acl_cache()
 
295
        if self.request.user.may.write(pagename):
 
296
            _ = self.request.getText
 
297
            trivial = str2boolean(trivial)
 
298
            uid = user.getUserId(self.request, author)
 
299
            theuser = user.User(self.request, uid)
 
300
            save_user = self.request.user
 
301
            self.request.user = theuser
 
302
            page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author)
 
303
            try:
 
304
                page.saveText(self.extract_file(filename).decode("utf-8"), 0, trivial=trivial, comment=comment)
 
305
                self.msg += u"%(pagename)s added \n" % {"pagename": pagename}
 
306
            except PageEditor.Unchanged:
 
307
                pass
 
308
            self.request.user = save_user
 
309
            page.clean_acl_cache()
 
310
        else:
 
311
            self.msg += u"action add revision: not enough rights - nothing done \n"
 
312
 
 
313
    def do_renamepage(self, pagename, newpagename, author=u"Scripting Subsystem", comment=u"Renamed by the scripting subsystem."):
 
314
        """ Renames a page.
 
315
 
 
316
        @param pagename: name of the target page
 
317
        @param newpagename: name of the new page
 
318
        @param author:   user name of the editor (optional)
 
319
        @param comment:  comment related to this revision (optional)
 
320
        """
 
321
        if self.request.user.may.write(pagename):
 
322
            _ = self.request.getText
 
323
            page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author)
 
324
            if not page.exists():
 
325
                raise RuntimeScriptException(_("The page %s does not exist.") % pagename)
 
326
            newpage = PageEditor(self.request, newpagename)
 
327
            page.renamePage(newpage.page_name, comment=u"Renamed from '%s'" % (pagename))
 
328
            self.msg += u'%(pagename)s renamed to %(newpagename)s\n' % {
 
329
                            "pagename": pagename,
 
330
                            "newpagename": newpagename}
 
331
        else:
 
332
            self.msg += u"action rename page: not enough rights - nothing done \n"
226
333
 
227
334
    def do_deletepage(self, pagename, comment="Deleted by the scripting subsystem."):
228
335
        """ Marks a page as deleted (like the DeletePage action).
230
337
        @param pagename: page to delete
231
338
        @param comment:  the related comment (optional)
232
339
        """
233
 
        _ = self.request.getText
234
 
        page = PageEditor(self.request, pagename, do_editor_backup=0)
235
 
        if not page.exists():
236
 
            raise RuntimeScriptException(_("The page %s does not exist.") % pagename)
237
 
 
238
 
        page.deletePage(comment)
 
340
        if self.request.user.may.write(pagename):
 
341
            _ = self.request.getText
 
342
            page = PageEditor(self.request, pagename, do_editor_backup=0)
 
343
            if not page.exists():
 
344
                raise RuntimeScriptException(_("The page %s does not exist.") % pagename)
 
345
            page.deletePage(comment)
 
346
        else:
 
347
            self.msg += u"action delete page: not enough rights - nothing done \n"
239
348
 
240
349
    def do_replaceunderlay(self, filename, pagename):
241
350
        """
250
359
        pagedir = page.getPagePath(use_underlay=1, check_create=1)
251
360
 
252
361
        revdir = os.path.join(pagedir, 'revisions')
253
 
        cfn = os.path.join(pagedir,'current')
 
362
        cfn = os.path.join(pagedir, 'current')
254
363
 
255
364
        revstr = '%08d' % 1
256
365
        if not os.path.exists(revdir):
269
378
        except AttributeError:
270
379
            pass
271
380
        self.request.pages = {}
272
 
        caching.CacheEntry(self.request, 'wikidicts', 'dicts_groups').remove()
 
381
        caching.CacheEntry(self.request, 'wikidicts', 'dicts_groups', scope='wiki').remove()
273
382
        page.clean_acl_cache()
274
383
 
275
384
    def runScript(self, commands):
298
407
                self.goto -= 1
299
408
                continue
300
409
 
301
 
            if line.startswith("#"):
 
410
            if line.startswith("#") or len(line) == 0:
302
411
                continue
303
412
            elements = unpackLine(line)
304
413
            fnname = elements[0].strip().lower()
361
470
 
362
471
    def isPackage(self):
363
472
        """ Returns true if this package is recognised. """
364
 
        raise NotImplementedException
 
473
        raise NotImplementedError
365
474
 
366
475
class ZipPackage(Package, ScriptEngine):
367
476
    """ A package that reads its files from a .zip file. """
424
533
        request_url = "localhost/"
425
534
 
426
535
    # Setup MoinMoin environment
427
 
    from MoinMoin.request import RequestCLI
428
 
    request = RequestCLI(url = 'localhost/')
 
536
    from MoinMoin.request import request_cli
 
537
    request = request_cli.Request(url=request_url)
429
538
    request.form = request.args = request.setup_args()
430
539
 
431
540
    package = ZipPackage(request, packagefile)
442
551
            print "Installation failed."
443
552
        if package.msg:
444
553
            print package.msg
445
 
    
 
554
 
446
555
if __name__ == '__main__':
447
556
    main()