示例#1
0
文件: buildTest.py 项目: sdinc/viz3d
 def test_main(self):
     '''
     Test main with no arguments
     '''
     old_args = sys.argv
     sys.argv = ['']
     build.main()
     sys.argv = old_args
示例#2
0
文件: buildTest.py 项目: sdinc/viz3d
 def test_main(self):
     '''
     Test main with no arguments
     '''
     old_args = sys.argv
     sys.argv = ['']
     build.main()
     sys.argv = old_args
示例#3
0
def main():
  parser = argparse.ArgumentParser()
  parser.add_argument('--example', default='dashboard')
  parser.add_argument('--jwm-version', default=None)
  parser.add_argument('--skija-version', default='0.98.0')
  parser.add_argument('--skija-dir', default=None)
  parser.add_argument('--types-dir', default=None)
  args = parser.parse_args()

  if not args.jwm_version:
    build.main()

  if args.skija_dir:
    skija_dir = os.path.abspath(args.skija_dir)
  
  os.chdir(common.basedir)

  # compile
  classpath = common.deps_compile()
  
  if args.jwm_version:
    classpath += [
      build_utils.fetch_maven('io.github.humbleui.jwm', 'jwm', args.jwm_version)
    ]
  else:
    classpath += [
      'target/classes',
      build_utils.system + '/build'
    ]

  if args.skija_dir:
    classpath += [
      skija_dir + '/platform/build',
      skija_dir + '/platform/target/classes',
      skija_dir + '/shared/target/classes',
    ]
  else:
    skija_native = 'skija-' + build_utils.system + (('-' + build_utils.arch) if 'macos' == build_utils.system else '')
    classpath += [
      build_utils.fetch_maven('io.github.humbleui', 'skija-shared', args.skija_version),
      build_utils.fetch_maven('io.github.humbleui', skija_native, args.skija_version),
    ]
  sources = build_utils.files(f'examples/{args.example}/java/**/*.java')
  build_utils.javac(sources, f'examples/{args.example}/target/classes', classpath = classpath, release='16')
  
  # run
  subprocess.check_call([
    'java',
    '--class-path', build_utils.classpath_join(classpath + [f'examples/{args.example}/target/classes']),
    '-Djava.awt.headless=true',
    '-enableassertions',
    '-enablesystemassertions',
    '-Dfile.encoding=UTF-8',
    '-Xcheck:jni',
    'io.github.humbleui.jwm.examples.Example'
  ])

  return 0
示例#4
0
 def test_main(self):
     '''
     execute main
     '''
     import build
     old_args = sys.argv
     sys.argv = ['buildrun', '--test-env', '-b', '-c', '-d', '-e', '-f']
     build.main()
     sys.argv = old_args
示例#5
0
 def test_printhelp(self):
     '''
     print the help
     '''
     import build
     old_args = sys.argv
     sys.argv = ['buildrun']
     build.main()
     sys.argv = old_args
def continuous_build(should_run):
    """

    :type should_run: Event
    """
    import build

    while should_run['now']:
        build.main()
        sleep(1)
示例#7
0
def main():
    # Get the branch name
    name = raw_input('Enter in branch name: ')
    print util.log('Checking to new branch')
    # Attempt to checkout branch
    print subprocess.check_output(['git', 'checkout', '-b', name])
    # Once done, push to new branch
    print util.log('Pushing to remote branch')
    # If it's updated, let's go through with the next process
    print subprocess.check_output(['git', 'push', 'origin', 'HEAD'])
    print util.log('Update build')
    build.main()
示例#8
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--dry-run", action="store_true")
    (args, _) = parser.parse_known_args()

    # Build
    build.main()

    # Update poms
    rev = revision.revision()

    os.chdir(common.root + '/platform')
    artifact = "skija-" + common.classifier

    with common.replaced(
            'deploy/META-INF/maven/org.jetbrains.skija/' + artifact +
            '/pom.xml', {'${version}': rev}):
        with common.replaced(
                'deploy/META-INF/maven/org.jetbrains.skija/' + artifact +
                '/pom.properties', {'${version}': rev}):
            with open(
                    'target/classes/org/jetbrains/skija/' +
                    common.classifier.replace('-', '/') + '/skija.version',
                    'w') as f:
                f.write(rev)

            print("Packaging " + artifact + "-" + rev + ".jar")
            subprocess.check_call([
                "jar", "--create", "--file",
                "target/" + artifact + "-" + rev + ".jar", "-C",
                "target/classes", ".", "-C", "deploy",
                "META-INF/maven/org.jetbrains.skija/" + artifact
            ])

            if not args.dry_run:
                print("Deploying", artifact + "-" + rev + ".jar")
                subprocess.check_call([
                    common.mvn,
                    "--batch-mode",
                    "--settings",
                    "deploy/settings.xml",
                    "-Dspace.username="******"USER_NAME"),
                    "-Dspace.password="******"SPACE_TOKEN"),
                    "deploy:deploy-file",
                    "-Dfile=target/" + artifact + "-" + rev + ".jar",
                    "-DpomFile=deploy/META-INF/maven/org.jetbrains.skija/" +
                    artifact + "/pom.xml",
                    "-DrepositoryId=space-maven",
                    "-Durl=" + common.space_skija,
                ])

    return 0
示例#9
0
文件: main.py 项目: zzwei1/nuwrf
def build_from_tarball(my_build, target):
    apps_dir = ""
    nuwrf_dir = os.environ.get("NUWRFDIR")
    if "discover" in platform.node() or "borg" in platform.node():
        apps_dir = "/discover/nobackup/projects/nu-wrf/external_apps/"
    if os.path.isfile(apps_dir + target + ".tgz"):
        os.chdir(nuwrf_dir)
        tf = tarfile.open(apps_dir + target + ".tgz")
        tf.extractall()
        build.main(my_build, target)
    else:
        logger.error(apps_dir + target + ".tgz not found!\n"
                     "To build, place tarball named " + target +
                     ".tgz in {} and re-run command".format(nuwrf_dir))
示例#10
0
def main():
    ruby_version = subprocess.check_output(['cat', '.ruby-version'
                                            ]).replace('\n', '')
    # Sets up ruby
    print util.log('Installing ruby ' + ruby_version)
    print subprocess.check_output(['rvm', 'install', ruby_version])
    # Sets up rvm
    print util.log('Use Ruby ' + ruby_version)
    subprocess.call(['./bin/use-rvm.sh'])
    # Install bundle
    print util.log('Install Bundle')
    print subprocess.check_output(['gem', 'install', 'bundler'])
    # Install gems
    build.main()
示例#11
0
def main():
    # Save option
    option = int(show_menu())
    # Go through
    if option == 1:
        devmenu.main()
    elif option == 2:
        merge.main()
    elif option == 3:
        build.main()
    elif option == 4:
        setup.main()
    elif option == 5:
        quit()
示例#12
0
def run_tests(args):
  # Update node modules if needed.
  if not shakaBuildHelpers.update_node_modules():
    return 1

  # Generate dependencies and compile library.
  # This is required for the tests.
  if gendeps.gen_deps([]) != 0:
    return 1

  build_args = []
  if '--force' in args:
    build_args.append('--force')
    args.remove('--force')

  if '--no-build' in args:
    args.remove('--no-build')
  else:
    if build.main(build_args) != 0:
      return 1

  if '--runs' in args:
    return run_tests_multiple(args)
  else:
    return run_tests_single(args)
