Delivered-To: bbb@zzz.org
Received: by mail.zzz.org (Postfix, from userid 889)
id 27CEAD38CC; Fri, 4 May 2001 14:05:44 -0400 (EDT)
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
From: bbb@ddd.com (John X. Doe)
To: bbb@zzz.org
Subject: This is a test message
Date: Fri, 4 May 2001 14:05:44 -0400
Content-Type: text/plain; charset="us-ascii";
title*="us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21"
Hi,
Do you like this message?
-Me
""")
def test_rfc2231_get_content_charset(self):
eq = self.assertEqual
msg = self._msgobj('msg_32.txt')
eq(msg.get_content_charset(), 'us-ascii')
def test_rfc2231_no_language_or_charset(self):
m = '''\
Content-Transfer-Encoding: 8bit
Content-Disposition: inline; filename="file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm"
Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEM; NAME*1=P_nsmail.htm
'''
msg = email.message_from_string(m)
param = msg.get_param('NAME')
self.assertFalse(isinstance(param, tuple))
self.assertEqual(
param,
'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
def test_rfc2231_no_language_or_charset_in_filename(self):
m = '''\
Content-Disposition: inline;
\tfilename*0*="''This%20is%20even%20more%20";
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_filename(),
'This is even more ***fun*** is it not.pdf')
def test_rfc2231_no_language_or_charset_in_filename_encoded(self):
m = '''\
Content-Disposition: inline;
\tfilename*0*="''This%20is%20even%20more%20";
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_filename(),
'This is even more ***fun*** is it not.pdf')
def test_rfc2231_partly_encoded(self):
m = '''\
Content-Disposition: inline;
\tfilename*0="''This%20is%20even%20more%20";
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(
msg.get_filename(),
'This%20is%20even%20more%20***fun*** is it not.pdf')
def test_rfc2231_partly_nonencoded(self):
m = '''\
Content-Disposition: inline;
\tfilename*0="This%20is%20even%20more%20";
\tfilename*1="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(
msg.get_filename(),
'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20is it not.pdf')
def test_rfc2231_no_language_or_charset_in_boundary(self):
m = '''\
Content-Type: multipart/alternative;
\tboundary*0*="''This%20is%20even%20more%20";
\tboundary*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tboundary*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_boundary(),
'This is even more ***fun*** is it not.pdf')
def test_rfc2231_no_language_or_charset_in_charset(self):
# This is a nonsensical charset value, but tests the code anyway
m = '''\
Content-Type: text/plain;
\tcharset*0*="This%20is%20even%20more%20";
\tcharset*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tcharset*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_content_charset(),
'this is even more ***fun*** is it not.pdf')
def test_rfc2231_bad_encoding_in_filename(self):
m = '''\
Content-Disposition: inline;
\tfilename*0*="bogus'xx'This%20is%20even%20more%20";
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2="is it not.pdf"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_filename(),
'This is even more ***fun*** is it not.pdf')
def test_rfc2231_bad_encoding_in_charset(self):
m = """\
Content-Type: text/plain; charset*=bogus''utf-8%E2%80%9D
"""
msg = email.message_from_string(m)
# This should return None because non-ascii characters in the charset
# are not allowed.
self.assertEqual(msg.get_content_charset(), None)
def test_rfc2231_bad_character_in_charset(self):
m = """\
Content-Type: text/plain; charset*=ascii''utf-8%E2%80%9D
"""
msg = email.message_from_string(m)
# This should return None because non-ascii characters in the charset
# are not allowed.
self.assertEqual(msg.get_content_charset(), None)
def test_rfc2231_bad_character_in_filename(self):
m = '''\
Content-Disposition: inline;
\tfilename*0*="ascii'xx'This%20is%20even%20more%20";
\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
\tfilename*2*="is it not.pdf%E2"
'''
msg = email.message_from_string(m)
self.assertEqual(msg.get_filename(),
u'This is even more ***fun*** is it not.pdf\ufffd')
def test_rfc2231_unknown_encoding(self):
m = """\
Content-Transfer-Encoding: 8bit
Content-Disposition: inline; filename*=X-UNKNOWN''myfile.txt
"""
msg = email.message_from_string(m)
self.assertEqual(msg.get_filename(), 'myfile.txt')
def test_rfc2231_single_tick_in_filename_extended(self):
eq = self.assertEqual
m = """\
Content-Type: application/x-foo;
\tname*0*=\"Frank's\"; name*1*=\" Document\"
"""
msg = email.message_from_string(m)
charset, language, s = msg.get_param('name')
eq(charset, None)
eq(language, None)
eq(s, "Frank's Document")
def test_rfc2231_single_tick_in_filename(self):
m = """\
Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"
"""
msg = email.message_from_string(m)
param = msg.get_param('name')
self.assertFalse(isinstance(param, tuple))
self.assertEqual(param, "Frank's Document")
def test_rfc2231_tick_attack_extended(self):
eq = self.assertEqual
m = """\
Content-Type: application/x-foo;
\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\"
"""
msg = email.message_from_string(m)
charset, language, s = msg.get_param('name')
eq(charset, 'us-ascii')
eq(language, 'en-us')
eq(s, "Frank's Document")
def test_rfc2231_tick_attack(self):
m = """\
Content-Type: application/x-foo;
\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\"
"""
msg = email.message_from_string(m)
param = msg.get_param('name')
self.assertFalse(isinstance(param, tuple))
self.assertEqual(param, "us-ascii'en-us'Frank's Document")
def test_rfc2231_no_extended_values(self):
eq = self.assertEqual
m = """\
Content-Type: application/x-foo; name=\"Frank's Document\"
"""
msg = email.message_from_string(m)
eq(msg.get_param('name'), "Frank's Document")
def test_rfc2231_encoded_then_unencoded_segments(self):
eq = self.assertEqual
m = """\
Content-Type: application/x-foo;
\tname*0*=\"us-ascii'en-us'My\";
\tname*1=\" Document\";
\tname*2*=\" For You\"
"""
msg = email.message_from_string(m)
charset, language, s = msg.get_param('name')
eq(charset, 'us-ascii')
eq(language, 'en-us')
eq(s, 'My Document For You')
def test_rfc2231_unencoded_then_encoded_segments(self):
eq = self.assertEqual
m = """\
Content-Type: application/x-foo;
\tname*0=\"us-ascii'en-us'My\";
\tname*1*=\" Document\";
\tname*2*=\" For You\"
"""
msg = email.message_from_string(m)
charset, language, s = msg.get_param('name')
eq(charset, 'us-ascii')
eq(language, 'en-us')
eq(s, 'My Document For You')
def _testclasses():
mod = sys.modules[__name__]
return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
def suite():
suite = unittest.TestSuite()
for testclass in _testclasses():
suite.addTest(unittest.makeSuite(testclass))
return suite
def test_main():
for testclass in _testclasses():
run_unittest(testclass)
if __name__ == '__main__':
unittest.main(defaultTest='suite')
# -*- coding: utf-8 -*-
from micolog_plugin import *
import logging,re
from google.appengine.api import mail
from model import *
from google.appengine.api import users
from base import BaseRequestHandler,urldecode
from google.appengine.ext.webapp import template
SBODY='''New comment on your post "%(title)s"
Author : %(author)s
E-mail : %(email)s
URL : %(weburl)s
Comment:
%(content)s
You can see all comments on this post here:
%(commenturl)s
'''
BBODY='''Hi~ New reference on your comment for post "%(title)s"
Author : %(author)s
URL : %(weburl)s
Comment:
%(content)s
You can see all comments on this post here:
%(commenturl)s
'''
class NotifyHandler(BaseRequestHandler):
def __init__(self):
BaseRequestHandler.__init__(self)
self.current="config"
self.sbody=OptionSet.getValue('sys_plugin_sbody',SBODY)
self.bbody=OptionSet.getValue('sys_plugin_bbody',BBODY)
def get(self):
self.template_vals.update({'self':self})
content=template.render('plugins/sys_plugin/setup.html',self.template_vals)
self.render2('views/admin/setup_base.html',{'m_id':'sysplugin_notify','content':content})
#Also you can use:
#self.render2('plugins/sys_plugin/setup2.html',{'m_id':'sysplugin_notify','self':self})
def post(self):
self.bbody=self.param('bbody')
self.sbody=self.param('sbody')
self.blog.comment_notify_mail=self.parambool('comment_notify_mail')
self.blog.put()
OptionSet.setValue('sys_plugin_sbody',self.sbody)
OptionSet.setValue('sys_plugin_bbody',self.bbody)
self.get()
class sys_plugin(Plugin):
def __init__(self):
Plugin.__init__(self,__file__)
self.author="xuming"
self.authoruri="http://xuming.net"
self.uri="http://xuming.net"
self.description="System plugin for micolog"
self.name="Sys Plugin"
self.version="0.2"
self.blocklist=OptionSet.getValue("sys_plugin_blocklist",default="")
self.register_filter('head',self.head)
self.register_filter('footer',self.footer)
self.register_urlmap('sys_plugin/setup',self.setup)
self.register_urlhandler('/admin/sys_plugin/notify',NotifyHandler)
self.register_setupmenu('sysplugin_notify',_('Notify'),'/admin/sys_plugin/notify')
self.register_action('pre_comment',self.pre_comment)
self.register_action('save_comment',self.save_comment)
self.sbody=OptionSet.getValue('sys_plugin_sbody',SBODY)
self.bbody=OptionSet.getValue('sys_plugin_bbody',BBODY)
def head(self,content,blog=None,*arg1,**arg2):
content=content+''%blog.version
return content
def footer(self,content,blog=None,*arg1,**arg2):
return content+''%blog.version
def setup(self,page=None,*arg1,**arg2):
if not page.is_login:
page.redirect(users.create_login_url(page.request.uri))
tempstr='''
blocklist:
'''
if page.request.method=='GET':
page.render2('views/admin/base.html',{'m_id':'sysplugin_block','content':tempstr%self.blocklist})
else:
self.blocklist=page.param("ta_list")
OptionSet.setValue("sys_plugin_blocklist",self.blocklist)
page.render2('views/admin/base.html',{'m_id':'sysplugin_block','content':tempstr%self.blocklist})
def get(self,page):
return '''Sys Plugin
This is a system plugin for micolog.
Also a demo for how to write plugin for micolog.
feature
- Add Meta <meta name="generator" content="Micolog x.x" />
- Add footer "<!--Powered by micolog x.x-->"
- Comments Filter with blocklist Setup
- Comment Notify Setup
'''
def pre_comment(self,comment,*arg1,**arg2):
for s in self.blocklist.splitlines():
if comment.content.find(s)>-1:
raise Exception
def save_comment(self,comment,*arg1,**arg2):
if self.blog.comment_notify_mail:
self.notify(comment)
def notify(self,comment):
try:
sbody=self.sbody.decode('utf-8')
except:
sbody=self.sbody
try:
bbody=self.bbody.decode('utf-8')
except:
bbody=self.bbody
if self.blog.comment_notify_mail and self.blog.owner and not users.is_current_user_admin() :
sbody=sbody%{'title':comment.entry.title,
'author':comment.author,
'weburl':comment.weburl,
'email':comment.email,
'content':comment.content,
'commenturl':comment.entry.fullurl+"#comment-"+str(comment.key().id())
}
mail.send_mail_to_admins(self.blog.owner.email(),'Comments:'+comment.entry.title, sbody,reply_to=comment.email)
#reply comment mail notify
refers = re.findall(r'#comment-(\d+)', comment.content)
if len(refers)!=0:
replyIDs=[int(a) for a in refers]
commentlist=comment.entry.comments()
emaillist=[c.email for c in commentlist if c.reply_notify_mail and c.key().id() in replyIDs]
emaillist = {}.fromkeys(emaillist).keys()
for refer in emaillist:
if self.blog.owner and mail.is_email_valid(refer):
emailbody = bbody%{'title':comment.entry.title,
'author':comment.author,
'weburl':comment.weburl,
'email':comment.email,
'content':comment.content,
'commenturl':comment.entry.fullurl+"#comment-"+str(comment.key().id())
}
message = mail.EmailMessage(sender = self.blog.owner.email(),subject = 'Comments:'+comment.entry.title)
message.to = refer
message.body = emailbody
message.send()
'''
Allmyvideos urlresolver plugin
Copyright (C) 2013 Vinnydude
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
'''
import re
from t0mm0.common.net import Net
from urlresolver.plugnplay.interfaces import UrlResolver
from urlresolver.plugnplay.interfaces import PluginSettings
from urlresolver.plugnplay import Plugin
from urlresolver import common
class ShareVidResolver(Plugin, UrlResolver, PluginSettings):
implements = [UrlResolver, PluginSettings]
name = "sharevid"
domains = ["sharevid.org"]
def __init__(self):
p = self.get_setting('priority') or 100
self.priority = int(p)
self.net = Net()
def get_media_url(self, host, media_id):
url = self.get_url(host, media_id)
html = self.net.http_GET(url).content
data = {}
r = re.findall(r'type="hidden" name="(.+?)"\s* value="?(.+?)">', html)
for name, value in r:
data[name] = value
html = self.net.http_POST(url, data).content
r = re.search("file\s*:\s*'(.+?)'", html)
if r:
return r.group(1)
else:
raise UrlResolver.ResolverError('could not find video')
def get_url(self, host, media_id):
return 'http://sharevid.org/%s' % media_id
def get_host_and_id(self, url):
r = re.search('//(.+?)/(?:embed-)?([0-9a-zA-Z]+)', url)
if r:
return r.groups()
else:
return False
return('host', 'media_id')
def valid_url(self, url, host):
if self.get_setting('enabled') == 'false': return False
return (re.match('http://(www.)?sharevid.org/[0-9A-Za-z]+', url) or re.match('http://(www.)?sharevid.org/embed-[0-9A-Za-z]+[\-]*\d*[x]*\d*.*[html]*', url) or 'sharevid' in host)
######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Communicator client code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 1998
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
# Mark Pilgrim - port to Python
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
######################### END LICENSE BLOCK #########################
from .euctwfreq import (EUCTWCharToFreqOrder, EUCTW_TABLE_SIZE,
EUCTW_TYPICAL_DISTRIBUTION_RATIO)
from .euckrfreq import (EUCKRCharToFreqOrder, EUCKR_TABLE_SIZE,
EUCKR_TYPICAL_DISTRIBUTION_RATIO)
from .gb2312freq import (GB2312CharToFreqOrder, GB2312_TABLE_SIZE,
GB2312_TYPICAL_DISTRIBUTION_RATIO)
from .big5freq import (Big5CharToFreqOrder, BIG5_TABLE_SIZE,
BIG5_TYPICAL_DISTRIBUTION_RATIO)
from .jisfreq import (JISCharToFreqOrder, JIS_TABLE_SIZE,
JIS_TYPICAL_DISTRIBUTION_RATIO)
from .compat import wrap_ord
ENOUGH_DATA_THRESHOLD = 1024
SURE_YES = 0.99
SURE_NO = 0.01
MINIMUM_DATA_THRESHOLD = 3
class CharDistributionAnalysis:
def __init__(self):
# Mapping table to get frequency order from char order (get from
# GetOrder())
self._mCharToFreqOrder = None
self._mTableSize = None # Size of above table
# This is a constant value which varies from language to language,
# used in calculating confidence. See
# http://www.mozilla.org/projects/intl/UniversalCharsetDetection.html
# for further detail.
self._mTypicalDistributionRatio = None
self.reset()
def reset(self):
"""reset analyser, clear any state"""
# If this flag is set to True, detection is done and conclusion has
# been made
self._mDone = False
self._mTotalChars = 0 # Total characters encountered
# The number of characters whose frequency order is less than 512
self._mFreqChars = 0
def feed(self, aBuf, aCharLen):
"""feed a character with known length"""
if aCharLen == 2:
# we only care about 2-bytes character in our distribution analysis
order = self.get_order(aBuf)
else:
order = -1
if order >= 0:
self._mTotalChars += 1
# order is valid
if order < self._mTableSize:
if 512 > self._mCharToFreqOrder[order]:
self._mFreqChars += 1
def get_confidence(self):
"""return confidence based on existing data"""
# if we didn't receive any character in our consideration range,
# return negative answer
if self._mTotalChars <= 0 or self._mFreqChars <= MINIMUM_DATA_THRESHOLD:
return SURE_NO
if self._mTotalChars != self._mFreqChars:
r = (self._mFreqChars / ((self._mTotalChars - self._mFreqChars)
* self._mTypicalDistributionRatio))
if r < SURE_YES:
return r
# normalize confidence (we don't want to be 100% sure)
return SURE_YES
def got_enough_data(self):
# It is not necessary to receive all data to draw conclusion.
# For charset detection, certain amount of data is enough
return self._mTotalChars > ENOUGH_DATA_THRESHOLD
def get_order(self, aBuf):
# We do not handle characters based on the original encoding string,
# but convert this encoding string to a number, here called order.
# This allows multiple encodings of a language to share one frequency
# table.
return -1
class EUCTWDistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = EUCTWCharToFreqOrder
self._mTableSize = EUCTW_TABLE_SIZE
self._mTypicalDistributionRatio = EUCTW_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for euc-TW encoding, we are interested
# first byte range: 0xc4 -- 0xfe
# second byte range: 0xa1 -- 0xfe
# no validation needed here. State machine has done that
first_char = wrap_ord(aBuf[0])
if first_char >= 0xC4:
return 94 * (first_char - 0xC4) + wrap_ord(aBuf[1]) - 0xA1
else:
return -1
class EUCKRDistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = EUCKRCharToFreqOrder
self._mTableSize = EUCKR_TABLE_SIZE
self._mTypicalDistributionRatio = EUCKR_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for euc-KR encoding, we are interested
# first byte range: 0xb0 -- 0xfe
# second byte range: 0xa1 -- 0xfe
# no validation needed here. State machine has done that
first_char = wrap_ord(aBuf[0])
if first_char >= 0xB0:
return 94 * (first_char - 0xB0) + wrap_ord(aBuf[1]) - 0xA1
else:
return -1
class GB2312DistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = GB2312CharToFreqOrder
self._mTableSize = GB2312_TABLE_SIZE
self._mTypicalDistributionRatio = GB2312_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for GB2312 encoding, we are interested
# first byte range: 0xb0 -- 0xfe
# second byte range: 0xa1 -- 0xfe
# no validation needed here. State machine has done that
first_char, second_char = wrap_ord(aBuf[0]), wrap_ord(aBuf[1])
if (first_char >= 0xB0) and (second_char >= 0xA1):
return 94 * (first_char - 0xB0) + second_char - 0xA1
else:
return -1
class Big5DistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = Big5CharToFreqOrder
self._mTableSize = BIG5_TABLE_SIZE
self._mTypicalDistributionRatio = BIG5_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for big5 encoding, we are interested
# first byte range: 0xa4 -- 0xfe
# second byte range: 0x40 -- 0x7e , 0xa1 -- 0xfe
# no validation needed here. State machine has done that
first_char, second_char = wrap_ord(aBuf[0]), wrap_ord(aBuf[1])
if first_char >= 0xA4:
if second_char >= 0xA1:
return 157 * (first_char - 0xA4) + second_char - 0xA1 + 63
else:
return 157 * (first_char - 0xA4) + second_char - 0x40
else:
return -1
class SJISDistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = JISCharToFreqOrder
self._mTableSize = JIS_TABLE_SIZE
self._mTypicalDistributionRatio = JIS_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for sjis encoding, we are interested
# first byte range: 0x81 -- 0x9f , 0xe0 -- 0xfe
# second byte range: 0x40 -- 0x7e, 0x81 -- oxfe
# no validation needed here. State machine has done that
first_char, second_char = wrap_ord(aBuf[0]), wrap_ord(aBuf[1])
if (first_char >= 0x81) and (first_char <= 0x9F):
order = 188 * (first_char - 0x81)
elif (first_char >= 0xE0) and (first_char <= 0xEF):
order = 188 * (first_char - 0xE0 + 31)
else:
return -1
order = order + second_char - 0x40
if second_char > 0x7F:
order = -1
return order
class EUCJPDistributionAnalysis(CharDistributionAnalysis):
def __init__(self):
CharDistributionAnalysis.__init__(self)
self._mCharToFreqOrder = JISCharToFreqOrder
self._mTableSize = JIS_TABLE_SIZE
self._mTypicalDistributionRatio = JIS_TYPICAL_DISTRIBUTION_RATIO
def get_order(self, aBuf):
# for euc-JP encoding, we are interested
# first byte range: 0xa0 -- 0xfe
# second byte range: 0xa1 -- 0xfe
# no validation needed here. State machine has done that
char = wrap_ord(aBuf[0])
if char >= 0xA0:
return 94 * (char - 0xA1) + wrap_ord(aBuf[1]) - 0xa1
else:
return -1
# -*- encoding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
#
##############################################################################
import order
import report_lunch_order
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
# Copyright (C) 2013 Google Inc., authors, and contributors
# Licensed under http://www.apache.org/licenses/LICENSE-2.0
# Created By: david@reciprocitylabs.com
# Maintained By: david@reciprocitylabs.com
from collections import namedtuple
from flask import session
from ggrc.login import get_current_user
from .user_permissions import UserPermissions
Permission = namedtuple('Permission', 'action resource_type context_id')
class DefaultUserPermissionsProvider(object):
def __init__(self, settings):
pass
def permissions_for(self, user):
return DefaultUserPermissions()
class DefaultUserPermissions(UserPermissions):
def _is_allowed(self, permission):
if 'permissions' not in session:
return False
permissions = session['permissions']
if permissions is None:
return True
return permission.context_id in \
permissions\
.get(permission.action, {})\
.get(permission.resource_type, ())
def is_allowed_create(self, resource_type, context_id):
"""Whether or not the user is allowed to create a resource of the specified
type in the context."""
return self._is_allowed(Permission('create', resource_type, context_id))
def is_allowed_read(self, resource_type, context_id):
"""Whether or not the user is allowed to read a resource of the specified
type in the context."""
return self._is_allowed(Permission('read', resource_type, context_id))
def is_allowed_update(self, resource_type, context_id):
"""Whether or not the user is allowed to update a resource of the specified
type in the context."""
return self._is_allowed(Permission('update', resource_type, context_id))
def is_allowed_delete(self, resource_type, context_id):
"""Whether or not the user is allowed to delete a resource of the specified
type in the context."""
return self._is_allowed(Permission('delete', resource_type, context_id))
def _get_contexts_for(self, action, resource_type):
if 'permissions' not in session:
return False
permissions = session['permissions']
if permissions is None:
return None
ret = list(permissions.get(action, {}).get(resource_type, ()))
return ret
def create_contexts_for(self, resource_type):
"""All contexts in which the user has create permission."""
return self._get_contexts_for('create', resource_type)
def read_contexts_for(self, resource_type):
"""All contexts in which the user has read permission."""
return self._get_contexts_for('read', resource_type)
def update_contexts_for(self, resource_type):
"""All contexts in which the user has update permission."""
return self._get_contexts_for('update', resource_type)
def delete_contexts_for(self, resource_type):
"""All contexts in which the user has delete permission."""
return self._get_contexts_for('delete', resource_type)
"""
sentry.models.user
~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
import warnings
from django.contrib.auth.models import AbstractBaseUser, UserManager
from django.db import IntegrityError, models, transaction
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
from sentry.db.models import BaseManager, BaseModel, BoundedAutoField
class UserManager(BaseManager, UserManager):
pass
class User(BaseModel, AbstractBaseUser):
id = BoundedAutoField(primary_key=True)
username = models.CharField(_('username'), max_length=128, unique=True)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=30, blank=True)
email = models.EmailField(_('email address'), blank=True)
is_staff = models.BooleanField(
_('staff status'), default=False,
help_text=_('Designates whether the user can log into this admin '
'site.'))
is_active = models.BooleanField(
_('active'), default=True,
help_text=_('Designates whether this user should be treated as '
'active. Unselect this instead of deleting accounts.'))
is_superuser = models.BooleanField(
_('superuser status'), default=False,
help_text=_('Designates that this user has all permissions without '
'explicitly assigning them.'))
is_managed = models.BooleanField(
_('managed'), default=False,
help_text=_('Designates whether this user should be treated as '
'managed. Select this to disallow the user from '
'modifying their account (username, password, etc).'))
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
objects = UserManager(cache_fields=['pk'])
USERNAME_FIELD = 'username'
REQUIRED_FIELDS = ['email']
class Meta:
app_label = 'sentry'
db_table = 'auth_user'
verbose_name = _('user')
verbose_name_plural = _('users')
def delete(self):
if self.username == 'sentry':
raise Exception('You cannot delete the "sentry" user as it is required by Sentry.')
return super(User, self).delete()
def save(self, *args, **kwargs):
if not self.username:
self.username = self.email
return super(User, self).save(*args, **kwargs)
def has_perm(self, perm_name):
warnings.warn('User.has_perm is deprecated', DeprecationWarning)
return self.is_superuser
def has_module_perms(self, app_label):
# the admin requires this method
return self.is_superuser
def get_full_name(self):
return self.first_name
def get_short_name(self):
return self.username
def merge_to(from_user, to_user):
# TODO: we could discover relations automatically and make this useful
from sentry.models import (
AuditLogEntry, Activity, AuthIdentity, GroupBookmark,
OrganizationMember, UserOption
)
for obj in OrganizationMember.objects.filter(user=from_user):
with transaction.atomic():
try:
obj.update(user=to_user)
except IntegrityError:
pass
for obj in GroupBookmark.objects.filter(user=from_user):
with transaction.atomic():
try:
obj.update(user=to_user)
except IntegrityError:
pass
for obj in UserOption.objects.filter(user=from_user):
with transaction.atomic():
try:
obj.update(user=to_user)
except IntegrityError:
pass
Activity.objects.filter(
user=from_user,
).update(user=to_user)
AuditLogEntry.objects.filter(
actor=from_user,
).update(actor=to_user)
AuditLogEntry.objects.filter(
target_user=from_user,
).update(target_user=to_user)
AuthIdentity.objects.filter(
user=from_user,
).update(user=to_user)
def get_display_name(self):
return self.first_name or self.email or self.username
def is_active_superuser(self):
# TODO(dcramer): add VPN support via INTERNAL_IPS + ipaddr ranges
return self.is_superuser
#!/usr/bin/env python
import os, sys, tempfile
assert sys.version_info[:2] >= ( 2, 4 )
def __main__():
# Read parms.
input_name = sys.argv[1]
output_name = sys.argv[2]
attribute_name = sys.argv[3]
# Create temp files.
tmp_name1 = tempfile.NamedTemporaryFile().name
tmp_name2 = tempfile.NamedTemporaryFile().name
# Do conversion.
skipped_lines = 0
first_skipped_line = 0
out = open( tmp_name1, 'w' )
# Write track data to temporary file.
i = 0
for i, line in enumerate( file( input_name ) ):
line = line.rstrip( '\r\n' )
if line and not line.startswith( '#' ):
try:
elems = line.split( '\t' )
start = str( int( elems[3] ) - 1 ) # GTF coordinates are 1-based, BedGraph are 0-based.
strand = elems[6]
if strand not in ['+', '-']:
strand = '+'
attributes_list = elems[8].split(";")
attributes = {}
for name_value_pair in attributes_list:
pair = name_value_pair.strip().split(" ")
name = pair[0].strip()
if name == '':
continue
# Need to strip double quote from values
value = pair[1].strip(" \"")
attributes[name] = value
value = attributes[ attribute_name ]
# GTF format: chrom source, name, chromStart, chromEnd, score, strand, frame, attributes.
# BedGraph format: chrom, chromStart, chromEnd, value
out.write( "%s\t%s\t%s\t%s\n" %( elems[0], start, elems[4], value ) )
except:
skipped_lines += 1
if not first_skipped_line:
first_skipped_line = i + 1
else:
skipped_lines += 1
if not first_skipped_line:
first_skipped_line = i + 1
out.close()
# Sort tmp file by chromosome name and chromosome start to create ordered track data.
cmd = "sort -k1,1 -k2,2n < %s > %s" % ( tmp_name1, tmp_name2 )
try:
os.system(cmd)
os.remove(tmp_name1)
except Exception, ex:
sys.stderr.write( "%s\n" % ex )
sys.exit(1)
# Create bedgraph file by combining track definition with ordered track data.
cmd = "echo 'track type=bedGraph' | cat - %s > %s " % ( tmp_name2, output_name )
try:
os.system(cmd)
os.remove(tmp_name2)
except Exception, ex:
sys.stderr.write( "%s\n" % ex )
sys.exit(1)
info_msg = "%i lines converted to BEDGraph. " % ( i + 1 - skipped_lines )
if skipped_lines > 0:
info_msg += "Skipped %d blank/comment/invalid lines starting with line #%d." %( skipped_lines, first_skipped_line )
print info_msg
if __name__ == "__main__": __main__()
"""
Tests for memcache in util app
"""
from django.test import TestCase
from django.core.cache import caches
from util.memcache import safe_key
class MemcacheTest(TestCase):
"""
Test memcache key cleanup
"""
# Test whitespace, control characters, and some non-ASCII UTF-16
UNICODE_CHAR_CODES = (range(30) + [127] +
[129, 500, 2 ** 8 - 1, 2 ** 8 + 1, 2 ** 16 - 1])
def setUp(self):
super(MemcacheTest, self).setUp()
self.cache = caches['default']
def test_safe_key(self):
key = safe_key('test', 'prefix', 'version')
self.assertEqual(key, 'prefix:version:test')
def test_numeric_inputs(self):
# Numeric key
self.assertEqual(safe_key(1, 'prefix', 'version'), 'prefix:version:1')
# Numeric prefix
self.assertEqual(safe_key('test', 5, 'version'), '5:version:test')
# Numeric version
self.assertEqual(safe_key('test', 'prefix', 5), 'prefix:5:test')
def test_safe_key_long(self):
# Choose lengths close to memcached's cutoff (250)
for length in [248, 249, 250, 251, 252]:
# Generate a key of that length
key = 'a' * length
# Make the key safe
key = safe_key(key, '', '')
# The key should now be valid
self.assertTrue(self._is_valid_key(key),
msg="Failed for key length {0}".format(length))
def test_long_key_prefix_version(self):
# Long key
key = safe_key('a' * 300, 'prefix', 'version')
self.assertTrue(self._is_valid_key(key))
# Long prefix
key = safe_key('key', 'a' * 300, 'version')
self.assertTrue(self._is_valid_key(key))
# Long version
key = safe_key('key', 'prefix', 'a' * 300)
self.assertTrue(self._is_valid_key(key))
def test_safe_key_unicode(self):
for unicode_char in self.UNICODE_CHAR_CODES:
# Generate a key with that character
key = unichr(unicode_char)
# Make the key safe
key = safe_key(key, '', '')
# The key should now be valid
self.assertTrue(self._is_valid_key(key),
msg="Failed for unicode character {0}".format(unicode_char))
def test_safe_key_prefix_unicode(self):
for unicode_char in self.UNICODE_CHAR_CODES:
# Generate a prefix with that character
prefix = unichr(unicode_char)
# Make the key safe
key = safe_key('test', prefix, '')
# The key should now be valid
self.assertTrue(self._is_valid_key(key),
msg="Failed for unicode character {0}".format(unicode_char))
def test_safe_key_version_unicode(self):
for unicode_char in self.UNICODE_CHAR_CODES:
# Generate a version with that character
version = unichr(unicode_char)
# Make the key safe
key = safe_key('test', '', version)
# The key should now be valid
self.assertTrue(self._is_valid_key(key),
msg="Failed for unicode character {0}".format(unicode_char))
def _is_valid_key(self, key):
"""
Test that a key is memcache-compatible.
Based on Django's validator in core.cache.backends.base
"""
# Check the length
if len(key) > 250:
return False
# Check that there are no spaces or control characters
for char in key:
if ord(char) < 33 or ord(char) == 127:
return False
return True
# -*- coding: utf-8 -*-
import logging
import os
import time
from os import listdir
from os.path import join
from threading import Thread, Lock
from select import select
from Queue import Queue, Empty
import openerp
import openerp.addons.hw_proxy.controllers.main as hw_proxy
from openerp import http
from openerp.http import request
from openerp.tools.translate import _
_logger = logging.getLogger(__name__)
try:
import serial
except ImportError:
_logger.error('OpenERP module hw_scale depends on the pyserial python module')
serial = None
class Scale(Thread):
def __init__(self):
Thread.__init__(self)
self.lock = Lock()
self.scalelock = Lock()
self.status = {'status':'connecting', 'messages':[]}
self.input_dir = '/dev/serial/by-id/'
self.weight = 0
self.weight_info = 'ok'
self.device = None
def lockedstart(self):
with self.lock:
if not self.isAlive():
self.daemon = True
self.start()
def set_status(self, status, message = None):
if status == self.status['status']:
if message != None and message != self.status['messages'][-1]:
self.status['messages'].append(message)
else:
self.status['status'] = status
if message:
self.status['messages'] = [message]
else:
self.status['messages'] = []
if status == 'error' and message:
_logger.error('Scale Error: '+message)
elif status == 'disconnected' and message:
_logger.warning('Disconnected Scale: '+message)
def get_device(self):
try:
devices = [ device for device in listdir(self.input_dir)]
scales = [ device for device in devices if ('mettler' in device.lower()) or ('toledo' in device.lower()) ]
if len(scales) > 0:
print join(self.input_dir,scales[0])
self.set_status('connected','Connected to '+scales[0])
return serial.Serial(join(self.input_dir,scales[0]),
baudrate = 9600,
bytesize = serial.SEVENBITS,
stopbits = serial.STOPBITS_ONE,
parity = serial.PARITY_EVEN,
#xonxoff = serial.XON,
timeout = 0.01,
writeTimeout= 0.01)
else:
self.set_status('disconnected','Scale Not Found')
return None
except Exception as e:
self.set_status('error',str(e))
return None
def get_weight(self):
self.lockedstart()
return self.weight
def get_weight_info(self):
self.lockedstart()
return self.weight_info
def get_status(self):
self.lockedstart()
return self.status
def read_weight(self):
with self.scalelock:
if self.device:
try:
self.device.write('W')
time.sleep(0.1)
answer = []
while True:
char = self.device.read(1)
if not char:
break
else:
answer.append(char)
if '?' in answer:
stat = ord(answer[answer.index('?')+1])
if stat == 0:
self.weight_info = 'ok'
else:
self.weight_info = []
if stat & 1 :
self.weight_info.append('moving')
if stat & 1 << 1:
self.weight_info.append('over_capacity')
if stat & 1 << 2:
self.weight_info.append('negative')
self.weight = 0.0
if stat & 1 << 3:
self.weight_info.append('outside_zero_capture_range')
if stat & 1 << 4:
self.weight_info.append('center_of_zero')
if stat & 1 << 5:
self.weight_info.append('net_weight')
else:
answer = answer[1:-1]
if 'N' in answer:
answer = answer[0:-1]
try:
self.weight = float(''.join(answer))
except ValueError as v:
self.set_status('error','No data Received, please power-cycle the scale');
self.device = None
except Exception as e:
self.set_status('error',str(e))
self.device = None
def set_zero(self):
with self.scalelock:
if self.device:
try:
self.device.write('Z')
except Exception as e:
self.set_status('error',str(e))
self.device = None
def set_tare(self):
with self.scalelock:
if self.device:
try:
self.device.write('T')
except Exception as e:
self.set_status('error',str(e))
self.device = None
def clear_tare(self):
with self.scalelock:
if self.device:
try:
self.device.write('C')
except Exception as e:
self.set_status('error',str(e))
self.device = None
def run(self):
self.device = None
while True:
if self.device:
self.read_weight()
time.sleep(0.05)
else:
with self.scalelock:
self.device = self.get_device()
if not self.device:
time.sleep(5)
s = Scale()
hw_proxy.drivers['scale'] = s
class ScaleDriver(hw_proxy.Proxy):
@http.route('/hw_proxy/scale_read/', type='json', auth='none', cors='*')
def scale_read(self):
return {'weight':s.get_weight(), 'unit':'kg', 'info':s.get_weight_info()}
@http.route('/hw_proxy/scale_zero/', type='json', auth='none', cors='*')
def scale_zero(self):
s.set_zero()
return True
@http.route('/hw_proxy/scale_tare/', type='json', auth='none', cors='*')
def scale_tare(self):
s.set_tare()
return True
@http.route('/hw_proxy/scale_clear_tare/', type='json', auth='none', cors='*')
def scale_clear_tare(self):
s.clear_tare()
return True
# -*- coding: utf-8 -*-
"""
Host language sub-package for the pyRdfa package. It contains variables and possible modules necessary to manage various RDFa
host languages.
This module may have to be modified if a new host language is added to the system. In many cases the rdfa_core as a host language is enough, because there is no need for a special processing. However, some host languages may require an initial context, or their value may control some transformations, in which case additional data have to be added to this module. This module header contains all tables and arrays to be adapted, and the module content may contain specific transformation methods.
@summary: RDFa Host package
@requires: U{RDFLib package}
@organization: U{World Wide Web Consortium}
@author: U{Ivan Herman}
@license: This software is available for use under the
U{W3C® SOFTWARE NOTICE AND LICENSE}
@var content_to_host_language: a dictionary mapping a media type to a host language
@var preferred_suffixes: mapping from preferred suffixes for media types; used if the file is local, ie, there is not HTTP return value for the media type. It corresponds to the preferred suffix in the media type registration
@var initial_contexts: mapping from host languages to list of initial contexts
@var accept_xml_base: list of host languages that accept the xml:base attribute for base setting
@var accept_xml_lang: list of host languages that accept the xml:lang attribute for language setting. Note that XHTML and HTML have some special rules, and those are hard coded...
@var warn_xmlns_usage: list of host languages that should generate a warning for the usage of @xmlns (for RDFa 1.1)
@var accept_embedded_rdf_xml: list of host languages that might also include RDF data using an embedded RDF/XML (e.g., SVG). That RDF data may be merged with the output
@var accept_embedded_turtle: list of host languages that might also include RDF data using a C{script} element. That RDF data may be merged with the output
@var require_embedded_rdf: list of languages that must accept embedded RDF, ie, the corresponding option is irrelevant
@var host_dom_transforms: dictionary mapping a host language to an array of methods that are invoked at the beginning of the parsing process for a specific node. That function can do a last minute change on that DOM node, eg, adding or modifying an attribute. The method's signature is (node, state), where node is the DOM node, and state is the L{Execution context}.
@var predefined_1_0_rel: terms that are hardcoded for HTML+RDF1.0 and replace the initial context for that version
@var beautifying_prefixes: this is really just to make the output more attractive: for each media type a dictionary of prefix-URI pairs that can be used to make the terms look better...
@var default_vocabulary: as its name suggests, default @vocab value for a specific host language
"""
"""
$Id: __init__.py,v 1.21 2013-10-16 11:49:11 ivan Exp $
$Date: 2013-10-16 11:49:11 $
"""
__version__ = "3.0"
from .atom import atom_add_entry_type
from .html5 import html5_extra_attributes, remove_rel
class HostLanguage :
"""An enumeration style class: recognized host language types for this processor of RDFa. Some processing details may depend on these host languages. "rdfa_core" is the default Host Language is nothing else is defined."""
rdfa_core = "RDFa Core"
xhtml = "XHTML+RDFa"
xhtml5 = "XHTML5+RDFa"
html5 = "HTML5+RDFa"
atom = "Atom+RDFa"
svg = "SVG+RDFa"
# initial contexts for host languages
initial_contexts = {
HostLanguage.xhtml : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1",
"http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"],
HostLanguage.xhtml5 : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1"],
HostLanguage.html5 : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1"],
HostLanguage.rdfa_core : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1"],
HostLanguage.atom : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1"],
HostLanguage.svg : ["http://www.w3.org/2011/rdfa-context/rdfa-1.1"],
}
beautifying_prefixes = {
HostLanguage.xhtml : {
"xhv" : "http://www.w3.org/1999/xhtml/vocab#"
},
# HostLanguage.html5 : {
# "xhv" : "http://www.w3.org/1999/xhtml/vocab#"
# },
# HostLanguage.xhtml5 : {
# "xhv" : "http://www.w3.org/1999/xhtml/vocab#"
# },
HostLanguage.atom : {
"atomrel" : "http://www.iana.org/assignments/relation/"
}
}
accept_xml_base = [ HostLanguage.rdfa_core, HostLanguage.atom, HostLanguage.svg, HostLanguage.xhtml5 ]
accept_xml_lang = [ HostLanguage.rdfa_core, HostLanguage.atom, HostLanguage.svg ]
accept_embedded_rdf_xml = [ HostLanguage.svg, HostLanguage.rdfa_core ]
accept_embedded_turtle = [ HostLanguage.svg, HostLanguage.html5, HostLanguage.xhtml5, HostLanguage.xhtml ]
# some languages, eg, SVG, require that embedded content should be combined with the default graph,
# ie, it cannot be turned down by an option
require_embedded_rdf = [ HostLanguage.svg ]
warn_xmlns_usage = [ HostLanguage.html5, HostLanguage.xhtml5, HostLanguage.xhtml ]
host_dom_transforms = {
HostLanguage.atom : [atom_add_entry_type],
HostLanguage.html5 : [html5_extra_attributes, remove_rel],
HostLanguage.xhtml5 : [html5_extra_attributes, remove_rel]
}
default_vocabulary = {
HostLanguage.atom : "http://www.iana.org/assignments/relation/"
}
predefined_1_0_rel = ['alternate', 'appendix', 'cite', 'bookmark', 'chapter', 'contents',
'copyright', 'glossary', 'help', 'icon', 'index', 'meta', 'next', 'p3pv1', 'prev', 'previous',
'role', 'section', 'subsection', 'start', 'license', 'up', 'last', 'stylesheet', 'first', 'top']
# ----------------------------------------------------------------------------------------------------------
class MediaTypes :
"""An enumeration style class: some common media types (better have them at one place to avoid misstyping...)"""
rdfxml = 'application/rdf+xml'
turtle = 'text/turtle'
html = 'text/html'
xhtml = 'application/xhtml+xml'
svg = 'application/svg+xml'
svgi = 'image/svg+xml'
smil = 'application/smil+xml'
atom = 'application/atom+xml'
xml = 'application/xml'
xmlt = 'text/xml'
nt = 'text/plain'
# mapping from (some) content types to RDFa host languages. This may control the exact processing or at least the initial context (see below)...
content_to_host_language = {
MediaTypes.html : HostLanguage.html5,
MediaTypes.xhtml : HostLanguage.xhtml,
MediaTypes.xml : HostLanguage.rdfa_core,
MediaTypes.xmlt : HostLanguage.rdfa_core,
MediaTypes.smil : HostLanguage.rdfa_core,
MediaTypes.svg : HostLanguage.svg,
MediaTypes.svgi : HostLanguage.svg,
MediaTypes.atom : HostLanguage.atom,
}
# mapping preferred suffixes to media types...
preferred_suffixes = {
".rdf" : MediaTypes.rdfxml,
".ttl" : MediaTypes.turtle,
".n3" : MediaTypes.turtle,
".owl" : MediaTypes.rdfxml,
".html" : MediaTypes.html,
".shtml" : MediaTypes.html,
".xhtml" : MediaTypes.xhtml,
".svg" : MediaTypes.svg,
".smil" : MediaTypes.smil,
".xml" : MediaTypes.xml,
".nt" : MediaTypes.nt,
".atom" : MediaTypes.atom
}
# DTD combinations that may determine the host language and the rdfa version
_XHTML_1_0 = [
("-//W3C//DTD XHTML+RDFa 1.0//EN", "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd")
]
_XHTML_1_1 = [
("-//W3C//DTD XHTML+RDFa 1.1//EN", "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-2.dtd"),
("-//W3C//DTD HTML 4.01+RDFa 1.1//EN", "http://www.w3.org/MarkUp/DTD/html401-rdfa11-1.dtd")
]
_XHTML = [
("-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"),
("-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"),
("-//W3C//DTD XHTML 1.1//EN", "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd")
]
def adjust_html_version(input, rdfa_version) :
"""
Adjust the rdfa_version based on the (possible) DTD
@param input: the input stream that has to be parsed by an xml parser
@param rdfa_version: the current rdfa_version; will be returned if nothing else is found
@return: the rdfa_version, either "1.0" or "1.1, if the DTD says so, otherwise the input rdfa_version value
"""
import xml.dom.minidom
parse = xml.dom.minidom.parse
dom = parse(input)
(hl,version) = adjust_xhtml_and_version(dom, HostLanguage.xhtml, rdfa_version)
return version
def adjust_xhtml_and_version(dom, incoming_language, rdfa_version) :
"""
Check if the xhtml+RDFa is really XHTML 0 or 1 or whether it should be considered as XHTML5. This is done
by looking at the DTD. Furthermore, checks whether whether the system id signals an rdfa 1.0, in which case the
version is also set.
@param dom: top level DOM node
@param incoming_language: host language to be checked; the whole check is relevant for xhtml only.
@param rdfa_version: rdfa_version as known by the caller
@return: a tuple of the possibly modified host language (ie, set to XHTML5) and the possibly modified rdfa version (ie, set to "1.0", "1.1", or the incoming rdfa_version if nothing is found)
"""
if incoming_language == HostLanguage.xhtml :
try :
# There may not be any doctype set in the first place...
publicId = dom.doctype.publicId
systemId = dom.doctype.systemId
if (publicId, systemId) in _XHTML_1_0 :
return (HostLanguage.xhtml,"1.0")
elif (publicId, systemId) in _XHTML_1_1 :
return (HostLanguage.xhtml,"1.1")
elif (publicId, systemId) in _XHTML :
return (HostLanguage.xhtml, rdfa_version)
else :
return (HostLanguage.xhtml5, rdfa_version)
except :
# If any of those are missing, forget it...
return (HostLanguage.xhtml5, rdfa_version)
else :
return (incoming_language, rdfa_version)
#!/usr/bin/env python
"""
Checks that all examples load and synthesize successfully.
"""
import unittest
import glob
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..","src","lib"))
import specCompiler
class TestExample(unittest.TestCase):
def __init__(self, spec_filename):
super(TestExample, self).__init__()
self.spec_filename = spec_filename
def runTest(self):
title_str = "#### Testing project '{0}' ####".format(self.spec_filename)
print
if sys.platform not in ['win32', 'cygwin']:
print "\033[41m" # red background color
print "#"*len(title_str)
print title_str
print "#"*len(title_str),
if sys.platform not in ['win32', 'cygwin']:
print "\033[0m" # end coloring
print
c = specCompiler.SpecCompiler(self.spec_filename)
c_out = c.compile()
self.assertIsNotNone(c_out, msg="Compilation failed due to parser error")
realizable, realizableFS, output = c_out
print output
expectedToBeUnrealizable = ("unsynth" in self.spec_filename) or \
("unreal" in self.spec_filename) or \
("unsat" in self.spec_filename)
if expectedToBeUnrealizable:
self.assertFalse(realizable, msg="Specification was realizable but we did not expect this")
else:
self.assertTrue(realizable, msg="Specification was unrealizable")
# TODO: test analysis/cores
# TODO: test config files
#self.assertEqual(function_to_test(self.input), self.output)
def getTester(spec_filename):
class NewTester(TestExample): pass
NewTester.__name__ = "TestExample_" + spec_filename.replace(".","_").replace("\\","_").replace("/","_")
return NewTester(spec_filename)
def suiteAll():
suite = unittest.TestSuite()
for fname in glob.iglob(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..","src","examples","*","*.spec")):
# Skip any files untracked by git
if os.system("git ls-files \"{}\" --error-unmatch".format(fname)) != 0:
print ">>> Skipping untracked specification: {}".format(fname)
continue
suite.addTest(getTester(fname))
return suite
def suiteFromList(paths):
suite = unittest.TestSuite()
for fname in paths:
suite.addTest(getTester(fname))
return suite
if __name__ == '__main__':
# If we are called with arguments, test only those projects.
# Otherwise, test every tracked project in the examples/ directory
if len(sys.argv) >= 2:
unittest.TextTestRunner().run(suiteFromList(sys.argv[1:]))
else:
unittest.TextTestRunner().run(suiteAll())
#!/usr/bin/env python
'''
A boottool clone, but written in python and relying mostly on grubby[1].
[1] - http://git.fedorahosted.org/git/?p=grubby.git
'''
import os
import re
import sys
import optparse
import logging
import subprocess
import urllib
import tarfile
import tempfile
import shutil
import struct
#
# Get rid of DeprecationWarning messages on newer Python version while still
# making it run on properly on Python 2.4
#
try:
import hashlib as md5
except ImportError:
import md5
__all__ = ['Grubby', 'OptionParser', 'EfiVar', 'EfiToolSys',
'EliloConf', 'find_executable', 'parse_entry']
#
# Information on default requirements and installation for grubby
#
GRUBBY_REQ_VERSION = (8, 15)
GRUBBY_TARBALL_URI = ('http://pkgs.fedoraproject.org/repo/pkgs/grubby/'
'grubby-8.15.tar.bz2/c53d3f4cb5d22b25d27e3ee4c7ed5b80/'
'grubby-8.15.tar.bz2')
GRUBBY_TARBALL_MD5 = 'c53d3f4cb5d22b25d27e3ee4c7ed5b80'
GRUBBY_DEFAULT_SYSTEM_PATH = '/sbin/grubby'
GRUBBY_DEFAULT_USER_PATH = '/tmp/grubby'
#
# All options that are first class actions
# One of them should be given on the command line
#
ACTIONS = ['bootloader-probe',
'arch-probe',
'add-kernel',
'boot-once',
'install',
'remove-kernel',
'info',
'set-default',
'default',
'update-kernel',
# Commands not available in the old boottool
'grubby-version',
'grubby-version-check',
'grubby-install']
#
# When the command line is parsed, 'opts' gets attributes that are named
# after the command line options, but with slight changes
#
ACTIONS_OPT_METHOD_NAME = [act.replace('-', '_') for act in ACTIONS]
#
# Actions (as a opt/method name) that require a --title parameter
#
ACTIONS_REQUIRE_TITLE = ['boot_once', ]
#
# Include the logger (logging channel) name on the default logging config
#
LOGGING_FORMAT = "%(levelname)s: %(name)s: %(message)s"
#
# Default log object
#
log = logging.getLogger('boottool')
def find_header(hdr):
"""
Find a given header in the system.
"""
for dir in ['/usr/include', '/usr/local/include']:
file = os.path.join(dir, hdr)
if os.path.exists(file):
return file
raise ValueError('Missing header: %s' % hdr)
class EfiVar(object):
'''
Helper class to manipulate EFI firmware variables
This class has no notion of the EFI firmware variables interface, that is,
where it should read from or write to in order to create or delete EFI
variables.
On systems with kernel >= 2.6, that interface is a directory structure
under /sys/firmware/efi/vars.
On systems with kernel <= 2.4, that interface is going to be a directory
structure under /proc/efi/vars. But be advised: this has not been tested
yet on kernels <= 2.4.
'''
GUID_FMT = '16B'
GUID_CONTENT = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
ATTR_NON_VOLATILE = 0x0000000000000001
ATTR_BOOTSERVICE_ACCESS = 0x0000000000000002
ATTR_RUNTIME_ACCESS = 0x0000000000000004
DEFAULT_ATTRIBUTES = (ATTR_NON_VOLATILE |
ATTR_BOOTSERVICE_ACCESS |
ATTR_RUNTIME_ACCESS)
FMT = ('512H' +
GUID_FMT +
'1L' +
'512H' +
'1L' +
'1I')
def __init__(self, name, data, guid=None, attributes=None):
'''
Instantiates a new EfiVar
:type name: string
:param name: the name of the variable that will be created
:type data: string
:param data: user data that will populate the variable
:type guid: tuple
:param guid: content for the guid value that composes the full variable
name
:param attributes: integer
:param attributes: bitwise AND of the EFI attributes this variable will
have set
'''
self.data = data
self.name = name
if guid is None:
guid = self.GUID_CONTENT
self.guid = guid
if attributes is None:
attributes = self.DEFAULT_ATTRIBUTES
self.attributes = attributes
def get_name(self):
'''
Returns the variable name in a list ready for struct.pack()
'''
l = []
for i in range(512):
l.append(0)
for i in range(len(self.name)):
l[i] = ord(self.name[i])
return l
def get_data(self):
'''
Returns the variable data in a list ready for struct.pack()
'''
l = []
for i in range(512):
l.append(0)
for i in range(len(self.data)):
l[i] = ord(self.data[i])
return l
def get_packed(self):
'''
Returns the EFI variable raw data packed by struct.pack()
This data should be written to the appropriate interface to create
an EFI variable
'''
params = self.get_name()
params += self.guid
params.append((len(self.data) * 2) + 2)
params += self.get_data()
params.append(0)
params.append(self.attributes)
return struct.pack(self.FMT, *params)
class EfiToolSys(object):
'''
Interfaces with /sys/firmware/efi/vars provided by the kernel
This interface is present on kernels >= 2.6 with CONFIG_EFI and
CONFIG_EFI_VARS options set.
'''
BASE_PATH = '/sys/firmware/efi/vars'
NEW_VAR = os.path.join(BASE_PATH, 'new_var')
DEL_VAR = os.path.join(BASE_PATH, 'del_var')
def __init__(self):
if not os.path.exists(self.BASE_PATH):
sys.exit(-1)
self.log = logging.getLogger(self.__class__.__name__)
def create_variable(self, name, data, guid=None, attributes=None):
'''
Creates a new EFI variable
:type name: string
:param name: the name of the variable that will be created
:type data: string
:param data: user data that will populate the variable
:type guid: tuple
:param guid: content for the guid value that composes the full variable
name
:param attributes: integer
:param attributes: bitwise AND of the EFI attributes this variable will
have set
'''
if not self.check_basic_structure():
return False
var = EfiVar(name, data, guid, attributes)
f = open(self.NEW_VAR, 'w')
f.write(var.get_packed())
return True
def delete_variable(self, name, data, guid=None, attributes=None):
'''
Delets an existing EFI variable
:type name: string
:param name: the name of the variable that will be deleted
:type data: string
:param data: user data that will populate the variable
:type guid: tuple
:param guid: content for the guid value that composes the full variable
name
:param attributes: integer
:param attributes: bitwise AND of the EFI attributes this variable will
have set
'''
if not self.check_basic_structure():
return False
var = EfiVar(name, data, guid, attributes)
f = open(self.DEL_VAR, 'w')
f.write(var.get_packed())
return True
def check_basic_structure(self):
'''
Checks the basic directory structure for the /sys/.../vars interface
'''
status = True
if not os.path.isdir(self.BASE_PATH):
self.log.error('Could not find the base directory interface for '
'EFI variables: "%s"', self.BASE_PATH)
status = False
if not os.path.exists(self.NEW_VAR):
self.log.error('Could not find the file interface for creating new'
' EFI variables: "%s"', self.NEW_VAR)
status = False
if not os.path.exists(self.DEL_VAR):
self.log.error('Could not find the file interface for deleting '
'EFI variables: "%s"', self.DEL_VAR)
status = False
return status
class EliloConf(object):
'''
A simple parser for elilo configuration file
Has simple features to add and remove global options only, as this is all
we need. grubby takes care of manipulating the boot entries themselves.
'''
def __init__(self, path='/etc/elilo.conf'):
'''
Instantiates a new EliloConf
:type path: string
:param path: path to elilo.conf
'''
self.path = path
self.global_options_to_add = {}
self.global_options_to_remove = {}
self._follow_symlink()
def _follow_symlink(self):
'''
Dereference the path if it's a symlink and make it absolute
elilo.conf usually is a symlink to the EFI boot partition, so we
better follow it to the proper location.
'''
if os.path.islink(self.path):
self.path_link = self.path
self.path = os.path.realpath(self.path_link)
self.path = os.path.abspath(self.path)
def add_global_option(self, key, val=None):
'''
Adds a global option to the updated elilo configuration file
:type key: string
:param key: option name
:type val: string or None
:param key: option value or None for options with no values
:return: None
'''
self.global_options_to_add[key] = val
def remove_global_option(self, key, val=None):
'''
Removes a global option to the updated elilo configuration file
:type key: string
:param key: option name
:type val: string or None
:param key: option value or None for options with no values
:return: None
'''
self.global_options_to_remove[key] = val
def line_to_keyval(self, line):
'''
Transforms a text line from the configuration file into a tuple
:type line: string
:param line: line of text from the configuration file
:return: a tuple with key and value
'''
parts = line.split('=', 1)
key = parts[0].rstrip()
if len(parts) == 1:
val = None
elif len(parts) == 2:
val = parts[1].strip()
return (key, val)
def keyval_to_line(self, keyval):
'''
Transforms a tuple into a text line suitable for the config file
:type keyval: tuple
:param keyval: a tuple containing key and value
:return: a text line suitable for the config file
'''
key, val = keyval
if val is None:
return '%s\n' % key
else:
return '%s=%s\n' % (key, val)
def matches_global_option_to_remove(self, line):
'''
Utility method to check if option is to be removed
:type line: string
:param line: line of text from the configuration file
:return: True or False
'''
key, val = self.line_to_keyval(line)
if key in self.global_options_to_remove:
return True
else:
return False
def matches_global_option_to_add(self, line):
'''
Utility method to check if option is to be added
:type line: string
:param line: line of text from the configuration file
:return: True or False
'''
key, val = self.line_to_keyval(line)
if key in self.global_options_to_add:
return True
else:
return False
def get_updated_content(self):
'''
Returns the config file content with options to add and remove applied
'''
output = ''
for key, val in self.global_options_to_add.items():
output += self.keyval_to_line((key, val))
eliloconf = open(self.path, 'r')
for line in eliloconf.readlines():
if self.matches_global_option_to_remove(line):
continue
if self.matches_global_option_to_add(line):
continue
else:
output += line
eliloconf.close()
return output
def update(self):
'''
Writes the updated content to the configuration file
'''
content = self.get_updated_content()
eliloconf_write = open(self.path, 'w')
eliloconf_write.write(content)
eliloconf_write.close()
def find_executable(executable, favorite_path=None):
'''
Returns whether the system has a given executable
:type executable: string
:param executable: the name of a file that can be read and executed
'''
if os.path.isabs(executable):
paths = [os.path.dirname(executable)]
executable = os.path.basename(executable)
else:
paths = os.environ['PATH'].split(':')
if favorite_path is not None and favorite_path not in paths:
paths.insert(0, favorite_path)
for d in paths:
f = os.path.join(d, executable)
if os.path.exists(f) and os.access(f, os.R_OK | os.X_OK):
return f
return None
def parse_entry(entry_str, separator='='):
"""
Parse entry as returned by boottool.
:param entry_str: one entry information as returned by boottool
:return: dictionary of key -> value where key is the string before
the first ":" in an entry line and value is the string after
it
"""
entry = {}
for line in entry_str.splitlines():
if len(line) == 0:
continue
try:
name, value = line.split(separator, 1)
except ValueError:
continue
name = name.strip()
value = value.strip()
if name == 'index':
# index values are integrals
value = int(value)
entry[name] = value
return entry
def detect_distro_type():
'''
Simple distro detection based on release/version files
'''
if os.path.exists('/etc/redhat-release'):
return 'redhat'
elif os.path.exists('/etc/debian_version'):
return 'debian'
elif os.path.exists('/etc/issue'):
if re.match(r'.*SUSE.*', open('/etc/issue').read()):
return 'suse'
else:
return None
class DebianBuildDeps(object):
'''
Checks and install grubby build dependencies on Debian (like) systems
Tested on:
* Debian Squeeze (6.0)
* Ubuntu 12.04 LTS
'''
PKGS = ['gcc', 'make', 'libpopt-dev', 'libblkid-dev']
def check(self):
'''
Checks if necessary packages are already installed
'''
result = True
for p in self.PKGS:
args = ['dpkg-query', '--show', '--showformat=${Status}', p]
output = subprocess.Popen(args, shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True).stdout.read()
if not output == 'install ok installed':
result = False
return result
def install(self):
'''
Attempt to install the build dependencies via a package manager
'''
if self.check():
return True
else:
try:
args = ['apt-get', 'update', '-qq']
subprocess.call(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
args = ['apt-get', 'install', '-qq'] + self.PKGS
subprocess.call(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
pass
return self.check()
class RPMBuildDeps(object):
'''
Base class for RPM based systems
'''
def check(self):
'''
Checks if necessary packages are already installed
'''
result = True
for p in self.PKGS:
args = ['rpm', '-q', '--qf=%{NAME}', p]
output = subprocess.Popen(args, shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True).stdout.read()
if not output.startswith(p):
result = False
return result
class SuseBuildDeps(RPMBuildDeps):
'''
Checks and install grubby build dependencies on SuSE (like) systems
Tested on:
* OpenSuSE 12.2
'''
PKGS = ['gcc', 'make', 'popt-devel', 'libblkid-devel']
def install(self):
'''
Attempt to install the build dependencies via a package manager
'''
if self.check():
return True
else:
try:
args = ['zypper', '-n', '--no-cd', 'install'] + self.PKGS
result = subprocess.call(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
pass
return self.check()
class RedHatBuildDeps(RPMBuildDeps):
'''
Checks and install grubby build dependencies on RedHat (like) systems
Tested on:
* Fedora 17
* RHEL 5
* RHEL 6
'''
PKGS = ['gcc', 'make']
REDHAT_RELEASE_RE = re.compile('.*\srelease\s(\d)\.(\d)\s.*')
def __init__(self):
'''
Initializes a new dep installer, taking into account RHEL version
'''
match = self.REDHAT_RELEASE_RE.match(
open('/etc/redhat-release').read())
if match:
major, minor = match.groups()
if int(major) <= 5:
self.PKGS += ['popt', 'e2fsprogs-devel']
else:
self.PKGS += ['popt-devel', 'libblkid-devel']
def install(self):
'''
Attempt to install the build dependencies via a package manager
'''
if self.check():
return True
else:
try:
args = ['yum', 'install', '-q', '-y'] + self.PKGS
# This is an extra safety step, to install the needed header
# in case the blkid headers package could not be detected
args += ['/usr/include/popt.h',
'/usr/include/blkid/blkid.h']
result = subprocess.call(args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
pass
return self.check()
DISTRO_DEPS_MAPPING = {
'debian': DebianBuildDeps,
'redhat': RedHatBuildDeps,
'suse': SuseBuildDeps
}
def install_grubby_if_necessary(path=None):
'''
Installs grubby if it's necessary on this system
Or if the required version is not sufficient for the needs of boottool
'''
installed_grubby = False
if path is None:
if find_executable(GRUBBY_DEFAULT_USER_PATH):
executable = GRUBBY_DEFAULT_USER_PATH
else:
executable = find_executable(GRUBBY_DEFAULT_SYSTEM_PATH)
else:
executable = find_executable(path)
if executable is None:
log.info('Installing grubby because it was not found on this system')
grubby = Grubby()
path = grubby.grubby_install()
installed_grubby = True
else:
grubby = Grubby(executable)
current_version = grubby.get_grubby_version()
if current_version is None:
log.error('Could not find version for grubby executable "%s"',
executable)
path = grubby.grubby_install()
installed_grubby = True
elif current_version < GRUBBY_REQ_VERSION:
log.info('Installing grubby because currently installed '
'version (%s.%s) is not recent enough',
current_version[0], current_version[1])
path = grubby.grubby_install()
installed_grubby = True
if installed_grubby:
grubby = Grubby(path)
installed_version = grubby.get_grubby_version_raw()
log.debug('Installed: %s', installed_version)
class GrubbyInstallException(Exception):
'''
Exception that signals failure when doing grubby installation
'''
pass
class Grubby(object):
'''
Grubby wrapper
This class calls the grubby binary for most commands, but also
adds some functionality that is not really suited to be included
in int, such as boot-once.
'''
SUPPORTED_BOOTLOADERS = ('lilo', 'grub2', 'grub', 'extlinux', 'yaboot',
'elilo')
def __init__(self, path=None, opts=None):
self._set_path(path)
self.bootloader = None
self.opts = opts
self.log = logging.getLogger(self.__class__.__name__)
if os.environ.has_key('BOOTTOOL_DEBUG_RUN'):
self.debug_run = True
else:
self.debug_run = False
self._check_grubby_version()
self._set_bootloader()
def _set_path(self, path=None):
"""
Set grubby path.
If path is not provided, check first if there's a built grubby,
then look for the system grubby.
:param path: Alternate grubby path.
"""
if path is None:
if os.path.exists(GRUBBY_DEFAULT_USER_PATH):
self.path = GRUBBY_DEFAULT_USER_PATH
else:
self.path = GRUBBY_DEFAULT_SYSTEM_PATH
else:
self.path = path
#
# The following block contain utility functions that are used to build
# most of these class methods, such as methods for running commands
# and preparing grubby command line switches.
#
def _check_grubby_version(self):
'''
Checks the version of grubby in use and warns if it's not good enough
'''
current_version = self.get_grubby_version()
if current_version is None:
self.log.warn('Could not detect current grubby version. It may '
'be that you are running an unsupported version '
'of grubby')
elif current_version < GRUBBY_REQ_VERSION:
self.log.warn('version %s.%s being used is not guaranteed to '
'work properly. Mininum required version is %s.%s.',
current_version[0], current_version[1],
GRUBBY_REQ_VERSION[0], GRUBBY_REQ_VERSION[1])
def _run_get_output(self, arguments):
'''
Utility function that runs a command and returns command output
'''
if self.debug_run:
self.log.debug('running: "%s"', ' '.join(arguments))
result = None
try:
result = subprocess.Popen(arguments, shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=True).stdout.read()
except:
pass
if result is not None:
result = result.strip()
if self.debug_run:
logging.debug('previous command output: "%s"', result)
else:
self.log.error('_run_get_output error while running: "%s"',
' '.join(arguments))
return result
def _run_get_output_err(self, arguments):
'''
Utility function that runs a command and returns command output
'''
if self.debug_run:
self.log.debug('running: "%s"', ' '.join(arguments))
result = None
try:
result = subprocess.Popen(arguments, shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True).stdout.read()
except:
pass
if result is not None:
result = result.strip()
if self.debug_run:
logging.debug('previous command output/error: "%s"', result)
else:
self.log.error('_run_get_output_err error while running: "%s"',
' '.join(arguments))
return result
def _run_get_return(self, arguments):
'''
Utility function that runs a command and returns status code
'''
if self.debug_run:
self.log.debug('running: "%s"', ' '.join(arguments))
result = None
try:
result = subprocess.call(arguments)
if self.debug_run:
logging.debug('previous command result: %s', result)
except OSError:
result = -1
self.log.error('caught OSError, returning %s', result)
return result
def _set_bootloader(self, bootloader=None):
'''
Attempts to detect what bootloader is installed on the system
The result of this method is used in all other calls to grubby,
so that it acts accordingly to the bootloader detected.
'''
if bootloader is None:
result = self.get_bootloader()
if result is not None:
self.bootloader = result
else:
if bootloader in self.SUPPORTED_BOOTLOADERS:
self.bootloader = bootloader
else:
raise ValueError('Bootloader "%s" is not supported' %
bootloader)
def _run_grubby_prepare_args(self, arguments, include_bootloader=True):
'''
Prepares the argument list when running a grubby command
'''
args = []
if self.path is None:
self._set_path()
args.append(self.path)
if self.path is not None and not os.path.exists(self.path):
self.log.error('grubby executable does not exist: "%s"', self.path)
if not os.access(self.path, os.R_OK | os.X_OK):
self.log.error('insufficient permissions (read and execute) '
'for grubby executable: "%s"', self.path)
# If a bootloader has been detected, that is, a mode has been set,
# it's passed as the first command line argument to grubby
if include_bootloader and self.bootloader is not None:
args.append('--%s' % self.bootloader)
# Override configuration file
if self.opts is not None and self.opts.config_file:
args.append('--config-file=%s' % self.opts.config_file)
args += arguments
return args
def _run_grubby_get_output(self, arguments, include_bootloader=True):
'''
Utility function that runs grubby with arguments and returns output
'''
args = self._run_grubby_prepare_args(arguments, include_bootloader)
return self._run_get_output(args)
def _run_grubby_get_return(self, arguments, include_bootloader=True):
'''
Utility function that runs grubby with and returns status code
'''
args = self._run_grubby_prepare_args(arguments, include_bootloader)
return self._run_get_return(args)
def _extract_tarball(self, tarball, directory):
'''
Extract tarball into the an directory
This code assume the first (or only) entry is the main directory
:type tarball: string
:param tarball: tarball file path
:type directory: string
:param directory: directory path
:return: path of toplevel directory as extracted from tarball
'''
f = tarfile.open(tarball)
members = f.getmembers()
topdir = members[0]
assert topdir.isdir()
# we can not use extractall() because it is not available on python 2.4
for m in members:
f.extract(m, directory)
return os.path.join(directory, topdir.name)
def _get_entry_indexes(self, info):
'''
Returns the indexes found in a get_info() output
:type info: list of lines
:param info: result of utility method get_info()
:return: maximum index number
'''
indexes = []
for line in self.get_info_lines():
try:
key, value = line.split("=")
if key == 'index':
indexes.append(int(value))
except ValueError:
pass
return indexes
def _index_for_title(self, title):
'''
Returns the index of an entry based on the title of the entry
:type title: string
:param title: the title of the entry
:return: the index of the given entry or None
'''
if self._is_number(title):
return title
info = self.get_info_lines()
for i in self._get_entry_indexes(info):
info = self.get_info(i)
if info is None:
continue
lines = info.splitlines()
looking_for = ('title=%s' % title,
'label=%s' % title)
for line in lines:
if line in looking_for:
return i
return None
def _info_filter(self, info, key, value=None):
'''
Filters info, looking for keys, optionally set with a given value
:type info: list of lines
:param info: result of utility method get_info()
:type key: string
:param key: filter based on this key
:type value: string
:param value: filter based on this value
:return: value or None
'''
for line in info:
if value is not None:
looking_for = '%s=%s' % (key, value)
if line == looking_for:
return line.split("=")[1]
else:
if line.startswith("%s=" % key):
return line.split("=")[1]
return None
def _kernel_for_title(self, title):
'''
Returns the kernel path for an entry based on its title
:type title: string
:param title: the title of the entry
:return: the kernel path of None
'''
index = self._index_for_title(title)
if index is not None:
info = self.get_info_lines(index)
kernel = self._info_filter(info, 'kernel')
return kernel
else:
return None
def _is_number(self, data):
'''
Returns true if supplied data is an int or string with digits
'''
if isinstance(data, int):
return True
elif isinstance(data, str) and data.isdigit():
return True
return False
def _get_entry_selection(self, data):
'''
Returns a valid grubby parameter for commands such as --update-kernel
'''
if self._is_number(data):
return data
elif isinstance(data, str) and data.startswith('/'):
# assume it's the kernel filename
return data
elif isinstance(data, str):
return self._kernel_for_title(data)
else:
raise ValueError("Bad value for 'kernel' parameter. Expecting "
"either and int (index) or string (kernel or "
"title)")
def _remove_duplicate_cmdline_args(self, cmdline):
"""
Remove the duplicate entries in cmdline making sure that the first
duplicate occurrences are the ones removed and the last one remains
(this is in order to not change the semantics of the "console"
parameter where the last occurrence has special meaning)
:param cmdline: a space separate list of kernel boot parameters
(ex. 'console=ttyS0,57600n8 nmi_watchdog=1')
:return: a space separated list of kernel boot parameters without
duplicates
"""
copied = set()
new_args = []
for arg in reversed(cmdline.split()):
if arg not in copied:
new_args.insert(0, arg)
copied.add(arg)
return ' '.join(new_args)
#
# The following methods implement a form of "API" that action methods
# can rely on. Another goal is to maintain compatibility with the current
# client side API in autotest (client/shared/boottool.py)
#
def get_bootloader(self):
'''
Get the bootloader name that is detected on this machine
This module performs the same action as client side boottool.py
get_type() method, but with a better name IMHO.
:return: name of detected bootloader
'''
args = [self.path, '--bootloader-probe']
output = self._run_get_output_err(args)
if output is None:
return None
if output.startswith('grubby: bad argument'):
return None
elif output not in self.SUPPORTED_BOOTLOADERS:
return None
return output
# Alias for client side boottool.py API
get_type = get_bootloader
# Alias for boottool app
bootloader_probe = get_bootloader
def get_architecture(self):
'''
Get the system architecture
This is much simpler version then the original boottool version, that
does not attempt to filter the result of the command / system call
that returns the architecture.
:return: string with system architecture, such as x86_64, ppc64, etc
'''
return os.uname()[4]
# Alias for boottool app
arch_probe = get_architecture
def get_titles(self):
'''
Get the title of all boot entries.
:return: list with titles of boot entries
'''
titles = []
for line in self.get_info_lines():
try:
key, value = line.split("=")
if key in ['title', 'label']:
titles.append(value)
except ValueError:
pass
return titles
def get_default_index(self):
'''
Get the default entry index.
This module performs the same action as client side boottool.py
get_default() method, but with a better name IMHO.
:return: an integer with the the default entry.
'''
default_index = self._run_grubby_get_output(['--default-index'])
if default_index is not None and default_index:
default_index = int(default_index)
return default_index
# Alias for client side boottool.py API
get_default = get_default_index
# Alias for boottool app
default = get_default_index
def set_default_by_index(self, index):
"""
Sets the given entry number to be the default on every next boot
To set a default only for the next boot, use boot_once() instead.
This module performs the same action as client side boottool.py
set_default() method, but with a better name IMHO.
Note: both --set-default= and --set-default-index=
on grubby returns no error when it doesn't find the kernel or
index. So this method will, until grubby gets fixed, always return
success.
:param index: entry index number to set as the default.
"""
return self._run_grubby_get_return(['--set-default-index=%s' % index])
# Alias for client side boottool.py API
set_default = set_default_by_index
def get_default_title(self):
'''
Get the default entry title.
Conforms to the client side boottool.py API, but rely directly on
grubby functionality.
:return: a string of the default entry title.
'''
return self._run_grubby_get_output(['--default-title'])
def get_entry(self, search_info):
"""
Get a single bootloader entry information.
NOTE: if entry is "fallback" and bootloader is grub
use index instead of kernel title ("fallback") as fallback is
a special option in grub
:param search_info: can be 'default', position number or title
:return: a dictionary of key->value where key is the type of entry
information (ex. 'title', 'args', 'kernel', etc) and value
is the value for that piece of information.
"""
info = self.get_info(search_info)
return parse_entry(info)
def get_entries(self):
"""
Get all entries information.
:return: a dictionary of index -> entry where entry is a dictionary
of entry information as described for get_entry().
"""
raw = self.get_info()
entries = {}
for entry_str in re.split("index", raw):
if len(entry_str.strip()) == 0:
continue
if entry_str.startswith('boot='):
continue
if 'non linux entry' in entry_str:
continue
entry = parse_entry("index" + entry_str)
try:
entries[entry["index"]] = entry
except KeyError:
continue
return entries
def get_info(self, entry='ALL'):
'''
Returns information on a given entry, or all of them if not specified
The information is returned as a set of lines, that match the output
of 'grubby --info='
:type entry: string
:param entry: entry description, usually an index starting from 0
:return: set of lines
'''
command = '--info=%s' % entry
info = self._run_grubby_get_output([command])
if info:
return info
def get_title_for_kernel(self, path):
"""
Returns a title for a particular kernel.
:param path: path of the kernel image configured in the boot config
:return: if the given kernel path is found it will return a string
with the title for the found entry, otherwise returns None
"""
entries = self.get_entries()
for entry in entries.itervalues():
if entry.get('kernel') == path:
return entry['title']
return None
def add_args(self, kernel, args):
"""
Add cmdline arguments for the specified kernel.
:param kernel: can be a position number (index) or title
:param args: argument to be added to the current list of args
"""
entry_selection = self._get_entry_selection(kernel)
command_arguments = ['--update-kernel=%s' % entry_selection,
'--args=%s' % args]
self._run_grubby_get_return(command_arguments)
def remove_args(self, kernel, args):
"""
Removes specified cmdline arguments.
:param kernel: can be a position number (index) or title
:param args: argument to be removed of the current list of args
"""
entry_selection = self._get_entry_selection(kernel)
command_arguments = ['--update-kernel=%s' % entry_selection,
'--remove-args=%s' % args]
self._run_grubby_get_return(command_arguments)
def add_kernel(self, path, title='autoserv', root=None, args=None,
initrd=None, default=False, position='end'):
"""
Add a kernel entry to the bootloader (or replace if one exists
already with the same title).
:param path: string path to the kernel image file
:param title: title of this entry in the bootloader config
:param root: string of the root device
:param args: string with cmdline args
:param initrd: string path to the initrd file
:param default: set to True to make this entry the default one
(default False)
:param position: where to insert the new entry in the bootloader
config file (default 'end', other valid input 'start', or
# of the title)
:param xen_hypervisor: xen hypervisor image file (valid only when
xen mode is enabled)
"""
if title in self.get_titles():
self.remove_kernel(title)
parameters = ['--add-kernel=%s' % path, '--title=%s' % title]
# FIXME: grubby takes no --root parameter
# if root:
# parameters.append('--root=%s' % root)
if args:
parameters.append('--args=%s' %
self._remove_duplicate_cmdline_args(args))
if initrd:
parameters.append('--initrd=%s' % initrd)
if default:
parameters.append('--make-default')
# There's currently an issue with grubby '--add-to-bottom' feature.
# Because it uses the tail instead of the head of the list to add
# a new entry, when copying a default entry as a template
# (--copy-default), it usually copies the "recover" entries that
# usually go along a regular boot entry, specially on grub2.
#
# So, for now, until I fix grubby, we'll *not* respect the position
# (--position=end) command line option.
#
# if opts.position == 'end':
# parameters.append('--add-to-bottom')
parameters.append("--copy-default")
return self._run_grubby_get_return(parameters)
def remove_kernel(self, kernel):
"""
Removes a specific entry from the bootloader configuration.
:param kernel: entry position or entry title.
FIXME: param kernel should also take 'start' or 'end'.
"""
entry_selection = self._get_entry_selection(kernel)
if entry_selection is None:
self.log.debug('remove_kernel for title "%s" did not find an '
'entry. This is most probably NOT an error', kernel)
return 0
command_arguments = ['--remove-kernel=%s' % entry_selection]
return self._run_grubby_get_return(command_arguments)
#
# The following methods are not present in the original client side
# boottool.py
#
def get_info_lines(self, entry='ALL'):
'''
Returns information on a given entry, or all of them if not specified
The information is returned as a set of lines, that match the output
of 'grubby --info='
:type entry: string
:param entry: entry description, usually an index starting from 0
:return: set of lines
'''
info = self.get_info(entry)
if info:
return info.splitlines()
def get_grubby_version_raw(self):
'''
Get the version of grubby that is installed on this machine as is
:return: string with raw output from grubby --version
'''
return self._run_grubby_get_output(['--version'], False)
def get_grubby_version(self):
'''
Get the version of grubby that is installed on this machine
:return: tuple with (major, minor) grubby version
'''
output = self.get_grubby_version_raw()
if output is None:
self.log.warn('Could not run grubby to fetch its version')
return None
match = re.match('(grubby version)?(\s)?(\d+)\.(\d+)(.*)', output)
if match:
groups = match.groups()
return (int(groups[2]), int(groups[3]))
else:
return None
def grubby_install_patch_makefile(self):
'''
Patch makefile, making CFLAGS more forgivable to older toolchains
'''
cflags_line = 'CFLAGS += $(RPM_OPT_FLAGS) -std=gnu99 -ggdb\n'
libs_line = 'grubby_LIBS = -lblkid -lpopt -luuid\n'
shutil.move('Makefile', 'Makefile.boottool.bak')
o = open('Makefile', 'w')
for l in open('Makefile.boottool.bak').readlines():
if l.startswith('CFLAGS += '):
o.write(cflags_line)
elif l.startswith('grubby_LIBS = -lblkid -lpopt'):
o.write(libs_line)
else:
o.write(l)
o.close()
def grubby_install_backup(self, path):
'''
Backs up the current grubby binary to make room the one we'll build
:type path: string
:param path: path to the binary that should be backed up
'''
backup_path = '%s.boottool.bkp' % path
if (os.path.exists(path) and
not os.path.exists(backup_path)):
try:
shutil.move(path, backup_path)
except:
self.log.warn('Failed to backup the current grubby binary')
def grubby_install_fetch_tarball(self, topdir):
'''
Fetches and verifies the grubby source tarball
'''
tarball_name = os.path.basename(GRUBBY_TARBALL_URI)
# first look in the current directory
try:
tarball = tarball_name
f = open(tarball)
except:
try:
# then the autotest source directory
from autotest.client.shared.settings import settings
top_path = settings.get_value('COMMON', 'autotest_top_path')
tarball = os.path.join(top_path, tarball_name)
f = open(tarball)
except:
# then try to grab it from github
try:
tarball = os.path.join(topdir, tarball_name)
urllib.urlretrieve(GRUBBY_TARBALL_URI, tarball)
f = open(tarball)
except:
return None
tarball_md5 = md5.md5(f.read()).hexdigest()
if tarball_md5 != GRUBBY_TARBALL_MD5:
return None
return tarball
def grubby_build(self, topdir, tarball):
'''
Attempts to build grubby from the source tarball
'''
def log_lines(lines):
for line in lines:
self.log.debug(line.strip())
try:
find_header('popt.h')
except ValueError:
self.log.debug('No popt.h header present, skipping build')
return False
tarball_name = os.path.basename(tarball)
srcdir = os.path.join(topdir, 'src')
srcdir = self._extract_tarball(tarball, srcdir)
os.chdir(srcdir)
self.grubby_install_patch_makefile()
result = subprocess.Popen(['make'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if result.wait() != 0:
self.log.debug('Failed to build grubby during "make" step')
log_lines(result.stderr.read().splitlines())
return False
install_root = os.path.join(topdir, 'install_root')
os.environ['DESTDIR'] = install_root
result = subprocess.Popen(['make', 'install'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if result.wait() != 0:
self.log.debug('Failed to build grubby during "make install" step')
log_lines(result.stderr.read().splitlines())
return False
return True
def grubby_install(self, path=None):
'''
Attempts to install a recent enough version of grubby
So far tested on:
* Fedora 16 x86_64
* Debian 6 x86_64
* SuSE 12.1 x86_64
* RHEL 4 on ia64 (with updated python 2.4)
* RHEL 5 on ia64
* RHEL 6 on ppc64
'''
if path is None:
if os.geteuid() == 0:
path = GRUBBY_DEFAULT_SYSTEM_PATH
else:
path = GRUBBY_DEFAULT_USER_PATH
topdir = tempfile.mkdtemp()
deps_klass = DISTRO_DEPS_MAPPING.get(detect_distro_type(), None)
if deps_klass is not None:
deps = deps_klass()
if not deps.check():
self.log.warn('Installing distro build deps for grubby. This '
'may take a while, depending on bandwidth and '
'actual number of packages to install')
if not deps.install():
self.log.error('Failed to install distro build deps for '
'grubby')
tarball = self.grubby_install_fetch_tarball(topdir)
if tarball is None:
raise GrubbyInstallException('Failed to fetch grubby tarball')
srcdir = os.path.join(topdir, 'src')
install_root = os.path.join(topdir, 'install_root')
os.mkdir(install_root)
if not self.grubby_build(topdir, tarball):
raise GrubbyInstallException('Failed to build grubby')
self.grubby_install_backup(path)
grubby_bin = os.path.join(install_root, 'sbin', 'grubby')
inst_dir = os.path.dirname(path)
if not os.access(inst_dir, os.W_OK):
raise GrubbyInstallException('No permission to copy grubby '
'binary to directory "%s"' % inst_dir)
try:
shutil.copy(grubby_bin, path)
except:
raise GrubbyInstallException('Failed to copy grubby binary to '
'directory "%s"' % inst_dir)
return path
def boot_once(self, title=None):
'''
Configures the bootloader to boot an entry only once
This is not implemented by grubby, but directly implemented here, via
the 'boot_once_' method.
'''
self.log.debug('Title chosen to boot once: %s', title)
available_titles = self.get_titles()
if title not in available_titles:
self.log.error('Entry with title "%s" was not found', title)
return -1
default_title = self.get_default_title()
self.log.debug('Title actually set as default: %s', default_title)
if default_title == title:
self.log.info('Doing nothing: entry to boot once is the same as '
'default entry')
return
else:
self.log.debug('Setting boot once for entry: %s', title)
bootloader = self.get_bootloader()
if bootloader in ('grub', 'grub2', 'elilo'):
entry_index = self._index_for_title(title)
if entry_index is None:
self.log.error('Could not find index for entry with title '
'"%s"', title)
return -1
if bootloader == 'grub':
return self.boot_once_grub(entry_index)
elif bootloader == 'grub2':
return self.boot_once_grub2(entry_index)
elif bootloader == 'yaboot':
return self.boot_once_yaboot(title)
elif bootloader == 'elilo':
return self.boot_once_elilo(entry_index)
else:
self.log.error("Detected bootloader does not implement boot once")
return -1
def boot_once_grub(self, entry_index):
'''
Implements the boot once feature for the grub bootloader
'''
# grubonce is a hack present in distros like OpenSUSE
grubonce_cmd = find_executable('grubonce')
if grubonce_cmd is None:
# XXX: check the type of default set (numeric or "saved")
grub_instructions = ['savedefault --default=%s --once' %
entry_index, 'quit']
grub_instructions_text = '\n'.join(grub_instructions)
grub_binary = find_executable('grub')
if grub_binary is None:
self.log.error("Could not find the 'grub' binary, aborting")
return -1
p = subprocess.Popen([grub_binary, '--batch'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = p.communicate(grub_instructions_text)
complete_out = ''
if out is not None:
complete_out = out
if err is not None:
complete_out += "\n%s" % err
grub_batch_err = []
if complete_out:
for l in complete_out.splitlines():
if re.search('error', l, re.IGNORECASE):
grub_batch_err.append(l)
if grub_batch_err:
self.log.error("Error while running grub to set boot "
"once: %s", "\n".join(grub_batch_err))
return -1
self.log.debug('No error detected while running grub to set boot '
'once')
return 0
else:
rc = self._run_get_return([grubonce_cmd, str(entry_index)])
if rc:
self.log.error('Error running %s', grubonce_cmd)
else:
self.log.debug('No error detected while running %s',
grubonce_cmd)
return rc
def boot_once_grub2(self, entry_index):
'''
Implements the boot once feature for the grub2 bootloader
Caveat: this assumes the default set is of type "saved", and not a
numeric value.
'''
default_index_re = re.compile('\s*set\s+default\s*=\s*\"+(\d+)\"+')
grub_reboot_names = ['grub-reboot', 'grub2-reboot']
grub_reboot_exec = None
for grub_reboot in grub_reboot_names:
grub_reboot_exec = find_executable(grub_reboot)
if grub_reboot_exec is not None:
break
if grub_reboot_exec is None:
self.log.error('Could not find executable among searched names: '
'%s', ' ,'.join(grub_reboot_names))
return -1
grub_set_default_names = ['grub-set-default', 'grub2-set-default']
grub_set_default_exec = None
for grub_set_default in grub_set_default_names:
grub_set_default_exec = find_executable(grub_set_default)
if grub_set_default_exec is not None:
break
if grub_set_default_exec is None:
self.log.error('Could not find executable among searched names: '
'%s', ' ,'.join(grub_set_default_names))
return -1
# Make sure the "set default" entry in the configuration file is set
# to "${saved_entry}. Assuming the config file is at
# /boot/grub/grub.cfg
deb_grub_cfg_path = '/boot/grub/grub.cfg'
deb_grub_cfg_bkp_path = '%s.boottool.bak' % deb_grub_cfg_path
default_index = None
if os.path.exists(deb_grub_cfg_path):
shutil.move(deb_grub_cfg_path, deb_grub_cfg_bkp_path)
o = open(deb_grub_cfg_path, 'w')
for l in open(deb_grub_cfg_bkp_path).readlines():
m = default_index_re.match(l)
if m is not None:
default_index = int(m.groups()[0])
o.write('set default="${saved_entry}"\n')
else:
o.write(l)
o.close()
# Make the current default entry the "previous saved entry"
if default_index is None:
default_index = self.get_default_index()
else:
# grubby adds entries to top. this assumes a new entry to boot once
# has already been added to the top, so fallback to the second
# entry (index 1) if the boot once entry fails to boot
if entry_index == 0:
default_index = 1
else:
default_index = 0
# A negative index is never acceptable
if default_index >= 0:
prev_saved_return = self._run_get_return([grub_set_default_exec,
'%s' % default_index])
if prev_saved_return != 0:
self.log.error(
'Could not make entry %s the previous saved entry',
default_index)
return prev_saved_return
# Finally set the boot once entry
return self._run_get_return([grub_reboot_exec,
'%s' % entry_index])
def boot_once_yaboot(self, entry_title):
'''
Implements the boot once feature for the yaboot bootloader
'''
nvsetenv_cmd = find_executable('nvsetenv')
if nvsetenv_cmd is None:
self.log.error("Could not find nvsetenv in PATH")
return -1
return self._run_get_return([nvsetenv_cmd,
'boot-once',
entry_title])
def boot_once_elilo(self, entry_index):
'''
Implements boot once for machines with kernel >= 2.6
This manipulates EFI variables via the interface available at
/sys/firmware/efi/vars
'''
info = self.get_entry(entry_index)
kernel = os.path.basename(info['kernel'])
# remove quotes
args = info['args']
if args[0] == '"':
args = args[1:]
if args[-1] == '"':
args = args[:-1]
params = "root=%s %s" % (info['root'], args)
data = "%s %s" % (kernel, params)
efi = EfiToolSys()
if not (efi.create_variable('EliloAlt', data)):
return -1
eliloconf = EliloConf()
eliloconf.add_global_option('checkalt')
eliloconf.add_global_option('initrd', os.path.basename(info['initrd']))
eliloconf.remove_global_option('prompt')
eliloconf.update()
return 0
class OptionParser(optparse.OptionParser):
'''
Command line option parser
Aims to maintain compatibility at the command line level with boottool
'''
option_parser_usage = '''%prog [options]'''
def __init__(self, **kwargs):
optparse.OptionParser.__init__(self,
usage=self.option_parser_usage,
**kwargs)
misc = self.add_option_group('MISCELLANEOUS OPTIONS')
misc.add_option('--config-file',
help='Specifies the path and name of the bootloader '
'config file, overriding autodetection of this file')
misc.add_option('--force', action='store_true',
help='If specified, any conflicting kernels will be '
'removed')
misc.add_option('--bootloader',
help='Manually specify the bootloader to use. By '
'default, boottool will automatically try to detect '
'the bootloader being used')
misc.add_option('--root',
help='The device where the root partition is located')
misc.add_option('--debug', default=0,
help='Prints debug messages. This expects a numerical '
'argument corresponding to the debug message '
'verbosity')
probe = self.add_option_group('SYSTEM PROBING')
probe.add_option('--bootloader-probe', action='store_true',
help='Prints the bootloader in use on the system '
'and exits')
probe.add_option('--arch-probe', action='store_true',
help='Prints the arch of the system and exits')
actions = self.add_option_group('ACTIONS ON BOOT ENTRIES')
actions.add_option('--add-kernel',
help='Adds a new kernel with the given path')
actions.add_option('--remove-kernel',
help='Removes the bootloader entry with the given '
'position or title. Also accepts \'start\' or '
'\'end\'')
actions.add_option('--update-kernel',
help='Updates an existing kernel with the given '
'position number or title. Useful options when '
'modifying a kernel include --args and '
'--remove-args')
actions.add_option('--info',
help='Display information about the bootloader entry '
'at the given position number. Also accepts \'all\' '
'or \'default\'')
actions.add_option('--default', action='store_true',
help='Prints the current default kernel for the '
'bootloader')
actions.add_option('--set-default',
help='Updates the bootloader to set the default '
'boot entry to given given position or title')
actions.add_option('--install', action='store_true',
help='Causes bootloader to update and re-install '
'the bootloader file')
actions.add_option('--boot-once', action='store_true',
help='Causes the bootloader to boot the kernel '
'specified by --title just one time, then fall back'
' to the default entry. This option does not work '
'identically on all architectures')
act_args = self.add_option_group('ACTION PARAMETERS')
act_args.add_option('--title',
help='The title or label to use for the '
'bootloader entry. Required when adding a new '
'entry.')
act_args.add_option('--position',
help='Insert bootloader entry at the given '
'position number, counting from 0. Also accepts '
'\'start\' or \'end\'. Optional when adding a new '
'entry.')
act_args.add_option('--make-default', action='store_true',
help='Specifies that the bootloader entry being '
'added should be the new default')
kernel = self.add_option_group('LINUX KERNEL PARAMETERS',
'Options specific to manage boot '
'entries with Linux')
kernel.add_option('--args',
help='Add arguments to be passed to the kernel at '
'boot. Use when adding a new entry or when '
'modifying an existing entry.')
kernel.add_option('--remove-args',
help='Arguments to be removed from an existing entry'
'. Use when modifying an existing entry with '
'--update-kernel action.')
kernel.add_option('--initrd',
help='The initrd image path to use in the bootloader '
'entry')
kernel.add_option('--module',
help='This option adds modules to the new kernel. It'
' only works with Grub Bootloader. For more module '
'options just add another --module parameter')
grubby = self.add_option_group('GRUBBY',
'Manage grubby, the tool that drives '
'most of boottool functionality')
grubby.add_option('--grubby-version', action='store_true',
help='Prints the version of grubby installed on '
'this machine')
grubby.add_option('--grubby-version-check',
help='Checks if the installed version of grubby is '
'recent enough')
grubby.add_option('--grubby-install', action='store_true',
help='Attempts to install a recent enought version '
'of grubby')
grubby.add_option('--grubby-path',
help='Use a different grubby binary, located at the '
'given path')
def opts_has_action(self, opts):
'''
Checks if (parsed) opts has a first class action
'''
global ACTIONS_OPT_METHOD_NAME
has_action = False
for action in ACTIONS_OPT_METHOD_NAME:
value = getattr(opts, action)
if value is not None:
has_action = True
return has_action
def opts_get_action(self, opts):
'''
Gets the selected action from the parsed opts
'''
global ACTIONS_OPT_METHOD_NAME
for action in ACTIONS_OPT_METHOD_NAME:
value = getattr(opts, action)
if value is not None:
return action
return None
def check_values(self, opts, args):
'''
Validate the option the user has supplied
'''
# check if an action has been selected
if not self.opts_has_action(opts):
self.print_help()
raise SystemExit
# check if action needs a --title option
action = self.opts_get_action(opts)
if action in ACTIONS_REQUIRE_TITLE:
if opts.title is None:
print 'Action %s requires a --title parameter' % action
raise SystemExit
return (opts, args)
class BoottoolApp(object):
'''
The boottool application itself
'''
def __init__(self):
self.opts = None
self.args = None
self.option_parser = OptionParser()
self.grubby = None
self.log = logging.getLogger(self.__class__.__name__)
def _parse_command_line(self):
'''
Parsers the command line arguments
'''
(self.opts,
self.args) = self.option_parser.parse_args()
def _configure_logging(self):
'''
Configures logging based on --debug= command line switch
We do not have as many levels as the original boottool(.pl) had, but
we accept the same range of parameters and adjust it to our levels.
'''
log_map = {0: logging.WARNING,
1: logging.INFO,
2: logging.DEBUG}
try:
level = int(self.opts.debug)
except ValueError:
level = 0
max_level = max(log_map.keys())
if level > max_level:
level = max_level
if os.environ.has_key('BOOTTOOL_DEBUG_RUN'):
logging_level = logging.DEBUG
else:
logging_level = log_map.get(level)
logging.basicConfig(level=logging_level,
format=LOGGING_FORMAT)
def run(self):
self._parse_command_line()
self._configure_logging()
# if we made this far, the command line checking succeeded
if self.opts.grubby_path:
self.grubby = Grubby(self.opts.grubby_path, self.opts)
else:
install_grubby_if_necessary()
self.grubby = Grubby(opts=self.opts)
if self.opts.bootloader:
self.log.debug('Forcing bootloader "%s"', self.opts.bootloader)
try:
self.grubby._set_bootloader(self.opts.bootloader)
except ValueError, msg:
self.log.error(msg)
sys.exit(-1)
#
# The following implements a simple action -> method dispatcher
# First, we look for a method named action_ + action_name on the
# app instance itself. If not found, we try to find a method with
# the same name as the action in the grubby instance.
#
action_name = self.option_parser.opts_get_action(self.opts)
try:
action_method = getattr(self, "action_%s" % action_name)
except AttributeError:
action_method = getattr(self.grubby, action_name)
if action_method:
result = action_method()
if result is None:
result = 0
elif isinstance(result, str):
print result
result = 0
sys.exit(result)
#
# The following block implements actions. Actions are methods that will be
# called because of user supplied parameters on the command line. Most
# actions, such as the ones that query information, are built around the
# "API" methods defined in the previous block
#
def action_grubby_version(self):
'''
Prints the of grubby that is installed on this machine
'''
version = self.grubby.get_grubby_version()
if version is not None:
print "%s.%s" % version
return
version = self.grubby.get_grubby_version_raw()
if version is not None:
print version
def action_grubby_version_check(self):
'''
Prints the of grubby that is installed on this machine
'''
current_version = self.grubby.get_grubby_version()
if current_version is None:
self.log.warn('Could not get version numbers from grubby')
return -1
required_version = self.opts.grubby_version_check.split('.', 1)
required_version_major = required_version[0]
if len(required_version) == 1:
req_version = (int(required_version_major), 0)
else:
req_version = (int(required_version_major),
int(required_version[1]))
if current_version >= req_version:
return 0
else:
return -1
def action_grubby_install(self):
'''
Attempts to install a recent enough version of grubby
'''
return self.grubby.grubby_install()
def action_info(self):
'''
Prints boot entry information
boottool is frequently called with 'all' lowercase, but
grubby expects it to be uppercase
'''
if not self.opts.info:
self.log.error('Parameter to info is required')
return -1
info_index = self.opts.info
if not ((info_index.lower() == 'all') or
(self.opts.info.isdigit())):
self.log.error('Parameter to info should be either "all", "ALL" '
'or an integer index')
return -1
if info_index == 'all':
info_index = 'ALL'
if info_index == 'ALL':
entries = self.grubby.get_entries()
else:
entries = {info_index: self.grubby.get_entry(info_index)}
for index, entry in entries.items():
print
for key, val in entry.items():
# remove quotes
if isinstance(val, str):
if val.startswith('"') and val.endswith('"'):
val = val[1:-1]
print '%-8s: %s' % (key, val)
def action_add_kernel(self):
'''
Adds a new boot entry based on the values of other command line options
:type opts: object
:param opts: parsed command line options
:return:
'''
if not self.opts.add_kernel:
self.log.error("Kernel to add is required")
return -1
if not self.opts.title:
self.log.error("Kernel title is required")
return -1
if not self.opts.initrd:
self.log.error("initrd is required")
return -1
return self.grubby.add_kernel(self.opts.add_kernel,
self.opts.title,
args=self.opts.args,
initrd=self.opts.initrd)
def action_update_kernel(self):
'''
Updates a kernel entry
'''
if not self.opts.update_kernel:
self.log.error("Kernel title to update is required")
return -1
args = []
kernel = self.grubby._get_entry_selection(self.opts.update_kernel)
if kernel is not None:
args.append("--update-kernel=%s" % kernel)
if self.opts.args:
args.append("--args=%s" % self.opts.args)
if self.opts.remove_args:
args.append("--remove-args=%s" % self.opts.remove_args)
return self.grubby._run_grubby_get_return(args)
def action_remove_kernel(self):
'''
Removes a boot entry by the specified title
boottool expects: title
grubby expects: kernel path or special syntax (eg, TITLE=)
'''
if not self.opts.remove_kernel:
self.log.error("Kernel title to remove is required")
return -1
return self.grubby.remove_kernel(self.opts.remove_kernel)
def action_boot_once(self):
"""
Sets a specific entry for the next boot only
The subsequent boots will use the default kernel
"""
if not self.opts.boot_once:
self.log.error("Kernel to boot once is required")
return self.grubby.boot_once(self.opts.title)
def action_default(self):
"""
Get the default entry index
"""
print self.grubby.get_default_index()
def action_set_default(self):
"""
Sets the given entry number to be the default on every next boot
"""
if not self.opts.set_default:
self.log.error("Entry index is required")
return self.grubby.set_default_by_index(self.opts.set_default)
if __name__ == '__main__':
app = BoottoolApp()
app.run()
else:
logging.basicConfig(level=logging.INFO,
format=LOGGING_FORMAT)
callback_classes = [
['void', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned int', 'bool', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'unsigned int', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::dot11s::PeerLink::PeerState', 'ns3::dot11s::PeerLink::PeerState', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['std::vector >', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'bool', 'ns3::Ptr', 'ns3::Mac48Address', 'ns3::Mac48Address', 'unsigned short', 'unsigned int', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['unsigned int', 'ns3::Mac48Address', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::WifiMacHeader const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Ptr', 'ns3::Mac48Address', 'ns3::Mac48Address', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Mac48Address', 'unsigned char', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['void', 'ns3::Mac48Address', 'unsigned char', 'bool', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::Address const&', 'ns3::NetDevice::PacketType', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['bool', 'ns3::Ptr', 'ns3::Ptr', 'unsigned short', 'ns3::Address const&', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
['unsigned char', 'ns3::Ptr', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty', 'ns3::empty'],
]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 2011-2012 Nigel Small
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from syntaq import __author__ as syntaq_author
from syntaq import __license__ as syntaq_license
from syntaq import __package__ as syntaq_package
from syntaq import __version__ as syntaq_version
from distutils.core import setup
setup(
name=syntaq_package,
version=syntaq_version,
description="Lightweight markup language parser/compiler based on Creole",
long_description="Syntaq is a lightweight markup language based on (and " \
"backward compatible with) Creole.",
author=syntaq_author,
author_email="nigel@nigelsmall.name",
url="http://nigelsmall.com/syntaq",
scripts=[],
packages=["syntaq"],
license=syntaq_license,
classifiers=[]
)
"""
Tests for the CORS CSRF middleware
"""
from mock import patch, Mock
import ddt
from django.test import TestCase
from django.test.utils import override_settings
from django.core.exceptions import MiddlewareNotUsed, ImproperlyConfigured
from django.http import HttpResponse
from django.middleware.csrf import CsrfViewMiddleware
from cors_csrf.middleware import CorsCSRFMiddleware, CsrfCrossDomainCookieMiddleware
SENTINEL = object()
class TestCorsMiddlewareProcessRequest(TestCase):
"""
Test processing a request through the middleware
"""
def get_request(self, is_secure, http_referer):
"""
Build a test request
"""
request = Mock()
request.META = {'HTTP_REFERER': http_referer}
request.is_secure = lambda: is_secure
return request
@override_settings(FEATURES={'ENABLE_CORS_HEADERS': True})
def setUp(self):
super(TestCorsMiddlewareProcessRequest, self).setUp()
self.middleware = CorsCSRFMiddleware()
def check_not_enabled(self, request):
"""
Check that the middleware does NOT process the provided request
"""
with patch.object(CsrfViewMiddleware, 'process_view') as mock_method:
res = self.middleware.process_view(request, None, None, None)
self.assertIsNone(res)
self.assertFalse(mock_method.called)
def check_enabled(self, request):
"""
Check that the middleware does process the provided request
"""
def cb_check_req_is_secure_false(request, callback, args, kwargs):
"""
Check that the request doesn't pass (yet) the `is_secure()` test
"""
self.assertFalse(request.is_secure())
return SENTINEL
with patch.object(CsrfViewMiddleware, 'process_view') as mock_method:
mock_method.side_effect = cb_check_req_is_secure_false
res = self.middleware.process_view(request, None, None, None)
self.assertIs(res, SENTINEL)
self.assertTrue(request.is_secure())
@override_settings(CORS_ORIGIN_WHITELIST=['foo.com'])
def test_enabled(self):
request = self.get_request(is_secure=True, http_referer='https://foo.com/bar')
self.check_enabled(request)
@override_settings(
FEATURES={'ENABLE_CORS_HEADERS': False},
CORS_ORIGIN_WHITELIST=['foo.com']
)
def test_disabled_no_cors_headers(self):
with self.assertRaises(MiddlewareNotUsed):
CorsCSRFMiddleware()
@override_settings(CORS_ORIGIN_WHITELIST=['bar.com'])
def test_disabled_wrong_cors_domain(self):
request = self.get_request(is_secure=True, http_referer='https://foo.com/bar')
self.check_not_enabled(request)
@override_settings(CORS_ORIGIN_WHITELIST=['foo.com'])
def test_disabled_wrong_cors_domain_reversed(self):
request = self.get_request(is_secure=True, http_referer='https://bar.com/bar')
self.check_not_enabled(request)
@override_settings(CORS_ORIGIN_WHITELIST=['foo.com'])
def test_disabled_http_request(self):
request = self.get_request(is_secure=False, http_referer='https://foo.com/bar')
self.check_not_enabled(request)
@override_settings(CORS_ORIGIN_WHITELIST=['foo.com'])
def test_disabled_http_referer(self):
request = self.get_request(is_secure=True, http_referer='http://foo.com/bar')
self.check_not_enabled(request)
@ddt.ddt
class TestCsrfCrossDomainCookieMiddleware(TestCase):
"""Tests for `CsrfCrossDomainCookieMiddleware`. """
REFERER = 'https://www.example.com'
COOKIE_NAME = 'shared-csrftoken'
COOKIE_VALUE = 'abcd123'
COOKIE_DOMAIN = '.edx.org'
@override_settings(
FEATURES={'ENABLE_CROSS_DOMAIN_CSRF_COOKIE': True},
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN
)
def setUp(self):
super(TestCsrfCrossDomainCookieMiddleware, self).setUp()
self.middleware = CsrfCrossDomainCookieMiddleware()
@override_settings(FEATURES={'ENABLE_CROSS_DOMAIN_CSRF_COOKIE': False})
def test_disabled_by_feature_flag(self):
with self.assertRaises(MiddlewareNotUsed):
CsrfCrossDomainCookieMiddleware()
@ddt.data('CROSS_DOMAIN_CSRF_COOKIE_NAME', 'CROSS_DOMAIN_CSRF_COOKIE_DOMAIN')
def test_improperly_configured(self, missing_setting):
settings = {
'FEATURES': {'ENABLE_CROSS_DOMAIN_CSRF_COOKIE': True},
'CROSS_DOMAIN_CSRF_COOKIE_NAME': self.COOKIE_NAME,
'CROSS_DOMAIN_CSRF_COOKIE_DOMAIN': self.COOKIE_DOMAIN
}
del settings[missing_setting]
with override_settings(**settings):
with self.assertRaises(ImproperlyConfigured):
CsrfCrossDomainCookieMiddleware()
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_not_secure(self):
response = self._get_response(is_secure=False)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_not_sending_csrf_token(self):
response = self._get_response(csrf_cookie_used=False)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_not_cross_domain_decorator(self):
response = self._get_response(cross_domain_decorator=False)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_WHITELIST=['other.example.com']
)
def test_skip_if_referer_not_whitelisted(self):
response = self._get_response()
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN
)
def test_skip_if_not_cross_domain(self):
response = self._get_response(
referer="https://courses.edx.org/foo",
host="courses.edx.org"
)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_no_referer(self):
response = self._get_response(delete_referer=True)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_referer_not_https(self):
response = self._get_response(referer="http://www.example.com")
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_ALLOW_ALL=True
)
def test_skip_if_referer_no_protocol(self):
response = self._get_response(referer="example.com")
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ALLOW_INSECURE=True
)
def test_skip_if_no_referer_insecure(self):
response = self._get_response(delete_referer=True)
self._assert_cookie_sent(response, False)
@override_settings(
CROSS_DOMAIN_CSRF_COOKIE_NAME=COOKIE_NAME,
CROSS_DOMAIN_CSRF_COOKIE_DOMAIN=COOKIE_DOMAIN,
CORS_ORIGIN_WHITELIST=['www.example.com']
)
def test_set_cross_domain_cookie(self):
response = self._get_response()
self._assert_cookie_sent(response, True)
def _get_response(self,
is_secure=True,
csrf_cookie_used=True,
cross_domain_decorator=True,
referer=None,
host=None,
delete_referer=False):
"""Process a request using the middleware. """
request = Mock()
request.META = {
'HTTP_REFERER': (
referer if referer is not None
else self.REFERER
)
}
request.is_secure = lambda: is_secure
if host is not None:
request.get_host = lambda: host
if delete_referer:
del request.META['HTTP_REFERER']
if csrf_cookie_used:
request.META['CSRF_COOKIE_USED'] = True
request.META['CSRF_COOKIE'] = self.COOKIE_VALUE
if cross_domain_decorator:
request.META['CROSS_DOMAIN_CSRF_COOKIE_USED'] = True
return self.middleware.process_response(request, HttpResponse())
def _assert_cookie_sent(self, response, is_set):
"""Check that the cross-domain CSRF cookie was sent. """
if is_set:
self.assertIn(self.COOKIE_NAME, response.cookies)
cookie_header = str(response.cookies[self.COOKIE_NAME])
expected = 'Set-Cookie: {name}={value}; Domain={domain};'.format(
name=self.COOKIE_NAME,
value=self.COOKIE_VALUE,
domain=self.COOKIE_DOMAIN
)
self.assertIn(expected, cookie_header)
self.assertIn('Max-Age=31449600; Path=/; secure', cookie_header)
else:
self.assertNotIn(self.COOKIE_NAME, response.cookies)
from django.contrib import admin
from django.contrib.auth import views
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.urls import urlpatterns as auth_urlpatterns
from django.contrib.messages.api import info
from django.http import HttpRequest, HttpResponse
from django.shortcuts import render
from django.template import RequestContext, Template
from django.urls import path, re_path, reverse_lazy
from django.views.decorators.cache import never_cache
from django.views.i18n import set_language
class CustomRequestAuthenticationForm(AuthenticationForm):
def __init__(self, request, *args, **kwargs):
assert isinstance(request, HttpRequest)
super().__init__(request, *args, **kwargs)
@never_cache
def remote_user_auth_view(request):
"Dummy view for remote user tests"
t = Template("Username is {{ user }}.")
c = RequestContext(request, {})
return HttpResponse(t.render(c))
def auth_processor_no_attr_access(request):
render(request, 'context_processors/auth_attrs_no_access.html')
# *After* rendering, we check whether the session was accessed
return render(request,
'context_processors/auth_attrs_test_access.html',
{'session_accessed': request.session.accessed})
def auth_processor_attr_access(request):
render(request, 'context_processors/auth_attrs_access.html')
return render(request,
'context_processors/auth_attrs_test_access.html',
{'session_accessed': request.session.accessed})
def auth_processor_user(request):
return render(request, 'context_processors/auth_attrs_user.html')
def auth_processor_perms(request):
return render(request, 'context_processors/auth_attrs_perms.html')
def auth_processor_perm_in_perms(request):
return render(request, 'context_processors/auth_attrs_perm_in_perms.html')
def auth_processor_messages(request):
info(request, "Message 1")
return render(request, 'context_processors/auth_attrs_messages.html')
def userpage(request):
pass
@permission_required('unknown.permission')
def permission_required_redirect(request):
pass
@permission_required('unknown.permission', raise_exception=True)
def permission_required_exception(request):
pass
@login_required
@permission_required('unknown.permission', raise_exception=True)
def login_and_permission_required_exception(request):
pass
uid_token = r'(?P[0-9A-Za-z_\-]+)/(?P[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})'
# special urls for auth test cases
urlpatterns = auth_urlpatterns + [
path('logout/custom_query/', views.LogoutView.as_view(redirect_field_name='follow')),
path('logout/next_page/', views.LogoutView.as_view(next_page='/somewhere/')),
path('logout/next_page/named/', views.LogoutView.as_view(next_page='password_reset')),
path('logout/allowed_hosts/', views.LogoutView.as_view(success_url_allowed_hosts={'otherserver'})),
path('remote_user/', remote_user_auth_view),
path('password_reset_from_email/', views.PasswordResetView.as_view(from_email='staffmember@example.com')),
path(
'password_reset_extra_email_context/',
views.PasswordResetView.as_view(
extra_email_context={'greeting': 'Hello!', 'domain': 'custom.example.com'},
),
),
path(
'password_reset/custom_redirect/',
views.PasswordResetView.as_view(success_url='/custom/')),
path(
'password_reset/custom_redirect/named/',
views.PasswordResetView.as_view(success_url=reverse_lazy('password_reset'))),
path(
'password_reset/html_email_template/',
views.PasswordResetView.as_view(
html_email_template_name='registration/html_password_reset_email.html'
)),
re_path(
'^reset/custom/{}/$'.format(uid_token),
views.PasswordResetConfirmView.as_view(success_url='/custom/'),
),
re_path(
'^reset/custom/named/{}/$'.format(uid_token),
views.PasswordResetConfirmView.as_view(success_url=reverse_lazy('password_reset')),
),
re_path(
'^reset/custom/token/{}/$'.format(uid_token),
views.PasswordResetConfirmView.as_view(reset_url_token='set-passwordcustom'),
),
re_path(
'^reset/post_reset_login/{}/$'.format(uid_token),
views.PasswordResetConfirmView.as_view(post_reset_login=True),
),
re_path(
'^reset/post_reset_login_custom_backend/{}/$'.format(uid_token),
views.PasswordResetConfirmView.as_view(
post_reset_login=True,
post_reset_login_backend='django.contrib.auth.backends.AllowAllUsersModelBackend',
),
),
path('password_change/custom/',
views.PasswordChangeView.as_view(success_url='/custom/')),
path('password_change/custom/named/',
views.PasswordChangeView.as_view(success_url=reverse_lazy('password_reset'))),
path('login_required/', login_required(views.PasswordResetView.as_view())),
path('login_required_login_url/', login_required(views.PasswordResetView.as_view(), login_url='/somewhere/')),
path('auth_processor_no_attr_access/', auth_processor_no_attr_access),
path('auth_processor_attr_access/', auth_processor_attr_access),
path('auth_processor_user/', auth_processor_user),
path('auth_processor_perms/', auth_processor_perms),
path('auth_processor_perm_in_perms/', auth_processor_perm_in_perms),
path('auth_processor_messages/', auth_processor_messages),
path(
'custom_request_auth_login/',
views.LoginView.as_view(authentication_form=CustomRequestAuthenticationForm)),
re_path('^userpage/(.+)/$', userpage, name='userpage'),
path('login/redirect_authenticated_user_default/', views.LoginView.as_view()),
path('login/redirect_authenticated_user/',
views.LoginView.as_view(redirect_authenticated_user=True)),
path('login/allowed_hosts/',
views.LoginView.as_view(success_url_allowed_hosts={'otherserver'})),
path('permission_required_redirect/', permission_required_redirect),
path('permission_required_exception/', permission_required_exception),
path('login_and_permission_required_exception/', login_and_permission_required_exception),
path('setlang/', set_language, name='set_language'),
# This line is only required to render the password reset with is_admin=True
path('admin/', admin.site.urls),
]
"""
Test the partitions and partitions service
"""
from collections import defaultdict
from unittest import TestCase
from mock import Mock
from xmodule.partitions.partitions import Group, UserPartition
from xmodule.partitions.partitions_service import PartitionService
class TestGroup(TestCase):
"""Test constructing groups"""
def test_construct(self):
test_id = 10
name = "Grendel"
group = Group(test_id, name)
self.assertEqual(group.id, test_id)
self.assertEqual(group.name, name)
def test_string_id(self):
test_id = "10"
name = "Grendel"
group = Group(test_id, name)
self.assertEqual(group.id, 10)
def test_to_json(self):
test_id = 10
name = "Grendel"
group = Group(test_id, name)
jsonified = group.to_json()
act_jsonified = {
"id": test_id,
"name": name,
"version": group.VERSION
}
self.assertEqual(jsonified, act_jsonified)
def test_from_json(self):
test_id = 5
name = "Grendel"
jsonified = {
"id": test_id,
"name": name,
"version": Group.VERSION
}
group = Group.from_json(jsonified)
self.assertEqual(group.id, test_id)
self.assertEqual(group.name, name)
def test_from_json_broken(self):
test_id = 5
name = "Grendel"
# Bad version
jsonified = {
"id": test_id,
"name": name,
"version": 9001
}
with self.assertRaisesRegexp(TypeError, "has unexpected version"):
group = Group.from_json(jsonified)
# Missing key "id"
jsonified = {
"name": name,
"version": Group.VERSION
}
with self.assertRaisesRegexp(TypeError, "missing value key 'id'"):
group = Group.from_json(jsonified)
# Has extra key - should not be a problem
jsonified = {
"id": test_id,
"name": name,
"version": Group.VERSION,
"programmer": "Cale"
}
group = Group.from_json(jsonified)
self.assertNotIn("programmer", group.to_json())
class TestUserPartition(TestCase):
"""Test constructing UserPartitions"""
def test_construct(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
user_partition = UserPartition(0, 'Test Partition', 'for testing purposes', groups)
self.assertEqual(user_partition.id, 0)
self.assertEqual(user_partition.name, "Test Partition")
self.assertEqual(user_partition.description, "for testing purposes")
self.assertEqual(user_partition.groups, groups)
def test_string_id(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
user_partition = UserPartition("70", 'Test Partition', 'for testing purposes', groups)
self.assertEqual(user_partition.id, 70)
def test_to_json(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
upid = 0
upname = "Test Partition"
updesc = "for testing purposes"
user_partition = UserPartition(upid, upname, updesc, groups)
jsonified = user_partition.to_json()
act_jsonified = {
"id": upid,
"name": upname,
"description": updesc,
"groups": [group.to_json() for group in groups],
"version": user_partition.VERSION
}
self.assertEqual(jsonified, act_jsonified)
def test_from_json(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
upid = 1
upname = "Test Partition"
updesc = "For Testing Purposes"
jsonified = {
"id": upid,
"name": upname,
"description": updesc,
"groups": [group.to_json() for group in groups],
"version": UserPartition.VERSION
}
user_partition = UserPartition.from_json(jsonified)
self.assertEqual(user_partition.id, upid)
self.assertEqual(user_partition.name, upname)
self.assertEqual(user_partition.description, updesc)
for act_group in user_partition.groups:
self.assertIn(act_group.id, [0, 1])
exp_group = groups[act_group.id]
self.assertEqual(exp_group.id, act_group.id)
self.assertEqual(exp_group.name, act_group.name)
def test_from_json_broken(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
upid = 1
upname = "Test Partition"
updesc = "For Testing Purposes"
# Missing field
jsonified = {
"name": upname,
"description": updesc,
"groups": [group.to_json() for group in groups],
"version": UserPartition.VERSION
}
with self.assertRaisesRegexp(TypeError, "missing value key 'id'"):
user_partition = UserPartition.from_json(jsonified)
# Wrong version (it's over 9000!)
jsonified = {
'id': upid,
"name": upname,
"description": updesc,
"groups": [group.to_json() for group in groups],
"version": 9001
}
with self.assertRaisesRegexp(TypeError, "has unexpected version"):
user_partition = UserPartition.from_json(jsonified)
# Has extra key - should not be a problem
jsonified = {
'id': upid,
"name": upname,
"description": updesc,
"groups": [group.to_json() for group in groups],
"version": UserPartition.VERSION,
"programmer": "Cale"
}
user_partition = UserPartition.from_json(jsonified)
self.assertNotIn("programmer", user_partition.to_json())
class StaticPartitionService(PartitionService):
"""
Mock PartitionService for testing.
"""
def __init__(self, partitions, **kwargs):
super(StaticPartitionService, self).__init__(**kwargs)
self._partitions = partitions
@property
def course_partitions(self):
return self._partitions
class MemoryUserTagsService(object):
"""
An implementation of a user_tags XBlock service that
uses an in-memory dictionary for storage
"""
COURSE_SCOPE = 'course'
def __init__(self):
self._tags = defaultdict(dict)
def get_tag(self, scope, key):
"""Sets the value of ``key`` to ``value``"""
print 'GETTING', scope, key, self._tags
return self._tags[scope].get(key)
def set_tag(self, scope, key, value):
"""Gets the value of ``key``"""
self._tags[scope][key] = value
print 'SET', scope, key, value, self._tags
class TestPartitionsService(TestCase):
"""
Test getting a user's group out of a partition
"""
def setUp(self):
groups = [Group(0, 'Group 1'), Group(1, 'Group 2')]
self.partition_id = 0
self.user_tags_service = MemoryUserTagsService()
user_partition = UserPartition(self.partition_id, 'Test Partition', 'for testing purposes', groups)
self.partitions_service = StaticPartitionService(
[user_partition],
user_tags_service=self.user_tags_service,
course_id=Mock(),
track_function=Mock()
)
def test_get_user_group_for_partition(self):
# get a group assigned to the user
group1 = self.partitions_service.get_user_group_for_partition(self.partition_id)
# make sure we get the same group back out if we try a second time
group2 = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertEqual(group1, group2)
# test that we error if given an invalid partition id
with self.assertRaises(ValueError):
self.partitions_service.get_user_group_for_partition(3)
def test_user_in_deleted_group(self):
# get a group assigned to the user - should be group 0 or 1
old_group = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertIn(old_group, [0, 1])
# Change the group definitions! No more group 0 or 1
groups = [Group(3, 'Group 3'), Group(4, 'Group 4')]
user_partition = UserPartition(self.partition_id, 'Test Partition', 'for testing purposes', groups)
self.partitions_service = StaticPartitionService(
[user_partition],
user_tags_service=self.user_tags_service,
course_id=Mock(),
track_function=Mock()
)
# Now, get a new group using the same call - should be 3 or 4
new_group = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertIn(new_group, [3, 4])
# We should get the same group over multiple calls
new_group_2 = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertEqual(new_group, new_group_2)
def test_change_group_name(self):
# Changing the name of the group shouldn't affect anything
# get a group assigned to the user - should be group 0 or 1
old_group = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertIn(old_group, [0, 1])
# Change the group names
groups = [Group(0, 'Group 0'), Group(1, 'Group 1')]
user_partition = UserPartition(self.partition_id, 'Test Partition', 'for testing purposes', groups)
self.partitions_service = StaticPartitionService(
[user_partition],
user_tags_service=self.user_tags_service,
course_id=Mock(),
track_function=Mock()
)
# Now, get a new group using the same call
new_group = self.partitions_service.get_user_group_for_partition(self.partition_id)
self.assertEqual(old_group, new_group)
###############################################################################
#
# Copyright (C) 2001-2014 Micronaet SRL ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see .
#
###############################################################################
{
'name': 'Show photo switch',
'version': '0.1',
'category': 'Product',
'description': '''
Parameter for user to show photo in product form
''',
'author': 'Micronaet S.r.l. - Nicola Riolini',
'website': 'http://www.micronaet.it',
'license': 'AGPL-3',
'depends': [
'base',
'product',
'quotation_photo',
],
'init_xml': [],
'demo': [],
'data': [
'photo_view.xml',
],
'active': False,
'installable': True,
'auto_install': False,
}
#!/usr/bin/python
#
# Created on Aug 25, 2016
# @author: Gaurav Rastogi (grastogi@avinetworks.com)
# Eric Anderson (eanderson@avinetworks.com)
# module_check: supported
# Avi Version: 16.3.8
#
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see .
#
ANSIBLE_METADATA = {'metadata_version': '1.0',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: avi_networkprofile
author: Gaurav Rastogi (grastogi@avinetworks.com)
short_description: Module for setup of NetworkProfile Avi RESTful Object
description:
- This module is used to configure NetworkProfile object
- more examples at U(https://github.com/avinetworks/devops)
requirements: [ avisdk ]
version_added: "2.3"
options:
state:
description:
- The state that should be applied on the entity.
default: present
choices: ["absent","present"]
description:
description:
- User defined description for the object.
name:
description:
- The name of the network profile.
required: true
profile:
description:
- Networkprofileunion settings for networkprofile.
required: true
tenant_ref:
description:
- It is a reference to an object of type tenant.
url:
description:
- Avi controller URL of the object.
uuid:
description:
- Uuid of the network profile.
extends_documentation_fragment:
- avi
'''
EXAMPLES = '''
- name: Create a network profile for an UDP application
avi_networkprofile:
controller: ''
username: ''
password: ''
name: System-UDP-Fast-Path
profile:
type: PROTOCOL_TYPE_UDP_FAST_PATH
udp_fast_path_profile:
per_pkt_loadbalance: false
session_idle_timeout: 10
snat: true
tenant_ref: admin
'''
RETURN = '''
obj:
description: NetworkProfile (api/networkprofile) object
returned: success, changed
type: dict
'''
from ansible.module_utils.basic import AnsibleModule
try:
from ansible.module_utils.avi import (
avi_common_argument_spec, HAS_AVI, avi_ansible_api)
except ImportError:
HAS_AVI = False
def main():
argument_specs = dict(
state=dict(default='present',
choices=['absent', 'present']),
description=dict(type='str',),
name=dict(type='str', required=True),
profile=dict(type='dict', required=True),
tenant_ref=dict(type='str',),
url=dict(type='str',),
uuid=dict(type='str',),
)
argument_specs.update(avi_common_argument_spec())
module = AnsibleModule(
argument_spec=argument_specs, supports_check_mode=True)
if not HAS_AVI:
return module.fail_json(msg=(
'Avi python API SDK (avisdk>=16.3.5.post1) is not installed. '
'For more details visit https://github.com/avinetworks/sdk.'))
return avi_ansible_api(module, 'networkprofile',
set([]))
if __name__ == '__main__':
main()
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.apps import apps
from django.conf import settings
from django.core import checks
def check_user_model(**kwargs):
errors = []
cls = apps.get_model(settings.AUTH_USER_MODEL)
# Check that REQUIRED_FIELDS is a list
if not isinstance(cls.REQUIRED_FIELDS, (list, tuple)):
errors.append(
checks.Error(
"'REQUIRED_FIELDS' must be a list or tuple.",
hint=None,
obj=cls,
id='auth.E001',
)
)
# Check that the USERNAME FIELD isn't included in REQUIRED_FIELDS.
if cls.USERNAME_FIELD in cls.REQUIRED_FIELDS:
errors.append(
checks.Error(
("The field named as the 'USERNAME_FIELD' "
"for a custom user model must not be included in 'REQUIRED_FIELDS'."),
hint=None,
obj=cls,
id='auth.E002',
)
)
# Check that the username field is unique
if not cls._meta.get_field(cls.USERNAME_FIELD).unique:
if (settings.AUTHENTICATION_BACKENDS ==
['django.contrib.auth.backends.ModelBackend']):
errors.append(
checks.Error(
"'%s.%s' must be unique because it is named as the 'USERNAME_FIELD'." % (
cls._meta.object_name, cls.USERNAME_FIELD
),
hint=None,
obj=cls,
id='auth.E003',
)
)
else:
errors.append(
checks.Warning(
"'%s.%s' is named as the 'USERNAME_FIELD', but it is not unique." % (
cls._meta.object_name, cls.USERNAME_FIELD
),
hint=('Ensure that your authentication backend(s) can handle '
'non-unique usernames.'),
obj=cls,
id='auth.W004',
)
)
return errors
import logging
from lxml import etree
from regparser.grammar.unified import notice_cfr_p
from regparser.notice.amendments.fetch import fetch_amendments
from regparser.notice.dates import fetch_dates
from regparser.notice.sxs import (build_section_by_section,
find_section_by_section)
from regparser.notice.util import spaces_then_remove, swap_emphasis_tags
from regparser.notice.xml import xmls_for_url
logger = logging.getLogger(__name__)
def build_notice(cfr_title, cfr_part, fr_notice, fetch_xml=True,
xml_to_process=None):
"""Given JSON from the federal register, create our notice structure"""
cfr_parts = {str(ref['part']) for ref in fr_notice['cfr_references']}
if cfr_part:
cfr_parts.add(cfr_part)
notice = {'cfr_title': cfr_title, 'cfr_parts': list(cfr_parts)}
# Copy over most fields
for field in ['comments_close_on', 'document_number', 'publication_date',
'regulation_id_numbers']:
if fr_notice[field]:
notice[field] = fr_notice[field]
if fr_notice['effective_on']:
notice['effective_on'] = fr_notice['effective_on']
notice['initial_effective_on'] = fr_notice['effective_on']
if fr_notice['html_url']:
notice['fr_url'] = fr_notice['html_url']
if fr_notice['citation']:
notice['fr_citation'] = fr_notice['citation']
notice['fr_volume'] = fr_notice['volume']
notice['meta'] = {}
for key in ('dates', 'end_page', 'start_page', 'type'):
notice['meta'][key] = fr_notice[key]
if xml_to_process is not None:
return [process_xml(notice, xml_to_process)]
elif fr_notice['full_text_xml_url'] and fetch_xml:
xmls = xmls_for_url(fr_notice['full_text_xml_url'])
notices = [process_xml(notice, xml) for xml in xmls]
set_document_numbers(notices)
return notices
return [notice]
def split_doc_num(doc_num, effective_date):
""" If we have a split notice, we construct a document number
based on the original document number and the effective date. """
effective_date = ''.join(effective_date.split('-'))
return '{0}_{1}'.format(doc_num, effective_date)
def set_document_numbers(notices):
"""If we have multiple notices (due to being split across multiple
effective dates,) we need to fix their document numbers."""
if len(notices) > 1:
for notice in notices:
notice['document_number'] = split_doc_num(
notice['document_number'], notice['effective_on'])
return notices
def process_sxs(notice, notice_xml):
""" Find and build SXS from the notice_xml. """
sxs = find_section_by_section(notice_xml)
# note we will continue to use cfr_parts[0] as the default SxS label until
# we find a counter example
sxs = build_section_by_section(sxs, notice['meta']['start_page'],
notice['cfr_parts'][0])
notice['section_by_section'] = sxs
# @todo - this can be deleted once we remove process_xml
def fetch_cfr_parts(notice_xml):
""" Sometimes we need to read the CFR part numbers from the notice
XML itself. This would need to happen when we've broken up a
multiple-effective-date notice that has multiple CFR parts that
may not be included in each date. """
parts = []
for cfr_elm in notice_xml.xpath('//CFR'):
parts.extend(notice_cfr_p.parseString(cfr_elm.text).cfr_parts)
return list(sorted(set(parts)))
def process_xml(notice, notice_xml):
"""Pull out relevant fields from the xml and add them to the notice"""
notice = dict(notice) # defensive copy
if not notice.get('effective_on'):
dates = fetch_dates(notice_xml)
if dates and 'effective' in dates:
notice['effective_on'] = dates['effective'][0]
if not notice.get('cfr_parts'):
cfr_parts = fetch_cfr_parts(notice_xml)
notice['cfr_parts'] = cfr_parts
process_sxs(notice, notice_xml)
amds = fetch_amendments(notice_xml)
if amds:
notice['amendments'] = amds
add_footnotes(notice, notice_xml)
return notice
def add_footnotes(notice, notice_xml):
""" Parse the notice xml for footnotes and add them to the notice. """
notice['footnotes'] = {}
for child in notice_xml.xpath('//FTNT/*'):
spaces_then_remove(child, 'PRTPAGE')
swap_emphasis_tags(child)
ref = child.xpath('.//SU')
if ref:
child.text = ref[0].tail
child.remove(ref[0])
content = child.text
for cc in child:
content += etree.tounicode(cc)
if child.tail:
content += child.tail
notice['footnotes'][ref[0].text] = content.strip()
async def asyncgen():
yield 10
async def run():
{i async for i in asyncgen()}
[i async for i in asyncgen()]
{i: i ** 2 async for i in asyncgen()}
(i ** 2 async for i in asyncgen())
list(i async for i in asyncgen())
dataset = {data for line in gen()
async for data in line
if check(data)}
dataset = {data async for line in asyncgen()
async for data in line
if check(data)}
# copyright (c) 2018 paddlepaddle authors. all rights reserved.
#
# licensed under the apache license, version 2.0 (the "license");
# you may not use this file except in compliance with the license.
# you may obtain a copy of the license at
#
# http://www.apache.org/licenses/license-2.0
#
# unless required by applicable law or agreed to in writing, software
# distributed under the license is distributed on an "as is" basis,
# without warranties or conditions of any kind, either express or implied.
# see the license for the specific language governing permissions and
# limitations under the license.
from __future__ import print_function
import os
import numpy as np
import random
import unittest
import logging
import paddle
import paddle.fluid as fluid
from paddle.fluid import core
from paddle.fluid.log_helper import get_logger
from test_imperative_qat import TestImperativeQat
paddle.enable_static()
os.environ["CPU_NUM"] = "1"
if core.is_compiled_with_cuda():
fluid.set_flags({"FLAGS_cudnn_deterministic": True})
_logger = get_logger(
__name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
class TestImperativeQatChannelWise(TestImperativeQat):
def set_vars(self):
self.weight_quantize_type = 'channel_wise_abs_max'
self.activation_quantize_type = 'moving_average_abs_max'
print('weight_quantize_type', self.weight_quantize_type)
if __name__ == '__main__':
unittest.main()
"""SCons.Tool.wix
Tool-specific initialization for wix, the Windows Installer XML Tool.
There normally shouldn't be any need to import this module directly.
It will usually be imported through the generic SCons.Tool.Tool()
selection method.
"""
#
# Copyright (c) 2001 - 2016 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
__revision__ = "src/engine/SCons/Tool/wix.py rel_2.5.0:3543:937e55cd78f7 2016/04/09 11:29:54 bdbaddog"
import SCons.Builder
import SCons.Action
import os
def generate(env):
"""Add Builders and construction variables for WiX to an Environment."""
if not exists(env):
return
env['WIXCANDLEFLAGS'] = ['-nologo']
env['WIXCANDLEINCLUDE'] = []
env['WIXCANDLECOM'] = '$WIXCANDLE $WIXCANDLEFLAGS -I $WIXCANDLEINCLUDE -o ${TARGET} ${SOURCE}'
env['WIXLIGHTFLAGS'].append( '-nologo' )
env['WIXLIGHTCOM'] = "$WIXLIGHT $WIXLIGHTFLAGS -out ${TARGET} ${SOURCES}"
env['WIXSRCSUF'] = '.wxs'
env['WIXOBJSUF'] = '.wixobj'
object_builder = SCons.Builder.Builder(
action = '$WIXCANDLECOM',
suffix = '$WIXOBJSUF',
src_suffix = '$WIXSRCSUF')
linker_builder = SCons.Builder.Builder(
action = '$WIXLIGHTCOM',
src_suffix = '$WIXOBJSUF',
src_builder = object_builder)
env['BUILDERS']['WiX'] = linker_builder
def exists(env):
env['WIXCANDLE'] = 'candle.exe'
env['WIXLIGHT'] = 'light.exe'
# try to find the candle.exe and light.exe tools and
# add the install directory to light libpath.
for path in os.environ['PATH'].split(os.pathsep):
if not path:
continue
# workaround for some weird python win32 bug.
if path[0] == '"' and path[-1:]=='"':
path = path[1:-1]
# normalize the path
path = os.path.normpath(path)
# search for the tools in the PATH environment variable
try:
files = os.listdir(path)
if env['WIXCANDLE'] in files and env['WIXLIGHT'] in files:
env.PrependENVPath('PATH', path)
# include appropriate flags if running WiX 2.0
if 'wixui.wixlib' in files and 'WixUI_en-us.wxl' in files:
env['WIXLIGHTFLAGS'] = [ os.path.join( path, 'wixui.wixlib' ),
'-loc',
os.path.join( path, 'WixUI_en-us.wxl' ) ]
else:
env['WIXLIGHTFLAGS'] = []
return 1
except OSError:
pass # ignore this, could be a stale PATH entry.
return None
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4:
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
#
import bpy
from bpy.types import Menu, Panel
from rna_prop_ui import PropertyPanel
class LAMP_MT_sunsky_presets(Menu):
bl_label = "Sun & Sky Presets"
preset_subdir = "sunsky"
preset_operator = "script.execute_preset"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
draw = Menu.draw_preset
class DataButtonsPanel:
bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW'
bl_context = "data"
@classmethod
def poll(cls, context):
engine = context.scene.render.engine
return context.lamp and (engine in cls.COMPAT_ENGINES)
class DATA_PT_context_lamp(DataButtonsPanel, Panel):
bl_label = ""
bl_options = {'HIDE_HEADER'}
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
def draw(self, context):
layout = self.layout
ob = context.object
lamp = context.lamp
space = context.space_data
split = layout.split(percentage=0.65)
texture_count = len(lamp.texture_slots.keys())
if ob:
split.template_ID(ob, "data")
elif lamp:
split.template_ID(space, "pin_id")
if texture_count != 0:
split.label(text=str(texture_count), icon='TEXTURE')
class DATA_PT_preview(DataButtonsPanel, Panel):
bl_label = "Preview"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
def draw(self, context):
self.layout.template_preview(context.lamp)
class DATA_PT_lamp(DataButtonsPanel, Panel):
bl_label = "Lamp"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
def draw(self, context):
layout = self.layout
lamp = context.lamp
layout.prop(lamp, "type", expand=True)
split = layout.split()
col = split.column()
sub = col.column()
sub.prop(lamp, "color", text="")
sub.prop(lamp, "energy")
if lamp.type in {'POINT', 'SPOT'}:
sub.label(text="Falloff:")
sub.prop(lamp, "falloff_type", text="")
sub.prop(lamp, "distance")
if lamp.falloff_type == 'LINEAR_QUADRATIC_WEIGHTED':
col.label(text="Attenuation Factors:")
sub = col.column(align=True)
sub.prop(lamp, "linear_attenuation", slider=True, text="Linear")
sub.prop(lamp, "quadratic_attenuation", slider=True, text="Quadratic")
col.prop(lamp, "use_sphere")
if lamp.type == 'AREA':
col.prop(lamp, "distance")
col.prop(lamp, "gamma")
col = split.column()
col.prop(lamp, "use_negative")
col.prop(lamp, "use_own_layer", text="This Layer Only")
col.prop(lamp, "use_specular")
col.prop(lamp, "use_diffuse")
class DATA_PT_sunsky(DataButtonsPanel, Panel):
bl_label = "Sky & Atmosphere"
COMPAT_ENGINES = {'BLENDER_RENDER'}
@classmethod
def poll(cls, context):
lamp = context.lamp
engine = context.scene.render.engine
return (lamp and lamp.type == 'SUN') and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
lamp = context.lamp.sky
row = layout.row(align=True)
row.prop(lamp, "use_sky")
row.menu("LAMP_MT_sunsky_presets", text=bpy.types.LAMP_MT_sunsky_presets.bl_label)
row.operator("lamp.sunsky_preset_add", text="", icon='ZOOMIN')
row.operator("lamp.sunsky_preset_add", text="", icon='ZOOMOUT').remove_active = True
row = layout.row()
row.active = lamp.use_sky or lamp.use_atmosphere
row.prop(lamp, "atmosphere_turbidity", text="Turbidity")
split = layout.split()
col = split.column()
col.active = lamp.use_sky
col.label(text="Blending:")
sub = col.column()
sub.prop(lamp, "sky_blend_type", text="")
sub.prop(lamp, "sky_blend", text="Factor")
col.label(text="Color Space:")
sub = col.column()
sub.row().prop(lamp, "sky_color_space", expand=True)
sub.prop(lamp, "sky_exposure", text="Exposure")
col = split.column()
col.active = lamp.use_sky
col.label(text="Horizon:")
sub = col.column()
sub.prop(lamp, "horizon_brightness", text="Brightness")
sub.prop(lamp, "spread", text="Spread")
col.label(text="Sun:")
sub = col.column()
sub.prop(lamp, "sun_brightness", text="Brightness")
sub.prop(lamp, "sun_size", text="Size")
sub.prop(lamp, "backscattered_light", slider=True, text="Back Light")
layout.separator()
layout.prop(lamp, "use_atmosphere")
split = layout.split()
col = split.column()
col.active = lamp.use_atmosphere
col.label(text="Intensity:")
col.prop(lamp, "sun_intensity", text="Sun")
col.prop(lamp, "atmosphere_distance_factor", text="Distance")
col = split.column()
col.active = lamp.use_atmosphere
col.label(text="Scattering:")
sub = col.column(align=True)
sub.prop(lamp, "atmosphere_inscattering", slider=True, text="Inscattering")
sub.prop(lamp, "atmosphere_extinction", slider=True, text="Extinction")
class DATA_PT_shadow(DataButtonsPanel, Panel):
bl_label = "Shadow"
COMPAT_ENGINES = {'BLENDER_RENDER'}
@classmethod
def poll(cls, context):
lamp = context.lamp
engine = context.scene.render.engine
return (lamp and lamp.type in {'POINT', 'SUN', 'SPOT', 'AREA'}) and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
lamp = context.lamp
layout.prop(lamp, "shadow_method", expand=True)
if lamp.shadow_method == 'NOSHADOW' and lamp.type == 'AREA':
split = layout.split()
col = split.column()
col.label(text="Form factor sampling:")
sub = col.row(align=True)
if lamp.shape == 'SQUARE':
sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
elif lamp.shape == 'RECTANGLE':
sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
if lamp.shadow_method != 'NOSHADOW':
split = layout.split()
col = split.column()
col.prop(lamp, "shadow_color", text="")
col = split.column()
col.prop(lamp, "use_shadow_layer", text="This Layer Only")
col.prop(lamp, "use_only_shadow")
if lamp.shadow_method == 'RAY_SHADOW':
split = layout.split()
col = split.column()
col.label(text="Sampling:")
if lamp.type in {'POINT', 'SUN', 'SPOT'}:
sub = col.row()
sub.prop(lamp, "shadow_ray_samples", text="Samples")
sub.prop(lamp, "shadow_soft_size", text="Soft Size")
elif lamp.type == 'AREA':
sub = col.row(align=True)
if lamp.shape == 'SQUARE':
sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
elif lamp.shape == 'RECTANGLE':
sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
col.row().prop(lamp, "shadow_ray_sample_method", expand=True)
if lamp.shadow_ray_sample_method == 'ADAPTIVE_QMC':
layout.prop(lamp, "shadow_adaptive_threshold", text="Threshold")
if lamp.type == 'AREA' and lamp.shadow_ray_sample_method == 'CONSTANT_JITTERED':
row = layout.row()
row.prop(lamp, "use_umbra")
row.prop(lamp, "use_dither")
row.prop(lamp, "use_jitter")
elif lamp.shadow_method == 'BUFFER_SHADOW':
col = layout.column()
col.label(text="Buffer Type:")
col.row().prop(lamp, "shadow_buffer_type", expand=True)
if lamp.shadow_buffer_type in {'REGULAR', 'HALFWAY', 'DEEP'}:
split = layout.split()
col = split.column()
col.label(text="Filter Type:")
col.prop(lamp, "shadow_filter_type", text="")
sub = col.column(align=True)
sub.prop(lamp, "shadow_buffer_soft", text="Soft")
sub.prop(lamp, "shadow_buffer_bias", text="Bias")
col = split.column()
col.label(text="Sample Buffers:")
col.prop(lamp, "shadow_sample_buffers", text="")
sub = col.column(align=True)
sub.prop(lamp, "shadow_buffer_size", text="Size")
sub.prop(lamp, "shadow_buffer_samples", text="Samples")
if lamp.shadow_buffer_type == 'DEEP':
col.prop(lamp, "compression_threshold")
elif lamp.shadow_buffer_type == 'IRREGULAR':
layout.prop(lamp, "shadow_buffer_bias", text="Bias")
split = layout.split()
col = split.column()
col.prop(lamp, "use_auto_clip_start", text="Autoclip Start")
sub = col.column()
sub.active = not lamp.use_auto_clip_start
sub.prop(lamp, "shadow_buffer_clip_start", text="Clip Start")
col = split.column()
col.prop(lamp, "use_auto_clip_end", text="Autoclip End")
sub = col.column()
sub.active = not lamp.use_auto_clip_end
sub.prop(lamp, "shadow_buffer_clip_end", text=" Clip End")
class DATA_PT_area(DataButtonsPanel, Panel):
bl_label = "Area Shape"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@classmethod
def poll(cls, context):
lamp = context.lamp
engine = context.scene.render.engine
return (lamp and lamp.type == 'AREA') and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
lamp = context.lamp
col = layout.column()
col.row().prop(lamp, "shape", expand=True)
sub = col.row(align=True)
if lamp.shape == 'SQUARE':
sub.prop(lamp, "size")
elif lamp.shape == 'RECTANGLE':
sub.prop(lamp, "size", text="Size X")
sub.prop(lamp, "size_y", text="Size Y")
class DATA_PT_spot(DataButtonsPanel, Panel):
bl_label = "Spot Shape"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@classmethod
def poll(cls, context):
lamp = context.lamp
engine = context.scene.render.engine
return (lamp and lamp.type == 'SPOT') and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
lamp = context.lamp
split = layout.split()
col = split.column()
sub = col.column()
sub.prop(lamp, "spot_size", text="Size")
sub.prop(lamp, "spot_blend", text="Blend", slider=True)
col.prop(lamp, "use_square")
col.prop(lamp, "show_cone")
col = split.column()
col.active = (lamp.shadow_method != 'BUFFER_SHADOW' or lamp.shadow_buffer_type != 'DEEP')
col.prop(lamp, "use_halo")
sub = col.column(align=True)
sub.active = lamp.use_halo
sub.prop(lamp, "halo_intensity", text="Intensity")
if lamp.shadow_method == 'BUFFER_SHADOW':
sub.prop(lamp, "halo_step", text="Step")
class DATA_PT_falloff_curve(DataButtonsPanel, Panel):
bl_label = "Falloff Curve"
bl_options = {'DEFAULT_CLOSED'}
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@classmethod
def poll(cls, context):
lamp = context.lamp
engine = context.scene.render.engine
return (lamp and lamp.type in {'POINT', 'SPOT'} and lamp.falloff_type == 'CUSTOM_CURVE') and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
lamp = context.lamp
self.layout.template_curve_mapping(lamp, "falloff_curve", use_negative_slope=True)
class DATA_PT_custom_props_lamp(DataButtonsPanel, PropertyPanel, Panel):
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
_context_path = "object.data"
_property_type = bpy.types.Lamp
if __name__ == "__main__": # only for live edit.
bpy.utils.register_module(__name__)
#!/usr/bin/env python3
# Copyright (c) 2018-2019 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test the deriveaddresses rpc call."""
from test_framework.test_framework import BitcoinTestFramework
from test_framework.descriptors import descsum_create
from test_framework.util import assert_equal, assert_raises_rpc_error
class DeriveaddressesTest(BitcoinTestFramework):
def set_test_params(self):
self.num_nodes = 1
def run_test(self):
assert_raises_rpc_error(-5, "Missing checksum", self.nodes[0].deriveaddresses, "a")
descriptor = "wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0)#t6wfjs64"
address = "bcrt1qjqmxmkpmxt80xz4y3746zgt0q3u3ferr34acd5"
assert_equal(self.nodes[0].deriveaddresses(descriptor), [address])
descriptor = descriptor[:-9]
assert_raises_rpc_error(-5, "Missing checksum", self.nodes[0].deriveaddresses, descriptor)
descriptor_pubkey = "wpkh(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/0)#s9ga3alw"
address = "bcrt1qjqmxmkpmxt80xz4y3746zgt0q3u3ferr34acd5"
assert_equal(self.nodes[0].deriveaddresses(descriptor_pubkey), [address])
ranged_descriptor = "wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)#kft60nuy"
assert_equal(self.nodes[0].deriveaddresses(ranged_descriptor, [1, 2]), ["bcrt1qhku5rq7jz8ulufe2y6fkcpnlvpsta7rq4442dy", "bcrt1qpgptk2gvshyl0s9lqshsmx932l9ccsv265tvaq"])
assert_equal(self.nodes[0].deriveaddresses(ranged_descriptor, 2), [address, "bcrt1qhku5rq7jz8ulufe2y6fkcpnlvpsta7rq4442dy", "bcrt1qpgptk2gvshyl0s9lqshsmx932l9ccsv265tvaq"])
assert_raises_rpc_error(-8, "Range should not be specified for an un-ranged descriptor", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0)"), [0, 2])
assert_raises_rpc_error(-8, "Range must be specified for a ranged descriptor", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)"))
assert_raises_rpc_error(-8, "End of range is too high", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)"), 10000000000)
assert_raises_rpc_error(-8, "Range is too large", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)"), [1000000000, 2000000000])
assert_raises_rpc_error(-8, "Range specified as [begin,end] must not have begin after end", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)"), [2, 0])
assert_raises_rpc_error(-8, "Range should be greater or equal than 0", self.nodes[0].deriveaddresses, descsum_create("wpkh(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)"), [-1, 0])
combo_descriptor = descsum_create("combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0)")
assert_equal(self.nodes[0].deriveaddresses(combo_descriptor), ["mtfUoUax9L4tzXARpw1oTGxWyoogp52KhJ", "mtfUoUax9L4tzXARpw1oTGxWyoogp52KhJ", address, "2NDvEwGfpEqJWfybzpKPHF2XH3jwoQV3D7x"])
hardened_without_privkey_descriptor = descsum_create("wpkh(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1'/1/0)")
assert_raises_rpc_error(-5, "Cannot derive script without private keys", self.nodes[0].deriveaddresses, hardened_without_privkey_descriptor)
bare_multisig_descriptor = descsum_create("multi(1,tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/0,tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/1)")
assert_raises_rpc_error(-5, "Descriptor does not have a corresponding address", self.nodes[0].deriveaddresses, bare_multisig_descriptor)
if __name__ == '__main__':
DeriveaddressesTest().main()
#!/usr/bin/env python
# Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import copy
import gyp.input
import optparse
import os.path
import re
import shlex
import sys
import traceback
from gyp.common import GypError
# Default debug modes for GYP
debug = {}
# List of "official" debug modes, but you can use anything you like.
DEBUG_GENERAL = 'general'
DEBUG_VARIABLES = 'variables'
DEBUG_INCLUDES = 'includes'
def DebugOutput(mode, message, *args):
if 'all' in gyp.debug or mode in gyp.debug:
ctx = ('unknown', 0, 'unknown')
try:
f = traceback.extract_stack(limit=2)
if f:
ctx = f[0][:3]
except:
pass
if args:
message %= args
print '%s:%s:%d:%s %s' % (mode.upper(), os.path.basename(ctx[0]),
ctx[1], ctx[2], message)
def FindBuildFiles():
extension = '.gyp'
files = os.listdir(os.getcwd())
build_files = []
for file in files:
if file.endswith(extension):
build_files.append(file)
return build_files
def Load(build_files, format, default_variables={},
includes=[], depth='.', params=None, check=False,
circular_check=True):
"""
Loads one or more specified build files.
default_variables and includes will be copied before use.
Returns the generator for the specified format and the
data returned by loading the specified build files.
"""
if params is None:
params = {}
if '-' in format:
format, params['flavor'] = format.split('-', 1)
default_variables = copy.copy(default_variables)
# Default variables provided by this program and its modules should be
# named WITH_CAPITAL_LETTERS to provide a distinct "best practice" namespace,
# avoiding collisions with user and automatic variables.
default_variables['GENERATOR'] = format
default_variables['GENERATOR_FLAVOR'] = params.get('flavor', '')
# Format can be a custom python file, or by default the name of a module
# within gyp.generator.
if format.endswith('.py'):
generator_name = os.path.splitext(format)[0]
path, generator_name = os.path.split(generator_name)
# Make sure the path to the custom generator is in sys.path
# Don't worry about removing it once we are done. Keeping the path
# to each generator that is used in sys.path is likely harmless and
# arguably a good idea.
path = os.path.abspath(path)
if path not in sys.path:
sys.path.insert(0, path)
else:
generator_name = 'gyp.generator.' + format
# These parameters are passed in order (as opposed to by key)
# because ActivePython cannot handle key parameters to __import__.
generator = __import__(generator_name, globals(), locals(), generator_name)
for (key, val) in generator.generator_default_variables.items():
default_variables.setdefault(key, val)
# Give the generator the opportunity to set additional variables based on
# the params it will receive in the output phase.
if getattr(generator, 'CalculateVariables', None):
generator.CalculateVariables(default_variables, params)
# Give the generator the opportunity to set generator_input_info based on
# the params it will receive in the output phase.
if getattr(generator, 'CalculateGeneratorInputInfo', None):
generator.CalculateGeneratorInputInfo(params)
# Fetch the generator specific info that gets fed to input, we use getattr
# so we can default things and the generators only have to provide what
# they need.
generator_input_info = {
'non_configuration_keys':
getattr(generator, 'generator_additional_non_configuration_keys', []),
'path_sections':
getattr(generator, 'generator_additional_path_sections', []),
'extra_sources_for_rules':
getattr(generator, 'generator_extra_sources_for_rules', []),
'generator_supports_multiple_toolsets':
getattr(generator, 'generator_supports_multiple_toolsets', False),
'generator_wants_static_library_dependencies_adjusted':
getattr(generator,
'generator_wants_static_library_dependencies_adjusted', True),
'generator_wants_sorted_dependencies':
getattr(generator, 'generator_wants_sorted_dependencies', False),
'generator_filelist_paths':
getattr(generator, 'generator_filelist_paths', None),
}
# Process the input specific to this generator.
result = gyp.input.Load(build_files, default_variables, includes[:],
depth, generator_input_info, check, circular_check,
params['parallel'], params['root_targets'])
return [generator] + result
def NameValueListToDict(name_value_list):
"""
Takes an array of strings of the form 'NAME=VALUE' and creates a dictionary
of the pairs. If a string is simply NAME, then the value in the dictionary
is set to True. If VALUE can be converted to an integer, it is.
"""
result = { }
for item in name_value_list:
tokens = item.split('=', 1)
if len(tokens) == 2:
# If we can make it an int, use that, otherwise, use the string.
try:
token_value = int(tokens[1])
except ValueError:
token_value = tokens[1]
# Set the variable to the supplied value.
result[tokens[0]] = token_value
else:
# No value supplied, treat it as a boolean and set it.
result[tokens[0]] = True
return result
def ShlexEnv(env_name):
flags = os.environ.get(env_name, [])
if flags:
flags = shlex.split(flags)
return flags
def FormatOpt(opt, value):
if opt.startswith('--'):
return '%s=%s' % (opt, value)
return opt + value
def RegenerateAppendFlag(flag, values, predicate, env_name, options):
"""Regenerate a list of command line flags, for an option of action='append'.
The |env_name|, if given, is checked in the environment and used to generate
an initial list of options, then the options that were specified on the
command line (given in |values|) are appended. This matches the handling of
environment variables and command line flags where command line flags override
the environment, while not requiring the environment to be set when the flags
are used again.
"""
flags = []
if options.use_environment and env_name:
for flag_value in ShlexEnv(env_name):
value = FormatOpt(flag, predicate(flag_value))
if value in flags:
flags.remove(value)
flags.append(value)
if values:
for flag_value in values:
flags.append(FormatOpt(flag, predicate(flag_value)))
return flags
def RegenerateFlags(options):
"""Given a parsed options object, and taking the environment variables into
account, returns a list of flags that should regenerate an equivalent options
object (even in the absence of the environment variables.)
Any path options will be normalized relative to depth.
The format flag is not included, as it is assumed the calling generator will
set that as appropriate.
"""
def FixPath(path):
path = gyp.common.FixIfRelativePath(path, options.depth)
if not path:
return os.path.curdir
return path
def Noop(value):
return value
# We always want to ignore the environment when regenerating, to avoid
# duplicate or changed flags in the environment at the time of regeneration.
flags = ['--ignore-environment']
for name, metadata in options._regeneration_metadata.iteritems():
opt = metadata['opt']
value = getattr(options, name)
value_predicate = metadata['type'] == 'path' and FixPath or Noop
action = metadata['action']
env_name = metadata['env_name']
if action == 'append':
flags.extend(RegenerateAppendFlag(opt, value, value_predicate,
env_name, options))
elif action in ('store', None): # None is a synonym for 'store'.
if value:
flags.append(FormatOpt(opt, value_predicate(value)))
elif options.use_environment and env_name and os.environ.get(env_name):
flags.append(FormatOpt(opt, value_predicate(os.environ.get(env_name))))
elif action in ('store_true', 'store_false'):
if ((action == 'store_true' and value) or
(action == 'store_false' and not value)):
flags.append(opt)
elif options.use_environment and env_name:
print >>sys.stderr, ('Warning: environment regeneration unimplemented '
'for %s flag %r env_name %r' % (action, opt,
env_name))
else:
print >>sys.stderr, ('Warning: regeneration unimplemented for action %r '
'flag %r' % (action, opt))
return flags
class RegeneratableOptionParser(optparse.OptionParser):
def __init__(self):
self.__regeneratable_options = {}
optparse.OptionParser.__init__(self)
def add_option(self, *args, **kw):
"""Add an option to the parser.
This accepts the same arguments as OptionParser.add_option, plus the
following:
regenerate: can be set to False to prevent this option from being included
in regeneration.
env_name: name of environment variable that additional values for this
option come from.
type: adds type='path', to tell the regenerator that the values of
this option need to be made relative to options.depth
"""
env_name = kw.pop('env_name', None)
if 'dest' in kw and kw.pop('regenerate', True):
dest = kw['dest']
# The path type is needed for regenerating, for optparse we can just treat
# it as a string.
type = kw.get('type')
if type == 'path':
kw['type'] = 'string'
self.__regeneratable_options[dest] = {
'action': kw.get('action'),
'type': type,
'env_name': env_name,
'opt': args[0],
}
optparse.OptionParser.add_option(self, *args, **kw)
def parse_args(self, *args):
values, args = optparse.OptionParser.parse_args(self, *args)
values._regeneration_metadata = self.__regeneratable_options
return values, args
def gyp_main(args):
my_name = os.path.basename(sys.argv[0])
parser = RegeneratableOptionParser()
usage = 'usage: %s [options ...] [build_file ...]'
parser.set_usage(usage.replace('%s', '%prog'))
parser.add_option('--build', dest='configs', action='append',
help='configuration for build after project generation')
parser.add_option('--check', dest='check', action='store_true',
help='check format of gyp files')
parser.add_option('--config-dir', dest='config_dir', action='store',
env_name='GYP_CONFIG_DIR', default=None,
help='The location for configuration files like '
'include.gypi.')
parser.add_option('-d', '--debug', dest='debug', metavar='DEBUGMODE',
action='append', default=[], help='turn on a debugging '
'mode for debugging GYP. Supported modes are "variables", '
'"includes" and "general" or "all" for all of them.')
parser.add_option('-D', dest='defines', action='append', metavar='VAR=VAL',
env_name='GYP_DEFINES',
help='sets variable VAR to value VAL')
parser.add_option('--depth', dest='depth', metavar='PATH', type='path',
help='set DEPTH gyp variable to a relative path to PATH')
parser.add_option('-f', '--format', dest='formats', action='append',
env_name='GYP_GENERATORS', regenerate=False,
help='output formats to generate')
parser.add_option('-G', dest='generator_flags', action='append', default=[],
metavar='FLAG=VAL', env_name='GYP_GENERATOR_FLAGS',
help='sets generator flag FLAG to VAL')
parser.add_option('--generator-output', dest='generator_output',
action='store', default=None, metavar='DIR', type='path',
env_name='GYP_GENERATOR_OUTPUT',
help='puts generated build files under DIR')
parser.add_option('--ignore-environment', dest='use_environment',
action='store_false', default=True, regenerate=False,
help='do not read options from environment variables')
parser.add_option('-I', '--include', dest='includes', action='append',
metavar='INCLUDE', type='path',
help='files to include in all loaded .gyp files')
# --no-circular-check disables the check for circular relationships between
# .gyp files. These relationships should not exist, but they've only been
# observed to be harmful with the Xcode generator. Chromium's .gyp files
# currently have some circular relationships on non-Mac platforms, so this
# option allows the strict behavior to be used on Macs and the lenient
# behavior to be used elsewhere.
# TODO(mark): Remove this option when http://crbug.com/35878 is fixed.
parser.add_option('--no-circular-check', dest='circular_check',
action='store_false', default=True, regenerate=False,
help="don't check for circular relationships between files")
parser.add_option('--no-parallel', action='store_true', default=False,
help='Disable multiprocessing')
parser.add_option('-S', '--suffix', dest='suffix', default='',
help='suffix to add to generated files')
parser.add_option('--toplevel-dir', dest='toplevel_dir', action='store',
default=None, metavar='DIR', type='path',
help='directory to use as the root of the source tree')
parser.add_option('-R', '--root-target', dest='root_targets',
action='append', metavar='TARGET',
help='include only TARGET and its deep dependencies')
options, build_files_arg = parser.parse_args(args)
build_files = build_files_arg
# Set up the configuration directory (defaults to ~/.gyp)
if not options.config_dir:
home = None
home_dot_gyp = None
if options.use_environment:
home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None)
if home_dot_gyp:
home_dot_gyp = os.path.expanduser(home_dot_gyp)
if not home_dot_gyp:
home_vars = ['HOME']
if sys.platform in ('cygwin', 'win32'):
home_vars.append('USERPROFILE')
for home_var in home_vars:
home = os.getenv(home_var)
if home != None:
home_dot_gyp = os.path.join(home, '.gyp')
if not os.path.exists(home_dot_gyp):
home_dot_gyp = None
else:
break
else:
home_dot_gyp = os.path.expanduser(options.config_dir)
if home_dot_gyp and not os.path.exists(home_dot_gyp):
home_dot_gyp = None
if not options.formats:
# If no format was given on the command line, then check the env variable.
generate_formats = []
if options.use_environment:
generate_formats = os.environ.get('GYP_GENERATORS', [])
if generate_formats:
generate_formats = re.split(r'[\s,]', generate_formats)
if generate_formats:
options.formats = generate_formats
else:
# Nothing in the variable, default based on platform.
if sys.platform == 'darwin':
options.formats = ['xcode']
elif sys.platform in ('win32', 'cygwin'):
options.formats = ['msvs']
else:
options.formats = ['make']
if not options.generator_output and options.use_environment:
g_o = os.environ.get('GYP_GENERATOR_OUTPUT')
if g_o:
options.generator_output = g_o
options.parallel = not options.no_parallel
for mode in options.debug:
gyp.debug[mode] = 1
# Do an extra check to avoid work when we're not debugging.
if DEBUG_GENERAL in gyp.debug:
DebugOutput(DEBUG_GENERAL, 'running with these options:')
for option, value in sorted(options.__dict__.items()):
if option[0] == '_':
continue
if isinstance(value, basestring):
DebugOutput(DEBUG_GENERAL, " %s: '%s'", option, value)
else:
DebugOutput(DEBUG_GENERAL, " %s: %s", option, value)
if not build_files:
build_files = FindBuildFiles()
if not build_files:
raise GypError((usage + '\n\n%s: error: no build_file') %
(my_name, my_name))
# TODO(mark): Chromium-specific hack!
# For Chromium, the gyp "depth" variable should always be a relative path
# to Chromium's top-level "src" directory. If no depth variable was set
# on the command line, try to find a "src" directory by looking at the
# absolute path to each build file's directory. The first "src" component
# found will be treated as though it were the path used for --depth.
if not options.depth:
for build_file in build_files:
build_file_dir = os.path.abspath(os.path.dirname(build_file))
build_file_dir_components = build_file_dir.split(os.path.sep)
components_len = len(build_file_dir_components)
for index in xrange(components_len - 1, -1, -1):
if build_file_dir_components[index] == 'src':
options.depth = os.path.sep.join(build_file_dir_components)
break
del build_file_dir_components[index]
# If the inner loop found something, break without advancing to another
# build file.
if options.depth:
break
if not options.depth:
raise GypError('Could not automatically locate src directory. This is'
'a temporary Chromium feature that will be removed. Use'
'--depth as a workaround.')
# If toplevel-dir is not set, we assume that depth is the root of our source
# tree.
if not options.toplevel_dir:
options.toplevel_dir = options.depth
# -D on the command line sets variable defaults - D isn't just for define,
# it's for default. Perhaps there should be a way to force (-F?) a
# variable's value so that it can't be overridden by anything else.
cmdline_default_variables = {}
defines = []
if options.use_environment:
defines += ShlexEnv('GYP_DEFINES')
if options.defines: