Exemplo n.º 1
0
    def get_version(rel_url, ext_path, refs):
        if 'tag' in refs:
            return

        bare_svn = False
        if git_externals[rel_url]["vcs"] == "svn":
            revision = command('svnversion', '-c').strip()
            match = re_from_svnversion.search(revision)
            if match:
                revision = "svn:r" + match.group(2)  # 565:56555 -> svn:r56555
                bare_svn = True
            else:
                message = git("log", "--format=%b", "--grep", "git-svn-id:", "-1")
                match = re_from_git_svn_id.search(message)
                if match:
                    revision = "svn:r" + match.group(1)
                else:
                    here = os.path.relpath(os.getcwd(), repo_root)
                    error("Unsupported external format, svn or git-svn repo expected:\n\t{}".format(here))
        else:
            branch_name = current_branch()
            remote_name = git("config", "branch.%s.remote" % branch_name)
            revision = git("log", "%s/%s" % (remote_name, branch_name), "-1", "--format=%H")

        info("Freeze {0} at {1}".format(rel_url, revision))
        if messages and not bare_svn:
            old = resolve_revision(git_externals[rel_url]["ref"])
            new = resolve_revision(revision)
            git("log", "--format=- %h %s", "{}..{}".format(old, new), capture=False)
        git_externals[rel_url]["ref"] = revision
Exemplo n.º 2
0
def gitext_update(recursive, gitsvn, reset):
    """Update the working copy cloning externals if needed and create the desired layout using symlinks
    """
    from git_externals import externals_sanity_check, root_path, is_workingtree_clean, foreach_externals, gitext_up

    externals_sanity_check()
    root = root_path()

    if reset:
        git('reset', '--hard')

    # Aggregate in a list the `clean flags` of all working trees (root + externals)
    clean = [is_workingtree_clean(root, fail_on_empty=False)]
    foreach_externals(root,
                      lambda u, p, r: clean.append(
                          is_workingtree_clean(p, fail_on_empty=False)),
                      recursive=recursive)

    if reset or all(clean):
        # Proceed with update if everything is clean
        try:
            gitext_up(recursive, reset=reset, use_gitsvn=gitsvn)
        except ProgError as e:
            error(str(e), exitcode=e.errcode)
    else:
        echo(
            "Cannot perform git externals update because one or more repositories contain some local modifications"
        )
        echo("Run:\tgit externals status\tto have more information")
Exemplo n.º 3
0
    def get_version(rel_url, ext_path, refs):
        if 'tag' in refs:
            return

        if git_externals[rel_url]["vcs"] == "svn":
            revision = command('svnversion', '-c').strip()
            match = re_from_svnversion.search(revision)
            if match:
                revision = "svn:r" + match.group(2)  # 565:56555 -> svn:r56555
            else:
                message = git("log", "--format=%b", "--grep", "git-svn-id:",
                              "-1")
                match = re_from_git_svn_id.search(message)
                if match:
                    revision = "svn:r" + match.group(1)
                else:
                    error(
                        "Unsupported external format, should be svn or git-svn repo"
                    )
        else:
            branch_name = current_branch()
            remote_name = git("config", "branch.%s.remote" % branch_name)
            revision = git("log", "%s/%s" % (remote_name, branch_name), "-1",
                           "--format=%H")

        info("Freeze {0} at {1}".format(rel_url, revision))
        git_externals[rel_url]["ref"] = revision