示例#13
0
def run_tests(args):
    # Update node modules if needed.
    if not shakaBuildHelpers.update_node_modules():
        return 1

    # Generate dependencies and compile library.
    # This is required for the tests.
    if gendeps.gen_deps([]) != 0:
        return 1

    build_args = []
    if '--force' in args:
        build_args.append('--force')
        args.remove('--force')

    if '--no-build' in args:
        args.remove('--no-build')
    else:
        if build.main(build_args) != 0:
            return 1

    if '--runs' in args:
        return run_tests_multiple(args)
    else:
        return run_tests_single(args)
示例#14
0
def main() -> Tuple[str, str, str]:
    build.main()

    os.chdir(common.basedir)

    build_utils.copy_replace(
        "deploy/META-INF/maven/io.github.humbleui/jwm/pom.xml",
        "target/maven/META-INF/maven/io.github.humbleui/jwm/pom.xml",
        {"${version}": common.version})

    build_utils.copy_replace(
        "deploy/META-INF/maven/io.github.humbleui/jwm/pom.properties",
        "target/maven/META-INF/maven/io.github.humbleui/jwm/pom.properties",
        {"${version}": common.version})

    jar = build_utils.jar(f"target/jwm-{common.version}.jar",
                          ("target/classes", "."),
                          ("target/maven", "META-INF"))

    build_utils.makedirs("target/src/io/github/humbleui/jwm")
    shutil.copytree("linux/java",
                    "target/src/io/github/humbleui/jwm",
                    dirs_exist_ok=True)
    shutil.copytree("macos/java",
                    "target/src/io/github/humbleui/jwm",
                    dirs_exist_ok=True)
    shutil.copytree("shared/java",
                    "target/src/io/github/humbleui/jwm",
                    dirs_exist_ok=True)
    shutil.copytree("windows/java",
                    "target/src/io/github/humbleui/jwm",
                    dirs_exist_ok=True)
    sources = build_utils.jar(f"target/jwm-{common.version}-sources.jar",
                              ("target/src", "."),
                              ("target/maven", "META-INF"))

    build_utils.delombok(["target/src"],
                         "target/delomboked",
                         classpath=common.deps_compile())
    build_utils.javadoc(["target/delomboked"],
                        "target/apidocs",
                        classpath=common.deps_compile())
    javadoc = build_utils.jar(f"target/jwm-{common.version}-javadoc.jar",
                              ("target/apidocs", "."),
                              ("target/maven", "META-INF"))

    return (jar, sources, javadoc)
示例#15
0
文件: test.py 项目: JetBrains/skija
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--skija-version')
    (args, _) = parser.parse_known_args()

    modulepath = []
    if args.skija_version:
        modulepath += [
            common.fetch_maven('org.jetbrains.skija',
                               'skija-shared',
                               args.skija_version,
                               repo=common.space_skija),
            common.fetch_maven('org.jetbrains.skija',
                               'skija-' + common.classifier,
                               args.skija_version,
                               repo=common.space_skija)
        ]
    else:
        build.main()
        modulepath += [
            '../shared/target/classes', '../platform/target/classes'
        ]

    os.chdir(common.root + '/tests')
    sources = common.glob('java', '*.java')
    common.javac(sources,
                 'target/classes',
                 modulepath=modulepath,
                 add_modules=[common.module])

    common.check_call([
        'java',
        # '--class-path', common.classpath_separator.join(modulepath + ['target/classes']),
        '--class-path',
        'target/classes',
        '--module-path',
        common.classpath_separator.join(modulepath),
        '--add-modules',
        common.module
    ] + (['-XstartOnFirstThread'] if 'macos' == common.system else []) + [
        '-Djava.awt.headless=true', '-enableassertions',
        '-enablesystemassertions', '-Xcheck:jni', '-Dskija.logLevel=DEBUG',
        'org.jetbrains.skija.test.TestSuite'
    ])

    return 0
示例#16
0
def main():
	
	# Clean, then build. Couldn't be simpler!
	
	error = clean.main()
	if error!=0:
		return error
	return build.main()
示例#17
0
def main(args):
  parser = argparse.ArgumentParser(
      description='User facing build script for building the Shaka'
                  ' Player Project.')

  parser.add_argument(
      '--force',
      '-f',
      help='Force building the library even if no files have changed.',
      action='store_true')

  parser.add_argument(
      '--debug',
      help='Limit which build types to build. Will at least build the debug '
           'version.',
      action='store_true')

  parser.add_argument(
      '--release',
      help='Limit which build types to build. Will at least build the '
           'release version.',
      action='store_true')

  parsed_args = parser.parse_args(args)

  code = gendeps.gen_deps([])
  if code != 0:
    return code

  code = check.main([])
  if code != 0:
    return code

  build_args = ['--name', 'compiled', '+@complete']

  if parsed_args.force:
    build_args += ['--force']

  # Create the list of build modes to build with. If the list is empty
  # by the end, then populate it with every mode.
  modes = []
  modes += ['debug'] if parsed_args.debug else []
  modes += ['release'] if parsed_args.release else []

  # If --debug or --release are not given, build with everything.
  if not modes:
    modes += ['debug', 'release']

  result = 0

  for mode in modes:
    result = build.main(build_args + ['--mode', mode])

    # If a build fails then there is no reason to build the other modes.
    if result:
      break

  return result
示例#18
0
def main(args):
  parser = argparse.ArgumentParser(
      description='User facing build script for building the Shaka'
                  ' Player Project.')

  parser.add_argument(
      '--force',
      '-f',
      help='Force building the library even if no files have changed.',
      action='store_true')

  parser.add_argument(
      '--debug',
      help='Limit which build types to build. Will at least build the debug '
           'version.',
      action='store_true')

  parser.add_argument(
      '--release',
      help='Limit which build types to build. Will at least build the '
           'release version.',
      action='store_true')

  parsed_args = parser.parse_args(args)

  code = gendeps.gen_deps([])
  if code != 0:
    return code

  code = check.main([])
  if code != 0:
    return code

  build_args = ['--name', 'compiled', '+@complete']

  if parsed_args.force:
    build_args += ['--force']

  # Create the list of build modes to build with. If the list is empty
  # by the end, then populate it with every mode.
  modes = []
  modes += ['--debug'] if parsed_args.debug else []
  modes += ['--release'] if parsed_args.release else []

  # If --debug or --release are not given, build with everything.
  if not modes:
    modes += ['--debug', '--release']

  result = 0

  for mode in modes:
    result = build.main(build_args + [mode])

    # If a build fails then there is no reason to build the other modes.
    if result:
      break

  return result
