podnix 0.2.0 → 0.3.0

data/lib/podnix/core/images_collection.rb

@@ -1,148 +0,0 @@
-# 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 ImagesCollection
-    include Enumerable
-
-    
-    attr_reader :iterator
-    def initialize
-      @appreqs = Array.new
-      @appreqs_by_name = Hash.new
-      @insert_after_idx = nil
-    end
-
-    def all_appreqs
-      @appreqs
-    end
-
-    def [](index)
-      @appreqs[index]
-    end
-
-    def []=(index, arg)
-      is_megam_appreq(arg)
-      @appreqs[index] = arg
-      @appreqs_by_name[arg.id] = index
-    end
-
-    def <<(*args)
-      args.flatten.each do |a|
-        is_megam_appreq(a)
-        @appreqs << a
-        @appreqs_by_name[a.id] = @appreqs.length - 1
-      end
-      self
-    end
-
-    # 'push' is an alias method to <<
-    alias_method :push, :<<
-
-    def insert(appreq)
-      is_megam_appreq(appreq)
-      if @insert_after_idx
-        # in the middle of executing a run, so any Appreqss inserted now should
-        # be placed after the most recent addition done by the currently executing
-        # appreqs
-        @appreqs.insert(@insert_after_idx + 1, appreq)
-        # update name -> location mappings and register new appreqs
-        @appreqs_by_name.each_key do |key|
-        @appreqs_by_name[key] += 1 if @appreqs_by_name[key] > @insert_after_idx
-        end
-        @appreqs_by_name[appreq.id] = @insert_after_idx + 1
-        @insert_after_idx += 1
-      else
-      @appreqs << appreq
-      @appreqs_by_name[appreq.id] = @appreqs.length - 1 
-      end
-    end
-
-    def each
-      @appreqs.each do |appreq|
-        yield appreq
-      end
-    end
-
-    def each_index
-      @appreqs.each_index do |i|
-        yield i
-      end
-    end
-
-    def empty?
-      @appreqs.empty?
-    end
-
-    def lookup(appreq)
-      lookup_by = nil
-      if appreq.kind_of?(Megam::AppRequest)
-      lookup_by = appreq.id
-      elsif appreq.kind_of?(String)
-      lookup_by = appreq
-      else
-        raise ArgumentError, "Must pass a Megam::Appreqs or String to lookup"
-      end
-      res = @appreqs_by_name[lookup_by]
-      unless res
-        raise ArgumentError, "Cannot find a appreq matching #{lookup_by} (did you define it first?)"
-      end
-      @appreqs[res]
-    end
-    
-     # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |appreq|
-        index_hash[appreq.id] = appreq.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
-
-
-    def self.json_create(o)
-      collection = self.new()
-      o["results"].each do |appreqs_list|
-       appreqs_array = appreqs_list.kind_of?(Array) ? appreqs_list : [ appreqs_list ]
-        appreqs_array.each do |appreq|
-          collection.insert(appreq)
-        end
-      end
-      collection
-    end
-
-    private
-
-    
-    
-    def is_megam_appreq(arg)
-      unless arg.kind_of?(Megam::AppRequest)
-        raise ArgumentError, "Members must be Megam::Appreq's"
-      end
-      true
-    end
-
-    def to_s
-      Podnix::Stuff.styled_hash(to_hash)
-    end
-
-  end
-end

data/lib/podnix/core/json_compat.rb