Exemplo n.º 4
0
def gitext_update(recursive, gitsvn, reset):
    """Update the working copy cloning externals if needed and create the desired layout using symlinks
    """
    from git_externals import externals_sanity_check, root_path, is_workingtree_clean, foreach_externals, gitext_up

    externals_sanity_check()
    root = root_path()

    if reset:
        git('reset', '--hard')

    # Aggregate in a list the `clean flags` of all working trees (root + externals)
    clean = [is_workingtree_clean(root, fail_on_empty=False)]
    foreach_externals(root,
        lambda u, p, r: clean.append(is_workingtree_clean(p, fail_on_empty=False)),
        recursive=recursive)

    if reset or all(clean):
        # Proceed with update if everything is clean
        try:
            gitext_up(recursive, reset=reset, use_gitsvn=gitsvn)
        except ProgError as e:
            error(str(e), exitcode=e.errcode)
    else:
        echo("Cannot perform git externals update because one or more repositories contain some local modifications")
        echo("Run:\tgit externals status\tto have more information")
    def build(self):
        if self.args.target is None:
            print('No default target expecting something like "x86_64-unknown-elf"')
            return 1

        self.args.installPrefixDir = '{}/{}'.format(
                self.args.installPrefixDir, self.args.target)
        dst_dir = os.path.join(self.args.installPrefixDir, 'bin')
        os.makedirs(dst_dir, exist_ok=True)
        retval = 0

        self.args.app = '{}-{}'.format(self.args.target, self.args.app)

        try:
            dst = os.path.join(dst_dir, self.args.app)
            output = subprocess.check_output([dst, '--version'],
                    stderr=subprocess.STDOUT)
            if output is None:
                output = b''
        except BaseException as err:
            output = b''

        if not self.args.forceInstall and bytes(self.args.ver, 'utf-8') in output:
            print('{app} {ver} is already installed'
                    .format(app=self.args.app, ver=self.args.ver))
        else:
            print('compiling {app} {ver}'
                    .format(app=self.args.app, ver=self.args.ver))
            code_dir = os.path.join(self.args.codePrefixDir,
                    '{}/{}'.format(self.args.crossDir, self.args.target))
            if self.args.forceInstall:
                shutil.rmtree(code_dir, ignore_errors=True)
            os.makedirs(code_dir)

            if self.args.target == X86_64_TARGET or self.args.target == I386_TARGET:
                # Get gcc from git which supports attribute(interrupt)
                # gcc_path must match GCC_CUSTOM_LOCATION in config.x86_64-unknown-elf
                gcc_path = os.path.expanduser(os.path.join('~/prgs', 'ct-ng-gcc'))
                shutil.rmtree(gcc_path, ignore_errors=True)
                print('gcc_install: gcc_path=', gcc_path)
                utils.git('clone', [GCC_GIT_REPO_URL, gcc_path, '--depth', '1', '--single-branch',
                    '--branch', CHECKOUT_LABEL])
                os.chdir(gcc_path)
                
            thisDir = os.path.dirname(os.path.realpath(__file__))
            src = os.path.abspath('{}/config.{}'.format(thisDir, self.args.target))
            dst = os.path.abspath('{}/.config'.format(code_dir))
            print('config src=', src)
            print('config dst=', dst)
            shutil.copy2(src, dst)
            os.chdir(code_dir)

            # Build and install app's
            subprocess.check_call(['ct-ng', 'build.4'])

        return retval
Exemplo n.º 6
0
 def get_status(rel_url, ext_path, targets):
     try:
         if porcelain:
             echo(rel_url)
             click.echo(git('status', '--porcelain'))
         elif verbose or not is_workingtree_clean(ext_path):
             info("External {}".format(get_repo_name(rel_url)))
             echo(git('status', '--untracked-files=no' if not verbose else ''))
     except CommandError as err:
         error(str(err), exitcode=err.errcode)
