alterant 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58a70e9ec9e231c880a288c9c1ad0c0a839a2721448ed869567ab3b8b926c874
-  data.tar.gz: 9584c3391e717d9317a6513ec2d9e7b768d22aac33f368bf488aa3e9babed725
+  metadata.gz: 75ea4212fe9ff199e8d8b8447331ff908d2e5656b32761fd88faf017a837efc4
+  data.tar.gz: 55e19cf00b05ab47a58bcab3a46ce7cfbbd1b510c878b7d6ff53886d1cb37771
 SHA512:
-  metadata.gz: 1d076a7e5e5b1949740d829545223e75095f9fdbd96d7fc7abe0ea3de459ea9ac6a326964f28a27a2f3b07f03e70378c72f2ba44b72359cd76f3370df1152e8b
-  data.tar.gz: f2518b91cbe170114b526e3c873906b63894efd52ddac645974cd8094a7c1c82e98713ffd9d2a87a9ca148d1e3d67a56c76390da6513b58adc0c23c79148e65e
+  metadata.gz: '098f04bfe52130e4523d0bfd1e66489f1866aed4c8395926674f7ea8ffdea2c864ff0797eeda4839fb006b1fbdca6e5d4ed6e320ba40c8925c85a05a5ab596a9'
+  data.tar.gz: 7e8525ea905705450f4e8d320ddf1815eaacc47dd14adaf65a280f3089fac1909770152da2fac844e62aae897a8644bece4eb58a05726d7341d09538c25414a3

data/README.md

