jongleur 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07160e415a435e146c2b162340f0bacef4f3fb27
-  data.tar.gz: 8205d5c8ea466a6e9b1e89d4cc03a5d2f2aba548
+  metadata.gz: 1db9f251078cde21dde04e7c3c1c39c9ad6507ac
+  data.tar.gz: '0609f7301f92b48d44f9c7f62d5a5456b927945e'
 SHA512:
-  metadata.gz: 9755c27900cda89b1a8c1a083d6fd05cf62f90ec1a5fd1ed796b57a35ef5049acb740984085c19e2e7feeca41f789fa4f67a1daea9574f99eef908e5a810ae66
-  data.tar.gz: 1dfc257b182634e4af25886e64fdc46986258d6739db8b5e27d0682db2b4f4989ef576eaedf3480fb7c86d574681220a3651b912e93ad5d7b3c13b093dad622a
+  metadata.gz: 1a849e5637bd3aa31f3cc9f80ebf335ee9691f2d54033bde1ace51b05fa86a4f78abb995ef647e1cb025f0050697bef151421d0530db3c1486d8baaf23df5766
+  data.tar.gz: eb9d2f5f43b0fa02ff67620f1b4731de57491d70e437e80c9f0f58153d765d7118ba0a6280022846ec903cb02b1c43431ddf1c0b5ddd6f92c8e1d51f0d0c12f6

data/CHANGELOG.md

@@ -16,4 +16,12 @@ All notable changes to this project will be documented in this file.
 
 ## [1.0.4] - 20-Oct-2018
 ### Added
-- bin/setup enhanced to install Graphviz dependency
+- bin/setup enhanced to install Graphviz dependency
+
+## [1.1.0] - 31-Dec-2018
+### Added
+- 'Completed' asynchronous callback when execution is finished (via Hollerback gem)
+- Added finish_time atrribute to task_matrix as to timestamp process completion
+
+### Changed
+- Re-written specs to use async callback

data/README.md

@@ -4,7 +4,7 @@
 
 Jongleur is a process scheduler and manager. It allows its users to declare a number of executable tasks as Ruby classes, define precedence between those tasks and run each task as a separate process.
 
-Jongleur is particularly useful for implementing workflows modeled as a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph) 
+Jongleur is particularly useful for implementing workflows modelled as a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph) 
 (Directed Acyclic Graph), but can be also used to run multiple tasks in parallel or even sequential workflows where each task needs to run as a separate OS process. 
 
 ## Environment
@@ -14,6 +14,16 @@ It will work on Linux and Mac OS but not on Windows.
 
 Jongleur has been tested with MRuby 2.4.3, 2.4.4, 2.5.0 and 2.5.1. I would also expect it to work with other Ruby implementations too, such as JRuby or Rubinius though it hasn't yet been tested on those.
 