Exemplo n.º 7
0
 def get_status(rel_url, ext_path, targets):
     try:
         if porcelain:
             echo(rel_url)
             click.echo(git('status', '--porcelain'))
         elif verbose or not is_workingtree_clean(ext_path):
             info("External {}".format(get_repo_name(rel_url)))
             echo(
                 git('status',
                     '--untracked-files=no' if not verbose else ''))
     except CommandError as err:
         error(str(err), exitcode=err.errcode)
    def install(self):
        dst_dir = os.path.join(self.args.installPrefixDir, 'bin')
        os.makedirs(dst_dir, exist_ok=True)
        retval = 0

        try:
            theApp = AN_APP
            if self.args.target != '':
                theApp = '{}-{}'.format(self.args.target, theApp)

            theApp = os.path.join(dst_dir, theApp)
            output = subprocess.check_output([theApp, '--version'],
                    stderr=subprocess.STDOUT)
            if output is None:
                output = b''
        except BaseException as err:
            output = b''

        if not self.args.forceInstall and bytes(self.args.ver, 'utf-8') in output:
            print('{app} {ver} is already installed'
                    .format(app=self.args.app, ver=self.args.ver))
        else:
            print('compiling {app} {ver}'
                    .format(app=self.args.app, ver=self.args.ver))
            code_dir = self.args.codePrefixDir
            if self.args.target != '':
                code_dir = os.path.join(code_dir, self.args.target)
            code_dir = os.path.join(code_dir, self.args.app)
            if self.args.forceInstall:
                shutil.rmtree(code_dir, ignore_errors=True)
            os.makedirs(code_dir)

            utils.git('clone', [URL, code_dir])
            os.chdir(code_dir)
            version = self.args.ver.replace('.','_')
            utils.git('checkout', ['binutils-{}'.format(version)])
            os.mkdir('build')
            os.chdir('build')

            configureCmd = '../configure --prefix={} --disable-nls'.format(
                    self.args.installPrefixDir)
            if self.args.target != '':
                configureCmd += ' --target={}'.format(self.args.target)
            subprocess.run(configureCmd,
                    shell=True,
                    stdout=subprocess.DEVNULL) # Too much logging overflows 4MB travis-ci log limit
            subprocess.run('make all -j {}'.format(multiprocessing.cpu_count()),
                    shell=True,
                    stdout=subprocess.DEVNULL) # Too much logging overflows 4MB travis-ci log limit
            utils.bash('make install')

        return retval
Exemplo n.º 9
0
 def __init__(self):
     print('---> saving to github')
     git(['pull', '--allow-unrelated-history', 'origin', 'dev'])
     git(['add', '.'])
     git(['commit', '-m', 'octoblog-save'])
     git(['push', 'origin', 'dev'])
     print('---> done')
    def install(self):
        dst_dir = os.path.join(self.args.installPrefixDir, 'bin')
        os.makedirs(dst_dir, exist_ok=True)
        retval = 0

        try:
            dst = os.path.join(dst_dir, self.args.app)
            output = subprocess.check_output([dst, 'version'],
                    stderr=subprocess.STDOUT)
            if output is None:
                output = b''
        except BaseException as err:
            output = b''

        if not self.args.forceInstall and bytes(self.args.ver, 'utf-8') in output:
            print('{app} {ver} is already installed'
                    .format(app=self.args.app, ver=self.args.ver))
        else:
            print('compiling {app} {ver}'
                    .format(app=self.args.app, ver=self.args.ver))
            code_dir = os.path.join(self.args.codePrefixDir, self.args.app)
            if self.args.forceInstall:
                shutil.rmtree(code_dir, ignore_errors=True)
            os.makedirs(code_dir)

            utils.git('clone', [URL, code_dir])
            os.chdir(code_dir)
            if CHECKOUT_SHA1:
              checkout_ver = self.args.ver
            else:
              checkout_ver = 'crosstool-ng-{}'.format(self.args.ver)
            utils.git('checkout', [checkout_ver])

            subprocess.check_call(['./bootstrap'])
            subprocess.check_call(['./configure', '--prefix={}'.format(self.args.installPrefixDir)])
            subprocess.check_call(['make'])
            subprocess.check_call(['make', 'install'])

        return retval
Exemplo n.º 11
0
    def get_version(rel_url, ext_path, refs):
        if 'tag' in refs:
            return

        bare_svn = False
        if git_externals[rel_url]["vcs"] == "svn":
            revision = command('svnversion', '-c').strip()
            match = re_from_svnversion.search(revision)
            if match:
                revision = "svn:r" + match.group(2)  # 565:56555 -> svn:r56555
                bare_svn = True
            else:
                message = git("log", "--format=%b", "--grep", "git-svn-id:",
                              "-1")
                match = re_from_git_svn_id.search(message)
                if match:
                    revision = "svn:r" + match.group(1)
                else:
                    here = os.path.relpath(os.getcwd(), repo_root)
                    error(
                        "Unsupported external format, svn or git-svn repo expected:\n\t{}"
                        .format(here))
        else:
            branch_name = current_branch()
            remote_name = git("config", "branch.%s.remote" % branch_name)
            revision = git("log", "%s/%s" % (remote_name, branch_name), "-1",
                           "--format=%H")

        info("Freeze {0} at {1}".format(rel_url, revision))
        if messages and not bare_svn:
            old = resolve_revision(git_externals[rel_url]["ref"])
            new = resolve_revision(revision)
            git("log",
                "--format=- %h %s",
                "{}..{}".format(old, new),
                capture=False)
        git_externals[rel_url]["ref"] = revision