@@ -1,162 +0,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.
-
-# Wrapper class for interacting with JSON.
-
-require 'yajl/json_gem'
-require 'yajl'
-
-module Podnix
-  class JSONCompat
-    JSON_MAX_NESTING = 1000
-
-    JSON_CLAZ = "json_claz".freeze
-
-    PODNIX_ERROR             = "Podnix::Error".freeze
-    PODNIX_IMAGES              = "Podnix::Image".freeze
-    PODNIX_IMAGESCOLLECTION    = "Podnix::NodeCollection".freeze
-    PODNIX_SERVERS            = "Megam::Predef".freeze
-    PODNIX_SERVERSCOLLECTION  = "Megam::PredefCollection".freeze
-    
-    class <<self
-      # Increase the max nesting for JSON, which defaults
-      # to 19, and isn't enough for some (for example, a Node within a Node)
-      # structures.
-      def opts_add_max_nesting(opts)
-        if opts.nil? || !opts.has_key?(:max_nesting)
-          opts = opts.nil? ? Hash.new : opts.clone
-          opts[:max_nesting] = JSON_MAX_NESTING
-        end
-        opts
-      end
-
-      # Just call the JSON gem's parse method with a modified :max_nesting field
-      def from_json(source, opts = {})
-        obj = ::Yajl::Parser.parse(source)
-        # JSON gem requires top level object to be a Hash or Array (otherwise
-        # you get the "must contain two octets" error). Yajl doesn't impose the
-        # same limitation. For compatibility, we re-impose this condition.
-        unless obj.kind_of?(Hash) or obj.kind_of?(Array)
-          raise JSON::ParserError, "Top level JSON object must be a Hash or Array. (actual: #{obj.class})"
-        end
-
-        # The old default in the json gem (which we are mimicing because we
-        # sadly rely on this misfeature) is to "create additions" i.e., convert
-        # JSON objects into ruby objects. Explicit :create_additions => false
-        # is required to turn it off.
-        if opts[:create_additions].nil? || opts[:create_additions]
-          map_to_rb_obj(obj)
-        else
-        obj
-        end
-      end
-
-      # Look at an object that's a basic type (from json parse) and convert it
-      # to an instance of Megam classes if desired.
-      def map_to_rb_obj(json_obj)
-        case json_obj
-        when Hash
-          mapped_hash = map_hash_to_rb_obj(json_obj)
-          if json_obj.has_key?(JSON_CLAZ) && (class_to_inflate = class_for_json_class(json_obj[JSON_CLAZ]))
-          class_to_inflate.json_create(mapped_hash)
-          else
-          mapped_hash
-          end
-        when Array
-          json_obj.map {|e| map_to_rb_obj(e) }
-        else
-        json_obj
-        end
-      end
-
-      def map_hash_to_rb_obj(json_hash)
-        json_hash.each do |key, value|
-          json_hash[key] = map_to_rb_obj(value)
-        end
-        json_hash
-      end
-
-      def to_json(obj, opts = nil)
-        obj.to_json(opts_add_max_nesting(opts))
-      end
-
-      def to_json_pretty(obj, opts = nil)
-        ::JSON.pretty_generate(obj, opts_add_max_nesting(opts))
-      end
-
-      # Map +JSON_CLAZ+ to a Class object. We use a +case+ instead of a Hash
-      # assigned to a constant because otherwise this file could not be loaded
-      # until all the constants were defined, which means you'd have to load
-      # the world to get json.
-      def class_for_json_class(json_class)
-        case json_class
-        when MEGAM_ERROR
-          Megam::Error
-        when MEGAM_AUTH
-          Megam::Auth
-        when MEGAM_ACCOUNT
-          Megam::Account
-        when MEGAM_NODE
-          Megam::Node
-        when MEGAM_APPDEFNS
-          Megam::Appdefns
-        when MEGAM_APPREQUEST
-          Megam::AppRequest
-        when MEGAM_BOLTREQUEST
-          Megam::BoltRequest
-        when MEGAM_BOLTDEFNS
-          Megam::Boltdefns
-        when MEGAM_NODECOLLECTION
-          Megam::NodeCollection
-        when MEGAM_APPDEFNSCOLLECTION
-          Megam::AppdefnsCollection
-        when MEGAM_APPREQUESTCOLLECTION
-          Megam::AppRequestCollection
-        when MEGAM_BOLTREQUESTCOLLECTION
-          Megam::BoltRequestCollection
-        when MEGAM_BOLTDEFNSCOLLECTION
-          Megam::BoltdefnsCollection
-        when MEGAM_REQUEST
-          Megam::Request
-        when MEGAM_REQUESTCOLLECTION
-          Megam::RequestCollection
-        when MEGAM_PREDEF
-          Megam::Predef
-        when MEGAM_PREDEFCOLLECTION
-          Megam::PredefCollection
-        when MEGAM_PREDEFCLOUD
-          Megam::PredefCloud
-        when MEGAM_PREDEFCLOUDCOLLECTION
-          Megam::PredefCloudCollection
-        when MEGAM_CLOUDTOOL
-          Megam::CloudTool
-        when MEGAM_CLOUDTOOLCOLLECTION
-          Megam::CloudToolCollection
-        when MEGAM_CLOUDTEMPLATE
-          Megam::CloudTemplate
-        when MEGAM_CLOUDTEMPLATECOLLECTION
-          Megam::CloudTemplateCollection
-        when MEGAM_CLOUDINSTRUCTION
-          Megam::CloudInstruction
-        when MEGAM_CLOUDINSTRUCTIONGROUP
-          Megam::CloudInstructionGroup
-        when MEGAM_CLOUDINSTRUCTIONCOLLECTION
-          Megam::CloudInstructionCollection
-        else
-        raise JSON::ParserError, "Unsupported `json_class` type '#{json_class}'"
-        end
-      end
-
-    end
-  end
-end

data/lib/podnix/core/server.rb

@@ -1,375 +0,0 @@
-# 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