podnix 0.1.0

data/lib/podnix/core/server.rb

@@ -0,0 +1,375 @@
+# Copyright:: Copyright (c) 2012, 2013 Megam Systems
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'hashie'
+module Podnix
+  class Node
+    # Each notify entry is a resource/action pair, modeled as an
+    # Struct with a #resource and #action member
+=begin
+  def self.hash_tree
+    Hash.new do |hash, key|
+      hash[key] = hash_tree
+    end
+  end
+=end
+
+    def initialize
+      @id = nil
+      @node_name = nil
+      @accounts_id = nil
+      @node_type = nil
+      @req_type = nil
+      @status=nil
+      @noofinstances=0
+      @request ={}
+      @predefs={}
+      @some_msg = {}
+      #@command = self.class.hash_tree
+	@command = Hashie::Mash.new
+	@appdefnsid = nil
+	@boltdefnsid = nil
+	@appdefns = {}
+	@boltdefns = {}
+      @created_at = nil
+    end
+    def node
+      self
+    end
+
+    def podnix_rest
+      options = { :email => Megam::Config[:email], :api_key => Megam::Config[:api_key]}
+      Megam::API.new(options)
+    end
+
+    def node_name(arg=nil)
+      if arg != nil
+        @node_name = arg
+      else
+      @node_name
+      end
+    end
+
+    def noofinstances(arg=nil)
+      if arg != nil
+        @noofinstances = arg
+      else
+      @noofinstances
+      end
+    end
+
+    def command(arg=nil)
+      if arg != nil
+        @command = arg
+      else
+      @command
+      end
+    end
+
+    def id(arg=nil)
+      if arg != nil
+        @id = arg
+      else
+      @id
+      end
+    end
+
+    def accounts_id(arg=nil)
+      if arg != nil
+        @accounts_id = arg
+      else
+      @accounts_id
+      end
+    end
+
+    def node_type(arg=nil)
+      if arg != nil
+        @node_type = arg
+      else
+      @node_type
+      end
+    end
+
+    def req_type(arg=nil)
+      if arg != nil
+        @req_type = arg
+      else
+      @req_type
+      end
+    end
+
+    def status(arg=nil)
+      if arg != nil
+        @status = arg
+      else
+      @status
+      end
+    end
+
+    def request(arg=nil)
+      if arg != nil
+        @request = arg
+      else
+      @request
+      end
+    end
+
+    def predefs(arg=nil)
+      if arg != nil
+        @predefs = arg
+      else
+      @predefs
+      end
+    end
+
+    def appdefns(arg=nil)
+      if arg != nil
+        @appdefns = arg
+      else
+      @appdefns
+      end
+    end
+
+    def boltdefns(arg=nil)
+      if arg != nil
+        @boltdefns = arg
+      else
+      @boltdefns
+      end
+    end
+    def appdefnsid(arg=nil)
+      if arg != nil
+        @appdefnsid = arg
+      else
+      @appdefnsid
+      end
+    end
+
+    def boltdefnsid(arg=nil)
+      if arg != nil
+        @boltdefnsid = arg
+      else
+      @boltdefnsid
+      end
+    end
+
+    def created_at(arg=nil)
+      if arg != nil
+        @created_at = arg
+      else
+      @created_at
+      end
+    end
+
+    def some_msg(arg=nil)
+      if arg != nil
+        @some_msg = arg
+      else
+      @some_msg
+      end
+    end
+
+    def error?
+      crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+    end
+
+    # Transform the ruby obj ->  to a Hash
+    def to_hash
+      index_hash = Hash.new
+      index_hash["json_claz"] = self.class.name
+      index_hash["id"] = id
+      index_hash["node_name"] = node_name
+      index_hash["accounts_id"] = accounts_id
+      index_hash["node_type"] = node_type
+      index_hash["req_type"] = req_type
+      index_hash["status"] = status
+      index_hash["command"] = command
+      index_hash["request"] = request
+      index_hash["predefs"] = predefs
+      index_hash["appdefns"] = appdefns
+      index_hash["boltdefns"] = boltdefns
+      index_hash["some_msg"] = some_msg
+      index_hash["noofinstances"] = noofinstances.to_i
+      index_hash["appdefnsid"] = appdefnsid
+      index_hash["boltdefnsid"] = boltdefnsid
+      index_hash["created_at"] = created_at
+      index_hash
+    end
+
+    # Serialize this object as a hash: called from JsonCompat.
+    # Verify if this called from JsonCompat during testing.
+    def to_json(*a)
+      for_json.to_json(*a)
+    end
+
+    def for_json
+      result = {
+        "id" => id,
+        "node_name" => node_name,
+        "accounts_id" => accounts_id,
+        "node_type" => node_type,
+        "req_type" => req_type,
+        "status" => status,
+        "request" => request,
+        "predefs" => predefs,
+        "appdefns" => appdefns,
+        "boltdefns" => boltdefns,
+        "appdefnsid" => appdefnsid,
+        "boltdefnsid" => boltdefnsid,
+        "noofinstances" => noofinstances,
+        "created_at" => created_at
+      }
+      result
+    end
+
+    # Create a Megam::Node from NodeResult-JSON
+    #
+    #[{
+    #"id":"NOD362212018897289216",
+    #"accounts_id":"ACT362211962353876992",
+    #"json_claz":"Megam::Node",
+    #"request":{
+    #"req_id":"NOD362212018897289216",
+    #"command":"commands"
+    #},
+    #"predefs":{
+    #"name":"",
+    #"scm":"",
+    #"war":"",
+    #"db":"",
+    #"queue":""
+    #}
+    #}]
+    #
+    def self.json_create(o)
+      node = new
+      node.id(o["id"]) if o.has_key?("id")
+      node.node_name(o["node_name"]) if o.has_key?("node_name")
+      node.accounts_id(o["accounts_id"]) if o.has_key?("accounts_id")
+      node.node_type(o["node_type"]) if o.has_key?("node_type")
+      node.req_type(o["req_type"]) if o.has_key?("req_type")
+      node.status(o["status"]) if o.has_key?("status")
+      node.appdefnsid(o["appdefnsid"]) if o.has_key?("appdefnsid")
+      node.boltdefnsid(o["boltdefnsid"]) if o.has_key?("boltdefnsid")
+      node.noofinstances(o["noofinstances"]) if o.has_key?("noofinstances")
+      node.created_at(o["created_at"]) if o.has_key?("created_at")
+      #requests
+      oq = o["request"]
+      node.request[:req_id] = oq["req_id"] if oq && oq.has_key?("req_id")
+      node.request[:req_type] = oq["req_type"] if oq && oq.has_key?("req_type")
+      node.request[:command] = oq["command"] if oq && oq.has_key?("command")
+
+      #Command
+=begin
+	node.command[:systemprovider][:provider][:prov] = oc["systemprovider"]["provider"]["prov"]
+	node.command[:compute][:cctype] = oc["compute"]["cctype"]
+	node.command[:compute][:cc][:groups] = oc["compute"]["cc"]["groups"]
+	node.command[:compute][:cc][:image] = oc["compute"]["cc"]["image"]
+	node.command[:compute][:cc][:flavor] = oc["compute"]["cc"]["flavor"]
+	node.command[:compute][:access][:ssh_key] = oc["compute"]["access"]["ssh_key"]
+	node.command[:compute][:access][:identity_file] = oc["compute"]["access"]["identity_file"]
+	node.command[:compute][:access][:ssh_user] = oc["compute"]["access"]["ssh_user"]
+	node.command[:cloudtool][:chef][:command] = oc["cloudtool"]["chef"]["command"]
+	node.command[:cloudtool][:chef][:plugin] = oc["cloudtool"]["chef"]["plugin"]
+	node.command[:cloudtool][:chef][:run_list] = oc["cloudtool"]["chef"]["run_list"]
+	node.command[:cloudtool][:chef][:name] = oc["cloudtool"]["chef"]["name"]
+=end
+      #predef
+      op = o["predefs"]
+      node.predefs[:name] = op["name"] if op && op.has_key?("name")
+      node.predefs[:scm] = op["scm"] if op && op.has_key?("scm")
+      node.predefs[:war]= op["war"] if op && op.has_key?("war")
+      node.predefs[:db] = op["db"] if op && op.has_key?("db")
+      node.predefs[:queue] = op["queue"] if op && op.has_key?("queue")
+
+      #APP DEFINITIONS
+      op = o["appdefns"]
+      node.appdefns[:timetokill] = op["timetokill"] if op && op.has_key?("timetokill")
+      node.appdefns[:metered] = op["metered"] if op && op.has_key?("metered")
+      node.appdefns[:logging]= op["logging"] if op && op.has_key?("logging")
+      node.appdefns[:runtime_exec] = op["runtime_exec"] if op && op.has_key?("runtime_exec")
+
+      #BOLT DEFINITIONS
+      op = o["boltdefns"]
+      node.boltdefns[:username] = op["username"] if op && op.has_key?("username")
+      node.boltdefns[:apikey] = op["apikey"] if op && op.has_key?("apikey")
+      node.boltdefns[:store_name]= op["store_name"] if op && op.has_key?("store_name")
+      node.boltdefns[:url] = op["url"] if op && op.has_key?("url")
+      node.boltdefns[:timetokill] = op["timetokill"] if op && op.has_key?("timetokill")
+      node.boltdefns[:metered] = op["metered"] if op && op.has_key?("metered")
+      node.boltdefns[:logging]= op["logging"] if op && op.has_key?("logging")
+      node.boltdefns[:runtime_exec] = op["runtime_exec"] if op && op.has_key?("runtime_exec")
+
+      #success or error
+      node.some_msg[:code] = o["code"] if o.has_key?("code")
+      node.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+      node.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+      node.some_msg[:links] = o["links"] if o.has_key?("links")
+
+      node
+    end
+
+    def self.from_hash(o)
+      node = self.new()
+      node.from_hash(o)
+      node
+    end
+
+    def from_hash(o)
+      @node_name = o["node_name"] if o.has_key?("node_name")
+      @command   = o["command"] if o.has_key?("command")
+      @id        = o["id"] if o.has_key?("id")
+      @accounts_id    = o["accounts_id"] if o.has_key?("accounts_id")
+      @node_type    = o["node_type"] if o.has_key?("node_type")
+      @req_type    = o["req_type"] if o.has_key?("req_type")
+      @request   = o["request"] if o.has_key?("request")
+      @predefs   = o["predefs"] if o.has_key?("predefs")
+      @appdefns   = o["appdefns"] if o.has_key?("appdefns")
+      @boltdefns   = o["boltdefns"] if o.has_key?("boltdefns")
+      @appdefnsid   = o["appdefnsid"] if o.has_key?("appdefnsid")
+      @boltdefnsid   = o["boltdefnsid"] if o.has_key?("boltdefnsid")
+      @noofinstances        = o["noofinstances"] if o.has_key?("noofinstances")
+      @created_at        = o["created_at"] if o.has_key?("created_at")
+      self
+    end
+
+    def self.create(o)
+      acct = from_hash(o)
+      acct.create
+    end
+
+    # Create the node via the REST API
+    def create
+      podnix_rest.post_node(to_hash)
+    end
+
+    # Load a account by email_p
+    def self.show(node_name)
+      node = self.new()
+      node.podnix_rest.get_node(node_name)
+    end
+
+    def self.list
+      node = self.new()
+      node.podnix_rest.get_nodes
+    end
+
+    def to_s
+      Podnix::Stuff.styled_hash(to_hash)
+    #"---> Megam::Account:[error=#{error?}]\n"+
+    end
+
+  end
+end