Exemplo n.º 12
0
        print('gcc-install: mpfr_path=', mpfr_path)
        mpc_path = os.path.join(os.path.dirname(args.o.src), 'mpc')
        print('gcc-install: mpc_path=', mpc_path)

        try:
            utils.wget_extract(GMP_URL, dst_path=gmp_path)
            utils.wget_extract(MPFR_URL, dst_path=mpfr_path)
            utils.wget_extract(MPC_URL, dst_path=mpc_path)
            if True:
                # Use wget as its faster
                utils.wget_extract(GCC_URL.format(args.o.ver), dst_path=args.o.src)
                os.chdir(args.o.src)
            else:
                # Use git, but this was slower
                os.makedirs(args.o.src, exist_ok=True)
                utils.git('clone', [GCC_GIT_REPO_URL, args.o.src])
                os.chdir(args.o.src)
                utils.git('checkout', [CHECKOUT_LABEL])

            # Create the build directory and cd into it
            os.mkdir('build')
            os.chdir('build')
        except BaseException as ex:
            traceback.print_exc()
            exit(1)

        # ls the directory with gcc, gmp, mpfr and mpc for debug purposes
        #utils.bash('ls -al {}'.format(os.path.dirname(args.o.src)))

        try:
            print('gcc-install: configure')
Exemplo n.º 13
0
        output = subprocess.check_output([dst, '--version'])
        if output is None:
            output = b''
    except BaseException as err:
        output = b''

    if bytes(args.o.ver, 'utf-8') in output:
        print('{app} {ver} is already installed'.format(app=args.o.src, ver=VER))
        exit(0)
    else:
        print('compiling {app} {ver}'.format(app=args.o.src, ver=VER))
        os.makedirs(args.o.src, exist_ok=True)

        try:
            url = 'git://sourceware.org/git/binutils-gdb.git'
            utils.git('clone', [url, args.o.src])
            os.chdir(args.o.src)
            version = VER.replace('.','_')
            utils.git('checkout', ['binutils-{ver}'.format(ver=version)])
            os.mkdir('build')
            os.chdir('build')
        except BaseException as ex:
            traceback.print_exc()
            exit(1)

        print('configure')
        utils.bash('../configure --prefix={0} --target={1} --disable-nls'
                .format(args.o.prefix, TARGET))
        utils.bash('make all -j {}'.format(multiprocessing.cpu_count()))
        utils.bash('make install')
Exemplo n.º 14
0
def enable_colored_output():
    from git_externals import externals_root_path, get_entries

    for entry in get_entries():
        with chdir(os.path.join(externals_root_path(), entry)):
            git('config', 'color.ui', 'always')
Exemplo n.º 15
0
        output = subprocess.check_output([dst, '--version'])
        if output is None:
            output = b''
    except BaseException as err:
        output = b''

    if bytes(args.o.ver, 'utf-8') in output:
        print('{app} {ver} is already installed'.format(app=args.o.src, ver=VER))
        exit(0)
    else:
        print('compiling {app} {ver}'.format(app=args.o.src, ver=VER))
        os.makedirs(args.o.src, exist_ok=True)

        try:
            url = 'git://git.qemu.org/qemu.git'
            utils.git('clone', [url, args.o.src])
            os.chdir(args.o.src)
            utils.git('checkout', ['v{ver}'.format(ver=VER)])
            utils.git('submodule', ['update', '--init', 'dtc'])
            os.mkdir('build')
            os.chdir('build')
        except BaseException as ex:
            traceback.print_exc()
            exit(1)

        print('configure')
        utils.bashPython2(
                '../configure --prefix={} --target-list=arm-softmmu,arm-linux-user'
                .format(args.o.prefix))
        utils.bashPython2('make -j {}'.format(multiprocessing.cpu_count()))
        utils.bashPython2('make install')
Exemplo n.º 16
0
def gitext_diff(external):
    """Call git diff on the given externals"""
    from git_externals import iter_externals
    for _ in iter_externals(external):
        click.echo(git('diff'))
