tortoiselabs 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e136ce22e408526d7c3b1943109df33754828a51
+  data.tar.gz: 034993dbd882ec9335b1cdd8305c3d2befa3353b
+SHA512:
+  metadata.gz: 5c26e7690ab29d6c04eb5c283b2cddf807fa6f15329cc04abd865204d66fa17bdaf5e38c873749440d8b81d84c898bff2b640c759045a78798e4567d47148cb6
+  data.tar.gz: dcae0f8796209cce5dc8bc22d2be75efc9cb95265670d7e381f1520e71cdefffea5a555e627ebf94df9218ef5829cd3f1cf7a2ae7118604848a45a3ee6377e38

data/lib/tortoiselabs.rb

@@ -0,0 +1,7 @@
+require 'httparty'
+require 'json'
+
+require 'tortoiselabs/client'
+require 'tortoiselabs/vps'
+require 'tortoiselabs/dns'
+require 'tortoiselabs/billing'

data/lib/tortoiselabs/billing.rb

@@ -0,0 +1,58 @@
+module TortoiseLabs
+  class Invoice
+    attr_reader :items, :creation_ts, :payment_ts, :total, :user, :id
+    
+    def initialize(ihash)
+      @creation_ts, @total = ihash["creation_ts"], ihash["total"]
+      @payment_ts, @user = ihash["payment_ts"], ihash["user"]
+      @id = ihash["invoice"]
+      @items = Array.new
+      
+      ihash["items"].each do |itemhash|
+        obj = Item.new(itemhash)
+        @items << obj
+      end
+    end
+    
+    # Instance methods
+    
+    def to_s
+      "Invoice ##{@id}"
+    end
+    
+    # Class Methods
+    
+    def self.list
+      result = TortoiseLabs::Client.get("/invoice/list")
+      invoices = Array.new
+      JSON.parse(result)["invoices"].each do |invoice|
+        obj = self.new(invoice)
+        invoices << obj
+      end
+      invoices
+    end
+    
+    def self.add_credit(amount)
+      response = TortoiseLabs::Client.post("/invoice/svccredit",
+                                          {:creditamt => amount})
+      return response.request.last_uri.to_s
+    end
+    
+    def self.get(id)
+      result = TortoiseLabs::Client.get("/invoice/#{id}")
+      self.new(JSON.parse(result)["invoice"])
+    end
+  end
+  
+  class Item
+    attr_reader :price, :btc_price, :description, :line_item, :invoice
+    attr_reader :entry_ts, :service
+    
+    def initialize(ihash)
+      @btc_price, @price = ihash["btc_price"], ihash["price"]
+      @description, @line_item = ihash["description"], ihash["line_item"]
+      @entry_ts, @invoice = ihash["entry_ts"], ihash["invoice"]
+      @service = ihash["service"]
+    end
+  end
+end

data/lib/tortoiselabs/client.rb

@@ -0,0 +1,37 @@
+module TortoiseLabs
+  class Client
+    
+    def self.base_uri
+      @base_uri ||= "https://manage.tortois.es"
+    end
+    
+    def self.base_uri=(value)
+      @base_uri = value.to_s.chomp("/")
+    end
+    
+    def self.username=(value)
+      @username = value
+    end
+    
+    def self.password=(value)
+      @password = value
+    end
+    
+    def self.auth_options
+      if @username.nil? or @password.nil?
+        raise NotAuthenticated
+      end
+      
+      {:basic_auth => {:username => @username, :password => @password}}
+    end
+    
+    def self.get(path, options = {})
+      HTTParty.get(base_uri + path, options.merge(auth_options))
+    end
+    
+    def self.post(path, options)
+      options = {:body => options}.merge(auth_options)
+      HTTParty.post(base_uri + path, options)
+    end
+  end
+end

data/lib/tortoiselabs/dns.rb

