megam_api 0.7.0 → 0.7.1

data/lib/megam/core/account.rb

@@ -152,9 +152,9 @@ module Megam
     end
 
     # Load a account by email_p
-    def self.show(email_p)
-      megam_rest.get_accounts(email)
-      self
+    def self.show(email)
+      acct = self.new()
+      acct.megam_rest.get_accounts(email)
     end
 
     # Create the node via the REST API

data/lib/megam/core/cloudtoolsetting.rb

@@ -0,0 +1,197 @@
+
+# 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 Megam
+  class CloudToolSetting
+    # Each notify entry is a resource/action pair, modeled as an
+    # Struct with a #resource and #action member
+    def initialize
+      @id = nil      
+      @accounts_id = nil
+      @cloud_type = nil
+      @repo = nil
+      @vault_location=nil      
+      @created_at = nil
+      @some_msg = {}
+    end
+
+    def cloud_tool_setting
+      self
+    end
+
+    def megam_rest
+      options = { :email => Megam::Config[:email], :api_key => Megam::Config[:api_key]}
+      Megam::API.new(options)
+    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 cloud_type(arg=nil)
+      if arg != nil
+        @cloud_type = arg
+      else
+      @cloud_type
+      end
+    end
+
+    def repo(arg=nil)
+      if arg != nil
+        @repo = arg
+      else
+      @repo
+      end
+    end
+
+    def vault_location(arg=nil)
+      if arg != nil
+        @vault_location= arg
+      else
+      @vault_location
+      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["accounts_id"] = accounts_id
+      index_hash["cloud_type"] = cloud_type
+      index_hash["repo"] = repo
+      index_hash["vault_location"] = vault_location     
+      index_hash["created_at"] = created_at
+      index_hash["some_msg"] = some_msg
+      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,        
+        "accounts_id" => accounts_id,
+        "cloud_type" => cloud_type,
+        "repo" => repo,
+        "vault_location" => vault_location,  
+        "created_at" => created_at
+      }
+      result
+    end
+
+    #
+    def self.json_create(o)
+      cts = new
+      cts.id(o["id"]) if o.has_key?("id")      
+      cts.accounts_id(o["accounts_id"]) if o.has_key?("accounts_id")
+      cts.cloud_type(o["cloud_type"]) if o.has_key?("cloud_type")
+      cts.repo(o["repo"]) if o.has_key?("repo")
+      cts.vault_location(o["vault_location"]) if o.has_key?("vault_location")    
+      
+      cts.created_at(o["created_at"]) if o.has_key?("created_at")
+      #success or error
+      cts.some_msg[:code] = o["code"] if o.has_key?("code")
+      cts.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+      cts.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+      cts.some_msg[:links] = o["links"] if o.has_key?("links")
+      cts
+    end
+
+    def self.from_hash(o)
+      cts = self.new()
+      cts.from_hash(o)
+      cts
+    end
+
+    def from_hash(o)
+      @id        = o[:id] if o.has_key?(:id)
+      @accounts_id = o[:accounts_id] if o.has_key?(:accounts_id)
+      @cloud_type   = o[:cloud_type] if o.has_key?(:cloud_type)
+      @repo     = o[:repo] if o.has_key?(:repo)
+      @vault_location   = o[:vault_location] if o.has_key?(:vault_location)    
+      @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 cloudtoolsetting via the REST API
+    def create
+      megam_rest.post_cloudtoolsetting(to_hash)
+    end
+
+    # Load all cloudtoolsettings -
+    # returns a cloudtoolsettingsCollection
+    # don't return self. check if the Megam::cloudtoolsettingCollection is returned.
+    def self.list
+    cts = self.new()
+      cts.megam_rest.get_cloudtoolsettings
+    end
+
+    # Show a particular cloudtoolsetting by name,
+    # Megam::cloudtoolsetting
+    def self.show(p_name)
+    pre = self.new()
+      pre.megam_rest.get_cloudtoolsetting(p_name)
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    #"---> Megam::Account:[error=#{error?}]\n"+
+    end
+
+  end
+end