示例#19
0
def main(cmd_line_args):
    """Description of t main setup process
     - get all absolute paths of foxBMS repositories
     - clone all repositories or general and specified ones
     - build documentation (sphinx, and Doxygen for both microcontrollers) if
       not otherwise specified

    Args:
        cmd_line_args (Namespace): Arguments passed by the command line
    """
    if cmd_line_args.verbosity == 1:
        logging.basicConfig(level=logging.INFO)
    elif cmd_line_args.verbosity > 1:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.WARNING)

    if cmd_line_args.specfiy_software_branch:
        global SW_VERSION
        SW_VERSION = cmd_line_args.specfiy_software_branch
    if cmd_line_args.specfiy_hardware_branch:
        global HW_VERSION
        HW_VERSION = cmd_line_args.specfiy_hardware_branch

    repository_basepath, setup_repo_name = get_main_git_path()

    logging.info(PRINT_MARK)
    logging.info('Setting up the foxBMS project in directory')
    logging.info(os.path.dirname(os.path.realpath(__file__)))
    logging.info(PRINT_MARK)

    # setup general software dependency repositories
    repo_list = read_yaml()
    for repos in repo_list:
        yaml_repos_abspath = set_git_paths(repository_basepath, repos[0])
        setup_repo_class(repos[0], yaml_repos_abspath, repos[1], repos[2])

    if cmd_line_args.specfiy_repos:
        info = 'specified repositories'
        setup_repo_class(specified_repos, specified_repos_abspath, info)

    if not cmd_line_args.dont_build_documentation:
        builders = ['--primary', '--secondary', '--doxygen', '--sphinx']
        build.main(builders)
示例#20
0
def main(_):
  code = gendeps.genDeps([])
  if code != 0:
    return code

  code = check.main([])
  if code != 0:
    return code

  return build.main(['--name', 'compiled', '+@complete'])
示例#21
0
def main(_):
    code = gendeps.genDeps([])
    if code != 0:
        return code

    code = check.main([])
    if code != 0:
        return code

    return build.main(['--name', 'compiled', '+@complete'])
示例#22
0
    def RunCommand(self, karma_conf):
        """Build a command and send it to Karma for execution.

       Uses |self.parsed_args| and |self.karma_config| to build and run a Karma
       command.
    """
        if self.parsed_args.use_xvfb and not shakaBuildHelpers.is_linux():
            logging.error('xvfb can only be used on Linux')
            return 1

        if not shakaBuildHelpers.update_node_modules():
            logging.error('Failed to update node modules')
            return 1

        karma = shakaBuildHelpers.get_node_binary('karma')
        cmd = ['xvfb-run', '--auto-servernum'
               ] if self.parsed_args.use_xvfb else []
        cmd += karma + ['start']
        cmd += [karma_conf] if karma_conf else []
        cmd += ['--settings', json.dumps(self.karma_config)]

        # There is no need to print a status here as the gendep and build
        # calls will print their own status updates.
        if self.parsed_args.build:
            if gendeps.main([]) != 0:
                logging.error('Failed to generate project dependencies')
                return 1

            if build.main(['--force'] if self.parsed_args.force else []) != 0:
                logging.error('Failed to build project')
                return 1

        # Before Running the command, print the command.
        if self.parsed_args.print_command:
            logging.info('Karma Run Command')
            logging.info('%s', cmd)

        # Run the command.
        results = []
        for run in range(self.parsed_args.runs):
            logging.info('Running test (%d / %d, %d failed so far)...',
                         run + 1, self.parsed_args.runs,
                         len(results) - results.count(0))
            results.append(shakaBuildHelpers.execute_get_code(cmd))

        # Print a summary of the results.
        if self.parsed_args.runs > 1:
            logging.info('All runs completed. %d / %d runs passed.',
                         results.count(0), len(results))
            logging.info('Results (exit code): %r', results)
        else:
            logging.info('Run complete')
            logging.info('Result (exit code): %d', results[0])

        return 0 if all(result == 0 for result in results) else 1
示例#23
0
def main(args):
    command = ""
    if len(args) > 1 :
        command = args[1]

    if command == "create":
        return create.main(args)
    elif command == "build":
        return build.main(args)
    else:
        return help.main(args)
示例#24
0
def main():
    import sys
    if len(sys.argv) != 2:
        print help
        sys.exit(2)
        raise

    path = sys.argv[1]

    from build import main
    main()

    import os
    pwd = os.path.abspath(os.curdir)
    export = os.path.join(pwd, 'EXPORT')

    from utils.install import copy_all, build_envs_sh
    copy_all(export, path)

    build_envs_sh(path)
    return
示例#25
0
def main():
    # Install homebrew
    print util.log('Installing Homebrew')
    brew = subprocess.check_output(['which', 'brew']).replace('\n', '')
    if brew == '/usr/local/bin/brew':
        print subprocess.check_output(['brew', 'update'])
    else:
        print subprocess.check_output([
            '/usr/bin/ruby', '-e',
            '"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"'
        ])
    # Set up vapor
    print util.log('Installing Vapor')
    install_package('vapor')
    # Setup other dependicies
    print util.log('Installing dependencies')
    install_package('postgresql')
    install_package('redis')
    install_package('libpq')
    # attempt to build
    build.main()
示例#26
0
  def RunCommand(self, karma_conf):
    """Build a command and send it to Karma for execution.

       Uses |self.parsed_args| and |self.karma_config| to build and run a Karma
       command.
    """
    if self.parsed_args.use_xvfb and not shakaBuildHelpers.is_linux():
      logging.error('xvfb can only be used on Linux')
      return 1

    if not shakaBuildHelpers.update_node_modules():
      logging.error('Failed to update node modules')
      return 1

    karma = shakaBuildHelpers.get_node_binary('karma')
    cmd = ['xvfb-run', '--auto-servernum'] if self.parsed_args.use_xvfb else []
    cmd += karma + ['start']
    cmd += [karma_conf] if karma_conf else []
    cmd += ['--settings', json.dumps(self.karma_config)]

    # There is no need to print a status here as the gendep and build
    # calls will print their own status updates.
    if self.parsed_args.build:
      if gendeps.gen_deps([]) != 0:
        logging.error('Failed to generate project dependencies')
        return 1

      if build.main(['--force'] if self.parsed_args.force else []) != 0:
        logging.error('Failed to build project')
        return 1

    # Before Running the command, print the command.
    if self.parsed_args.print_command:
      logging.info('Karma Run Command')
      logging.info('%s', cmd)

    # Run the command.
    results = []
    for run in range(self.parsed_args.runs):
      logging.info('Running test (%d / %d)...', run + 1, self.parsed_args.runs)
      results.append(shakaBuildHelpers.execute_get_code(cmd))

    # Print a summary of the results.
    if self.parsed_args.runs > 1:
      logging.info('All runs completed. %d / %d runs passed.',
                   results.count(0),
                   len(results))
      logging.info('Results (exit code): %r', results)
    else:
      logging.info('Run complete')
      logging.info('Result (exit code): %d', results[0])

    return 0 if all(result == 0 for result in results) else 1
示例#27
0
def main(args):
    code = gendeps.gen_deps([])
    if code != 0:
        return code

    code = check.main([])
    if code != 0:
        return code

    build_args = ['--name', 'compiled', '+@complete']

    if '--force' in args:
        build_args.append('--force')

    if '--debug' in args or '--release' not in args:
        if build.main(build_args + ['--debug']) != 0:
            return 1
    if '--release' in args or '--debug' not in args:
        if build.main(build_args) != 0:
            return 1

    return 0