@@ -0,0 +1,94 @@
+module TortoiseLabs
+  
+  module DNS
+    
+    # DNS zone class
+    
+    class Zone
+      attr_reader :id, :name, :records, :user
+      
+      def initialize(zhash)
+        @id, @name, @user = zhash["id"], zhash["name"], zhash["user"]
+        @records = Array.new
+        
+        zhash["records"].each do |record|
+          obj = Record.new(record)
+          obj.zoneid = @id
+          @records << obj
+        end
+      end
+      
+      # Instance Methods      
+      
+      def delete
+        resp = TortoiseLabs::Client.get("/dns/zone/#{@id}/delete")
+        Zone.list
+      end
+      
+      def new_record(subdomain, type, content, ttl = 3600, prio = 0)
+        resp = TortoiseLabs::Client.post("/dns/zone/#{@id}/record/new", 
+           {:subdomain => subdomain, :type => type, :ttl => ttl,
+            :prio => prio, :content => content})
+        Zone.list[@name]
+      end
+      
+      def to_s
+        @name
+      end
+      
+      # Class Methods
+      
+      def self.list
+        response = TortoiseLabs::Client.get("/dns/zones").parsed_response
+        json = JSON.parse(response)
+        zones = Hash.new
+        
+        json["zones"].each do |zone|
+          obj = self.new(zone)
+          zones[obj.name] = obj
+        end
+        
+        zones
+      end
+      
+      def self.create(domain)
+        TortoiseLabs::Client.post("/dns/zone/new", {:domain_name => domain})
+        list = self.list
+        if list.keys.include?(domain)
+          return list[domain]
+        else
+          return false
+        end
+      end
+    end
+    
+    # DNS record class
+    
+    class Record
+      attr_reader :id, :name, :content, :prio, :ttl, :type
+      attr_accessor :zoneid
+      
+      def initialize(rhash)
+        @id, @name, @content = rhash["id"], rhash["name"], rhash["content"]
+        @prio, @ttl, @type = rhash["prio"], rhash["ttl"], rhash["type"]
+      end
+      
+      def modify(new_content, subdomain = @name)
+        TortoiseLabs::Client.post("/dns/zone/#{@zoneid}/record/#{@id}",
+            {:content => new_content, :subdomain => subdomain})
+        Zone.list.values.select { |z| z.id == zoneid }[0]
+      end
+      
+      def delete
+        resp = TortoiseLabs::Client.get("/dns/zone/#{@zoneid}/record/#{@id}/delete")
+        Zone.new(JSON.parse(resp)["zone"])
+      end
+      
+      def to_s
+        "#{@type}:#{@name}"
+      end
+    end
+  end
+end
+      
+      

data/lib/tortoiselabs/vps.rb

