Exemplo n.º 1
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.__build_targets
     query_list = []
     target_path = relative_path(self.__working_dir, self.__root_dir)
     t_path = ''
     for t in targets:
         if t.find(':') != -1:
             key = t.split(':')
             if target_path == '.':
                 t_path = key[0]
             else:
                 t_path = target_path + '/' + key[0]
             t_path = os.path.normpath(t_path)
             query_list.append((t_path, key[1]))
         elif t.endswith('...'):
             t_path = os.path.normpath(target_path + '/' + t[:-3])
             for tkey in all_targets:
                 if tkey[0].startswith(t_path):
                     query_list.append((tkey[0], tkey[1]))
         else:
             t_path = os.path.normpath(target_path + '/' + t)
             for tkey in all_targets:
                 if tkey[0] == t_path:
                     query_list.append((t_path, tkey[1]))
     result_map = {}
     for key in query_list:
         deps = all_targets[key].expanded_deps
         # depended_by = [k for k in all_targets if key in all_targets[k].expanded_deps]
         depended_by = self.__depended_targets[key]
         result_map[key] = (sorted(deps), sorted(depended_by))
     return result_map
Exemplo n.º 2
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.__build_targets
     query_list = []
     target_path = relative_path(self.__working_dir, self.__root_dir)
     t_path = ''
     for t in targets:
         key = t.split(':')
         if target_path == '.':
             t_path = key[0]
         else:
             t_path = target_path + '/' + key[0]
         t_path = os.path.normpath(t_path)
         query_list.append((t_path, key[1]))
     result_map = {}
     for key in query_list:
         result_map[key] = ([], [])
         deps = all_targets[key].expanded_deps
         deps.sort(key=lambda x: x, reverse=False)
         depended_by = []
         for tkey in all_targets:
             if key in all_targets[tkey].expanded_deps:
                 depended_by.append(tkey)
         depended_by.sort(key=lambda x: x, reverse=False)
         result_map[key] = (list(deps), list(depended_by))
     return result_map
Exemplo n.º 3
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.all_targets_expanded
     query_list = []
     target_path = relative_path(self.working_dir, self.current_source_path)
     t_path = ''
     for t in targets:
         key = t.split(':')
         if target_path == '.':
             t_path = key[0]
         else:
             t_path = target_path + '/' + key[0]
         t_path = os.path.normpath(t_path)
         query_list.append((t_path, key[1]))
     result_map = {}
     for key in query_list:
         result_map[key] = ([], [])
         deps = all_targets.get(key, {}).get('deps', [])
         deps.sort(key=lambda x: x, reverse=False)
         depended_by = []
         for tkey in all_targets.keys():
             if key in all_targets[tkey]['deps']:
                 depended_by.append(tkey)
         depended_by.sort(key=lambda x: x, reverse=False)
         result_map[key] = (list(deps), list(depended_by))
     return result_map
Exemplo n.º 4
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.__build_targets
     query_list = []
     target_path = relative_path(self.__working_dir, self.__root_dir)
     t_path = ''
     for t in targets:
         key = t.split(':')
         if target_path == '.':
             t_path = key[0]
         else:
             t_path = target_path + '/' + key[0]
         t_path = os.path.normpath(t_path)
         query_list.append((t_path, key[1]))
     result_map = {}
     for key in query_list:
         result_map[key] = ([], [])
         deps = all_targets[key].expanded_deps
         deps.sort(key=lambda x: x, reverse=False)
         depended_by = []
         for tkey in all_targets:
             if key in all_targets[tkey].expanded_deps:
                 depended_by.append(tkey)
         depended_by.sort(key=lambda x: x, reverse=False)
         result_map[key] = (list(deps), list(depended_by))
     return result_map
Exemplo n.º 5
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.all_targets_expanded
     query_list = []
     target_path = relative_path(self.working_dir, self.current_source_path)
     t_path = ''
     for t in targets:
         key = t.split(':')
         if target_path == '.':
             t_path = key[0]
         else:
             t_path = target_path + '/' + key[0]
         t_path = os.path.normpath(t_path)
         query_list.append((t_path, key[1]))
     result_map = {}
     for key in query_list:
         result_map[key] = ([], [])
         deps = all_targets.get(key, {}).get('deps', [])
         deps.sort(key=lambda x: x, reverse=False)
         depended_by = []
         for tkey in all_targets.keys():
             if key in all_targets[tkey]['deps']:
                 depended_by.append(tkey)
         depended_by.sort(key=lambda x: x, reverse=False)
         result_map[key] = (list(deps), list(depended_by))
     return result_map
Exemplo n.º 6
0
 def query_helper(self, targets):
     """Query the targets helper method. """
     all_targets = self.__build_targets
     query_list = []
     target_path = relative_path(self.__working_dir, self.__root_dir)
     t_path = ''
     for t in targets:
         if t.find(':') != -1:
             key = t.split(':')
             if target_path == '.':
                 t_path = key[0]
             else:
                 t_path = target_path + '/' + key[0]
             t_path = os.path.normpath(t_path)
             query_list.append((t_path, key[1]))
         elif t.endswith('...'):
             t_path = os.path.normpath(target_path + '/' + t[:-3])
             for tkey in all_targets:
                 if tkey[0].startswith(t_path):
                     query_list.append((tkey[0], tkey[1]))
         else:
             t_path = os.path.normpath(target_path + '/' + t)
             for tkey in all_targets:
                 if tkey[0] == t_path:
                     query_list.append((t_path, tkey[1]))
     result_map = {}
     for key in query_list:
         deps = all_targets[key].expanded_deps
         # depended_by = [k for k in all_targets if key in all_targets[k].expanded_deps]
         depended_by = self.__depended_targets[key]
         result_map[key] = (sorted(deps), sorted(depended_by))
     return result_map