data/lib/megam/core/cloudtoolsetting_collection.rb

@@ -0,0 +1,168 @@
+# 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 Megam
+  class CloudToolSettingCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @cloudtoolsettings = Array.new
+      @cloudtoolsettings_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_cloudtoolsettings
+      @cloudtoolsettings
+    end
+
+    def [](index)
+      @cloudtoolsettings[index]
+    end
+
+    def []=(index, arg)
+      is_megam_cloudtoolsettings(arg)
+      @cloudtoolsettings[index] = arg
+      @cloudtoolsettings_by_name[arg.name] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_cloudtoolsettings(a)
+        @cloudtoolsettings << a
+        @cloudtoolsettings_by_name[a.name] =@cloudtoolsettings.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(cloudtoolsettings)
+      is_megam_cloudtoolsettings(cloudtoolsettings)
+      if @insert_after_idx
+        # in the middle of executing a run, so any cloudtoolsettings inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # cloudtoolsettings
+        @cloudtoolsettings.insert(@insert_after_idx + 1, cloudtoolsettings)
+        # update name -> location mappings and register new cloudtoolsettings
+        @cloudtoolsettings_by_name.each_key do |key|
+        @cloudtoolsettings_by_name[key] += 1 if@cloudtoolsettings_by_name[key] > @insert_after_idx
+        end
+        @cloudtoolsettings_by_name[cloudtoolsettings.cloud_type] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @cloudtoolsettings << cloudtoolsettings
+      @cloudtoolsettings_by_name[cloudtoolsettings.cloud_type] =@cloudtoolsettings.length - 1
+      end
+    end
+
+    def each
+      @cloudtoolsettings.each do |cloudtoolsettings|
+        yield cloudtoolsettings
+      end
+    end
+
+    def each_index
+      @cloudtoolsettings.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @cloudtoolsettings.empty?
+    end
+
+    def lookup(cloudtoolsettings)
+      lookup_by = nil
+      if cloudtoolsettings.kind_of?(Megam::CloudToolSetting)
+      lookup_by = cloudtoolsettings.cloud_type
+      elsif cloudtoolsettings.kind_of?(String)
+      lookup_by = cloudtoolsettings
+      else
+        raise ArgumentError, "Must pass a Megam::cloudtoolsettings or String to lookup"
+      end
+      res =@cloudtoolsettings_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a cloudtoolsettings matching #{lookup_by} (did you define it first?)"
+      end
+      @cloudtoolsettings[res]
+    end
+
+    # Transform the ruby obj ->  to a Hash
+    def to_hash
+      index_hash = Hash.new
+      self.each do |cloudtoolsettings|
+        index_hash[cloudtoolsettings.cloud_type] = cloudtoolsettings.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::PredefCloudCollection",
+"results":[{
+"id":"NOD362554470640386048",
+"name":"ec2_rails",
+"account_id":"ACT362544229488001024",
+"json_claz":"Megam::PredefCloud",
+"spec":{
+"type_name":"sensor-type",
+"groups":"sens-group",
+"image":"sens-image",
+"flavor":"sens-flvr"
+},
+"access":{
+"ssh_key":"sens-ssh",
+"identity_file":"sens-identity-file",
+"ssh_user":"sens-sshuser"
+},
+"ideal":"",
+"performance":""
+}]
+}
+=end
+    def self.json_create(o)
+      collection = self.new()
+      o["results"].each do |cloudtoolsettings_list|
+        cloudtoolsettings_array = cloudtoolsettings_list.kind_of?(Array) ? cloudtoolsettings_list : [ cloudtoolsettings_list ]
+        cloudtoolsettings_array.each do |cloudtoolsettings|
+          collection.insert(cloudtoolsettings)
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_cloudtoolsettings(arg)
+      unless arg.kind_of?(Megam::CloudToolSetting)
+        raise ArgumentError, "Members must be Megam::cloudtoolsetting's"
+      end
+      true
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/megam/core/json_compat.rb