@@ -0,0 +1,230 @@
+module TortoiseLabs
+  
+  # IPs
+  
+  class IP
+    attr_reader :broadcast, :netmask, :version, :gateway, :network, :ip
+    
+    def initialize(iphash)
+      @ip = iphash["ip"]
+      ipnet = iphash["ipnet"]
+      @netmask, @broadcast, @version, @gateway, @network = ipnet["netmask"],
+        ipnet["broadcast"], ipnet["version"].to_i, ipnet["gateway"],
+        ipnet["network"]
+    end
+    
+    def to_s
+      @ip
+    end
+  end
+  
+  # Jobs
+  
+  class Job
+    attr_reader :id, :method, :entry_ts, :start_ts, :success
+    
+    def initialize(job)
+      @id, @method, @entry_ts, @start_ts = job["id"], job["req_env"]["method"],
+        job["entry_ts"], job["start_ts"]
+        
+      @success = job["rsp_env"]["params"]["success"]
+    end
+    
+    def to_s
+      "Job #{@id}: #{@method}"
+    end
+    
+    def success?
+      @success
+    end
+  end
+  
+  # VPS
+        
+  class VPS
+    attr_reader :id, :disk, :mac, :memory, :name, :node
+    attr_reader :swap, :user, :nickname, :ips
+    
+    # Instance methods
+    
+    def initialize(vps)
+      @node, @name, @mac, @memory, @disk = vps["node"], vps["name"],  
+        vps["mac"], vps["memory"], vps["disk"]
+        
+      @nickname, @id, @swap, @user = vps["nickname"], vps["id"], 
+        vps["swap"], vps["user"]
+        
+      @ips = Hash.new
+      vps["ips"].each do |iphash|
+        obj = IP.new(iphash)
+        @ips[obj.ip] = obj
+      end
+    end
+    
+    def to_s
+      @nickname
+    end
+    
+    def nickname=(newnickname)
+      options = {:nickname => newnickname}
+      result = TortoiseLabs::Client.post("/vps/#{@id}/setnickname",  options)
+      @nickname = result["nickname"]
+    end
+    
+    def monitoring=(boolean)
+      if boolean
+        result = TortoiseLabs::Client.get("/vps/#{@id}/monitoring/enable")
+      else
+        result = TortoiseLabs::Client.get("/vps/#{@id}/monitoring/disable")
+      end
+      boolean
+    end
+    
+    def monitoring?
+      vps = JSON.parse(TortoiseLabs::Client.get("/vps/#{id}"))
+      vps["service"]["monitoring"]
+    end
+    
+    def templates
+      result = TortoiseLabs::Client.get("/vps/#{@id}/deploy")
+      JSON.parse(result)["templates"]
+    end
+    
+    def deploy(image, rootpass, arch = "x86_64")
+      # arch can be either x86_64 or i386
+      # Image is one of the values returned by the templates method above
+      
+      unless image =~ /_login\.xml$/i
+        image = image + "_login.xml"
+      end
+      
+      result = TortoiseLabs::Client.post("/vps/#{@id}/deploy", 
+        {:imagename => image, :rootpass => rootpass, :arch => arch})
+      jobs
+    end
+    
+    def running?
+      result = TortoiseLabs::Client.get("/vps/#{@id}/status.json")
+      result.parsed_response["running"]
+    end
+    
+    def destroy
+      result = TortoiseLabs::Client.get("/vps/#{@id}/destroy")
+      result.parsed_response["job"]
+    end
+    
+    def shutdown
+      result = TortoiseLabs::Client.get("/vps/#{@id}/shutdown")
+      result.parsed_response["job"]
+    end
+    
+    def create
+      result = TortoiseLabs::Client.get("/vps/#{@id}/create")
+      result.parsed_response["job"]
+    end
+    
+    def powercycle
+      result = TortoiseLabs::Client.get("/vps/#{@id}/powercycle")
+      result.parsed_response["job"]
+    end
+    
+    def jobs
+      res = TortoiseLabs::Client.get("/vps/#{@id}/jobs.json").parsed_response
+      
+      jobs = Hash.new
+      res.each do |jobhash|
+        begin
+          obj = Job.new(jobhash)
+          jobs[obj.id] = obj
+        rescue NoMethodError => err
+          # occurs when there are no jobs
+        end
+      end
+      
+      jobs
+    end
+    
+    def hvm
+      result = TortoiseLabs::Client.get("/vps/#{@id}/hvm").parsed_response
+      JSON.parse(result)["isolist"]
+    end
+    
+    def set_iso(isoid)
+      result = TortoiseLabs::Client.post("/vps/#{@id}/hvm/setiso", 
+        {:isoid => isoid})
+      hvm
+    end
+    
+    def set_boot_order(bootorder)
+      result = TortoiseLabs::Client.post("/vps/#{@id}/hvm/setbootorder",
+        {:bootorder => bootorder})
+      result.parsed_response["isolist"]
+    end
+    
+    def set_nic_type(nictype)
+      # nictype can be e1000, virtio-net or rtl8139
+      result = TortoiseLabs::Client.post("/vps/#{@id}/hvm/setnictype",
+        {:nictype => nictype})
+      hvm
+    end
+    
+    def new_iso(isoname, isouri)
+      result = TortoiseLabs::Client.post("/vps/#{@id}/hvmiso/new", 
+        {:isoname => isoname, :isouri => isouri})
+      hvm
+    end
+    
+    def delete_iso(isoid)
+      result = TortoiseLabs::Client.post("/vps/#{@id}/hvmiso/#{isoid}/delete")
+      hvm
+    end
+    
+    # Class methods
+    
+    def self.list
+      json = JSON.parse(TortoiseLabs::Client.get("/vps/list"))
+      return nil if json.empty?
+      
+      vpses = Hash.new
+      json["vpslist"].each do |vps|
+        obj = self.new(vps)
+        vpses[obj.nickname] = obj
+      end
+      
+      vpses
+    end
+
+#    This is commented out because the API method itself is broken
+#    and I cannot verify it works. I will uncomment it when I can.    
+#    def self.regions
+#      result = JSON.parse(TortoiseLabs::Client.get("/vps/signup"))["regions"]
+#      regions = Array.new
+#      result.each { |r| regions << Region.new(r["id"], r["name"]) }
+#      regions
+#    end
+    
+#    def self.plans
+#      result = JSON.parse(TortoiseLabs::Client.get("/vps/signup"))
+#      plans = Array.new
+#      result["resource_plans"].each do |p|
+#        obj = Plan.new(p["id"], p["disk"], p["memory"], p["name"], 
+#          p["price_btc"], p["price_usd"], p["swap"])
+#        plans << obj
+#      end
+#      plans
+#    end
+    
+    def self.get(id)
+      vpshash = JSON.parse(TortoiseLabs::Client.get("/vps/#{id}"))["service"]
+      self.new(vpshash)
+    end
+  end
+  
+  # Helper structs
+    
+  Region = Struct.new(:id, name)
+    
+  Plan = Struct.new(:id, :disk, :memory, :name, :price_btc,
+                      :price_usd, :swap)
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: tortoiselabs
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Andrew Northall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A TortoiseLabs API wrapper.
+email: andrew@northall.me.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tortoiselabs.rb
+- lib/tortoiselabs/billing.rb
+- lib/tortoiselabs/client.rb
+- lib/tortoiselabs/dns.rb
+- lib/tortoiselabs/vps.rb
+homepage: https://github.com/somasonic/tortoiselabs-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: A TortoiseLabs API wrapper
+test_files: []