+## Pre-requisites
+
+This gem depends on the [Graphviz](https://www.graphviz.org/) package for drawing graphs. If this isn't already installed on your system please install with
+
+`$ sudo apt-get install graphviz`  (Linux)
+
+or 
+
+`$ brew cask install graphviz`(Mac OS)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -31,9 +41,11 @@ Or install it yourself as:
     $ gem install jongleur
 
 
+In either case, call `require jongleur` before using the gem.
+
 ## What does it do?
 
-In a nutshell, Jongleur keeps track of a number of tasks and executes them as separate OS processes according to their precedence criteria. For instance, if there are 3 tasks A, B and C, and task C depends on A and B, Jongleur will start executing A and B in separate processes (i.e. in parallel) and will wait until they are both finished before it executes C in a separate process. 
+In a nutshell, Jongleur keeps track of a number of tasks and executes them as separate OS processes according to their precedence criteria. For instance, if there are 3 tasks A, B and C, and task C depends on A and B, Jongleur will start executing A and B in separate processes (i.e.. in parallel) and will wait until they are both finished before it executes C in a separate process. 
 
 Jongleur is ideal for running workflows represented as DAGs, but is also useful for simply running tasks in parallel or for whenever you need some multi-processing capability. 
 
@@ -68,9 +80,9 @@ run only after this Task is finished. So in the above example:
 
 * Tasks Q, R and T can only start after task S has finished.
 * Task R can only start after Q has finished.
-* Tasks T and T have no dependents. No other task need wait for them.
+* Tasks T and T have no dependants. No other task need wait for them.
 
-__N.B:__ Since the _Task Graph_ is a Hash, any duplicate key entries will be overriden. For instance, if this Task Graph
+__N.B:__ Since the _Task Graph_ is a Hash, any duplicate key entries will be overridden. For instance, if this Task Graph
 
 ```
 my_task_graph = { A: [:B, :C], B: [:D] }
@@ -97,20 +109,21 @@ Jongleur::API.task_matrix
  After defining your Task Graph and before running Jongleur, your _Task Matrix_ should look like this:
 
 ```
-#<Jongleur::Task name=:A, pid=-1, running=false, exit_status=nil, success_status=nil>,
-#<Jongleur::Task name=:B, pid=-1, running=false, exit_status=nil, success_status=nil>,
-#<Jongleur::Task name=:C, pid=-1, running=false, exit_status=nil, success_status=nil>,
-#<Jongleur::Task name=:D, pid=-1, running=false, exit_status=nil, success_status=nil>,
-#<Jongleur::Task name=:E, pid=-1, running=false, exit_status=nil, success_status=nil>
+#<Jongleur::Task name=:A, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+#<Jongleur::Task name=:B, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+#<Jongleur::Task name=:C, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+#<Jongleur::Task name=:D, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+#<Jongleur::Task name=:E, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>
+
 ``` 
 After Jongleur finishes, your _Task Matrix_ will look something like this:
 
 ```
-#<Jongleur::Task name=:A, pid=95117, running=false, exit_status=0, success_status=true>
-#<Jongleur::Task name=:B, pid=95118, running=false, exit_status=0, success_status=true>
-#<Jongleur::Task name=:C, pid=95120, running=false, exit_status=0, success_status=true>
-#<Jongleur::Task name=:D, pid=95122, running=false, exit_status=0, success_status=true>
-#<Jongleur::Task name=:E, pid=95123, running=false, exit_status=0, success_status=true>
+#<Jongleur::Task name=:A, pid=95117, running=false, exit_status=0, finish_time=1546279899.005019, success_status=true>
+#<Jongleur::Task name=:B, pid=95118, running=false, exit_status=0, finish_time=1546279901.0053551, success_status=true>
+#<Jongleur::Task name=:C, pid=95120, running=false, exit_status=0, finish_time=1546279900.0213592, success_status=true>
+#<Jongleur::Task name=:D, pid=95122, running=false, exit_status=0, finish_time=1546279912.0673511, success_status=true>
+#<Jongleur::Task name=:E, pid=95123, running=false, exit_status=0, finish_time=1546279909.0876418, success_status=true>
 ```
 
 The `Jongleur::Task` attribute values are as follows
@@ -119,6 +132,7 @@ The `Jongleur::Task` attribute values are as follows
 * pid : the Task process id (`nil` if the task hasn't yet ran)
 * running : `true` if task is currently running
 *  exit_status : usually 0 if process finished without errors, <>0 or `nil` otherwise
+*  finish_time : the Task's completion timestamp as a flating point number of seconds since Epoch
 *  success_status :  `true` if process finished successfully, `false` if it didn't or `nil` if process didn't exit at all
 
 
@@ -131,11 +145,10 @@ This is the implementation template for a Task. For each Task in your Task Graph
 
 Using Jongleur is easy:
 
-1. (Optional) You may want to head your code with `require Jongleur` so that you won't have to namespace every api call.
+1. (Optional) Add `include jongleur` so that you won't have to namespace every api call.
 
 2. Define your Task Graph
 
-
 		test_graph = {
 	      A: [:B, :C],
 	      B: [:D],
@@ -144,17 +157,17 @@ Using Jongleur is easy:
 	      E: []
 	    }
 
+	Each Task corresponds to a Ruby class with an `execute` method
 
 3. Add your Task Graph to Jongleur
 		
-
 		API.add_task_graph test_graph
 	
-		=> [#<struct Jongleur::Task name=:A, pid=-1, running=false, exit_status=nil, success_status=nil>,
-	 		#<struct Jongleur::Task name=:B, pid=-1, running=false, exit_status=nil, success_status=nil>,
-	 		#<struct Jongleur::Task name=:C, pid=-1, running=false, exit_status=nil, success_status=nil>,
-	 		#<struct Jongleur::Task name=:D, pid=-1, running=false, exit_status=nil, success_status=nil>,
-	 		#<struct Jongleur::Task name=:E, pid=-1, running=false, exit_status=nil, success_status=nil>]
+		=> [#<struct Jongleur::Task name=:A, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+	 		#<struct Jongleur::Task name=:B, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+	 		#<struct Jongleur::Task name=:C, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+	 		#<struct Jongleur::Task name=:D, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>,
+	 		#<struct Jongleur::Task name=:E, pid=-1, running=false, exit_status=nil, finish_time=0, success_status=nil>]
 
 	
 	Jongleur will show you the Task Matrix for your Task Graph with all attributes set at their initial values, obviously, since the Tasks haven't ran yet.
@@ -170,22 +183,29 @@ Using Jongleur is easy:
 	
 	<img src="./bin/img/DAG_graph_1.png"  width="225" height="450" alt="ETL DAG">
 	
-5. Implement your tasks. To do that you have to (i) create a new class, based on `WorkerTask` and (ii) define and `#execute` method in your class. This is the method hat Jongleur will call to run the Task. For instance task A from your Task Graph may look something like that:
+5. Implement your tasks. To do that you have to 
+
+	* create a new class, based on `WorkerTask` and named as in your Task Graph
+	* define an `#execute` method in your class. This is the method that Jongleur will call to run the Task. 
+	
+	For instance task A from your Task Graph may look something like that:
    
 
 		   class A < Jongleur::WorkerTask
 		  	  @desc = 'this is task A'
 		  	  def execute
-		       sleep 1
+		       sleep 1 # do something
 		       'A is running... '
 		  	  end
 			end
 
-	You'll have to do the same for Tasks B, C, D and E, as these ae the tasks declared in the Task Graph.
+	You'll have to do the same for Tasks B, C, D and E, as these are the tasks declared in the Task Graph.
 
-6. Run the tasks. Ok, pay attention now because this is the complex bit. Nah, only joking - it's simply:
+6. Run the tasks and implement the `completed` callback. This will be called asynchronously when Jongleur has finished running all the tasks. 
 
-		   $> API.run
+		   $ API.run do |on|
+          		on.completed { |task_matrix| puts "Done!"}
+        	end
 		   
 		  => Starting workflow...
 		  => starting task A
@@ -199,10 +219,10 @@ Using Jongleur is easy:
 		 => starting task E
 		 => finished task: E, process: 2506, exit_status: 0, success: true
 		 => Workflow finished
+		 => Done!
 	  
    
-A simple example of a client app for Jongleur can be found [on GitLab](https://gitlab.com/RedFred7/jongleur-client) 
-		
+Examples of running Jongleur can be found in the `examples` directory.		
 ## Use-Cases
 ### Extract-Transform-Load
 The ETL workflow is ideally suited to Jongleur.  You can define many Extraction tasks -maybe separate Tasks for different data sources- and have them ran in parallel to each other. At the same time Transformation and Loading Tasks wait in turn for the previous task to finish before they start, as in this DAG illustration: 
@@ -210,7 +230,7 @@ The ETL workflow is ideally suited to Jongleur.  You can define many Extraction
 <img src="./bin/img/ETL_DAG.png"  width="450" height="450" alt="ETL DAG">
 
 ### Transactions
-Transactional workflows can be greatly sped up by Jongleur by parallelising parts of the transaction that are usually performed sequentially, i.e:
+Transactional workflows can be greatly sped up by Jongleur by parallelising parts of the transaction that are usually performed sequentially, i.e.:
 
 <img src="./bin/img/transactional_DAG.png"  width="550" height="450" alt="Transaction DAG">
 		
@@ -224,10 +244,10 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## F.A.Q
 
 ### Does Jongleur allow me to pass messages between Tasks?
-No it doesn't. Each task is run competely independently from the other Tasks. There is no Inter-Process Communication, no common data contexts, no shared memory.
+No it doesn't. Each task is run completely independently from the other Tasks. There is no Inter-Process Communication, no common data contexts, no shared memory.
 
 ### How can I share data created by a predecessor Task?
-This is something that I wouldl ike to build into Jongleur. For now, you can save a Task's data in a detabase or KV Store and using the Tasks process id as part of the key.  Subsequent Tasks can retrieve their predecessor's process ids with
+This is something that I would like to build into Jongleur. For now, you can save a Task's data in a database or KV Store and using the Task's process id as part of the key.  Subsequent Tasks can retrieve their predecessor's process ids with
 
 ```
 API.get_predecessor_pids
@@ -239,13 +259,25 @@ and therefore retrieve the data created by those Tasks.
 According to [the official docs](https://ruby-doc.org/core-2.4.3/Process/Status.html) `exit_status` returns the least significant eight bits of the return code of the `stat` call while `success_status` returns true if `stat` is successful.
 
 ### What happens when Jongleur finishes running?
-When Jongleur finishes running all tasks in its Task Graph -and regardless of whether the Tasks themselves have failed ot not- it will exit the parent process with an exit code of 0. 
+When Jongleur finishes running all tasks in its Task Graph -and regardless of whether the Tasks themselves have failed or not- it will exit the parent process with an exit code of 0. 
 
 ### What happens if a Task fails
-If a Task fails to run or to finish its run, Jongleur will simply go on running any other tasks it can. It will not run any Tasks which depend on the failed Task. The status of the failed Task will be indicated via an appropriate output message and also on the Task Matrix. 
+If a Task fails to run or to finish its run, Jongleur will simply go on running any other tasks it can. It will not run any Tasks which depend on the failed Task. The status of the failed Task will be indicated via an appropriate output message and will also be visible on the Task Matrix. 
+
+### Can I quickly analyse the Task Matrix after Jongleur has finished?
+Yes. When the `completed` callback is called, Jongleur will enable the following methods:
+
+```
+API::successful_tasks
+API::failed_tasks
+API::not_ran_tasks
+API::hung_tasks
+```
+
+
+### Are there any execution logs saved?
 
-### How can I examine the Task Matrix after Jongleur has finished?
-Jongleur serializes each run's Task Matrix as a JSON file in the `/tmp` directory. You can either view this in an editor or load it and manipulate it in Ruby with 
+Jongleur serializes each run's Task Matrix as a time-stamped JSON file in the `/tmp` directory. You can either view this in an editor or load it and manipulate it in Ruby with 
 
 `JSON.parse( File.read('/tmp/jongleur_task_matrix_08272018_103406.json') )`
 

data/examples/example_tasks.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class A < Jongleur::WorkerTask
+  @desc = 'this is task A'
+  def execute
+    sleep 1
+    'A is running... '
+  end
+end
+
+class B < Jongleur::WorkerTask
+  @desc = 'this is task B'
+  def execute(colour: 'red', size: 45_634)
+    sleep 3
+    "B is running... with #{colour} and #{size}"
+  end
+end
+
+class C < Jongleur::WorkerTask
+  @desc = 'this is task C'
+  def execute
+    sleep 1
+    'C is running...'
+  end
+end
+
+class D < Jongleur::WorkerTask
+  @desc = 'this is task D'
+  def execute
+    sleep 1
+    'D is running...'
+  end
+end
+
+class E < Jongleur::WorkerTask
+  @desc = 'this is task E'
+  def execute
+    sleep 1
+    'E is running...'
+  end
+end
+
+class F < Jongleur::WorkerTask
+  @desc = 'this is task F'
+  def execute
+    sleep 1
+    'F is running...'
+  end
+end

data/examples/simple.rb

@@ -0,0 +1,25 @@
+require_relative File.expand_path('../lib/jongleur.rb', __dir__)
+require_relative './example_tasks' 
+include Jongleur
+
+test_graph = {
+      A: [:C],
+      B: [:D],
+      C: [:E],
+      D: [:E],
+      E: []
+    }
+
+API.add_task_graph test_graph
+
+API.run do |on|
+    puts ">>>> client does something"
+    on.completed do |task_matrix|
+      puts "Jongleur run is complete \n"
+       puts API.successful_tasks(task_matrix)
+       puts "oh-oh" if API.failed_tasks(task_matrix).length > 0 
+       # print tasks in order of finishing time
+       task_matrix.sort_by { |x| x.finish_time }.map { |t| STDOUT.puts t.name }
+    end
+    puts ">>>> client does another thing"
+  end

data/jongleur.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['fred@bootstrap.me.uk']
 
   spec.summary       = 'A multi-processing task scheduler and manager.'
-  spec.description   = 'Launches, schedules and manages tasks represented in a DAG as multiple processes'
+  spec.description   = 'Launches, schedules and manages tasks represented in a DAG, as multiple processes'
   spec.homepage      = 'https://gitlab.com/RedFred7/Jongleur'
   spec.license       = 'MIT'
 
@@ -24,6 +24,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'graphviz', '~> 1.1'
   spec.add_dependency 'os', '~> 1.0'
+  spec.add_dependency 'hollerback', '~> 0.1'
+
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'pry-byebug', '~> 3.4'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/jongleur/api.rb

@@ -7,6 +7,7 @@ module Jongleur
   # Here be methods to be accessed by the gem's client, i.e. the public API
   module API
     # @!scope class
+    include Hollerback
 
     # Accepts a task_graph and does some initialisation, namely the assigning
     # of class variables and creation of the inital task matrix
@@ -54,7 +55,7 @@ module Jongleur
     #   @return [Array<Jongleur::Task>] a list of Tasks and their current state
     #   @see Jongleur::Task
     def self.task_matrix
-      @@task_matrix
+      @@task_matrix || []
     end
 
     # @!attribute task_graph
@@ -123,7 +124,7 @@ module Jongleur
     # all children processes have finished.
     # @raise [RuntimeError] if there are no implementations for Tasks in the Task Graph
     # @return [void]
-    def self.run
+    def self.run(&block)
       unless Implementation.valid_tasks?(task_graph.keys)
         raise RuntimeError, 'Not all the tasks in the Task Graph are implemented as WorkerTask classes'
       end
@@ -136,13 +137,14 @@ module Jongleur
         begin
           # with WNOHANG flag we make sure Process.wait is not blocking
           while (res = Process.wait2(-1, Process::WNOHANG))
-            dead_pid = res[0]
-            status = res[1]
+            dead_pid, status = res
+            finish_time = Time.now.to_f
             dead_task_name = ''
             Implementation.find_task_by(:pid, dead_pid) do |t|
               t.running = false
               t.exit_status = status.exitstatus
               t.success_status = status.success?
+              t.finish_time = finish_time
               dead_task_name = t.name
             end
             msg = "finished task: %s, process: %i, exit_status: %i, success: %s"
@@ -168,17 +170,17 @@ module Jongleur
       end
 
       loop do
-        # We exit once all the child processes and their descendants are
-        # accounted for
+        # We exit once all the child processes and their descendants are accounted for
         if Implementation.running_tasks.empty?
           Implementation.process_message 'Workflow finished'
           file_name = File.expand_path("jongleur_task_matrix_#{Time.now.strftime('%m%d%Y_%H%M%S')}.json", '/tmp')
           File.open(file_name, 'w') {|f| f.write(task_matrix.to_json) }
+          hollerback_for(block) { |cb| cb.respond_with(:completed , task_matrix) } if block_given?
           exit 0
         end
         sleep 1
       end
-    end #method
+    end # method
 
 
     # Starts all tasks without dependencies as separate processes

data/lib/jongleur/implementation.rb

@@ -133,6 +133,11 @@ module Jongleur
       API.task_matrix.select(&:running)
     end
 
+    def self.get_task_list
+      API.task_matrix.select(&:running)
+    end
+
+
     # Find task based on an attribute's value
     #
     # @note the methof will find the first matching task. If there are more than one matches,
@@ -207,7 +212,8 @@ module Jongleur
     end
 
     def self.process_message(a_msg)
-      puts(a_msg)
+      STDOUT.puts(a_msg)
+      STDOUT.sync
     end
 
   end # module

data/lib/jongleur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jongleur
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 end

data/lib/jongleur.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 require 'graphviz'
 require 'json'
+require 'set'
+require 'hollerback'
 require_relative 'jongleur/version'
 require_relative 'jongleur/helpers'
 require_relative 'jongleur/worker_task'
@@ -23,10 +25,13 @@ module Jongleur
   # @!attribute exit_status
   #   @return [Integer, Nil] the process's return code when the process is exited
   #   Usually 0 for success, 1 for error or Nil otherwise
+  # @!attribute finish_time
+  #   @return [Float, 0] the timestamp of process completion as a floating point number 
+  #   of seconds since the Epoch 
   # @!attribute success_status
   #   @return [Boolean, Nil] true if process finished successfully, false if it didn't 
   #       or nil if process didn't exit properly.
-  Task = Struct.new(:name, :pid, :running, :exit_status, :success_status)
+  Task = Struct.new(:name, :pid, :running, :exit_status, :finish_time, :success_status)
 
   $stdout.sync = true
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jongleur
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Fred Heath
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-21 00:00:00.000000000 Z
+date: 2018-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphviz
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hollerback
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -136,12 +150,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: Launches, schedules and manages tasks represented in a DAG as multiple
+description: Launches, schedules and manages tasks represented in a DAG, as multiple
   processes
 email:
 - fred@bootstrap.me.uk
-executables:
-- test_gem.sh
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -160,7 +173,8 @@ files:
 - bin/img/jongleur_m-2015.jpg
 - bin/img/transactional_DAG.png
 - bin/setup
-- exe/test_gem.sh
+- examples/example_tasks.rb
+- examples/simple.rb
 - jongleur.gemspec
 - lib/jongleur.rb
 - lib/jongleur/api.rb

data/exe/test_gem.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-echo "Hello World!"