@@ -44,6 +44,8 @@ module Megam
     MEGAM_PREDEFCLOUDCOLLECTION    = "Megam::PredefCloudCollection".freeze
     MEGAM_CLOUDTOOL     = "Megam::CloudTool".freeze
     MEGAM_CLOUDTOOLCOLLECTION    = "Megam::CloudToolCollection".freeze
+    MEGAM_CLOUDTOOLSETTING     = "Megam::CloudToolSetting".freeze
+    MEGAM_CLOUDTOOLSETTINGCOLLECTION    = "Megam::CloudToolSettingCollection".freeze
     MEGAM_CLOUDTEMPLATE     = "Megam::CloudTemplate".freeze
     MEGAM_CLOUDTEMPLATECOLLECTION    = "Megam::CloudTemplateCollection".freeze
     MEGAM_CLOUDINSTRUCTION     = "Megam::CloudInstruction".freeze
@@ -163,6 +165,10 @@ module Megam
           Megam::CloudTool
         when MEGAM_CLOUDTOOLCOLLECTION
           Megam::CloudToolCollection
+        when MEGAM_CLOUDTOOLSETTING
+          Megam::CloudToolSetting
+        when MEGAM_CLOUDTOOLSETTINGCOLLECTION
+          Megam::CloudToolSettingCollection
         when MEGAM_CLOUDTEMPLATE
           Megam::CloudTemplate
         when MEGAM_CLOUDTEMPLATECOLLECTION

data/lib/megam/core/log.rb

@@ -15,13 +15,14 @@
 
 require 'logger'
 require 'mixlib/log'
+require 'megam/core/monologger'
 
 module Megam
   class Log
     extend Mixlib::Log
 
     # Force initialization of the primary log device (@logger)
-    init
+    init(Megam::MonoLogger.new(STDOUT))
 
     class Formatter
       def self.show_time=(*args)

data/lib/megam/core/monologger.rb

@@ -0,0 +1,89 @@
+require 'logger'
+require 'pp'
+
+module Megam
+  #== MonoLogger
+  # A subclass of Ruby's stdlib Logger with all the mutex and logrotation stuff
+  # ripped out.
+  class MonoLogger < Logger
+    #
+    # === Synopsis
+    #
+    #   Logger.new(name, shift_age = 7, shift_size = 1048576)
+    #   Logger.new(name, shift_age = 'weekly')
+    #
+    # === Args
+    #
+    # +logdev+::
+    #   The log device.  This is a filename (String) or IO object (typically
+    #   +STDOUT+, +STDERR+, or an open file).
+    # +shift_age+::
+    #   Number of old log files to keep, *or* frequency of rotation (+daily+,
+    #   +weekly+ or +monthly+).
+    # +shift_size+::
+    #   Maximum logfile size (only applies when +shift_age+ is a number).
+    #
+    # === Description
+    #
+    # Create an instance.
+    #
+    def initialize(logdev)
+      @progname = nil
+      @level = DEBUG
+      @default_formatter = Formatter.new
+      @formatter = nil
+      @logdev = nil
+      if logdev
+        @logdev = LocklessLogDevice.new(logdev)
+      end
+    end
+
+    class LocklessLogDevice < LogDevice
+      def initialize(log = nil)
+        @dev = @filename = @shift_age = @shift_size = nil
+        if log.respond_to?(:write) and log.respond_to?(:close)
+          @dev = log
+        else
+          @dev = open_logfile(log)
+          @dev.sync = true
+          @filename = log
+        end
+      end
+
+      def write(message)
+        @dev.write(message)
+      rescue Exception => ignored
+        warn("log writing failed. #{ignored}")
+        end
+
+      def close
+        @dev.close rescue nil
+      end
+
+      private
+
+      def open_logfile(filename)
+        if (FileTest.exist?(filename))
+          open(filename, (File::WRONLY | File::APPEND))
+        else
+          create_logfile(filename)
+        end
+      end
+
+      def create_logfile(filename)
+        logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT))
+        logdev.sync = true
+        add_log_header(logdev)
+        logdev
+      end
+
+      def add_log_header(file)
+        file.write(
+        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
+        )
+      end
+
+    end
+
+  end
+end