示例#28
0
def runTests(args):
    """Runs all the karma tests."""
    # Update node modules if needed.
    if not shakaBuildHelpers.updateNodeModules():
        return 1

    # Generate dependencies and compile library.
    # This is required for the tests.
    if gendeps.genDeps([]) != 0:
        return 1

    build_args = []
    if '--force' in args:
        build_args.append('--force')
        args.remove('--force')

    if '--no-build' in args:
        args.remove('--no-build')
    else:
        if build.main(build_args) != 0:
            return 1

    karma_command_name = 'karma'
    if shakaBuildHelpers.isWindows():
        # Windows karma program has a different name
        karma_command_name = 'karma.cmd'

    karma_path = shakaBuildHelpers.getNodeBinaryPath(karma_command_name)
    cmd = [karma_path, 'start']

    # Get the browsers supported on the local system.
    browsers = _GetBrowsers()
    if not browsers:
        print >> sys.stderr, 'Unrecognized system "%s"' % platform.uname()[0]
        return 1

    print 'Starting tests...'
    if len(args) == 0:
        # Run tests in all available browsers.
        print 'Running with platform default:', '--browsers', browsers
        cmdLine = cmd + ['--browsers', browsers]
        shakaBuildHelpers.printCmdLine(cmdLine)
        return subprocess.call(cmdLine)
    else:
        # Run with command-line arguments from the user.
        if '--browsers' not in args:
            print 'No --browsers specified.'
            print 'In this mode, browsers must be manually connected to karma.'
        cmdLine = cmd + args
        shakaBuildHelpers.printCmdLine(cmdLine)
        return subprocess.call(cmdLine)
示例#29
0
def runTests(args):
  """Runs all the karma tests."""
  # Update node modules if needed.
  if not shakaBuildHelpers.updateNodeModules():
    return 1

  # Generate dependencies and compile library.
  # This is required for the tests.
  if gendeps.genDeps([]) != 0:
    return 1

  build_args = []
  if '--force' in args:
    build_args.append('--force')
    args.remove('--force')

  if '--no-build' in args:
    args.remove('--no-build')
  else:
    if build.main(build_args) != 0:
      return 1

  karma_command_name = 'karma'
  if shakaBuildHelpers.isWindows():
    # Windows karma program has a different name
    karma_command_name = 'karma.cmd'

  karma_path = shakaBuildHelpers.getNodeBinaryPath(karma_command_name)
  cmd = [karma_path, 'start']

  # Get the browsers supported on the local system.
  browsers = _GetBrowsers()
  if not browsers:
    print >> sys.stderr, 'Unrecognized system "%s"' % platform.uname()[0]
    return 1

  print 'Starting tests...'
  if len(args) == 0:
    # Run tests in all available browsers.
    print 'Running with platform default:', '--browsers', browsers
    cmdLine = cmd + ['--browsers', browsers]
    shakaBuildHelpers.printCmdLine(cmdLine)
    return subprocess.call(cmdLine)
  else:
    # Run with command-line arguments from the user.
    if '--browsers' not in args:
      print 'No --browsers specified.'
      print 'In this mode, browsers must be manually connected to karma.'
    cmdLine = cmd + args
    shakaBuildHelpers.printCmdLine(cmdLine)
    return subprocess.call(cmdLine)
示例#30
0
def run_tests(args):
    """Runs all the karma tests."""
    # Update node modules if needed.
    if not shakaBuildHelpers.update_node_modules():
        return 1

    # Generate dependencies and compile library.
    # This is required for the tests.
    if gendeps.gen_deps([]) != 0:
        return 1

    build_args = []
    if "--force" in args:
        build_args.append("--force")
        args.remove("--force")

    if "--no-build" in args:
        args.remove("--no-build")
    else:
        if build.main(build_args) != 0:
            return 1

    karma_command_name = "karma"
    if shakaBuildHelpers.is_windows():
        # Windows karma program has a different name
        karma_command_name = "karma.cmd"

    karma_path = shakaBuildHelpers.get_node_binary_path(karma_command_name)
    cmd = [karma_path, "start"]

    # Get the browsers supported on the local system.
    browsers = _get_browsers()
    if not browsers:
        print >> sys.stderr, 'Unrecognized system "%s"' % platform.uname()[0]
        return 1

    print "Starting tests..."
    if not args:
        # Run tests in all available browsers.
        print "Running with platform default:", "--browsers", browsers
        cmd_line = cmd + ["--browsers", browsers]
        shakaBuildHelpers.print_cmd_line(cmd_line)
        return subprocess.call(cmd_line)
    else:
        # Run with command-line arguments from the user.
        if "--browsers" not in args:
            print "No --browsers specified."
            print "In this mode, browsers must be manually connected to karma."
        cmd_line = cmd + args
        shakaBuildHelpers.print_cmd_line(cmd_line)
        return subprocess.call(cmd_line)
示例#31
0
def run_tests_single(args):
    """Runs all the karma tests."""
    # Update node modules if needed.
    if not shakaBuildHelpers.update_node_modules():
        return 1

    # Generate dependencies and compile library.
    # This is required for the tests.
    if gendeps.gen_deps([]) != 0:
        return 1

    build_args = []
    if '--force' in args:
        build_args.append('--force')
        args.remove('--force')

    if '--no-build' in args:
        args.remove('--no-build')
    else:
        if build.main(build_args) != 0:
            return 1

    karma_path = shakaBuildHelpers.get_node_binary_path('karma')
    cmd = [karma_path, 'start']

    if shakaBuildHelpers.is_linux() and '--use-xvfb' in args:
        cmd = ['xvfb-run', '--auto-servernum'] + cmd

    # Get the browsers supported on the local system.
    browsers = _get_browsers()
    if not browsers:
        print >> sys.stderr, 'Unrecognized system "%s"' % platform.uname()[0]
        return 1

    print 'Starting tests...'
    if not args:
        # Run tests in all available browsers.
        print 'Running with platform default:', '--browsers', browsers
        cmd_line = cmd + ['--browsers', browsers]
        shakaBuildHelpers.print_cmd_line(cmd_line)
        return subprocess.call(cmd_line)
    else:
        # Run with command-line arguments from the user.
        if '--browsers' not in args:
            print 'No --browsers specified.'
            print 'In this mode, browsers must be manually connected to karma.'
        cmd_line = cmd + args
        shakaBuildHelpers.print_cmd_line(cmd_line)
        return subprocess.call(cmd_line)
示例#32
0
def main(args):
  code = gendeps.gen_deps([])
  if code != 0:
    return code

  code = check.main([])
  if code != 0:
    return code

  build_args = ['--name', 'compiled', '+@complete']

  if '--force' in args:
    build_args.append('--force')

  return build.main(build_args)
示例#33
0
def main(args):
    code = gendeps.gen_deps([])
    if code != 0:
        return code

    code = check.main([])
    if code != 0:
        return code

    build_args = ['--name', 'compiled', '+@complete']

    if '--force' in args:
        build_args.append('--force')

    return build.main(build_args)
示例#34
0
文件: BepBop.py 项目: Plawn/nginx_gui
def start_server():
    print('starting development server...')
    print('starting first compile')
    build.main([], 'First build -> ')

    class build_handler(FileSystemEventHandler):
        def on_any_event(self, event):
            build.main([], helper.nice_date())

    observer = Observer()
    observer.schedule(build_handler(), path='pages', recursive=True)
    observer.start()
    observer2 = Observer()
    observer2.schedule(build_handler(), path='static', recursive=True)
    observer2.start()

    try:
        while True:
            time.sleep(0.1)
    except KeyboardInterrupt:
        print('Gracefully exiting')
        observer.stop()

    observer.join()