Exemplo n.º 7
0
    def _java_jar_rules_prepare_dep(self, new_src):
        """Prepare building java jars, make class root and other work. """
        env_name = self._env_name()

        new_dep_source_list = []
        cmd_var = '%s_cmd_dep_var_' % self.name
        dep_cmd_var = ''
        cmd_var_idx = 0
        for dep_src in self.java_jar_dep_source_list:
            dep_dir = relative_path(dep_src[0], dep_src[1])
            new_path = os.path.join(new_src, dep_dir)
            if dep_dir != '.':
                new_dep_source_list.append(new_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            if cmd_var_idx == 0:
                dep_cmd_var = cmd_var_id
            if not new_path in self.java_jar_cmd_list:
                self._write_rule('%s = %s.Command("%s", "", [Mkdir("%s")])' % (
                        cmd_var_id,
                        env_name,
                        new_path,
                        new_path))
                self.cmd_var_list.append(cmd_var_id)
                self.java_jar_cmd_list.append(new_path)
                cmd_var_idx += 1
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = 'cp %s/*.java %s' % (dep_src[0], new_path)
            if dep_dir != '.':
                src_dir = dep_src[0]
            else:
                src_dir = ''
            self._write_rule('%s = %s.Command("%s/dummy_file_%s", "%s", ["%s"])' % (
                    cmd_var_id,
                    env_name,
                    new_path,
                    cmd_var_idx,
                    src_dir,
                    cmd))
            self.cmd_var_list.append(cmd_var_id)

        targets = self.blade.get_build_targets()
        if dep_cmd_var:
            for dep in self.expanded_deps:
                explict_files_depended = targets[dep].data.get('java_sources_explict_dependency')
                if explict_files_depended:
                    self._write_rule('%s.Depends(%s, %s)' % (
                                      env_name,
                                      dep_cmd_var,
                                      explict_files_depended))

        self._generate_target_explict_dependency(self.cmd_var_list)
        self.java_jar_after_dep_source_list = new_dep_source_list
Exemplo n.º 8
0
def generate_resource_index(target, source, env):
    res_source_path = str(target[0])
    res_header_path = str(target[1])

    if not os.path.exists(os.path.dirname(res_header_path)):
        os.mkdir(os.path.dirname(res_header_path))
    h = open(res_header_path, 'w')
    c = open(res_source_path, 'w')

    source_path = env["SOURCE_PATH"]
    full_name = blade_util.regular_variable_name(
        "%s/%s" % (source_path, env["TARGET_NAME"]))
    guard_name = 'BLADE_RESOURCE_%s_H' % full_name.upper()
    print >> h, '#ifndef %s\n#define %s' % (guard_name, guard_name)
    print >> h, '''
// This file was automatically generated by blade

#ifdef __cplusplus
extern "C" {
#endif

#ifndef BLADE_RESOURCE_TYPE_DEFINED
#define BLADE_RESOURCE_TYPE_DEFINED
struct BladeResourceEntry {
    const char* name;
    const char* data;
    unsigned int size;
};
#endif
'''
    res_index_name = 'RESOURCE_INDEX_%s' % full_name
    print >> c, '// This file was automatically generated by blade\n'
    print >> c, '#include "%s"\n' % res_header_path
    print >> c, 'const struct BladeResourceEntry %s[] = {' % res_index_name
    for s in source:
        src = str(s)
        var_name = blade_util.regular_variable_name(src)
        org_src = blade_util.relative_path(src, source_path)
        print >> h, '// %s' % org_src
        print >> h, 'extern const char RESOURCE_%s[%d];' % (var_name,
                                                            s.get_size())
        print >> h, 'extern const unsigned RESOURCE_%s_len;\n' % var_name
        print >> c, '    { "%s", RESOURCE_%s, %s },' % (org_src, var_name,
                                                        s.get_size())
    print >> c, '};'
    print >> c, 'const unsigned %s_len = %s;' % (res_index_name, len(source))
    print >> h, '// Resource index'
    print >> h, 'extern const struct BladeResourceEntry %s[];' % res_index_name
    print >> h, 'extern const unsigned %s_len;' % res_index_name
    print >> h, '\n#ifdef __cplusplus\n} // extern "C"\n#endif\n'
    print >> h, '\n#endif // %s' % guard_name
    c.close()
    h.close()
Exemplo n.º 9
0
    def _java_jar_rules_prepare_dep(self, new_src):
        """Prepare building java jars, make class root and other work. """
        env_name = self._env_name()

        new_dep_source_list = []
        cmd_var = '%s_cmd_dep_var_' % self.name
        dep_cmd_var = ''
        cmd_var_idx = 0
        for dep_src in self.java_jar_dep_source_list:
            dep_dir = relative_path(dep_src[0], dep_src[1])
            new_path = os.path.join(new_src, dep_dir)
            if dep_dir != '.':
                new_dep_source_list.append(new_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            if cmd_var_idx == 0:
                dep_cmd_var = cmd_var_id
            if not new_path in self.java_jar_cmd_list:
                self._write_rule('%s = %s.Command("%s", "", [Mkdir("%s")])' % (
                        cmd_var_id,
                        env_name,
                        new_path,
                        new_path))
                self.cmd_var_list.append(cmd_var_id)
                self.java_jar_cmd_list.append(new_path)
                cmd_var_idx += 1
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = 'cp %s/*.java %s' % (dep_src[0], new_path)
            if dep_dir != '.':
                src_dir = dep_src[0]
            else:
                src_dir = ''
            self._write_rule('%s = %s.Command("%s/dummy_file_%s", "%s", ["%s"])' % (
                    cmd_var_id,
                    env_name,
                    new_path,
                    cmd_var_idx,
                    src_dir,
                    cmd))
            self.cmd_var_list.append(cmd_var_id)

        targets = self.blade.get_build_targets()
        if dep_cmd_var:
            for dep in self.expanded_deps:
                explict_files_depended = targets[dep].data.get('java_sources_explict_dependency')
                if explict_files_depended:
                    self._write_rule('%s.Depends(%s, %s)' % (
                                      env_name,
                                      dep_cmd_var,
                                      explict_files_depended))

        self.java_jar_after_dep_source_list = new_dep_source_list
Exemplo n.º 10
0
def generate_resource_index(target, source, env):
    res_source_path = str(target[0])
    res_header_path = str(target[1])

    if not os.path.exists(os.path.dirname(res_header_path)):
        os.mkdir(os.path.dirname(res_header_path))
    h = open(res_header_path, 'w')
    c = open(res_source_path, 'w')

    source_path = env["SOURCE_PATH"]
    full_name = blade_util.regular_variable_name("%s/%s" % (source_path, env["TARGET_NAME"]))
    guard_name = 'BLADE_RESOURCE_%s_H' % full_name.upper()
    print >>h, '#ifndef %s\n#define %s' % (guard_name, guard_name)
    print >>h, '''
// This file was automatically generated by blade

#ifdef __cplusplus
extern "C" {
#endif

#ifndef BLADE_RESOURCE_TYPE_DEFINED
#define BLADE_RESOURCE_TYPE_DEFINED
struct BladeResourceEntry {
    const char* name;
    const char* data;
    unsigned int size;
};
#endif
'''
    res_index_name = 'RESOURCE_INDEX_%s' % full_name
    print >>c, '// This file was automatically generated by blade\n'
    print >>c, '#include "%s"\n' % res_header_path
    print >>c, 'const struct BladeResourceEntry %s[] = {' % res_index_name
    for s in source:
        src = str(s)
        var_name = blade_util.regular_variable_name(src)
        org_src = blade_util.relative_path(src, source_path)
        print >>h, '// %s' % org_src
        print >>h, 'extern const char RESOURCE_%s[%d];' % (var_name, s.get_size())
        print >>h, 'extern const unsigned RESOURCE_%s_len;\n' % var_name
        print >>c, '    { "%s", RESOURCE_%s, %s },' % (org_src, var_name, s.get_size())
    print >>c, '};'
    print >>c, 'const unsigned %s_len = %s;' % (res_index_name, len(source))
    print >>h, '// Resource index'
    print >>h, 'extern const struct BladeResourceEntry %s[];' % res_index_name
    print >>h, 'extern const unsigned %s_len;' % res_index_name
    print >>h, '\n#ifdef __cplusplus\n} // extern "C"\n#endif\n'
    print >>h, '\n#endif // %s' % guard_name
    c.close()
    h.close()
Exemplo n.º 11
0
    def _get_normpath_target(self, command_target):
        """returns a tuple (path, name).

        path is a full path from BLADE_ROOT

        """
        target_path = relative_path(self.working_dir, self.current_source_path)
        path, name = command_target.split(':')
        if target_path != '.':
            if path:
                path = target_path + '/' + path
            else:
                path = target_path
        path = os.path.normpath(path)
        return path, name
Exemplo n.º 12
0
    def _get_normpath_target(self, command_target):
        """returns a tuple (path, name).

        path is a full path from BLADE_ROOT

        """
        target_path = relative_path(self.__working_dir, self.__root_dir)
        path, name = command_target.split(':')
        if target_path != '.':
            if path:
                path = target_path + '/' + path
            else:
                path = target_path
        path = os.path.normpath(path)
        return path, name
Exemplo n.º 13
0
    def _java_jar_rules_prepare_dep(self, new_src):
        """Prepare building java jars, make class root and other work. """
        env_name = self._env_name()

        new_dep_source_list = []
        cmd_var = "%s_cmd_dep_var_" % self.data["name"]
        dep_cmd_var = ""
        cmd_var_idx = 0
        for dep_src in self.java_jar_dep_source_list:
            dep_dir = relative_path(dep_src[0], dep_src[1])
            new_path = os.path.join(new_src, dep_dir)
            if dep_dir != ".":
                new_dep_source_list.append(new_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            if cmd_var_idx == 0:
                dep_cmd_var = cmd_var_id
            if not new_path in self.java_jar_cmd_list:
                self._write_rule(
                    '%s = %s.Command("%s", "", [Mkdir("%s")])' % (cmd_var_id, env_name, new_path, new_path)
                )
                self.cmd_var_list.append(cmd_var_id)
                self.java_jar_cmd_list.append(new_path)
                cmd_var_idx += 1
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = "cp %s/*.java %s" % (dep_src[0], new_path)
            if dep_dir != ".":
                src_dir = dep_src[0]
            else:
                src_dir = ""
            self._write_rule(
                '%s = %s.Command("%s/dummy_file_%s", "%s", ["%s"])'
                % (cmd_var_id, env_name, new_path, cmd_var_idx, src_dir, cmd)
            )
            self.cmd_var_list.append(cmd_var_id)

        if dep_cmd_var:
            for dep in self.targets[self.key]["deps"]:
                explict_files_depended = self.sources_dependency_map.get(dep, [])
                if explict_files_depended:
                    self._write_rule("%s.Depends(%s, %s)" % (env_name, dep_cmd_var, explict_files_depended))

        self._generate_target_explict_dependency(self.cmd_var_list)
        self.java_jar_after_dep_source_list = new_dep_source_list
Exemplo n.º 14
0
def load_targets(target_ids, working_dir, blade_root_dir, blade):
    """load_targets.

    Parse and load targets, including those specified in command line
    and their direct and indirect dependencies, by loading related BUILD
    files.  Returns a map which contains all these targets.

    """
    target_database = blade.get_target_database()

    # targets specified in command line
    cited_targets = set()
    # cited_targets and all its dependencies
    related_targets = {}
    # source dirs mentioned in command line
    source_dirs = []
    # to prevent duplicated loading of BUILD files
    processed_source_dirs = set()

    direct_targets = []
    all_command_targets = []
    # Parse command line target_ids.  For those in the form of <path>:<target>,
    # record (<path>,<target>) in cited_targets; for the rest (with <path>
    # but without <target>), record <path> into paths.
    for target_id in target_ids:
        if target_id.find(':') == -1:
            source_dir, target_name = target_id, '*'
        else:
            source_dir, target_name = target_id.rsplit(':', 1)

        source_dir = relative_path(os.path.join(working_dir, source_dir),
                                   blade_root_dir)

        if target_name != '*' and target_name != '':
            cited_targets.add((source_dir, target_name))
        elif source_dir.endswith('...'):
            source_dir = source_dir[:-3]
            if not source_dir:
                source_dir = './'
            source_dirs.append((source_dir, WARN_IF_FAIL))
            for root, dirs, files in os.walk(source_dir):
                # Skip over subdirs starting with '.', e.g., .svn.
                dirs[:] = [d for d in dirs if not d.startswith('.')]
                for d in dirs:
                    source_dirs.append((os.path.join(root, d), IGNORE_IF_FAIL))
        else:
            source_dirs.append((source_dir, ABORT_IF_FAIL))

    direct_targets = list(cited_targets)

    # Load BUILD files in paths, and add all loaded targets into
    # cited_targets.  Together with above step, we can ensure that all
    # targets mentioned in the command line are now in cited_targets.
    for source_dir, action_if_fail in source_dirs:
        _load_build_file(source_dir, action_if_fail, processed_source_dirs,
                         blade)

    for key in target_database:
        cited_targets.add(key)
    all_command_targets = list(cited_targets)

    # Starting from targets specified in command line, breath-first
    # propagate to load BUILD files containing directly and indirectly
    # dependent targets.  All these targets form related_targets,
    # which is a subset of target_databased created by loading  BUILD files.
    while cited_targets:
        source_dir, target_name = cited_targets.pop()
        target_id = (source_dir, target_name)
        if target_id in related_targets:
            continue

        _load_build_file(source_dir, ABORT_IF_FAIL, processed_source_dirs,
                         blade)

        if target_id not in target_database:
            console.error_exit(
                '%s: target //%s:%s does not exists' %
                (_find_depender(target_id, blade), source_dir, target_name))

        related_targets[target_id] = target_database[target_id]
        for key in related_targets[target_id].expanded_deps:
            if key not in related_targets:
                cited_targets.add(key)

    # Iterating to get svn root dirs
    for path, name in related_targets:
        root_dir = path.split('/')[0].strip()
        if root_dir not in blade.svn_root_dirs and '#' not in root_dir:
            blade.svn_root_dirs.append(root_dir)

    return direct_targets, all_command_targets, related_targets
Exemplo n.º 15
0
    def _java_jar_rules_compile_src(self, target_source_list, new_src, pack_list, classes_var_list):
        """Compile the java sources. """
        env_name = self._env_name()
        class_root = self._java_jar_gen_class_root(self.path, self.name)
        jar_list = self._java_jar_deps_list(self.expanded_deps)
        classpath_list = self.java_classpath_list
        classpath = ":".join(classpath_list + jar_list)

        new_target_source_list = []
        for src_dir in target_source_list:
            rel_path = relative_path(src_dir, self.path)
            pos = rel_path.find("/")
            package = rel_path[pos + 1 :]
            new_src_path = os.path.join(new_src, package)
            new_target_source_list.append(new_src_path)

            cmd_var = "%s_cmd_src_var_" % self.name
            cmd_var_idx = 0
            if not new_src_path in self.java_jar_cmd_list:
                cmd_var_id = cmd_var + str(cmd_var_idx)
                self._write_rule(
                    '%s = %s.Command("%s", "", [Mkdir("%s")])' % (cmd_var_id, env_name, new_src_path, new_src_path)
                )
                cmd_var_idx += 1
                self.java_jar_cmd_list.append(new_src_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = "cp %s/*.java %s" % (src_dir, new_src_path)
            self._write_rule(
                '%s = %s.Command("%s/dummy_src_file_%s", "%s", ["%s"])'
                % (cmd_var_id, env_name, new_src_path, cmd_var_idx, src_dir, cmd)
            )
            self.cmd_var_list.append(cmd_var_id)

        new_target_idx = 0
        classes_var = "%s_classes" % (self._var_name())

        java_config = configparse.blade_config.get_config("java_config")
        source_version = java_config["source_version"]
        target_version = java_config["target_version"]
        javac_cmd = "javac"
        if source_version:
            javac_cmd += " -source %s" % source_version
        if target_version:
            javac_cmd += " -target %s" % target_version
        if not classpath:
            javac_class_path = ""
        else:
            javac_class_path = " -classpath %s" % classpath
        javac_classes_out = " -d %s" % class_root
        javac_source_path = " -sourcepath %s" % new_src

        no_dup_source_list = []
        for dep_src in self.java_jar_after_dep_source_list:
            if not dep_src in no_dup_source_list:
                no_dup_source_list.append(dep_src)
        for src in new_target_source_list:
            if not src in no_dup_source_list:
                no_dup_source_list.append(src)

        source_files_list = []
        for src_dir in no_dup_source_list:
            srcs = os.path.join(src_dir, "*.java")
            source_files_list.append(srcs)

        cmd = javac_cmd + javac_class_path + javac_classes_out
        cmd += javac_source_path + " " + " ".join(source_files_list)
        dummy_file = "%s_dummy_file_%s" % (self.name, str(new_target_idx))
        new_target_idx += 1
        class_root_dummy = os.path.join(class_root, dummy_file)
        self._write_rule('%s = %s.Command("%s", "", ["%s"])' % (classes_var, env_name, class_root_dummy, cmd))

        # Find out the java_jar depends
        targets = self.blade.get_build_targets()
        for dep in self.expanded_deps:
            dep_java_jar_list = targets[dep].data.get("java_jars")
            if dep_java_jar_list:
                self._write_rule("%s.Depends(%s, %s)" % (env_name, classes_var, dep_java_jar_list))

        for cmd in self.cmd_var_list:
            self._write_rule("%s.Depends(%s, %s)" % (env_name, classes_var, cmd))

        self.java_classpath_list.append(class_root)
        classes_var_list.append(classes_var)
        pack_list.append(class_root)
Exemplo n.º 16
0
    def _java_jar_rules_make_jar(self, pack_list, classes_var_list):
        """Make the java jar files, pack the files that the target needs. """
        env_name = self._env_name()
        target_base_dir = os.path.join(self.build_path, self.path)

        cmd_jar = '%s_cmd_jar' % self.name
        cmd_var = '%s_cmd_jar_var_' % self.name
        cmd_idx = 0
        cmd_var_id = ''
        cmd_list = []
        targets = self.blade.get_build_targets()
        build_file = os.path.join(self.blade.get_root_dir(), 'BLADE_ROOT')
        for class_path in pack_list:
            # need to place one dummy file into the source folder for user builder
            build_file_dst = os.path.join(class_path, 'BLADE_ROOT')
            if not build_file_dst in self.java_jar_cmd_list:
                self._write_rule(
                    '%s = %s.Command("%s", "%s", [Copy("%s", "%s")])' %
                    (cmd_jar, env_name, build_file_dst, build_file,
                     build_file_dst, build_file))
                cmd_list.append(cmd_jar)
                self.java_jar_cmd_list.append(build_file_dst)
            for key in self.expanded_deps:
                f = targets[key].data.get('jar_packing_files')
                if not f:
                    continue
                cmd_var_id = cmd_var + str(cmd_idx)
                f_dst = os.path.join(class_path, os.path.basename(f[0]))
                if not f_dst in self.java_jar_cmd_list:
                    self._write_rule('%s = %s.Command("%s", "%s", \
                            [Copy("$TARGET","$SOURCE")])' %
                                     (cmd_var_id, env_name, f_dst, f[0]))
                    self.java_jar_cmd_list.append(f_dst)
                    cmd_list.append(cmd_var_id)
                    cmd_idx += 1

            rel_path = relative_path(class_path, target_base_dir)
            class_path_name = rel_path.replace('/', '_')
            jar_var = '%s_%s_jar' % (self._generate_variable_name(
                self.path, self.name), class_path_name)
            jar_target = '%s.jar' % self._target_file_path()
            jar_target_object = '%s.jar' % jar_target
            cmd_remove_var = 'cmd_remove_%s' % jar_var
            removed = False
            if (not jar_target in self.java_jar_cmd_list) and (
                    os.path.exists(jar_target)):
                self._write_rule(
                    '%s = %s.Command("%s", "", [Delete("%s")])' %
                    (cmd_remove_var, env_name, jar_target_object, jar_target))
                removed = True
            self._write_rule('%s = %s.BladeJar(["%s"], "%s")' %
                             (jar_var, env_name, jar_target, build_file_dst))
            self.data['java_jars'].append(jar_target)

            for dep_classes_var in classes_var_list:
                if dep_classes_var:
                    self._write_rule('%s.Depends(%s, %s)' %
                                     (env_name, jar_var, dep_classes_var))
            for cmd in cmd_list:
                self._write_rule('%s.Depends(%s, %s)' %
                                 (env_name, jar_var, cmd))
            if removed:
                self._write_rule('%s.Depends(%s, %s)' %
                                 (env_name, jar_var, cmd_remove_var))
Exemplo n.º 17
0
    def _java_jar_rules_compile_src(self, target_source_list, new_src,
                                    pack_list, classes_var_list):
        """Compile the java sources. """
        env_name = self._env_name()
        class_root = self._java_jar_gen_class_root(self.path, self.name)
        jar_list = self._java_jar_deps_list(self.expanded_deps)
        classpath_list = self.java_classpath_list
        classpath = ':'.join(classpath_list + jar_list)

        new_target_source_list = []
        for src_dir in target_source_list:
            rel_path = relative_path(src_dir, self.path)
            pos = rel_path.find('/')
            package = rel_path[pos + 1:]
            new_src_path = os.path.join(new_src, package)
            new_target_source_list.append(new_src_path)

            cmd_var = '%s_cmd_src_var_' % self.name
            cmd_var_idx = 0
            if not new_src_path in self.java_jar_cmd_list:
                cmd_var_id = cmd_var + str(cmd_var_idx)
                self._write_rule(
                    '%s = %s.Command("%s", "", [Mkdir("%s")])' %
                    (cmd_var_id, env_name, new_src_path, new_src_path))
                cmd_var_idx += 1
                self.java_jar_cmd_list.append(new_src_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = 'cp %s/*.java %s' % (src_dir, new_src_path)
            self._write_rule(
                '%s = %s.Command("%s/dummy_src_file_%s", "%s", ["%s"])' %
                (cmd_var_id, env_name, new_src_path, cmd_var_idx, src_dir,
                 cmd))
            self.cmd_var_list.append(cmd_var_id)

        new_target_idx = 0
        classes_var = '%s_classes' % (self._generate_variable_name(
            self.path, self.name))

        java_config = configparse.blade_config.get_config('java_config')
        source_version = java_config['source_version']
        target_version = java_config['target_version']
        javac_cmd = 'javac'
        if source_version:
            javac_cmd += ' -source %s' % source_version
        if target_version:
            javac_cmd += ' -target %s' % target_version
        if not classpath:
            javac_class_path = ''
        else:
            javac_class_path = ' -classpath %s' % classpath
        javac_classes_out = ' -d %s' % class_root
        javac_source_path = ' -sourcepath %s' % new_src

        no_dup_source_list = []
        for dep_src in self.java_jar_after_dep_source_list:
            if not dep_src in no_dup_source_list:
                no_dup_source_list.append(dep_src)
        for src in new_target_source_list:
            if not src in no_dup_source_list:
                no_dup_source_list.append(src)

        source_files_list = []
        for src_dir in no_dup_source_list:
            srcs = os.path.join(src_dir, '*.java')
            source_files_list.append(srcs)

        cmd = javac_cmd + javac_class_path + javac_classes_out
        cmd += javac_source_path + ' ' + ' '.join(source_files_list)
        dummy_file = '%s_dummy_file_%s' % (self.name, str(new_target_idx))
        new_target_idx += 1
        class_root_dummy = os.path.join(class_root, dummy_file)
        self._write_rule('%s = %s.Command("%s", "", ["%s"])' %
                         (classes_var, env_name, class_root_dummy, cmd))

        # Find out the java_jar depends
        targets = self.blade.get_build_targets()
        for dep in self.expanded_deps:
            dep_java_jar_list = targets[dep].data.get('java_jars')
            if dep_java_jar_list:
                self._write_rule('%s.Depends(%s, %s)' %
                                 (env_name, classes_var, dep_java_jar_list))

        self._generate_target_explict_dependency(classes_var)

        for cmd in self.cmd_var_list:
            self._write_rule('%s.Depends(%s, %s)' %
                             (env_name, classes_var, cmd))

        self.java_classpath_list.append(class_root)
        classes_var_list.append(classes_var)
        pack_list.append(class_root)
Exemplo n.º 18
0
    def _java_jar_rules_make_jar(self, pack_list, classes_var_list):
        """Make the java jar files, pack the files that the target needs. """
        env_name = self._env_name()
        target_base_dir = os.path.join(self.build_path, self.data['path'])

        cmd_jar = '%s_cmd_jar' % self.data['name']
        cmd_var = '%s_cmd_jar_var_' % self.data['name']
        cmd_idx = 0
        cmd_var_id = ''
        cmd_list = []
        self.jar_packing_map = self.blade.get_java_jar_files_packing_map()
        self.java_jars_map[self.key] = []
        current_source_path = self.blade.get_current_source_path()
        for class_path in pack_list:
            # need to place one dummy file into the source folder for user builder
            build_file = os.path.join(current_source_path, 'BLADE_ROOT')
            build_file_dst = os.path.join(class_path, 'BLADE_ROOT')
            if not build_file_dst in self.java_jar_cmd_list:
                self._write_rule('%s = %s.Command("%s", "%s", [Copy("%s", "%s")])' % (
                        cmd_jar,
                        env_name,
                        build_file_dst,
                        build_file,
                        build_file_dst,
                        build_file))
                cmd_list.append(cmd_jar)
                self.java_jar_cmd_list.append(build_file_dst)
            for key in self.jar_packing_map:
                f = self.jar_packing_map[key]
                cmd_var_id = cmd_var + str(cmd_idx)
                f_dst = os.path.join(class_path, os.path.basename(f[0]))
                if not f_dst in self.java_jar_cmd_list:
                    self._write_rule('%s = %s.Command("%s", "%s", \
                            [Copy("$TARGET","$SOURCE")])' % (
                                    cmd_var_id,
                                    env_name,
                                    f_dst,
                                    f[0]))
                    self.java_jar_cmd_list.append(f_dst)
                    cmd_list.append(cmd_var_id)
                    cmd_idx += 1

            rel_path = relative_path(class_path, target_base_dir)
            class_path_name = rel_path.replace('/', '_')
            jar_var = '%s_%s_jar' % (
                self._generate_variable_name(self.data['path'], self.data['name']),
                    class_path_name)
            jar_target = '%s.jar' % self._target_file_path()
            jar_target_object = '%s.jar' % jar_target
            cmd_remove_var = "cmd_remove_%s" % jar_var
            removed = False
            if (not jar_target in self.java_jar_cmd_list) and (
                os.path.exists(jar_target)):
                self._write_rule('%s = %s.Command("%s", "", [Delete("%s")])' % (
                        cmd_remove_var,
                        env_name,
                        jar_target_object,
                        jar_target))
                removed = True
            self._write_rule('%s = %s.BladeJar(["%s"], "%s")' % (
                    jar_var,
                    env_name,
                    jar_target,
                    build_file_dst))
            self.java_jars_map[self.key].append(jar_target)

            for dep_classes_var in classes_var_list:
                if dep_classes_var:
                    self._write_rule('%s.Depends(%s, %s)' % (
                            env_name, jar_var, dep_classes_var))
            for cmd in cmd_list:
                self._write_rule('%s.Depends(%s, %s)' % (
                        env_name, jar_var, cmd ))
            if removed:
                self._write_rule('%s.Depends(%s, %s)' % (
                        env_name, jar_var, cmd_remove_var))
Exemplo n.º 19
0
    def _java_jar_rules_compile_src(self,
                                    target_source_list,
                                    new_src,
                                    pack_list,
                                    classes_var_list):
        """Compile the java sources. """
        env_name = self._env_name()
        class_root = self._java_jar_gen_class_root(self.data['path'],
                                                   self.data['name'])
        jar_list = self._java_jar_deps_list(self.targets[self.key]['deps'])
        classpath_list = self.java_classpath_list
        classpath = ':'.join(classpath_list + jar_list)

        new_target_source_list = []
        for src_dir in target_source_list:
            rel_path = relative_path(src_dir, self.data['path'])
            pos = rel_path.find('/')
            package = rel_path[pos + 1:]
            new_src_path = os.path.join(new_src, package)
            new_target_source_list.append(new_src_path)

            cmd_var = '%s_cmd_src_var_' % self.data['name']
            cmd_var_idx = 0
            if not new_src_path in self.java_jar_cmd_list:
                cmd_var_id = cmd_var + str(cmd_var_idx)
                self._write_rule('%s = %s.Command("%s", "", [Mkdir("%s")])' % (
                        cmd_var_id,
                        env_name,
                        new_src_path,
                        new_src_path))
                cmd_var_idx += 1
                self.java_jar_cmd_list.append(new_src_path)
            cmd_var_id = cmd_var + str(cmd_var_idx)
            cmd_var_idx += 1
            cmd = 'cp %s/*.java %s' % (src_dir, new_src_path)
            self._write_rule('%s = %s.Command("%s/dummy_src_file_%s", "%s", ["%s"])' % (
                    cmd_var_id,
                    env_name,
                    new_src_path,
                    cmd_var_idx,
                    src_dir,
                    cmd))
            self.cmd_var_list.append(cmd_var_id)

        new_target_idx = 0
        classes_var = '%s_classes' % (
        self._generate_variable_name(self.data['path'], self.data['name']))

        java_config = configparse.blade_config.get_config('java_config')
        source_version = java_config['source_version']
        target_version = java_config['target_version']
        javac_cmd = 'javac'
        if source_version:
            javac_cmd += ' -source %s' % source_version
        if target_version:
            javac_cmd += ' -target %s' % target_version
        if not classpath:
            javac_class_path = ''
        else:
            javac_class_path = ' -classpath %s' % classpath
        javac_classes_out = ' -d %s' % class_root
        javac_source_path = ' -sourcepath %s' % new_src

        no_dup_source_list = []
        for dep_src in self.java_jar_after_dep_source_list:
            if not dep_src in no_dup_source_list:
                no_dup_source_list.append(dep_src)
        for src in new_target_source_list:
            if not src in no_dup_source_list:
                no_dup_source_list.append(src)

        source_files_list = []
        for src_dir in no_dup_source_list:
            srcs = os.path.join(src_dir, "*.java")
            source_files_list.append(srcs)

        cmd = javac_cmd + javac_class_path + javac_classes_out
        cmd += javac_source_path + " " + " ".join(source_files_list)
        dummy_file = '%s_dummy_file_%s' % (
                self.data['name'], str(new_target_idx))
        new_target_idx += 1
        class_root_dummy = os.path.join(class_root, dummy_file)
        self._write_rule('%s = %s.Command("%s", "", ["%s"])' % (
                classes_var,
                env_name,
                class_root_dummy,
                cmd))

        # Find out the java_jar depends
        for dep in self.targets[self.key]['deps']:
            if dep in self.java_jars_map.keys():
                dep_java_jar_list = self.java_jars_map[dep]
                self._write_rule("%s.Depends(%s, %s)" % (
                    env_name,
                    classes_var,
                    dep_java_jar_list
                    ))

        self._generate_target_explict_dependency(classes_var)

        for cmd in self.cmd_var_list:
            self._write_rule('%s.Depends(%s, %s)' % (
                    env_name,
                    classes_var,
                    cmd))

        self.java_classpath_list.append(class_root)
        classes_var_list.append(classes_var)
        pack_list.append(class_root)
Exemplo n.º 20
0
def load_targets(target_ids, working_dir, blade_root_dir, blade):
    """load_targets.

    Parse and load targets, including those specified in command line
    and their direct and indirect dependencies, by loading related BUILD
    files.  Returns a map which contains all these targets.

    """
    target_database = blade.get_target_database()

    # targets specified in command line
    cited_targets = set()
    # cited_targets and all its dependencies
    related_targets = {}
    # source dirs mentioned in command line
    source_dirs = []
    # to prevent duplicated loading of BUILD files
    processed_source_dirs = set()

    direct_targets = []
    all_command_targets = []
    # Parse command line target_ids.  For those in the form of <path>:<target>,
    # record (<path>,<target>) in cited_targets; for the rest (with <path>
    # but without <target>), record <path> into paths.
    for target_id in target_ids:
        if target_id.find(':') == -1:
            source_dir, target_name = target_id, '*'
        else:
            source_dir, target_name = target_id.rsplit(':', 1)

        source_dir = relative_path(os.path.join(working_dir, source_dir),
                                    blade_root_dir)

        if target_name != '*' and target_name != '':
            cited_targets.add((source_dir, target_name))
        elif source_dir.endswith('...'):
            source_dir = source_dir[:-3]
            if not source_dir:
                source_dir = './'
            source_dirs.append((source_dir, WARN_IF_FAIL))
            for root, dirs, files in os.walk(source_dir):
                # Skip over subdirs starting with '.', e.g., .svn.
                # Note the dirs[:] = slice assignment; we are replacing the
                # elements in dirs (and not the list referred to by dirs) so
                # that os.walk() will not process deleted directories.
                dirs[:] = [d for d in dirs if not d.startswith('.')]
                for d in dirs:
                    source_dirs.append((os.path.join(root, d), IGNORE_IF_FAIL))
        else:
            source_dirs.append((source_dir, ABORT_IF_FAIL))

    direct_targets = list(cited_targets)

    # Load BUILD files in paths, and add all loaded targets into
    # cited_targets.  Together with above step, we can ensure that all
    # targets mentioned in the command line are now in cited_targets.
    for source_dir, action_if_fail in source_dirs:
        _load_build_file(source_dir,
                         action_if_fail,
                         processed_source_dirs,
                         blade)

    for key in target_database:
        cited_targets.add(key)
    all_command_targets = list(cited_targets)

    # Starting from targets specified in command line, breath-first
    # propagate to load BUILD files containing directly and indirectly
    # dependent targets.  All these targets form related_targets,
    # which is a subset of target_databased created by loading  BUILD files.
    while cited_targets:
        source_dir, target_name = cited_targets.pop()
        target_id = (source_dir, target_name)
        if target_id in related_targets:
            continue

        _load_build_file(source_dir,
                         ABORT_IF_FAIL,
                         processed_source_dirs,
                         blade)

        if target_id not in target_database:
            console.error_exit('%s: target //%s:%s does not exists' % (
                _find_depender(target_id, blade), source_dir, target_name))

        related_targets[target_id] = target_database[target_id]
        for key in related_targets[target_id].expanded_deps:
            if key not in related_targets:
                cited_targets.add(key)

    # Iterating to get svn root dirs
    for path, name in related_targets:
        root_dir = path.split('/')[0].strip()
        if root_dir not in blade.svn_root_dirs and '#' not in root_dir:
            blade.svn_root_dirs.append(root_dir)

    return direct_targets, all_command_targets, related_targets
Exemplo n.º 21
0
    def _java_jar_rules_make_jar(self, pack_list, classes_var_list):
        """Make the java jar files, pack the files that the target needs. """
        env_name = self._env_name()
        target_base_dir = os.path.join(self.build_path, self.path)

        cmd_jar = "%s_cmd_jar" % self.name
        cmd_var = "%s_cmd_jar_var_" % self.name
        cmd_idx = 0
        cmd_var_id = ""
        cmd_list = []
        targets = self.blade.get_build_targets()
        build_file = os.path.join(self.blade.get_root_dir(), "BLADE_ROOT")
        for class_path in pack_list:
            # need to place one dummy file into the source folder for user builder
            build_file_dst = os.path.join(class_path, "BLADE_ROOT")
            if not build_file_dst in self.java_jar_cmd_list:
                self._write_rule(
                    '%s = %s.Command("%s", "%s", [Copy("%s", "%s")])'
                    % (cmd_jar, env_name, build_file_dst, build_file, build_file_dst, build_file)
                )
                cmd_list.append(cmd_jar)
                self.java_jar_cmd_list.append(build_file_dst)
            for key in self.expanded_deps:
                f = targets[key].data.get("jar_packing_files")
                if not f:
                    continue
                cmd_var_id = cmd_var + str(cmd_idx)
                f_dst = os.path.join(class_path, os.path.basename(f[0]))
                if not f_dst in self.java_jar_cmd_list:
                    self._write_rule(
                        '%s = %s.Command("%s", "%s", \
                            [Copy("$TARGET","$SOURCE")])'
                        % (cmd_var_id, env_name, f_dst, f[0])
                    )
                    self.java_jar_cmd_list.append(f_dst)
                    cmd_list.append(cmd_var_id)
                    cmd_idx += 1

            rel_path = relative_path(class_path, target_base_dir)
            class_path_name = rel_path.replace("/", "_")
            jar_var = "%s_%s_jar" % (self._var_name(), class_path_name)
            jar_target = "%s.jar" % self._target_file_path()
            jar_target_object = "%s.jar" % jar_target
            cmd_remove_var = "cmd_remove_%s" % jar_var
            removed = False
            if (not jar_target in self.java_jar_cmd_list) and (os.path.exists(jar_target)):
                self._write_rule(
                    '%s = %s.Command("%s", "", [Delete("%s")])'
                    % (cmd_remove_var, env_name, jar_target_object, jar_target)
                )
                removed = True
            self._write_rule('%s = %s.BladeJar(["%s"], "%s")' % (jar_var, env_name, jar_target, build_file_dst))
            self.data["java_jars"].append(jar_target)

            for dep_classes_var in classes_var_list:
                if dep_classes_var:
                    self._write_rule("%s.Depends(%s, %s)" % (env_name, jar_var, dep_classes_var))
            for cmd in cmd_list:
                self._write_rule("%s.Depends(%s, %s)" % (env_name, jar_var, cmd))
            if removed:
                self._write_rule("%s.Depends(%s, %s)" % (env_name, jar_var, cmd_remove_var))