diff options
4 files changed, 506 insertions, 44 deletions
diff --git a/lib/oe/spdx.py b/lib/oe/spdx.py deleted file mode 100644 index b62b838..0000000 --- a/lib/oe/spdx.py +++ /dev/null @@ -1,40 +0,0 @@ -import os -import glob -import subprocess -import shutil -import multiprocessing -import re -import bb -import tempfile -import oe.utils -import string - -class Dosocs2(PackageManager): - def __init__(self): - self.dosocs2_cmd = bb.utils.which(os.getenv('PATH'), "dosocs2") - dosocs2_init_cmd = "%s dbinit --no-confirm" % (self.smart_cmd) - bb.note(dosocs2_init_cmd) - try: - complementary_pkgs = subprocess.check_output(dosocs2_init_cmd, - stderr=subprocess.STDOUT, - shell=True) - return - except subprocess.CalledProcessError as e: - bb.fatal("Could not invoke dosocs2 dbinit Command " - "'%s' returned %d:\n%s" % (dosocs2_init_cmd, e.returncode, e.output)) - - def _invoke_dosocs2( self, spdx_file): - cmd = "%s oneshot %s" % (self.smart_cmd, args) - - p = subprocess.Popen(cmd.split(), - stdout=subprocess.PIPE, stderr=subprocess.PIPE) - dosocs2_output, dosocs2_error = p.communicate() - if p.returncode != 0: - return None - - dosocs2_output = dosocs2_output.decode('utf-8') - - f = codecs.open(spdx_file,'w','utf-8') - f.write(dosocs2_output) - - diff --git a/recipes-devtools/python/python-dosocs2-native_0.16.1.bb b/recipes-devtools/python/python-dosocs2-native_0.16.1.bb index 2c7f124..2a9aaf8 100644 --- a/recipes-devtools/python/python-dosocs2-native_0.16.1.bb +++ b/recipes-devtools/python/python-dosocs2-native_0.16.1.bb @@ -28,14 +28,13 @@ DEPENDS += "python-jinja2-native \ python-markupsafe-native \ python-magic-native " -python do_dosocs2_init(){ +python populate_sysroot_append() { import os import subprocess import bb import oe.utils import string - bb.note("*********PATH = %s!" % os.getenv('PATH')) dosocs2_cmd = bb.utils.which(os.getenv('PATH'), "dosocs2") dosocs2_init_cmd = "%s dbinit --no-confirm" % (dosocs2_cmd) bb.note(dosocs2_init_cmd) @@ -48,5 +47,3 @@ python do_dosocs2_init(){ bb.fatal("Could not invoke dosocs2 dbinit Command " "'%s' returned %d:\n%s" % (dosocs2_init_cmd, e.returncode, e.output)) } - -addtask do_dosocs2_init after do_populate_sysroot diff --git a/recipes-devtools/python/python-magic-5.22/0001-Modified-the-magic.py-for-dosocs2-to-fix-the-error-a.patch b/recipes-devtools/python/python-magic-5.22/0001-Modified-the-magic.py-for-dosocs2-to-fix-the-error-a.patch new file mode 100644 index 0000000..1383df4 --- /dev/null +++ b/recipes-devtools/python/python-magic-5.22/0001-Modified-the-magic.py-for-dosocs2-to-fix-the-error-a.patch @@ -0,0 +1,504 @@ +From ef5ad90f3aba98ae3e222f6b076377701997585b Mon Sep 17 00:00:00 2001 +From: Zheng Ruoqin <zhengrq.fnst@cn.fujitsu.com> +Date: Fri, 5 May 2017 02:23:24 +0900 +Subject: [PATCH] Modified the magic.py for dosocs2 to fix the error as + fowllowing. + +AttributeError: 'module' object has no attribute 'from_file' + +Signed-off-by: Zheng Ruoqin <zhengrq.fnst@cn.fujitsu.com> +--- + magic.py | 462 ++++++++++++++++++++++++++++++++------------------------ + 1 file changed, 262 insertions(+), 200 deletions(-) + +diff --git a/magic.py b/magic.py +index a17e8da..c6142a7 100644 +--- a/magic.py ++++ b/magic.py +@@ -1,221 +1,283 @@ +-#!/usr/bin/env python +-''' +-Python bindings for libmagic +-''' ++""" ++magic is a wrapper around the libmagic file identification library. + +-import ctypes ++See README for more information. + +-from ctypes import * +-from ctypes.util import find_library ++Usage: + ++>>> import magic ++>>> magic.from_file("testdata/test.pdf") ++'PDF document, version 1.2' ++>>> magic.from_file("testdata/test.pdf", mime=True) ++'application/pdf' ++>>> magic.from_buffer(open("testdata/test.pdf").read(1024)) ++'PDF document, version 1.2' ++>>> + +-def _init(): +- """ +- Loads the shared library through ctypes and returns a library +- L{ctypes.CDLL} instance +- """ +- return ctypes.cdll.LoadLibrary(find_library('magic')) +- +-_libraries = {} +-_libraries['magic'] = _init() +- +-# Flag constants for open and setflags +-MAGIC_NONE = NONE = 0 +-MAGIC_DEBUG = DEBUG = 1 +-MAGIC_SYMLINK = SYMLINK = 2 +-MAGIC_COMPRESS = COMPRESS = 4 +-MAGIC_DEVICES = DEVICES = 8 +-MAGIC_MIME_TYPE = MIME_TYPE = 16 +-MAGIC_CONTINUE = CONTINUE = 32 +-MAGIC_CHECK = CHECK = 64 +-MAGIC_PRESERVE_ATIME = PRESERVE_ATIME = 128 +-MAGIC_RAW = RAW = 256 +-MAGIC_ERROR = ERROR = 512 +-MAGIC_MIME_ENCODING = MIME_ENCODING = 1024 +-MAGIC_MIME = MIME = 1040 +-MAGIC_APPLE = APPLE = 2048 +- +-MAGIC_NO_CHECK_COMPRESS = NO_CHECK_COMPRESS = 4096 +-MAGIC_NO_CHECK_TAR = NO_CHECK_TAR = 8192 +-MAGIC_NO_CHECK_SOFT = NO_CHECK_SOFT = 16384 +-MAGIC_NO_CHECK_APPTYPE = NO_CHECK_APPTYPE = 32768 +-MAGIC_NO_CHECK_ELF = NO_CHECK_ELF = 65536 +-MAGIC_NO_CHECK_TEXT = NO_CHECK_TEXT = 131072 +-MAGIC_NO_CHECK_CDF = NO_CHECK_CDF = 262144 +-MAGIC_NO_CHECK_TOKENS = NO_CHECK_TOKENS = 1048576 +-MAGIC_NO_CHECK_ENCODING = NO_CHECK_ENCODING = 2097152 +- +-MAGIC_NO_CHECK_BUILTIN = NO_CHECK_BUILTIN = 4173824 +- +- +-class magic_set(Structure): +- pass +-magic_set._fields_ = [] +-magic_t = POINTER(magic_set) +- +-_open = _libraries['magic'].magic_open +-_open.restype = magic_t +-_open.argtypes = [c_int] +- +-_close = _libraries['magic'].magic_close +-_close.restype = None +-_close.argtypes = [magic_t] +- +-_file = _libraries['magic'].magic_file +-_file.restype = c_char_p +-_file.argtypes = [magic_t, c_char_p] +- +-_descriptor = _libraries['magic'].magic_descriptor +-_descriptor.restype = c_char_p +-_descriptor.argtypes = [magic_t, c_int] +- +-_buffer = _libraries['magic'].magic_buffer +-_buffer.restype = c_char_p +-_buffer.argtypes = [magic_t, c_void_p, c_size_t] +- +-_error = _libraries['magic'].magic_error +-_error.restype = c_char_p +-_error.argtypes = [magic_t] +- +-_setflags = _libraries['magic'].magic_setflags +-_setflags.restype = c_int +-_setflags.argtypes = [magic_t, c_int] +- +-_load = _libraries['magic'].magic_load +-_load.restype = c_int +-_load.argtypes = [magic_t, c_char_p] +- +-_compile = _libraries['magic'].magic_compile +-_compile.restype = c_int +-_compile.argtypes = [magic_t, c_char_p] +- +-_check = _libraries['magic'].magic_check +-_check.restype = c_int +-_check.argtypes = [magic_t, c_char_p] +- +-_list = _libraries['magic'].magic_list +-_list.restype = c_int +-_list.argtypes = [magic_t, c_char_p] +- +-_errno = _libraries['magic'].magic_errno +-_errno.restype = c_int +-_errno.argtypes = [magic_t] +- +- +-class Magic(object): +- def __init__(self, ms): +- self._magic_t = ms +- +- def close(self): +- """ +- Closes the magic database and deallocates any resources used. +- """ +- _close(self._magic_t) + +- def file(self, filename): +- """ +- Returns a textual description of the contents of the argument passed +- as a filename or None if an error occurred and the MAGIC_ERROR flag +- is set. A call to errno() will return the numeric error code. +- """ +- try: # attempt python3 approach first +- if isinstance(filename, bytes): +- bi = filename +- else: +- bi = bytes(filename, 'utf-8') +- return str(_file(self._magic_t, bi), 'utf-8') +- except: +- return _file(self._magic_t, filename.encode('utf-8')) +- +- def descriptor(self, fd): +- """ +- Like the file method, but the argument is a file descriptor. +- """ +- return _descriptor(self._magic_t, fd) ++""" + +- def buffer(self, buf): +- """ +- Returns a textual description of the contents of the argument passed +- as a buffer or None if an error occurred and the MAGIC_ERROR flag +- is set. A call to errno() will return the numeric error code. +- """ +- try: # attempt python3 approach first +- return str(_buffer(self._magic_t, buf, len(buf)), 'utf-8') +- except: +- return _buffer(self._magic_t, buf, len(buf)) ++import sys ++import glob ++import os.path ++import ctypes ++import ctypes.util ++import threading + +- def error(self): +- """ +- Returns a textual explanation of the last error or None +- if there was no error. +- """ +- try: # attempt python3 approach first +- return str(_error(self._magic_t), 'utf-8') +- except: +- return _error(self._magic_t) ++from ctypes import c_char_p, c_int, c_size_t, c_void_p + +- def setflags(self, flags): +- """ +- Set flags on the magic object which determine how magic checking +- behaves; a bitwise OR of the flags described in libmagic(3), but +- without the MAGIC_ prefix. + +- Returns -1 on systems that don't support utime(2) or utimes(2) +- when PRESERVE_ATIME is set. +- """ +- return _setflags(self._magic_t, flags) ++class MagicException(Exception): ++ def __init__(self, message): ++ super(MagicException, self).__init__(message) ++ self.message = message + +- def load(self, filename=None): +- """ +- Must be called to load entries in the colon separated list of database +- files passed as argument or the default database file if no argument +- before any magic queries can be performed. + +- Returns 0 on success and -1 on failure. +- """ +- return _load(self._magic_t, filename) ++class Magic: ++ """ ++ Magic is a wrapper around the libmagic C library. + +- def compile(self, dbs): +- """ +- Compile entries in the colon separated list of database files +- passed as argument or the default database file if no argument. +- Returns 0 on success and -1 on failure. +- The compiled files created are named from the basename(1) of each file +- argument with ".mgc" appended to it. +- """ +- return _compile(self._magic_t, dbs) ++ """ + +- def check(self, dbs): +- """ +- Check the validity of entries in the colon separated list of +- database files passed as argument or the default database file +- if no argument. +- Returns 0 on success and -1 on failure. ++ def __init__(self, mime=False, magic_file=None, mime_encoding=False, ++ keep_going=False, uncompress=False): + """ +- return _check(self._magic_t, dbs) ++ Create a new libmagic wrapper. + +- def list(self, dbs): ++ mime - if True, mimetypes are returned instead of textual descriptions ++ mime_encoding - if True, codec is returned ++ magic_file - use a mime database other than the system default ++ keep_going - don't stop at the first match, keep going ++ uncompress - Try to look inside compressed files. + """ +- Check the validity of entries in the colon separated list of +- database files passed as argument or the default database file +- if no argument. +- Returns 0 on success and -1 on failure. +- """ +- return _list(self._magic_t, dbs) +- +- def errno(self): ++ self.flags = MAGIC_NONE ++ if mime: ++ self.flags |= MAGIC_MIME ++ elif mime_encoding: ++ self.flags |= MAGIC_MIME_ENCODING ++ if keep_going: ++ self.flags |= MAGIC_CONTINUE ++ ++ if uncompress: ++ self.flags |= MAGIC_COMPRESS ++ ++ self.cookie = magic_open(self.flags) ++ self.lock = threading.Lock() ++ ++ magic_load(self.cookie, magic_file) ++ ++ def from_buffer(self, buf): + """ +- Returns a numeric error code. If return value is 0, an internal +- magic error occurred. If return value is non-zero, the value is +- an OS error code. Use the errno module or os.strerror() can be used +- to provide detailed error information. ++ Identify the contents of `buf` + """ +- return _errno(self._magic_t) +- ++ with self.lock: ++ try: ++ return magic_buffer(self.cookie, buf) ++ except MagicException as e: ++ return self._handle509Bug(e) ++ ++ def from_file(self, filename): ++ # raise FileNotFoundException or IOError if the file does not exist ++ with open(filename): ++ pass ++ with self.lock: ++ try: ++ return magic_file(self.cookie, filename) ++ except MagicException as e: ++ return self._handle509Bug(e) ++ ++ def _handle509Bug(self, e): ++ # libmagic 5.09 has a bug where it might fail to identify the ++ # mimetype of a file and returns null from magic_file (and ++ # likely _buffer), but also does not return an error message. ++ if e.message is None and (self.flags & MAGIC_MIME): ++ return "application/octet-stream" ++ ++ def __del__(self): ++ # no _thread_check here because there can be no other ++ # references to this object at this point. ++ ++ # during shutdown magic_close may have been cleared already so ++ # make sure it exists before using it. ++ ++ # the self.cookie check should be unnecessary and was an ++ # incorrect fix for a threading problem, however I'm leaving ++ # it in because it's harmless and I'm slightly afraid to ++ # remove it. ++ if self.cookie and magic_close: ++ magic_close(self.cookie) ++ self.cookie = None ++ ++_instances = {} ++ ++def _get_magic_type(mime): ++ i = _instances.get(mime) ++ if i is None: ++ i = _instances[mime] = Magic(mime=mime) ++ return i ++ ++def from_file(filename, mime=False): ++ """" ++ Accepts a filename and returns the detected filetype. Return ++ value is the mimetype if mime=True, otherwise a human readable ++ name. ++ ++ >>> magic.from_file("testdata/test.pdf", mime=True) ++ 'application/pdf' ++ """ ++ m = _get_magic_type(mime) ++ return m.from_file(filename) + +-def open(flags): ++def from_buffer(buffer, mime=False): + """ +- Returns a magic object on success and None on failure. +- Flags argument as for setflags. ++ Accepts a binary string and returns the detected filetype. Return ++ value is the mimetype if mime=True, otherwise a human readable ++ name. ++ ++ >>> magic.from_buffer(open("testdata/test.pdf").read(1024)) ++ 'PDF document, version 1.2' + """ +- return Magic(_open(flags)) ++ m = _get_magic_type(mime) ++ return m.from_buffer(buffer) ++ ++ ++ ++ ++libmagic = None ++# Let's try to find magic or magic1 ++dll = ctypes.util.find_library('magic') or ctypes.util.find_library('magic1') or ctypes.util.find_library('cygmagic-1') ++ ++# This is necessary because find_library returns None if it doesn't find the library ++if dll: ++ libmagic = ctypes.CDLL(dll) ++ ++if not libmagic or not libmagic._name: ++ windows_dlls = ['magic1.dll','cygmagic-1.dll'] ++ platform_to_lib = {'darwin': ['/opt/local/lib/libmagic.dylib', ++ '/usr/local/lib/libmagic.dylib'] + ++ # Assumes there will only be one version installed ++ glob.glob('/usr/local/Cellar/libmagic/*/lib/libmagic.dylib'), ++ 'win32': windows_dlls, ++ 'cygwin': windows_dlls } ++ for dll in platform_to_lib.get(sys.platform, []): ++ try: ++ libmagic = ctypes.CDLL(dll) ++ break ++ except OSError: ++ pass ++ ++if not libmagic or not libmagic._name: ++ # It is better to raise an ImportError since we are importing magic module ++ raise ImportError('failed to find libmagic. Check your installation') ++ ++magic_t = ctypes.c_void_p ++ ++def errorcheck_null(result, func, args): ++ if result is None: ++ err = magic_error(args[0]) ++ raise MagicException(err) ++ else: ++ return result ++ ++def errorcheck_negative_one(result, func, args): ++ if result is -1: ++ err = magic_error(args[0]) ++ raise MagicException(err) ++ else: ++ return result ++ ++ ++def coerce_filename(filename): ++ if filename is None: ++ return None ++ ++ # ctypes will implicitly convert unicode strings to bytes with ++ # .encode('ascii'). If you use the filesystem encoding ++ # then you'll get inconsistent behavior (crashes) depending on the user's ++ # LANG environment variable ++ is_unicode = (sys.version_info[0] <= 2 and ++ isinstance(filename, unicode)) or \ ++ (sys.version_info[0] >= 3 and ++ isinstance(filename, str)) ++ if is_unicode: ++ return filename.encode('utf-8') ++ else: ++ return filename ++ ++magic_open = libmagic.magic_open ++magic_open.restype = magic_t ++magic_open.argtypes = [c_int] ++ ++magic_close = libmagic.magic_close ++magic_close.restype = None ++magic_close.argtypes = [magic_t] ++ ++magic_error = libmagic.magic_error ++magic_error.restype = c_char_p ++magic_error.argtypes = [magic_t] ++ ++magic_errno = libmagic.magic_errno ++magic_errno.restype = c_int ++magic_errno.argtypes = [magic_t] ++ ++_magic_file = libmagic.magic_file ++_magic_file.restype = c_char_p ++_magic_file.argtypes = [magic_t, c_char_p] ++_magic_file.errcheck = errorcheck_null ++ ++def magic_file(cookie, filename): ++ return _magic_file(cookie, coerce_filename(filename)) ++ ++_magic_buffer = libmagic.magic_buffer ++_magic_buffer.restype = c_char_p ++_magic_buffer.argtypes = [magic_t, c_void_p, c_size_t] ++_magic_buffer.errcheck = errorcheck_null ++ ++def magic_buffer(cookie, buf): ++ return _magic_buffer(cookie, buf, len(buf)) ++ ++ ++_magic_load = libmagic.magic_load ++_magic_load.restype = c_int ++_magic_load.argtypes = [magic_t, c_char_p] ++_magic_load.errcheck = errorcheck_negative_one ++ ++def magic_load(cookie, filename): ++ return _magic_load(cookie, coerce_filename(filename)) ++ ++magic_setflags = libmagic.magic_setflags ++magic_setflags.restype = c_int ++magic_setflags.argtypes = [magic_t, c_int] ++ ++magic_check = libmagic.magic_check ++magic_check.restype = c_int ++magic_check.argtypes = [magic_t, c_char_p] ++ ++magic_compile = libmagic.magic_compile ++magic_compile.restype = c_int ++magic_compile.argtypes = [magic_t, c_char_p] ++ ++ ++ ++MAGIC_NONE = 0x000000 # No flags ++MAGIC_DEBUG = 0x000001 # Turn on debugging ++MAGIC_SYMLINK = 0x000002 # Follow symlinks ++MAGIC_COMPRESS = 0x000004 # Check inside compressed files ++MAGIC_DEVICES = 0x000008 # Look at the contents of devices ++MAGIC_MIME = 0x000010 # Return a mime string ++MAGIC_MIME_ENCODING = 0x000400 # Return the MIME encoding ++MAGIC_CONTINUE = 0x000020 # Return all matches ++MAGIC_CHECK = 0x000040 # Print warnings to stderr ++MAGIC_PRESERVE_ATIME = 0x000080 # Restore access time on exit ++MAGIC_RAW = 0x000100 # Don't translate unprintable chars ++MAGIC_ERROR = 0x000200 # Handle ENOENT etc as real errors ++ ++MAGIC_NO_CHECK_COMPRESS = 0x001000 # Don't check for compressed files ++MAGIC_NO_CHECK_TAR = 0x002000 # Don't check for tar files ++MAGIC_NO_CHECK_SOFT = 0x004000 # Don't check magic entries ++MAGIC_NO_CHECK_APPTYPE = 0x008000 # Don't check application type ++MAGIC_NO_CHECK_ELF = 0x010000 # Don't check for elf details ++MAGIC_NO_CHECK_ASCII = 0x020000 # Don't check for ascii files ++MAGIC_NO_CHECK_TROFF = 0x040000 # Don't check ascii/troff ++MAGIC_NO_CHECK_FORTRAN = 0x080000 # Don't check ascii/fortran ++MAGIC_NO_CHECK_TOKENS = 0x100000 # Don't check ascii/tokens +-- +1.8.4.2 + diff --git a/recipes-devtools/python/python-magic_5.22.bb b/recipes-devtools/python/python-magic_5.22.bb index 5e0a4a2..57591a6 100644 --- a/recipes-devtools/python/python-magic_5.22.bb +++ b/recipes-devtools/python/python-magic_5.22.bb @@ -9,6 +9,7 @@ LICENSE = "BSD" LIC_FILES_CHKSUM = "file://setup.py;md5=1cf0577ca152455b257b815fcc8517de" SRC_URI = "ftp://ftp.astron.com/pub/file/file-${PV}.tar.gz \ + file://0001-Modified-the-magic.py-for-dosocs2-to-fix-the-error-a.patch \ " SRC_URI[md5sum] = "8fb13e5259fe447e02c4a37bc7225add" |