示例#35
0
def aho_corasick(blob, outfolder):
    count = 0
    state = build.main(images.types)
    for n in range(0, len(blob)):
        while state.g(blob[n]) is None:
            state = state.f
        state = state.g(blob[n])
        if state.output:
            if images.image.Image.verbose:
                print("Found magic for " + str(state.output) +
                      " at " + str(n) + ", ")
            for t in state.output:
                # We're at the last character in the needle,
                # figure out the offset of the start of the blob
                offset = n - len(t.magic) + 1
                l = t.calculate_length(blob, offset)
                if l > 0:
                    name = outfolder + '/image' + str(count) + t.get_extension()
                    f = open(name, 'wb')
                    f.write(blob[offset:offset+l])
                    f.close()
                    print("Saved %d-byte image to %s" % (l, name))
                    count += 1
    return count
示例#36
0
#    Realm667 - An Awesome Awesomeness
#    Copyright (C) 2015, 2016 Alexey Lysiuk
#
#    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 <http://www.gnu.org/licenses/>.
#

import os
import sys

if (sys.hexversion < 0x2070000
        or 0x3000000 <= sys.hexversion < 0x3020000):
    print('This script requires Python 2.7 or Python 3.2 and higher')
    exit(1)

# all modules are in the lib directory
sys.path[0] = os.path.dirname(os.path.abspath(__file__)) + '/lib'

import build
build.main()
示例#37
0
文件: test.py 项目: RTCXH/build.py
#!/usr/bin/python3

import build

build.main(__name__, __file__)


class Config(build.Config):
    languages = ['python']
示例#38
0
def main(argv):
    try:
        if '-h' in argv or '--help' in argv:
            return run_nose(argv)

        sb = Sandbox(SBROOT)

        #Add different options for using an appliance to run a test
        #more info about this can be found at
        #https:// ... /working-with-code/concepts/existing-appliances/run-tests-using-an-appliance # TODO refer to correct doc site
        #TODO move all the info below into the above website.
        #
        #This can
        #  speed things up when creating test
        #  Allows one to debug a test with a full appliance
        #  can be used to run tests with an appliance setup from a variety of repos
        #
        #This does not
        #  Replace the current system of running tests off of a sandbox as an appliance
        #  Does not leave behind it's files in a way that is easy to inspect
        #  Is not as reproducable of an environment
        #
        #The different options available are
        #  --setup sets up appliances to run tests off of, as well as some
        #  other setup options related to tests
        #  --sb-setup same as --setup, but is specific to the current sandbox
        #  --ip ipaddress --ea applianceName --user username --passwd password 
        #  accomplishes the same thing as --setup, but without going through the interactive prompts 
        #  --no-adding-args using --setup sb test can be set up to automatically add
        #  arguments when you run sb test, this prevents that from happening
        #  --app someApplianceName the setup file created with --setup or --sb-setup
        #  maps a user defined name with the appliance credentials. You can specify the name
        #  of one of those appliances to run test off of, or you can use a new name and 
        #  a brand new appliance will be created and used. You can then reuse that appliance as many times as desired
        #  --recreate-psa this can only be used with an appliance that was previously created
        #  with the above command. This restores the VM to a snapshot before any PSA RPMs were
        #  copied over and installed, the VM then refetches all of the necessary RPMs and
        #  installs them
        #  --branding someBranding --release release_branch these can be used to specify the branding and release
        #  branch when creating a PSA
        #  --repo this can be used instead of the above command to specify a different repo to install off of
        #  this command overrides any branding or release branches that were specified with the above command
        
        if '--setup' in argv:
            argv.remove('--setup')
            isetup.defaultSetup()
            print '\n'
            sys.exit('setup is complete')
        if '--sb-setup' in argv:
            argv.remove('--sb-setup')
            isetup.sbSetup()
            print '\n'
            sys.exit('setup is complete')
        global addingArgs
        if '--no-adding-args' in argv:
            addingArgs = False
            argv.remove('--no-adding-args')
        if addingArgs:
            argsToAdd = getAdditionalArgs()
            if argsToAdd:
                added = ''
                for arg in argsToAdd.split():
                    if arg not in argv:
                        added += ' ' + arg
                        argv.append(arg)
                if added:
                    print 'added', added
        global_vars.ea = None
        ip = None
        user = None
        passwd = None

        def retreiveAndDelArg(arg):
            for i, tryArg in enumerate(argv):
                if tryArg == arg:
                    ret = argv[i + 1]
                    del argv[i]
                    del argv[i]
            return ret

        branding = None
        release = None
        repo = None
        
        for i, arg in enumerate(argv):
            if arg == '--ea' or arg == '--psa':
                global_vars.ea = argv[i + 1]
                del argv[i]
                del argv[i]
        for i, arg in enumerate(argv):                
            if arg == '--ip' or arg == '--host':
                ip = argv[i + 1]
                del argv[i]
                del argv[i]
        for i, arg in enumerate(argv):       
            if arg == '--user':
                user = argv[i + 1]
                del argv[i]
                del argv[i]
        for i, arg in enumerate(argv):                
            if arg == '--passwd' or arg == '--password':
                passwd = argv[i + 1]
                del argv[i]
                del argv[i]

        for i, arg in enumerate(argv):
            if arg == '--release':
                release = argv[i + 1]
                del argv[i]
                del argv[i]
        for i, arg in enumerate(argv):
            if arg == '--branding':
                branding = argv[i + 1]
                del argv[i]
                del argv[i]
        for i, arg in enumerate(argv):
            if arg == '--repo':
                repo = argv[i + 1]
                del argv[i]
                del argv[i]
                
        if global_vars.ea and ip and user and passwd:
            setup.setSetupFile()
            setup.configAppliance(global_vars.ea, ip, user, passwd)
      
        #make sure we're creating a new PSA if an appliance sandbox type is being used
        if 'appliance' in sb.get_sandboxtype().get_variant():
            global_vars.ea = 'sb-test-appliance'
            if '--recreate-psa' not in argv and global_vars.ea in isetup.getAppliances():
                argv.append('--recreate-psa')
        isetup.setSetupFile()
        
        #create the appliance if the appliance doesn't exist in the setup file
        if global_vars.ea and global_vars.ea not in isetup.getAppliances():
            ansi.printc('Appliance %s does not exist, will attempt to create it in 5 seconds, push ctrl+c to cancel' % global_vars.ea, colors.WARNING_COLOR)
            time.sleep(5)
            ip = controlVM.createPSA(global_vars.ea, branding, release, repo)
            isetup.setAppliance(global_vars.ea, ip, 'root', 'psa')
        if '--recreate-psa' in argv:
            assert global_vars.ea, 'A VM must be specified with the --ea option to use the --recreate-psa option'
            controlVM.createPSA(global_vars.ea, branding, release, repo)
            argv.remove('--recreate-psa')
            

        # Support "modes" of tests. This allows us to run a set of tests in
        # more than one way -- for example, with valgrind enabled or disabled,
        # or with SearchServer using hs5 versus hs3.
        mode_path = os.path.join(sb.get_root(), _MODE_FILE)
        argv, modes = get_modes(argv)
        if os.path.isfile(mode_path):
            os.remove(mode_path)
        if modes:
            if modes[0].lower() != 'none':
                with open(mode_path, 'w') as f:
                    f.write(','.join(modes))

        attr_arg = find_attr_arg_index(argv)
        if len(modes) == 0 and attr_arg is None:
            modeattrs = sb.get_sandboxtype().get_test_mode_attrs_combo()
            result = 0
            runcompiled = True
            runcodescan = True
            for modeattr in modeattrs.split(';'):
                runnable_assembly._modes = None
                if modeattr.find(':') == -1:
                    if len(modeattr) > 3:
                        print('Skipping mode+attr combo "%s" because no separator ":" was found' % modeattr)
                    continue
                print('Running mode+attr combo: %s' % modeattr)
                mode, attrs = modeattr.split(':')
                argnew = argv[:]#copy argv  into argnew so we can append things for this round of tests
                argnew.insert(1, '-A')
                argnew.insert(2, attrs.strip())
                argnew.insert(3, '--mode')
                argnew.insert(4, mode.strip())
                if not runcompiled:
                    argnew.append('--skip-compiled')
                if not runcodescan:
                    argnew.append('--skip-codescan')
                result = result + main(argnew);
                runcompiled = False
                runcodescan = False
                print("")
            if result == 0:
                print("All test combos passed.")
            else:
                print("%s test combos failed!" % result)
            return result
        elif attr_arg is None:
            argv.insert(1, '-A')
            attrs = sb.get_sandboxtype().get_test_attrs()
            argv.insert(2, attrs)
            print('Running tests that are: %s.' % attrs)
        else:
            # If we're running interactive tests, make sure we're also
            # running with the -s switch.
            print('Running tests that are: %s.' % argv[attr_arg + 1])
            x = argv[attr_arg + 1].replace('not ', '!')
            if 'interactive' in x and '!interactive' not in x:
                if '-s' not in argv:
                    argv.insert(1, '-s')

        if len(modes) > 0:
            if modes[0].lower() == 'none':
                modes = []

        print('Running modes: %s' % ','.join(modes))
        # Make sure any path args in the arg list are fully normalized so they
        # are not sensitive to working directory changes.
        normalize_path_args(argv)

        # If we're collecting tests, it's virtually guaranteed that we want to
        # display the list...
        if '--collect-only' in argv:
            if '-v' not in argv and '--verbose' not in argv:
                verbosity_found = False
                for a in argv:
                    if a.startswith('--verbosity'):
                        verbosity_found = True
                        break
                if not verbosity_found:
                    argv.append('--verbose')

        # The "full" flag tells us to test all components in the sandbox,
        # instead of just the ones that are present in code form. If our scope
        # is full, no special effort is required. However, if our scope is
        # normal (quick), we have to tell nose which subdirs to use during
        # discovery.
        if not SPECIFIC_TESTS_SELECTED:
            global quick
            if '--full' in argv:
                argv.remove('--full')
                quick = False
            if '--quick' in argv:
                quick = True
                argv.remove('--quick')
            if quick:
                subset = []
                cr = sb.get_code_root()
                tr = sb.get_test_root()
                deps = [l.name for l in sb.get_cached_components()]
                for c in deps:
                    if component.CODE_ASPECT_NAME in sb.get_component_aspects(c) or c == sb.get_top_component():
                        component_test_root = sb.get_component_path(c, component.TEST_ASPECT_NAME)
                        if os.path.isdir(component_test_root):
                            if could_have_tests(component_test_root):
                                # Nose treats the first --where arg as a specifier
                                # of the working directory, and subsequent --where
                                # args as folders to use for discovery. So if we're
                                # going to add --where, we have to guarantee working
                                # dir is the first --where.
                                if not subset:
                                    argv.append('--where')
                                    argv.append(sb.get_root())
                                argv.append('--where')
                                argv.append(component_test_root)
                                subset.append(c)
                if subset:
                    print('Targeting: ' + ', '.join(subset) + ' (--full to override).')

        # The default behavior of the "sb test" command is supposed to be that
        # all tests get run, no matter what part of the sandbox you're in when
        # you invoke the command. This is consistent with "sb build", "sb publish",
        # and other sandbox-level commands. By default, nose will discover tests
        # beginning in the current working directory. We could override nose's
        # behavior by adding an extra arg that specifies that the scope for
        # discovery is the test root, but this would interfere with other logic
        # that we have, that disables the running of compiled tests when any
        # sort of constraining file/directory scope is given. So the simplest
        # way to achieve our goal is to temporarily set the current working dir
        # to the test root whenever no explicit scope is provided.
        try:
            restore_dir = os.getcwd()
            os.chdir(sb.get_test_root())    # always run tests with the current directory being the test root

            if '--with-id' not in argv:
                argv.insert(1, '--with-id')
            if '--auto' in argv:
                argv.remove('--auto')
                auto_test(sb, argv)
            else:
                if '--build-first' in argv:
                    sb.set_auto_build(True)
                    argv.remove('--build-first')
                    err = build.main([])
                    if err:
                        return err
                elif '--no-build-first' in argv:
                    sb.set_auto_build(False)
                    argv.remove('--no-build-first')
                # Before running tests, automatically build sandbox if it's out of date.
                # This allows testers to get a built sandbox and immediately run tests. It
                # also allows developers to repeatedly code and test without explicitly
                # rebuilding in between.
                elif sb.needs_build() and sb.get_auto_build():
                    print('''
    Built artifacts are out of date and will be refreshed before running tests.
    To run tests without automatic build as needed, use "--no-build-first".
                ''')
                    err = build.main([])
                    if err:
                        return err

                return 0 if run_all(sb, argv) else 1

        finally:
            os.chdir(restore_dir)
    except:
        print(traceback.print_exc())
        return 1 # make sure bad things show up as an error