@@ -1,9 +1,3 @@
-![Alterant Logo](https://s3.amazonaws.com/cdn.cloud66.com/images/alterant_logo.png)
-
 # Alterant
 
-Alterant is a tool to modify JSON and YAML configuration files.
-
-```bash
-alterant modify --in config.yml --out output.yml --modifier script.js
-```
+Alterant is a command line tool that lets you manipulate YAML and JSON files using simple Javascript files. This is useful when applying broad modifications to Kubernetes configuration files. For more information checkout [Alterant Website](https://help.cloud66.com/alterant/)

data/bin/alterant

@@ -32,6 +32,8 @@ module Alterant
 		option :diff, type: :boolean, default: false, desc: "Return the diff instead of the output itself"
 		option :debug, type: :boolean, default: false
 		option :input_format, type: :string, enum: ['yaml', 'json'], default: 'yaml', desc: "Input format if it's based on a stream and not a file"
+		option :mem, type: :numeric, default: 1048576, desc: 'Maximum memory allowed to the modifier in bytes'
+		option :timeout, type: :numeric, default: 500, desc: 'Timeout allowed for the modifier in milliseconds'
 		option :overwrite, type: :boolean, default: false
 		def modify
 			$debug = options[:debug] || false
@@ -39,6 +41,8 @@ module Alterant
 			diff = options[:diff]
 			output_format = options[:output_format]
 			input_format = options[:input_format]
+			max_mem = options[:mem]
+			timeout = options[:timeout]
 
 			in_file = options[:in]
 			if !in_file
@@ -121,7 +125,7 @@ module Alterant
 
 			run_context[:js_preload] = ::Alterant::Classes.LoadClasses
 			alter = ::Alterant::Alterant.new(input: data, modifier: modifier, filename: modifier_file, options: run_context)
-			results = alter.execute(timeout: 500)
+			results = alter.execute(timeout: timeout, max_memory: max_mem)
 
 			if results.nil?
 				STDERR.puts "Aborting".red

data/lib/alterant/alterant.rb

@@ -22,22 +22,19 @@ module Alterant
 			snapshot = MiniRacer::Snapshot.new("$$ = #{@input.to_json};\n" + @js_preload.join("\n")) # this is more efficient but we lose debug info (filename) of helper classes
 
 			isolate = MiniRacer::Isolate.new(snapshot)
-			@input.each_with_index do |input, idx|
+			begin
 				ctx = ::MiniRacer::Context.new(isolate: isolate, timeout: timeout, max_memory: max_memory)
-				ctx.eval("$ = #{input.to_json}")
-				ctx.eval("$['fetch'] = function(key) { return jpath.fetch(JSON.stringify($), key); }")
 				ctx.attach('jpath.fetch', proc{|x, y| jpath.fetch(x, y)})
 				ctx.attach('console.log', proc{|x| STDERR.puts("DEBUG: #{x.inspect}") if $debug })
 				ctx.attach('console.exception', proc{|x| raise ::Alterant::RuntimeError, x })
-				ctx.attach('$$.push', proc{|x| result << x })
-				ctx.attach('$.index', proc{ idx })
+				ctx.eval('$$.replace = function(item) { replaceResource($$, item); } ', proc { |x|  })
 				ctx.attach('YamlReader', ::Alterant::Classes::YamlReader.new(self, ctx))
 				ctx.attach('JsonReader', ::Alterant::Classes::JsonReader.new(self, ctx))
 
 				ctx.eval(@modifier, filename: @filename)
-				pre_convert = ctx.eval("JSON.stringify($)")
-				converted = JSON.parse(pre_convert)
-				result << converted
+
+				pre_convert = ctx.eval("JSON.stringify($$)")
+				result = JSON.parse(pre_convert)
 
 				ctx.dispose
 				isolate.idle_notification(100)
@@ -45,7 +42,11 @@ module Alterant
 				if $debug
 					raise
 				else
-					raise ::Alterant::ParseError, "part: #{idx} - #{exc.message}, #{exc.backtrace.first}"
+					if defined? idx
+						raise ::Alterant::ParseError, "part: #{idx} - #{exc.message}, #{exc.backtrace.first}"
+					else
+						raise ::Alterant::ParseError, "#{exc.message}, #{exc.backtrace.first}"
+					end
 				end
 			rescue ::Alterant::AlterantError => exc
 				STDERR.puts exc.message.red

data/lib/alterant/classes/finders.js

@@ -0,0 +1,179 @@
+// finds the deployment that's used for a service given it's labels and service's selectors
+function findDeploymentForService(list, selectors) {
+    return findByLabels(list, "Deployment", selectors);
+}
+
+function replaceResource(list, resource) {
+    replaceItem(list, resource.kind, resource.metadata.name, resource);
+}
+
+// replaces an item of the given kind and name with a replacement
+function replaceItem(list, kind, name, replacement) {
+    for (let index = 0; index < list.length; index++) {
+        const element = list[index];
+
+        if ((element.kind == kind) && (element.metadata.name == name)) {
+            // found it.
+            list[index] = replacement;
+            return
+        }
+    }
+}
+
+function findByName(list, kind, name) {
+    var found;
+    list.forEach(resource => {
+        if ((resource.kind == kind) && (resource.metadata.name == name)) {
+            found = resource;
+            return;
+        }
+    });
+
+    return found;
+}
+
+// finds an item using the labels and its kind
+function findByLabels(list, kind, labels) {
+    var found;
+    list.forEach(element => {
+        if (element.kind == kind) {
+            if (doLabelsMatch(element, labels)) {
+                found = element;
+                return;
+            }
+        }
+    });
+
+    return found;
+}
+
+// checks it two sets of labels (and selectors) match
+function doLabelsMatch(item, labels) {
+    itemLabels = getLabels(item);
+    for (label in labels) {
+        if (labels[label] != itemLabels[label]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function getLabels(item) {
+    return item.spec.template.metadata.labels;
+}
+
+function deepCompare () {
+    var i, l, leftChain, rightChain;
+
+    function compare2Objects (x, y) {
+      var p;
+
+      // remember that NaN === NaN returns false
+      // and isNaN(undefined) returns true
+      if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
+           return true;
+      }
+
+      // Compare primitives and functions.
+      // Check if both arguments link to the same object.
+      // Especially useful on the step where we compare prototypes
+      if (x === y) {
+          return true;
+      }
+
+      // Works in case when functions are created in constructor.
+      // Comparing dates is a common scenario. Another built-ins?
+      // We can even handle functions passed across iframes
+      if ((typeof x === 'function' && typeof y === 'function') ||
+         (x instanceof Date && y instanceof Date) ||
+         (x instanceof RegExp && y instanceof RegExp) ||
+         (x instanceof String && y instanceof String) ||
+         (x instanceof Number && y instanceof Number)) {
+          return x.toString() === y.toString();
+      }
+
+      // At last checking prototypes as good as we can
+      if (!(x instanceof Object && y instanceof Object)) {
+          return false;
+      }
+
+      if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
+          return false;
+      }
+
+      if (x.constructor !== y.constructor) {
+          return false;
+      }
+
+      if (x.prototype !== y.prototype) {
+          return false;
+      }
+
+      // Check for infinitive linking loops
+      if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
+           return false;
+      }
+
+      // Quick checking of one object being a subset of another.
+      // todo: cache the structure of arguments[0] for performance
+      for (p in y) {
+          if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+              return false;
+          }
+          else if (typeof y[p] !== typeof x[p]) {
+              return false;
+          }
+      }
+
+      for (p in x) {
+          if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+              return false;
+          }
+          else if (typeof y[p] !== typeof x[p]) {
+              return false;
+          }
+
+          switch (typeof (x[p])) {
+              case 'object':
+              case 'function':
+
+                  leftChain.push(x);
+                  rightChain.push(y);
+
+                  if (!compare2Objects (x[p], y[p])) {
+                      return false;
+                  }
+
+                  leftChain.pop();
+                  rightChain.pop();
+                  break;
+
+              default:
+                  if (x[p] !== y[p]) {
+                      return false;
+                  }
+                  break;
+          }
+      }
+
+      return true;
+    }
+
+    if (arguments.length < 1) {
+      return true; //Die silently? Don't know how to handle such case, please help...
+      // throw "Need two or more arguments to compare";
+    }
+
+    for (i = 1, l = arguments.length; i < l; i++) {
+
+        leftChain = []; //Todo: this can be cached
+        rightChain = [];
+
+        if (!compare2Objects(arguments[0], arguments[i])) {
+            return false;
+        }
+    }
+
+    return true;
+}

data/lib/alterant/version.rb

@@ -1,5 +1,5 @@
 module Alterant
-	VERSION = '0.0.1'
-	COPYRIGHT_MESSAGE = "(c) 2018 Cloud66 Inc."
+	VERSION = '0.0.2'
+	COPYRIGHT_MESSAGE = "(c) 2019 Cloud66 Inc."
 	APP_NAME = 'Alterant'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alterant
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Khash Sajadi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-20 00:00:00.000000000 Z
+date: 2019-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -155,6 +155,7 @@ files:
 - lib/alterant/classes/classes.rb
 - lib/alterant/classes/containers.js
 - lib/alterant/classes/docker_image.js
+- lib/alterant/classes/finders.js
 - lib/alterant/classes/json_reader.rb
 - lib/alterant/classes/ports.js
 - lib/alterant/classes/yaml_reader.rb