Exemplo n.º 17
0
    def __init__(self):
        git(['checkout', 'master'])
        git(['commit', '--allow-empty', '-m', 'octoblog-publish notification'])
        git(['checkout', 'dev'])

        print('---> generating blog to www/ directory')
        clear_dir('www')
        config = json.load(open('config.json', 'r'))
        generate_html(config, 'www')
        print('---> done')

        SaveCommand()

        print('---> pushing contents of www/ to master')
        git(['checkout', 'master'])
        clear_dir(os.getcwd())
        git(['checkout', 'dev', '--', 'www'])
        flatten('www')
        git(['add', '.'])
        git(['commit', '-m', '"octoblog-publish files"'])
        git(['push', 'origin', 'master'])
        git(['checkout', 'dev'])
        print('---> done')
Exemplo n.º 18
0
    def _fresh_blog_push(self, remote):
        git(['init'])
        git(['add', '.gitignore'])
        git(['commit', '-m', '"initial commit"'])
        git(['remote', 'add', 'origin', remote])
        git(['push', '-u', 'origin', 'master'])

        git(['branch', 'dev'])
        git(['checkout', 'dev'])
        git(['add', '.'])
        git(['commit', '-m', '"initial commit"'])
        git(['push', '-u', 'origin', 'dev'])
Exemplo n.º 19
0
 def __init__(self, remote):
     git(['clone', remote, '.'])
     git(['checkout', 'dev'])
Exemplo n.º 20
0
def gitext_diff(external):
    """Call git diff on the given externals"""
    from git_externals import iter_externals
    for _ in iter_externals(external):
        click.echo(git('diff'))
Exemplo n.º 21
0
    try:
        output = subprocess.check_output([dst, "--version"])
        if output is None:
            output = b""
    except BaseException as err:
        output = b""

    if bytes(args.o.ver, "utf-8") in output:
        print("{app} {ver} is already installed".format(app=APP, ver=args.o.ver))
        exit(0)
    else:
        print("compiling {app} {ver}".format(app=APP, ver=args.o.ver))
        url = "https://github.com/martine/ninja.git"
        os.makedirs(args.o.src, exist_ok=True)

        utils.git("clone", [url, args.o.src])
        os.chdir(args.o.src)

        try:
            subprocess.check_call(["./configure.py", "--bootstrap"])
        except:
            traceback.print_exc()
            exit(1)

        dst = os.path.abspath(args.o.prefix + "/bin")
        os.makedirs(dst, exist_ok=True)
        dst = os.path.abspath(dst + "/{app}".format(app=APP))
        try:
            shutil.copy2("./{app}".format(app=APP), dst)
        except OSError as err:
            traceback.print_exc()
Exemplo n.º 22
0
def enable_colored_output():
    from git_externals import externals_root_path, get_entries

    for entry in get_entries():
        with chdir(os.path.join(externals_root_path(), entry)):
            git('config', 'color.ui', 'always')