data/lib/podnix/core/server_collection.rb

@@ -0,0 +1,166 @@
+# Copyright:: Copyright (c) 2012, 2013 Megam Systems
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module Podnix
+  class NodeCollection
+    include Enumerable
+
+    
+    attr_reader :iterator
+    def initialize
+      @nodes = Array.new
+      @nodes_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_nodes
+      @nodes
+    end
+
+    def [](index)
+      @nodes[index]
+    end
+
+    def []=(index, arg)
+      is_megam_node(arg)
+      @nodes[index] = arg
+      @nodes_by_name[arg.node_name] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_node(a)
+        @nodes << a
+        @nodes_by_name[a.node_name] = @nodes.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(node)
+      is_megam_node(node)
+      if @insert_after_idx
+        # in the middle of executing a run, so any nodes inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # node
+        @nodes.insert(@insert_after_idx + 1, node)
+        # update name -> location mappings and register new node
+        @nodes_by_name.each_key do |key|
+        @nodes_by_name[key] += 1 if @nodes_by_name[key] > @insert_after_idx
+        end
+        @nodes_by_name[node.node_name] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @nodes << node
+      @nodes_by_name[node.node_name] = @nodes.length - 1 
+      end
+    end
+
+    def each
+      @nodes.each do |node|
+        yield node
+      end
+    end
+
+    def each_index
+      @nodes.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @nodes.empty?
+    end
+
+    def lookup(node)
+      lookup_by = nil
+      if node.kind_of?(Megam::Node)
+      lookup_by = node.node_name
+      elsif node.kind_of?(String)
+      lookup_by = node
+      else
+        raise ArgumentError, "Must pass a Megam::Node or String to lookup"
+      end
+      res = @nodes_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+      end
+      @nodes[res]
+    end
+    
+     # Transform the ruby obj ->  to a Hash
+    def to_hash
+      index_hash = Hash.new
+      self.each do |node|
+        index_hash[node.node_name] = node.to_s
+      end
+      index_hash
+    end
+
+    # Serialize this object as a hash: called from JsonCompat.
+    # Verify if this called from JsonCompat during testing.
+    def to_json(*a)
+      for_json.to_json(*a)
+    end
+
+
+=begin
+["json_claz":"Megam::NodeCollection",{
+"id":"NOD362428315933343744",
+"accounts_id":"ACT362211963352121344",
+"json_claz":"Megam::Node",
+"request":{
+"req_id":"NOD362428315933343744",
+"command":"commands"
+},
+"predefs":{
+"name":"",
+"scm":"",
+"war":"",
+"db":"",
+"queue":""
+}
+}]
+=end
+    def self.json_create(o)
+      collection = self.new()
+      o["results"].each do |nodes_list|
+        nodes_array = nodes_list.kind_of?(Array) ? nodes_list : [ nodes_list ]
+        nodes_array.each do |node|
+          collection.insert(node)
+        end
+      end
+      collection
+    end
+
+    private
+
+    
+    
+    def is_megam_node(arg)
+      unless arg.kind_of?(Megam::Node)
+        raise ArgumentError, "Members must be Megam::Node's"
+      end
+      true
+    end
+
+    def to_s
+      Podnix::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/podnix/core/stuff.rb