#!/usr/bin/env python

from build import CHECK, build_and_run, main
import sys

header = 'Race and BI-access checks'

def doit():
  checks = [CHECK.RACE, CHECK.BI_ACCESS]
  return build_and_run(checks)

def main_wrapper(argv):
  main(doit,header,argv)

if __name__ == '__main__':
  sys.exit(main(doit,header))
def main_wrapper(argv):
  main(doit,header,argv)
示例#41
0
 def run(self):
     """compile special java dependencies before the others."""
     java.main(path)
     develop.run(self)
示例#42
0
def main(args):
  parser = argparse.ArgumentParser(
      description='User facing build script for building the Shaka'
                  ' Player Project.')

  parser.add_argument(
      '--locales',
      type=str,
      nargs='+',
      default=generateLocalizations.DEFAULT_LOCALES,
      help='The list of locales to compile in (default %(default)r)')

  parser.add_argument(
      '--fix',
      help='Automatically fix style violations.',
      action='store_true')

  parser.add_argument(
      '--force',
      '-f',
      help='Force building the library even if no files have changed.',
      action='store_true')

  parser.add_argument(
      '--debug',
      help='Limit which build types to build. Will at least build the debug '
           'version.',
      action='store_true')

  parser.add_argument(
      '--release',
      help='Limit which build types to build. Will at least build the '
           'release version.',
      action='store_true')

  parsed_args = parser.parse_args(args)

  # Make the dist/ folder, ignore errors.
  base = shakaBuildHelpers.get_source_base()
  try:
    os.mkdir(os.path.join(base, 'dist'))
  except OSError:
    pass

  # Generate localizations before running gendeps, so the output is available
  # to the deps system.
  # TODO(#1858): It might be time to look at a third-party build system.
  localizations = compiler.GenerateLocalizations(parsed_args.locales)
  if not localizations.generate(parsed_args.force):
    return 1

  if gendeps.main([]) != 0:
    return 1

  check_args = []
  if parsed_args.fix:
    check_args += ['--fix']
  if parsed_args.force:
    check_args += ['--force']
  if check.main(check_args) != 0:
    return 1

  docs_args = []
  if parsed_args.force:
    docs_args += ['--force']
  if docs.main(docs_args) != 0:
    return 1

  if not compile_less('ui', 'controls', parsed_args):
    return 1;
  if not compile_less('demo', 'demo', parsed_args):
    return 1

  build_args_with_ui = ['--name', 'ui', '+@complete']
  build_args_with_ui += ['--locales'] + parsed_args.locales
  build_args_without_ui = ['--name', 'compiled', '+@complete', '-@ui']

  if parsed_args.force:
    build_args_with_ui += ['--force']
    build_args_without_ui += ['--force']

  # Create the list of build modes to build with. If the list is empty
  # by the end, then populate it with every mode.
  modes = []
  modes += ['debug'] if parsed_args.debug else []
  modes += ['release'] if parsed_args.release else []

  # If --debug or --release are not given, build with everything.
  if not modes:
    modes += ['debug', 'release']

  for mode in modes:
    # Complete build includes the UI library, but it is optional and player lib
    # should build and work without it as well.
    # First, build the full build (UI included) and then build excluding UI.
    for build_args in [build_args_with_ui, build_args_without_ui]:
      if build.main(build_args + ['--mode', mode]) != 0:
        return 1

    is_debug = mode == 'debug'
    if not apps.build_all(parsed_args.force, is_debug):
      return 1

  return 0