Exemplo n.º 23
0
    def install(self):
        dst_dir = os.path.join(self.args.installPrefixDir, 'bin')
        os.makedirs(dst_dir, exist_ok=True)
        retval = 0

        self.parseUnknownArgs()

        try:
            theApp = AN_APP
            if self.args.target != '':
                theApp = '{}-{}'.format(self.args.target, theApp)

            theApp = os.path.join(dst_dir, theApp)
            output = subprocess.check_output([theApp, '--version'],
                    stderr=subprocess.STDOUT)
            if output is None:
                output = b''
        except BaseException as err:
            output = b''

        if not self.args.forceInstall and bytes(self.args.ver, 'utf-8') in output:
            print('{app} {ver} is already installed'
                    .format(app=self.args.app, ver=self.args.ver))
        else:
            code_dir = self.args.codePrefixDir
            if self.args.target != '':
                code_dir = os.path.join(code_dir, self.args.target)
            gmp_path = os.path.join(code_dir, 'gmp')
            print('gcc_install: gmp_path=', gmp_path)
            mpfr_path = os.path.join(code_dir, 'mpfr')
            print('gcc_install: mpfr_path=', mpfr_path)
            mpc_path = os.path.join(code_dir, 'mpc')
            print('gcc_install: mpc_path=', mpc_path)
            #isl does't compile and its optional so don't add
            #isl_path = os.path.join(code_dir, 'isl')
            #print('gcc_install: isl_path=', isl_path)
            gcc_path = os.path.join(code_dir, 'gcc')
            print('gcc_install: gcc_path=', gcc_path)

            #envVars = ('LDFLAGS=-L/home/wink/opt/lib' +
            #          ' CPPFLAGS=-I/home/wink/opt/include')
            envVars = ''

            # If desired make false when testing so we don't download.
            if True:
                if self.args.forceInstall:
                    shutil.rmtree(gmp_path, ignore_errors=True)
                    shutil.rmtree(mpfr_path, ignore_errors=True)
                    shutil.rmtree(mpc_path, ignore_errors=True)
                    #shutil.rmtree(isl_path, ignore_errors=True)
                    shutil.rmtree(gcc_path, ignore_errors=True)

                utils.wget_extract(GMP_URL, dst_path=gmp_path)
                utils.wget_extract(MPFR_URL, dst_path=mpfr_path)
                utils.wget_extract(MPC_URL, dst_path=mpc_path)
                #utils.wget_extract(ISL_URL, dst_path=isl_path)
                if True:
                    # Use wget as its faster
                    utils.wget_extract(GCC_URL.format(self.args.ver), dst_path=gcc_path)
                    os.chdir(gcc_path)
                else:
                    # Use git, but its slower
                    os.makedirs(self.args.codePrefixDir, exist_ok=True)
                    utils.git('clone', [GCC_GIT_REPO_URL, gcc_path])
                    os.chdir(gcc_path)
                    utils.git('checkout', [CHECKOUT_LABEL])

            # Make the prerequisites (isl is optional)
            #self.makePrerequisiteLibrary(envVars, isl_path, os.path.dirname(self.args.installPrefixDir))

            # Make the prerequisites (Not needed if I install existing versions??)
            #self.makePrerequisiteLibrary(envVars, gmp_path, os.path.dirname(self.args.installPrefixDir))
            #self.makePrerequisiteLibrary(envVars, mpfr_path, os.path.dirname(self.args.installPrefixDir))
            #self.makePrerequisiteLibrary(envVars, mpc_path, os.path.dirname(self.args.installPrefixDir))

            # Create the build directory and cd into it
            os.chdir(gcc_path)
            os.makedirs('build', exist_ok=True)
            os.chdir('build')

            # ls the directory with gcc, gmp, mpfr and mpc for debug purposes
            #utils.bash('ls -al {}'.format(os.path.dirname(self.args.codePrefixDir)))

            cmd = ('{env}' +
                   ' ../configure --prefix={prefix}' +
                   ' --with-gmp={gmp}' +
                   ' --with-gmp-include={gmp}' +
                   ' --with-mpfr={mpfr}' +
                   ' --with-mpfr-include={mpfr}/src' +
                   ' --with-mpc={mpc}' +
                   ' --with-mpc-include={mpc}/src' +
                   #' --with-isl={isl}' +
                   #' --with-isl-include={isl}/include' +
                   ' --disable-nls ' +
                   ' --enable-languages=c,c++' +
                   ' --disable-multilib' +
                   ' --without-headers').format(
                           env=envVars, prefix=self.args.installPrefixDir, gmp=gmp_path, mpfr=mpfr_path,
                           mpc=mpc_path) #, isl=isl_path)
            if self.args.target != '':
                cmd += ' --target={}'.format(self.args.target)

            # Add extraFlags added on the command line
            for extraFlag in self.extraArgs.extraGccConfigFlags:
                cmd += ' {}'.format(extraFlag)

            # Add extraFlags passed to the constructor
            for extraFlag in self.extraFlags:
                cmd += ' {}'.format(extraFlag)
            self.runCmd(cmd)

            cpu_count = multiprocessing.cpu_count()
            cci = os.environ.get('CIRCLECI')
            if cci != None and cci == 'true':
                cpu_count = 4;

            self.runCmd('{env} make all-gcc -j {c}'
                    .format(env=envVars, c=cpu_count), verbose=True)

            self.runCmd('{env} make install-gcc'
                    .format(env=envVars))

            self.runCmd('{env} make all-target-libgcc -j {c}'
                    .format(env=envVars, c=cpu_count))

            self.runCmd('{env} make install-target-libgcc'
                    .format(env=envVars))

        return 0