@@ -0,0 +1,69 @@
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Podnix
+  module Stuff
+    extend self
+    def has_git?
+      %x{ git --version }
+      $?.success?
+    end
+
+    def git(args)
+      return "" unless has_git?
+      flattened_args = [args].flatten.compact.join(" ")
+      %x{ git #{flattened_args} 2>&1 }.strip
+    end
+
+    def time_ago(since)
+      if since.is_a?(String)
+        since = Time.parse(since)
+      end
+
+      elapsed = Time.now - since
+
+      message = since.strftime("%Y/%m/%d %H:%M:%S")
+      if elapsed <= 60
+        message << " (~ #{elapsed.floor}s ago)"
+      elsif elapsed <= (60 * 60)
+        message << " (~ #{(elapsed / 60).floor}m ago)"
+      elsif elapsed <= (60 * 60 * 25)
+        message << " (~ #{(elapsed / 60 / 60).floor}h ago)"
+      end
+      message
+    end
+
+    def spinner(ticks)
+      %w(/ - \\ |)[ticks % 4]
+    end
+
+    def launchy(message, url)
+      action(message) do
+        require("launchy")
+        launchy = Launchy.open(url)
+        if launchy.respond_to?(:join)
+        launchy.join
+        end
+      end
+    end
+
+    #
+    #left justified keyed hash with newlines.
+    def styled_hash(hash)
+      hash.map{|k,v| "#{k.ljust(15)}=#{v}"}.join("\n")
+    end
+
+  end
+end

data/lib/podnix/core/text.rb

@@ -0,0 +1,88 @@
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Podnix
+  class Text
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :stdin
+    attr_reader :config
+    def initialize(stdout, stderr, stdin, config)
+      @stdout, @stderr, @stdin, @config = stdout, stderr, stdin, config
+    end
+
+    def highline
+      @highline ||= begin
+      require 'highline'
+      HighLine.new
+      end
+    end
+
+    def msg(message)
+      stdout.puts message
+    end
+
+    # Prints a message to stdout. Aliased as +info+ for compatibility with
+    # the logger API.
+
+    def info(message)
+      stdout.puts("#{color('INFO:', :green, :bold)} #{message}")
+    end
+
+    # Prints a msg to stderr. Used for warn, error, and fatal.
+    def err(message)
+      stderr.puts message
+    end
+
+    # Print a warning message
+    def warn(message)
+      err("#{color('WARNING:', :yellow, :bold)} #{message}")
+    end
+
+    # Print an error message
+    def error(message)
+      err("#{color('ERROR:', :red, :bold)} #{message}")
+    end
+
+    # Print a message describing a fatal error.
+    def fatal(message)
+      err("#{color('FATAL:', :red, :bold)} #{message}")
+    end
+
+    def color(string, *colors)
+      if color?
+        highline.color(string, *colors)
+      else
+      string
+      end
+    end
+
+    # Should colored output be used ?. When output is not to a
+    # terminal, colored output is never used
+    def color?
+      stdout.tty?
+    end
+
+    def list(*args)
+      highline.list(*args)
+    end
+
+    def pretty_print(data)
+      stdout.puts data
+    end
+
+  end
+end

data/lib/podnix.rb

@@ -0,0 +1 @@
+require(File.join(File.dirname(__FILE__), "podnix", "api"))