示例#43
0
文件: BepBop.py 项目: Plawn/nginx_gui
 def on_any_event(self, event):
     build.main([], helper.nice_date())
示例#44
0
def evaluate(sb, options):
    state = EvalState()
    phase_argv = ['--sandbox', sb.get_root()]
    with ioutil.WorkingDir(sb.get_root()) as td:
        with sb.lock('eval') as lock:
            try:
                try:
                    if not options.no_update:
                        with Phase(state, EvalPhase.UPDATE, lock) as phase:
                            state.err = update(sb, lock)
                    if not state.err:
                        with Phase(state, EvalPhase.BUILD, lock) as phase:
                            argv = get_build_phase_args(phase_argv, options)
                            state.err = build.main(argv)
                    if not state.err:
                        with Phase(state, EvalPhase.TEST, lock) as phase:
                            argv = get_test_phase_args(["test"], options)
                            state.err = test.main(argv)
                    if (not state.err) and sb.get_sandboxtype().get_should_publish():
                        with Phase(state, EvalPhase.PUBLISH, lock) as phase:
                            state.err = publish.main(phase_argv)
                except:
                    txt = traceback.format_exc()
                    print(txt)
                    # It is possible for us to get an exception as we try to enter
                    # a phase (including the first one). In such a case, we need
                    # to work extra hard to help the user understand what's wrong.
                    txt = txt.replace('\r', '').replace('\n', '; ').replace(',', ' ')
                    state.reason = 'exception in build process itself: ' + txt
                    if not state.timestamps:
                        state.timestamps.append(time.time())
                        state.phase = EvalPhase.UPDATE
            finally:
                if os.path.exists(os.path.join(sb.get_root(), 'notify.txt')):
                    if (not sb.get_sandboxtype().get_notify_on_success()) and (not state.err):
                        os.remove('%snotify.txt' % sb.get_root())
                    else:
                        notify = open('%snotify.txt' % sb.get_root(), 'r')
                        emails = notify.read()
                        notify.close()
                        body = ''
                        if os.path.exists(os.path.join(sb.get_root(), 'eval-log.txt')):
                            body = os.path.join(sb.get_root(), 'eval-log.txt')
                        os.remove('%snotify.txt' % sb.get_root())
                        bi = buildinfo.BuildInfo()
                        if state.err:
                            status = 'Failed'
                        else:
                            status = 'Succeeded'
                        subject = '%s build of %s on %s %s.' % (sb.get_variant(), sb.get_top_component(), bi.host, status)
                        arguments = '--to %s --sender sadm --subject "%s" --host smtp.example.com --port 587' % (emails, subject) # TODO KIM TO CONF
                        arguments += ' --username [email protected] --password password' # TODO KIM TO CONF
                        if body:
                            arguments += ' --body "%s"' % body
                        os.system('python %s/buildscripts/mailout.py %s' % (sb.get_code_root(), arguments))
                if not state.err:
                    state.reason = ''
                if _should_report(sb, options):
                    report(sb, state)
                else:
                    print('Skipping report phase.')
    return state.err
示例#45
0
def main(args):
  parser = argparse.ArgumentParser(
      description='User facing build script for building the Shaka'
                  ' Player Project.')

  parser.add_argument(
      '--locales',
      type=str,
      nargs='+',
      default=generateLocalizations.DEFAULT_LOCALES,
      help='The list of locales to compile in (default %(default)r)')

  parser.add_argument(
      '--fix',
      help='Automatically fix style violations.',
      action='store_true')

  parser.add_argument(
      '--force',
      '-f',
      help='Force building the library even if no files have changed.',
      action='store_true')

  parser.add_argument(
      '--debug',
      help='Limit which build types to build. Will at least build the debug '
           'version.',
      action='store_true')

  parser.add_argument(
      '--release',
      help='Limit which build types to build. Will at least build the '
           'release version.',
      action='store_true')

  parsed_args = parser.parse_args(args)

  # Make the dist/ folder, ignore errors.
  base = shakaBuildHelpers.get_source_base()
  try:
    os.mkdir(os.path.join(base, 'dist'))
  except OSError:
    pass

  # Generate localizations before running gendeps, so the output is available
  # to the deps system.
  # TODO(#1858): It might be time to look at a third-party build system.
  localizations = compiler.GenerateLocalizations(parsed_args.locales)
  if not localizations.generate(parsed_args.force):
    return 1

  if gendeps.main([]) != 0:
    return 1

  check_args = []
  if parsed_args.fix:
    check_args += ['--fix']
  if parsed_args.force:
    check_args += ['--force']
  if check.main(check_args) != 0:
    return 1

  docs_args = []
  if parsed_args.force:
    docs_args += ['--force']
  if docs.main(docs_args) != 0:
    return 1

  if not compile_less('ui', 'controls', parsed_args):
    return 1;
  # if not compile_less('demo', 'demo', parsed_args):
  #   return 1

  build_args_with_ui = ['--name', 'ui', '+@complete']
  build_args_with_ui += ['--locales'] + parsed_args.locales
  build_args_without_ui = ['--name', 'compiled', '+@complete', '-@ui']

  if parsed_args.force:
    build_args_with_ui += ['--force']
    build_args_without_ui += ['--force']

  # Create the list of build modes to build with. If the list is empty
  # by the end, then populate it with every mode.
  modes = []
  modes += ['debug'] if parsed_args.debug else []
  modes += ['release'] if parsed_args.release else []

  # If --debug or --release are not given, build with everything.
  if not modes:
    modes += ['debug', 'release']

  for mode in modes:
    # Complete build includes the UI library, but it is optional and player lib
    # should build and work without it as well.
    # First, build the full build (UI included) and then build excluding UI.
    for build_args in [build_args_with_ui, build_args_without_ui]:
      if build.main(build_args + ['--mode', mode]) != 0:
        return 1

    is_debug = mode == 'debug'
    if not apps.build_all(parsed_args.force, is_debug):
      return 1

  return 0
