,'JAVA_COMP_IN_SYN' : 'javac/synthesized/'
,'JAVA_COMP_OUT' : 'jvm/'
,'JVM_IN' : 'jvm/'
- ,'TEMP' : 'Erebus/'
+ ,'TEMP' : 'scratch_pad/'
]
env.CLASSPATH += ":${dir_map.JVM_IN}"
# The build environment.
#
-
-# Ensure the script is sourced rather than run directly
+env_error=false
if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
- echo "This script must be sourced, not executed. Exiting."
+ echo "env_build:: This script must be sourced, not executed."
+ env_error=true
+fi
+if [ -z "$ENV_DEV" ]; then
+ echo "env_build:: script can only be run from the developer environment"
+ env_error=true
+fi
+if [ "$env_error" = true ]; then
return 1
fi
-export ENV_BUILD_VERSION="0.1"
+export JAVA_HOME="$REPO_HOME/tool/jdk-11"
+export GROOVY_HOME="$REPO_HOME/tool/groovy-4.0.9"
+export PATH=\
+:"$JAVA_HOME"/bin\
+:"$GROOVY_HOME"/bin\
+:"$PATH"
+
+export ENV_DEV_BUILD=true
+echo "${BASH_SOURCE[0]}" "complete"
#!/bin/env bash
+if [ -z "$ENV_DEV" ]; then
+ echo "make.sh:: script can only be run from in developer environment"
+ return 1
+fi
+
cd "$REPO_HOME"/developer/groovyc
groovyc AriadneGraph.groovy
// Access the environment variable REPO_HOME
def repo_home = System.getenv('REPO_HOME')
-if (!repo_home) {
- println "Error: REPO_HOME is not set."
- System.exit(1)
+def env_dev_build = System.getenv('ENV_DEV_BUILD')
+def arg_error = false;
+if(!repo_home){
+ println "release:: REPO_HOME is not set."
+ arg_error = true
+}
+if(!env_dev_build){
+ println "release:: ENV_BUILD_VERSION is not set."
+ arg_error = true
+}
+if(arg_error){
+ System.exit(1)
}
-def version = "0.1"
-
-def release_dir = "${repo_home}/user/Ariadne_${version}"
+def release_dir = "${repo_home}/release_candidate"
def release_dir_file = new File(release_dir)
-if (!release_dir_file.exists()) {
- release_dir_file.mkdirs()
+if (!release_dir_file.exists()){
+ release_dir_file.mkdirs()
}
// Function to use 'install' command for copying and setting permissions
-def install_file(source_fp, target_dp, perms) {
- def target_file = "${target_dp}/${new File(source_fp).name}"
- def cmd = ["install", "-m", perms, source_fp, target_file]
- def process = cmd.execute()
- process.waitFor()
- if (process.exitValue() != 0) {
- println "Error: Failed to install ${new File(source_fp).name} to ${target_dp}"
- println process.err.text
- System.exit(1)
- }
- println "Installed ${new File(source_fp).name} to ${target_dp} with permissions ${perms}"
+def install_file(source_fp, target_dp, perms){
+ def target_file = "${target_dp}/${new File(source_fp).name}"
+ def cmd = ["install", "-m", perms, source_fp, target_file]
+ def process = cmd.execute()
+ process.waitFor()
+ if( process.exitValue() != 0 ){
+ println "Error: Failed to install ${new File(source_fp).name} to ${target_dp}"
+ println process.err.text
+ System.exit(1)
+ }
+ println "Installed ${new File(source_fp).name} to ${target_dp} with permissions ${perms}"
}
def build_fp = "${repo_home}/developer/groovy/build"
def ariadne_class_files = new File("${repo_home}/developer/groovyc").listFiles().findAll {
- it.name.startsWith("AriadneGraph") && it.name.endsWith(".class")
+ it.name.startsWith("AriadneGraph") && it.name.endsWith(".class")
}
// Install the build script
// Install all matching class files
ariadne_class_files.each { class_file ->
- install_file(class_file.absolutePath, release_dir, "ug+r")
+ install_file(class_file.absolutePath, release_dir, "ug+r")
}
-println "Release version ${version} completed at $release_dir"
#!/bin/env bash
-echo 0.1
-
+# get this from the project management level exector directory
+"$REPO_HOME"/executor/version
\ No newline at end of file
#!/usr/bin/env groovy
// Function to load the graph class dynamically
-def include_graph_class( graph_class_fp ) {
- def class_loader = this.class.classLoader
- try {
- def graph_class = class_loader.loadClass(graph_class_fp)
- println "Successfully loaded class: ${graph_class}"
- return graph_class.newInstance()
- } catch (Exception e) {
- println "Error loading class: ${e.message}"
- e.printStackTrace()
- System.exit(1)
- }
+def include_a_class( a_class_fp ){
+ def class_loader = this.class.classLoader
+ try{
+ return class_loader.loadClass(a_class_fp)
+ } catch(Exception e){
+ return null
+ }
}
// Main build function for the Shell UI
-def build( graph_class_fp ) {
- // Load the graph class dynamically
- def graph_class = include_graph_class( graph_class_fp )
+def build(graph_definition_fp){
+ // Load the graph class dynamically
+ def graph_definition_class = include_a_class(graph_definition_fp)
+ if(graph_definition_class){
+ println "build:: loaded ${graph_definition_fp}.class"
+ } else{
+ println "build:: failed to load ${graph_definition_fp}.class"
+ System.exit(1)
+ }
- // Get the node_map and node_f_list from the graph class
- def node_map = graph_class.get_node_map()
- def node_f_list = graph_class.get_node_f_list()
+ // Get the node_map and node_f_list from the graph class
+ def node_map = graph_definition_class.get_node_map()
+ def node_f_list = graph_definition_class.get_node_f_list()
+ // println "node_map: ${node_map}"
+ // println "node_f_list: ${node_f_list}"
- // Log the result
- println "node_map: ${node_map}"
- println "node_f_list: ${node_f_list}"
+ graph = new AriadneGraph(node_map ,node_f_list)
- // Check if node_map and node_f_list are defined
- if( !(node_map instanceof Map) || !(node_f_list instanceof List) ){
- println "Error: Graph definition must define both 'node_map' and 'node_f_list'"
- System.exit(1)
- }
-
- // Call the build function in AriadneGraph
- AriadneGraph.run_build_scripts_f( node_map ,node_f_list )
+ // Call the build function in AriadneGraph
+ // AriadneGraph.run_build_scripts_f(node_map ,node_f_list)
}
// Entry point for the script
-if( args.length == 0 ){
- println "Usage: ./build <graph_class_definition>"
- System.exit(1)
+if(args.length == 0){
+ println "Usage: ./build <graph_definition.class>"
+ System.exit(1)
}
-def graph_class_fp = args[0]
-build( graph_class_fp )
+def graph_definition_fp = args[0]
+build( graph_definition_fp )
List node_f_list = []
// Constructor to accept a graph definition (node_map and node_f_list)
- AriadneGraph( Map node_map ,List node_f_list ){
+ AriadneGraph(Map node_map ,List node_f_list){
+ def accept_arg_list = true;
+ if( !(node_map === null) && !(node_map instanceof Map) ) accept_arg_list = false
+ if( !(node_f_list === null) && !(node_f_list instanceof List) ) accept_arg_list = false
+ if(node_map === null && node_f_list === null) accept_arg_list = false
+ if(!accept_arg_list){
+ println "AriandreGraph: requiers one or both of 'node_map' as Map, and 'node_f_list as List.'"
+ System.exit(1)
+ }
this.node_map = node_map ?: [:]
this.node_f_list = node_f_list ?: []
}
def wellformed_graph_q(root_node_labels ,boolean verbose = true){
def ret_value = [] as Set
def exists_malformed = false;
+ def result // used variously
// check the root nodes
- def result = mark_the_wellformed_f(root_node_labels ,verbose)
+ result = mark_the_wellformed_f(root_node_labels ,verbose)
if(result == 'exists_malformed'){
ret_value << 'exists_malformed'
}
// iterate over left side tree descent ,not ideal as it starts at the
// root each time ,but avoids complexity in the cycle detection logic.
do{
- def result = markup_graph_f_descend(path_stack ,verbose)
+ result = markup_graph_f_descend(path_stack ,verbose)
if('cycle_found' in result) ret_value << 'cycle_exists'
if('exists_malformed' in result) exists_malformed = true;
--- /dev/null
+
+Work Flow
+
+1. Development
+
+ 1.1. developer makes edits
+ 1.2. developer uses 'release' which will copy relevant files to the $REPO_HOME/release_candidate
+ 1.3. tester will test the candidate
+
+2. Release
+
+ 2.1. Upon completion of testing, project manager will make a new branch for release
+ named release_<version>. Version has a major and minor number.
+
+2.2. on the new branch the 'release_candidate' directory is renamed 'release_<version>'.
+
+3. Release specific fixes
+
+ 3.1.the 'release_candidate' directory is recreated
+ 3.2 steps 1.1 - 1.33 are repeated
+ 3.3 when testing is complete, 'release_candidate' is renamed 'release_version'
+ with the minor version incremented.
+
+4. Major release
+
+ Development continues on the `core_developer_branch` even after creation of a
+ `release_version` branch. For a next major release, increment the major release
+ number and do as described in steps 2 then 3.
+
echo REPO_HOME "$REPO_HOME"
echo PROJECT "$PROJECT"
echo "${BASH_SOURCE[0]}" "complete"
+
+export ENV_BASE=true
return 1
fi
-# Check if REPO_HOME is set, if not source env_base
-if [ -z "$REPO_HOME" ]; then
+if [ -z "$ENV_BASE" ]; then
script_path="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
source "${script_path}/env_base"
fi
-export JAVA_HOME="$REPO_HOME/tool/jdk-11"
-export GROOVY_HOME="$REPO_HOME/tool/groovy-4.0.9"
-
export PATH=\
"$REPO_HOME"/developer/executor\
-:"$JAVA_HOME"/bin\
-:"$GROOVY_HOME"/bin\
:"$PATH"
# so the .gitignore files can be seen:
# Corrected line:
cd "$REPO_HOME/developer"
+export ENV_DEV=true
source "$REPO_HOME"/developer/executor/env_build
-
echo "${BASH_SOURCE[0]}" "complete"
+
+
+
return 1
fi
-# Check if REPO_HOME is set, if not source env_base
-if [ -z "$REPO_HOME" ]; then
+if [ -z "$ENV_BASE" ]; then
script_path="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
source "${script_path}/env_base"
fi
+ENV_PM=true
+
PROJECT="$PROJECT"_PM
export PATH=\
# no sneaky hidden files
alias ls="ls -a"
+
+export ENV_PM=true
echo "${BASH_SOURCE[0]}" "complete"
fi
# Check if REPO_HOME is set, if not source env_base
-if [ -z "$REPO_HOME" ]; then
+if [ -z "$ENV_BASE" ]; then
script_path="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"
source "${script_path}/env_base"
fi
:"$PATH"
cd "$REPO_HOME"/tester
-source executor/env_test
+
+export ENV_TESTER=true
+source executor/env_tester
echo "${BASH_SOURCE[0]}" "complete"
--- /dev/null
+#!/bin/env bash
+
+echo 0.1
+
--- /dev/null
+#!/usr/bin/env groovy
+
+// Function to load the graph class dynamically
+def include_a_class( a_class_fp ){
+ def class_loader = this.class.classLoader
+ try{
+ return class_loader.loadClass(a_class_fp)
+ } catch(Exception e){
+ return null
+ }
+}
+
+// Main build function for the Shell UI
+def build(graph_definition_fp){
+ // Load the graph class dynamically
+ def graph_definition_class = include_a_class(graph_definition_fp)
+ if(graph_definition_class){
+ println "build:: loaded ${graph_definition_fp}.class"
+ } else{
+ println "build:: failed to load ${graph_definition_fp}.class"
+ System.exit(1)
+ }
+
+ // Get the node_map and node_f_list from the graph class
+ def node_map = graph_definition_class.get_node_map()
+ def node_f_list = graph_definition_class.get_node_f_list()
+ // println "node_map: ${node_map}"
+ // println "node_f_list: ${node_f_list}"
+
+ graph = new AriadneGraph(node_map ,node_f_list)
+
+ // Call the build function in AriadneGraph
+ // AriadneGraph.run_build_scripts_f(node_map ,node_f_list)
+}
+
+// Entry point for the script
+if(args.length == 0){
+ println "Usage: ./build <graph_definition.class>"
+ System.exit(1)
+}
+
+def graph_definition_fp = args[0]
+build( graph_definition_fp )
--- /dev/null
+#!/bin/env bash
+
+# Ensure the script is sourced
+if [ -z "$ENV_TESTER" ]; then
+ echo "env_build:: script can only be run in the tester environment"
+ return 1
+fi
+
+cd "$REPO_HOME"/tester/test0
+groovyc TestGraph.groovy
+++ /dev/null
-#!/usr/bin/env bash
-# environment common to all tests
-# each test directory also has an environment
\ No newline at end of file
--- /dev/null
+#!/usr/bin/env bash
+# environment common to all tests
+# each test directory also has an environment
+
+export JAVA_HOME="$REPO_HOME/tool/jdk-11"
+export GROOVY_HOME="$REPO_HOME/tool/groovy-4.0.9"
+
+export PATH=\
+"$REPO_HOME"/release_candidate\
+:"$JAVA_HOME"/bin\
+:"$GROOVY_HOME"/bin\
+:"$PATH"
--- /dev/null
+#!/bin/env bash
+
+if [ -z "$ENV_TESTER" ]; then
+ echo "make.sh:: script can only be run in the tester environment"
+ env_error=true
+fi
+
+cd "$REPO_HOME"/tester/test0
+groovyc TestGraph.groovy
-
-export JAVA_HOME="$REPO_HOME/tool/jdk-11"
-export GROOVY_HOME="$REPO_HOME/tool/groovy-4.0.9"
-
-export PATH=\
-"$REPO_HOME"/user/Ariadne_0.1\
-:"$JAVA_HOME"/bin\
-:"$GROOVY_HOME"/bin\
-:"$PATH"
-
-export CLASSPATH="$REPO_HOME"/user/Ariadne_0.1:"$REPO_HOME"/tester/test0:$CLASSPATH
+if [ -z "$ENV_TESTER" ]; then
+ echo "env_test0:: script can only be run in the tester environment"
+ env_error=true
+fi
+
+export CLASSPATH=\
+"$REPO_HOME"/release_candidate\
+:"$REPO_HOME"/tester/test0\
+:$CLASSPATH
+++ /dev/null
-#!/bin/env bash
-
-groovyc TestGraph.groovy
\ No newline at end of file
--- /dev/null
+#!/bin/env bash
+
+# smoke test, and yes, there was a lot of smoke
+
+source env_test0
+build TestGraph
+echo "test0 complete"
+
--- /dev/null
+2024-10-05T12:09:05Z[]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer§
+> cd Ariadne
+
+2024-10-05T12:09:24Z[]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne§
+> source executor/env_tester
+REPO_HOME /var/user_data/Thomas-developer/Ariadne
+PROJECT Ariadne
+/var/user_data/Thomas-developer/Ariadne/executor/env_base complete
+executor/env_tester complete
+
+2024-10-05T12:09:33Z[Ariadne_TESTER]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/tester§
+> cd test0
+
+2024-10-05T12:09:38Z[Ariadne_TESTER]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/tester/test0§
+> make.sh
+
+2024-10-05T12:09:42Z[Ariadne_TESTER]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/tester/test0§
+> ./test0.sh
+build:: loaded TestGraph.class
+test0 complete
+
+2024-10-05T12:09:51Z[Ariadne_TESTER]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/tester/test0§
+>
--- /dev/null
+2024-10-05T12:07:43Z[]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer§
+> repo Ariadne
+REPO_HOME /var/user_data/Thomas-developer/Ariadne
+PROJECT Ariadne
+/var/user_data/Thomas-developer/Ariadne/executor/env_base complete
+/var/user_data/Thomas-developer/Ariadne/developer/executor/env_build complete
+/var/user_data/Thomas-developer/Ariadne/executor/env_dev complete
+
+2024-10-05T12:07:51Z[Ariadne]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/developer§
+> make.sh
+
+2024-10-05T12:08:11Z[Ariadne]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/developer§
+> release
+Installed build to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r,ug+x
+Installed AriadneGraph.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_wellformed_q_closure1.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_wellformed_q_closure2.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_run_build_scripts_f_closure3.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_mark_the_wellformed_f_closure3.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_mark_the_wellformed_f_closure3$_closure13.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_markup_graph_f_descend_closure4.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_markup_graph_f_descend_closure5.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_markup_graph_f_descend_closure6.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_all_DAG_DF_closure7.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_all_DAG_DF_closure8.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_all_DAG_DF_closure9.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_good_dependency_q_closure10.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_newer_than_all_closure11.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+Installed AriadneGraph$_run_build_scripts_f_closure12.class to /var/user_data/Thomas-developer/Ariadne/release_candidate with permissions ug+r
+
+2024-10-05T12:08:18Z[Ariadne]
+Thomas-developer@Blossac§/var/user_data/Thomas-developer/Ariadne/developer§
+>
+++ /dev/null
-class AriadneGraph {
-
- // Instance variables for graph data if needed
- Map node_map = [:]
- List node_f_list = []
-
- // Constructor to accept a graph definition (node_map and node_f_list)
- AriadneGraph( Map node_map ,List node_f_list ){
- this.node_map = node_map ?: [:]
- this.node_f_list = node_f_list ?: []
- }
-
- /*--------------------------------------------------------------------------------
- File utility functions
- */
-
- static Map unpack_file_path( String file_fp ){
- def file = new File( file_fp )
-
- def parent_dp = file.getParent()
- def file_fn = file.getName()
- def file_fn_base = file_fn.lastIndexOf('.') > 0 ? file_fn[ 0..file_fn.lastIndexOf('.') - 1 ] : file_fn
- def file_fn_ext = file_fn.lastIndexOf('.') > 0 ? file_fn[ file_fn.lastIndexOf('.') + 1..-1 ] : ''
-
- return [
- parent_dp: parent_dp
- ,file_fn: file_fn
- ,file_fn_base: file_fn_base
- ,file_fn_ext: file_fn_ext
- ]
- }
-
- static boolean file_exists_q( String node_label ){
- def node_path = Paths.get( node_label )
- return Files.exists( node_path )
- }
-
- /*--------------------------------------------------------------------------------
- Node type checks and marking
- */
-
- static Set all_node_type_set = ['symbol' ,'path' ,'leaf' ,'generator'] as Set
- static Set persistent_node_mark_set = ['cycle_member' ,'wellformed' ,'build_failed'] as Set
-
- static boolean leaf_q( Map node ){
- return node && node.type == 'leaf'
- }
-
- static boolean has_mark( Map node ){
- return node?.mark?.isNotEmpty()
- }
-
- static void set_mark( Map node ,String mark ){
- node.mark = node.mark ?: [] as Set
- node.mark << mark
- }
-
- static void clear_mark( Map node ,String mark ){
- node?.mark?.remove( mark )
- }
-
- static boolean marked_good_q( Map node ){
- return node && node.mark && ( 'wellformed' in node.mark ) && !( 'cycle_member' in node.mark ) && !( 'build_failed' in node.mark )
- }
-
- /*--------------------------------------------------------------------------------
- Well-formed Node Check
- */
-
- static Set all_form_error_set = [
- 'no_node'
- ,'node_must_have_label'
- ,'label_must_be_string'
- ,'node_must_have_type'
- ,'bad_node_type'
- ,'neighbor_value_must_be_list'
- ,'neighbor_reference_must_be_string'
- ,'mark_property_value_must_be_set'
- ,'unregistered_mark'
- ,'missing_required_build_code'
- ,'leaf_given_neighbor_property'
- ,'leaf_given_build_property'
- ] as Set
-
- static Set wellformed_q( Map node ){
- def form_error_set = [] as Set
-
- if( !node ){
- form_error_set << 'no_node'
- return form_error_set
- }
-
- if( !node.label )
- form_error_set << 'node_must_have_label'
- else if( !( node.label instanceof String ) )
- form_error_set << 'label_must_be_string'
-
- if( !node.type )
- form_error_set << 'node_must_have_type'
- else if( !( node.type instanceof String ) || !( node.type in all_node_type_set ) )
- form_error_set << 'bad_node_type'
-
- if( node.neighbor ){
- if( !( node.neighbor instanceof List ) )
- form_error_set << 'neighbor_value_must_be_list'
- else if( !( node.neighbor.every { it instanceof String } ) )
- form_error_set << 'neighbor_reference_must_be_string'
- }
-
- if( node.mark ){
- if( !( node.mark instanceof Set ) )
- form_error_set << 'mark_property_value_must_be_set'
- else if( !( node.mark.every { it in persistent_node_mark_set } ) )
- form_error_set << 'unregistered_mark'
- }
-
- if( node.type == 'path' && ( !node.build || !( node.build instanceof Closure ) ) )
- form_error_set << 'missing_required_build_code'
-
- if( node.type == 'leaf' ){
- if( node.neighbor ) form_error_set << 'leaf_given_neighbor_property'
- if( node.build ) form_error_set << 'leaf_given_build_property'
- }
-
- return form_error_set
- }
-
- /*--------------------------------------------------------------------------------
- Graph traversal and build functions
- */
-
- def lookup( String node_label ,boolean verbose = false ){
- def lookup_node = node_map[ node_label ]
- if( !lookup_node ){
- def match_result
- for( func in node_f_list ){
- match_result = func( node_label )
- if( match_result.status == "matched" ){
- lookup_node = match_result
- break
- }
- }
- }
-
- if( !lookup_node && verbose ) println "lookup:: Node ${node_label} could not be found."
- return lookup_node
- }
-
- def run_build_scripts_f( List root_node_labels ,boolean verbose = true ){
- if( root_node_labels.isEmpty() ) return
-
- def node_function = { node ,error_token_set ->
-
- if( !can_be_built_q( node ) ){
- println( "Skipping build for ${node.label} due to dependency problems" )
- return
- }
- if( !should_be_built_q( node ) ){
- if( verbose ) println( "${node.label} already up to date" )
- return
- }
-
- println( "Running build script for ${node.label}" )
- node.build( node ,node.neighbor )
-
- if( should_be_built_q( node ) ){
- println( "Build failed for ${node.label}" )
- set_mark( node ,'build_failed' )
- }
- }
-
- println( "run_build_scripts_f:: running ..." )
- all_DAG_DF( root_node_labels ,node_function ,verbose )
- }
-
- // Add the rest of your methods here as instance/static methods based on whether they depend on the graph instance
-
-}
+++ /dev/null
-#!/usr/bin/env groovy
-
-// Function to load the graph class dynamically
-def include_graph_class( graph_class_fp ) {
- def class_loader = this.class.classLoader
- try {
- def graph_class = class_loader.loadClass(graph_class_fp)
- println "Successfully loaded class: ${graph_class}"
- return graph_class.newInstance()
- } catch (Exception e) {
- println "Error loading class: ${e.message}"
- e.printStackTrace()
- System.exit(1)
- }
-}
-
-// Main build function for the Shell UI
-def build( graph_class_fp ) {
- // Load the graph class dynamically
- def graph_class = include_graph_class( graph_class_fp )
-
- // Get the node_map and node_f_list from the graph class
- def node_map = graph_class.get_node_map()
- def node_f_list = graph_class.get_node_f_list()
-
- // Log the result
- println "node_map: ${node_map}"
- println "node_f_list: ${node_f_list}"
-
- // Check if node_map and node_f_list are defined
- if( !(node_map instanceof Map) || !(node_f_list instanceof List) ){
- println "Error: Graph definition must define both 'node_map' and 'node_f_list'"
- System.exit(1)
- }
-
-
- // Call the build function in AriadneGraph
- AriadneGraph.run_build_scripts_f( node_map ,node_f_list )
-}
-
-// Entry point for the script
-if( args.length == 0 ){
- println "Usage: ./build <graph_class_definition>"
- System.exit(1)
-}
-
-def graph_class_fp = args[0]
-build( graph_class_fp )
projects / Ariadne / commitdiff