示例#46
0
        vcs_args=['git', '--git-dir', '%(root)s/.git', 'describe',
                     '--tags', '--long', '--abbrev=999'],
    )

def pad_version(v):
    split = v.split('.')
    return '.'.join(split + ['0'] * (3 - len(split)))

version = '.'.join((
    pad_version(os.environ['PYQT5_VERSION']),
    version.version,
))

sys.stderr.write('another stderr test from {}\n'.format(__file__))

results = build.main()

with open('README.rst') as f:
    readme = f.read()

setuptools.setup(
    name="pyqt5-tools",
    description="Tools to supplement the official PyQt5 wheels",
    long_description=readme,
    long_description_content_type='text/x-rst',
    url='https://github.com/altendky/pyqt5-tools',
    author="Kyle Altendorf",
    author_email='*****@*****.**',
    license='GPLv3',
    classifiers=[
        # complete classifier list: https://pypi.org/pypi?%3Aaction=list_classifiers
示例#47
0
def build(request):
    if request.method == "POST":
        postData = re.split(r'\{\"(.+|\[+|\]+)\}', str(request.body))[1]
        postData = '{"' + postData + '}'
        jsonData = json.loads(postData)
        botIP = None
        botPort = None
        featList = {}
        # actionList will be used again when we send the list to the
        # BotMaster to record this Bots capabilites
        actionList = []
        if 'Execution Conditions' in jsonData:
            featList['Execution Conditions'] = []
            # gets a dict of all features in this category
            exeConds = jsonData['Execution Conditions']
            for f in exeConds:
                # str(f) gets the string representation of the feature
                # option in a list of 'option' checkbox values
                for option in exeConds[str(f)]:
                    # if the option that was checked was 'Yes'
                    # add the feature to the list
                    if option == "Yes":
                        featList['Execution Conditions'].append(str(f))
        if 'Options' in jsonData:
            featList['Options'] = []
            # gets a dict of all features in this category
            opts = jsonData['Options']
            for o in opts:
                # str(o) gets the string representation of the feature
                # option in a list of 'option' checkbox values
                for option in opts[str(o)]:
                    # if the option that was checked was 'Yes'
                    # add the feature to the list
                    if option == "Yes":
                        featList['Options'].append(str(o))
                        # if the option that was checked was 'Encode HTTP'
                        # let the botmaster know it can encode its http data
                        actionList.append(str(o))
        if 'Executable Features' in jsonData:
            featList['On Execution'] = []
            featList['As Remote Action'] = []
            # gets an dict of all features in this category
            exeFeats = jsonData['Executable Features']
            for f in exeFeats:
                # str(f) gets the string representation of the feature
                # option in a list of 'option' checkbox values
                for option in exeFeats[str(f)]:
                    # if the option that was checked was 'Yes'
                    # add this action to the list of actions the botmaster can sends
                    actionList.append(str(f))
                    # add the feature to the list
                    if option == "On Execution":
                        featList['On Execution'].append(str(f))
                    if option == "As Remote Action":
                        featList['As Remote Action'].append(str(f))
        if 'Action Sequence' in jsonData:
            featList['Action Sequence'] = []
            # gets an dict of all features in this category
            actionSeq = jsonData['Action Sequence']
            for f in actionSeq:
                # str(f) gets the string representation of the feature
                # option in a list of 'option' checkbox values
                for option in actionSeq[str(f)]:
                    # if the option that was checked was 'Yes'
                    # add this action to the list of actions the botmaster can sends
                    actionList.append(str(f))
                    # add the feature to the list
                    if option == "Yes":
                        featList['Action Sequence'].append(str(f))
        if 'Failed Condition Handler' in jsonData:
            featList['Failed Condition Handler'] = []
            # gets a dict of all features in this category
            failedHandler = jsonData['Failed Condition Handler']
            for o in failedHandler:
                # str(o) gets the string representation of the feature
                # option in a list of 'option' checkbox values
                for option in failedHandler[str(o)]:
                    # if the option that was checked was 'Yes'
                    # add the feature to the list
                    if option == "Yes":
                        featList['Options'].append(str(o))
                        # if the option that was checked was 'Encode HTTP'
                        # let the botmaster know it can encode its http data
                        actionList.append(str(o))
        if 'Pull Times' in jsonData:
            featList['Pull Times'] = []
            times = jsonData['Pull Times']
            for t in times:
                featList['Pull Times'].append(str(t))
        if 'Action Limit' in jsonData:
            featList['Action Limit'] = jsonData['Action Limit']
        if 'Action Frequency' in jsonData:
            featList['Action Frequency'] = jsonData['Action Frequency']
        if 'Maximum Action Limit' in jsonData:
            featList['Maximum Action Limit'] = jsonData['Maximum Action Limit']
        if 'Botmaster IP' in jsonData:
            featList['Botmaster IP'] = jsonData['Botmaster IP']
            botIP = jsonData['Botmaster IP']
        if 'Botmaster Port' in jsonData:
            featList['Botmaster Port'] = jsonData['Botmaster Port']
            botPort = jsonData['Botmaster Port']

    exePath, botID = main(featList)

    if exePath != -1:
        # if it failed the result will be -1 otherwise it'll be the path to the exe
        exePath = re.sub(r'\\', '/', exePath)
        filename = 'http://' + request.get_host() + '/' + exePath
        # send POST to the BotMaster with the bot's ID and a list of its available add_func_definitions
        success = sendBotActionList(botIP, botPort, actionList, botID)
        # if success == True:
        if True:
            return HttpResponse('200 ' + filename)
    return HttpResponse(503)
示例#48
0
# Our libs
import config
import build
from basehandler import BaseHandler

class MainHandler(BaseHandler):
    def get(self):
        context = {'message': 'Hello World'}
        self.render('index.html', context=context)


def get_handlers():
    return [
            (r"/", MainHandler),
            ]
    
if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option('-p', '--production', action='store_true', dest='production', default=False)
    (options, args) = parser.parse_args()
    build.main(debug=not options.production)
    settings = config.tornado_settings
    application = tornado.web.Application(get_handlers(), **settings)
    application.debug = not options.production

    server = HTTPServer(application)
    sockets = bind_sockets(int(config.application_port), address=config.application_ip)
    tornado.process.fork_processes(1 if not options.production else 0)
    server.add_sockets(sockets)
    IOLoop.instance().start()
示例#49
0
文件: build-all.py 项目: ClxS/Vulkan
    "texture",
    "texture3d",
    "texturearray",
    "texturecubemap",
    "texturemipmapgen",
    "triangle",
    "viewportarray",
    "vulkanscene"
]

COLOR_GREEN = '\033[92m'
COLOR_END = '\033[0m'

CURR_INDEX = 0

parser = argparse.ArgumentParser()
parser.add_argument('-deploy', default=False, action='store_true', help="install examples on device")
parser.add_argument('-validation', default=False, action='store_true')
args = parser.parse_args()

print("Building all examples...")

for example in EXAMPLES:
    print(COLOR_GREEN + "Building %s (%d/%d)" % (example, CURR_INDEX, len(EXAMPLES)) + COLOR_END)
    if not build.main(example, args.deploy, args.validation):
        print("Error during build process for %s" % example)
        sys.exit(-1)
    CURR_INDEX += 1

print("Successfully build %d examples" % CURR_INDEX)