mortar 0.1.0

data/lib/vendor/mortar/uuid.rb

@@ -0,0 +1,312 @@
+# Copyright(c) 2005 URABE, Shyouhei.
+#
+# Permission is hereby granted, free of  charge, to any person obtaining a copy
+# of  this code, to  deal in  the code  without restriction,  including without
+# limitation  the rights  to  use, copy,  modify,  merge, publish,  distribute,
+# sublicense, and/or sell copies of the code, and to permit persons to whom the
+# code is furnished to do so, subject to the following conditions:
+#
+#        The above copyright notice and this permission notice shall be
+#        included in all copies or substantial portions of the code.
+#
+# THE  CODE IS  PROVIDED "AS  IS",  WITHOUT WARRANTY  OF ANY  KIND, EXPRESS  OR
+# IMPLIED,  INCLUDING BUT  NOT LIMITED  TO THE  WARRANTIES  OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHOR  OR  COPYRIGHT  HOLDER BE  LIABLE  FOR  ANY  CLAIM, DAMAGES  OR  OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF  OR IN CONNECTION WITH  THE CODE OR THE  USE OR OTHER  DEALINGS IN THE
+# CODE.
+
+%w[
+  digest/md5
+  digest/sha1
+  tmpdir
+].each do |f|
+  require f
+end
+
+# Pure ruby UUID generator, which is compatible with RFC4122
+module Mortar
+  class UUID
+    # UUID epoch is 15th Oct. 1582
+    UNIXEpoch = 0x01B21DD213814000 # in 100-nanoseconds resolution
+
+    private_class_method :new
+
+    private
+    def initialize str
+      tmp = str.unpack "C*"
+      @num = tmp.inject do |r, i|
+        r * 256 | i
+      end
+      @num.freeze
+      self.freeze
+    end
+
+    public
+
+    def raw_bytes
+      ret = String.new
+      tmp = @num
+      16.times do |i|
+        x, y = tmp.divmod 256
+        ret << y
+        tmp = x
+      end
+      ret.reverse!
+      ret
+    end
+
+    class << self
+      def mask ver, str # :nodoc:
+        ver = ver & 15
+        v = str[6].ord
+        v &= 0b0000_1111
+        v |= ver << 4
+        str[6] = v.chr
+        r = str[8].ord
+        r &= 0b0011_1111
+        r |= 0b1000_0000
+        str[8] = r.chr
+        str
+      end
+
+      def prand # :nodoc:
+        rand 0x100000000
+      end
+
+      private :mask, :prand
+
+      # UUID generation using SHA1. Recommended over create_md5.
+      # Namespace object is another UUID, some of them are pre-defined below.
+      def create_sha1 str, namespace
+        sha1 = Digest::SHA1.new
+        sha1.update namespace.raw_bytes
+        sha1.update str
+        sum = sha1.digest
+        raw = mask 5, sum[0..15]
+        new raw
+      end
+
+      # UUID generation using MD5 (for backward compat.)
+      def create_md5 str, namespace
+        md5 = Digest::MD5.new
+        md5.update namespace.raw_bytes
+        md5.update str
+        sum = md5.digest
+        raw = mask 3, sum[0..16]
+        new raw
+      end
+
+      # UUID  generation  using  random-number  generator.   From  it's  random
+      # nature, there's  no warranty that  the created ID is  really universaly
+      # unique.
+      def create_random
+        rnd = [prand, prand, prand, prand].pack "N4"
+        raw = mask 4, rnd
+        new raw
+      end
+
+      def read_state fp       # :nodoc:
+        fp.rewind
+        Marshal.load fp.read
+      end
+
+      def write_state fp, c, m  # :nodoc:
+        fp.rewind
+        str = Marshal.dump [c, m]
+        fp.write str
+      end
+
+      private :read_state, :write_state
+      STATE_FILE = 'ruby-uuid'
+
+      # create  the "version  1" UUID  with current  system clock,  current UTC
+      # timestamp, and the IEEE 802 address (so-called MAC address).
+      #
+      # Speed notice: it's slow.  It writes  some data into hard drive on every
+      # invokation. If you want to speed  this up, try remounting tmpdir with a
+      # memory based filesystem  (such as tmpfs).  STILL slow?  then no way but
+      # rewrite it with c :)
+      def create clock=nil, time=Time.now, mac_addr=nil
+        c = t = m = nil
+        Dir.chdir Dir.tmpdir do
+          unless FileTest.exist? STATE_FILE then
+            # Generate a pseudo MAC address because we have no pure-ruby way
+            # to know  the MAC  address of the  NIC this system  uses.  Note
+            # that cheating  with pseudo arresses here  is completely legal:
+            # see Section 4.5 of RFC4122 for details.
+            sha1 = Digest::SHA1.new
+            256.times do
+              r = [prand].pack "N"
+              sha1.update r
+            end
+            ary = sha1.digest.bytes.to_a
+            node = ary.last 6
+            node[0] |= 0x01 # multicast bit
+            node = node.pack "C*"
+            k = rand 0x40000
+            open STATE_FILE, 'w' do |fp|
+              fp.flock IO::LOCK_EX
+              write_state fp, k, node
+              fp.chmod 0o777 # must be world writable
+            end
+          end
+          open STATE_FILE, 'r+' do |fp|
+            fp.flock IO::LOCK_EX
+            c, m = read_state fp
+            c += 1 # important; increment here
+            write_state fp, c, m
+          end
+        end
+        c = clock & 0b11_1111_1111_1111 if clock
+        m = mac_addr if mac_addr
+        time = Time.at time if time.is_a? Float
+        case time
+        when Time
+          t = time.to_i * 10_000_000 + time.tv_usec * 10 + UNIXEpoch
+        when Integer
+          t = time + UNIXEpoch
+        else
+          raise TypeError, "cannot convert ``#{time}'' into Time."
+        end
+
+        tl = t & 0xFFFF_FFFF
+        tm = t >> 32
+        tm = tm & 0xFFFF
+        th = t >> 48
+        th = th & 0b0000_1111_1111_1111
+        th = th | 0b0001_0000_0000_0000
+        cl = c & 0b0000_0000_1111_1111
+        ch = c & 0b0011_1111_0000_0000
+        ch = ch >> 8
+        ch = ch | 0b1000_0000
+        pack tl, tm, th, ch, cl, m
+      end
+
+      # A  simple GUID  parser:  just ignores  unknown  characters and  convert
+      # hexadecimal dump into 16-octet object.
+      def parse obj
+        str = obj.to_s.sub %r/\Aurn:uuid:/, ''
+        str.gsub! %r/[^0-9A-Fa-f]/, ''
+        raw = [str[0..31]].pack 'H*'
+        new raw
+      end
+
+      # The 'primitive constructor' of this class
+      # Note UUID.pack(uuid.unpack) == uuid
+      def pack tl, tm, th, ch, cl, n
+        raw = [tl, tm, th, ch, cl, n].pack "NnnCCa6"
+        new raw
+      end
+    end
+
+    # The 'primitive deconstructor', or the dual to pack.
+    # Note UUID.pack(uuid.unpack) == uuid
+    def unpack
+      raw_bytes.unpack "NnnCCa6"
+    end
+
+    # The timestamp of this UUID.
+    # Throws RageError if that time exceeds UNIX time range
+    def time
+      a = unpack
+      tl = a[0]
+      tm = a[1]
+      th = a[2] & 0x0FFF
+      t = tl
+      t += tm << 32
+      t += th << 48
+      t -= UNIXEpoch
+      tv_sec = t / 10_000_000
+      t -= tv_sec * 10_000_000
+      tv_usec = t / 10
+      Time.at tv_sec, tv_usec
+    end
+
+    # The version of this UUID
+    def version
+      v = unpack[2] & 0b1111_0000_0000_0000
+      v >> 12
+    end
+
+    # The clock sequence of this UUID
+    def clock
+      a = unpack
+      ch = a[3] & 0b0001_1111
+      cl = a[4]
+      c = cl
+      c += ch << 8
+      c
+    end
+
+    # The IEEE 802 address in a hexadecimal format
+    def node
+      m = unpack[5].unpack 'C*'
+      '%02x%02x%02x%02x%02x%02x' % m
+    end
+    alias mac_address node
+    alias ieee802 node
+
+    # Generate the string representation (a.k.a GUID) of this UUID
+    def to_s
+      a = unpack
+      a[-1] = mac_address
+      "%08x-%04x-%04x-%02x%02x-%s" % a
+    end
+    alias guid to_s
+
+    # Convert into a RFC4122-comforming URN representation
+    def to_uri
+      "urn:uuid:" + self.to_s
+    end
+    alias urn to_uri
+    alias inspect to_uri
+
+    # Convert into 128-bit unsigned integer
+    # Typically a Bignum instance, but can be a Fixnum.
+    def to_int
+      @num
+    end
+    alias to_i to_int
+
+    # Two  UUIDs  are  said  to  be  equal if  and  only  if  their  (byte-order
+    # canonicalized) integer representations are equivallent.  Refer RFC4122 for
+    # details.
+    def == other
+      to_i == other.to_i
+    end
+    alias eql? ==
+
+    # Two identical UUIDs should have same hash
+    def hash
+      to_i
+    end
+
+    include Comparable
+    # UUIDs are comparable (don't know what benefits are there, though).
+    def <=> other
+      to_s <=> other.to_s
+    end
+
+    # Pre-defined UUID Namespaces described in RFC4122 Appendix C.
+    NameSpace_DNS = parse "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+    NameSpace_URL = parse "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+    NameSpace_OID = parse "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
+    NameSpace_X500 = parse "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
+
+    # The Nil UUID in RFC4122 Section 4.1.7
+    Nil = parse "00000000-0000-0000-0000-000000000000"
+  end
+end
+
+# Local Variables:
+# mode: ruby
+# coding: utf-8
+# indent-tabs-mode: t
+# tab-width: 3
+# ruby-indent-level: 3
+# fill-column: 79
+# default-justification: full
+# End:
+# vi: ts=3 sw=3

data/spec/mortar/auth_spec.rb

@@ -0,0 +1,156 @@
+#
+# Copyright 2012 Mortar Data Inc.
+#
+# 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.
+#
+# Portions of this code from heroku (https://github.com/heroku/heroku/) Copyright Heroku 2008 - 2012,
+# used under an MIT license (https://github.com/heroku/heroku/blob/master/LICENSE).
+#
+
+require "spec_helper"
+require "mortar/auth"
+require "mortar/helpers"
+
+module Mortar
+  describe Auth do
+    include Mortar::Helpers
+
+    before do
+      ENV['MORTAR_API_KEY'] = nil
+      
+      @cli = Mortar::Auth
+      stub(@cli).display
+      stub(@cli).running_on_a_mac? {false}
+      @cli.credentials = nil
+
+      FakeFS.activate!
+      
+      stub(my_mode_output = Object.new).mode {"0600".to_i(8)}
+      stub(FakeFS::File).stat {my_mode_output}
+      stub(FakeFS::FileUtils).chmod
+      stub(FakeFS::File).readlines do |path|
+        File.read(path).split("\n").map {|line| "#{line}\n"}
+      end
+      
+      FileUtils.mkdir_p(@cli.netrc_path.split("/")[0..-2].join("/"))
+
+      File.open(@cli.netrc_path, "w") do |file|
+        file.puts("machine api.mortardata.com\n  login user\n  password pass\n")
+      end
+    end
+
+    after do
+      FileUtils.rm_rf(@cli.netrc_path)
+      FakeFS.deactivate!
+    end
+
+    it "asks for credentials when the file doesn't exist" do
+      stub(@cli).check
+      @cli.delete_credentials
+      mock(@cli).ask_for_credentials {["u", "p"]}
+      #@cli.should_receive(:check_for_associated_ssh_key)
+      @cli.user.should == 'u'
+      @cli.password.should == 'p'
+    end
+
+    it "writes credentials and uploads authkey when credentials are saved" do
+      stub(@cli).credentials
+      stub(@cli).check
+      stub(@cli).ask_for_credentials.returns("username", "apikey")
+      mock(@cli).write_credentials
+      #@cli.should_receive(:check_for_associated_ssh_key)
+      @cli.ask_for_and_save_credentials
+    end
+
+    it "save_credentials deletes the credentials when the upload authkey is unauthorized" do
+      stub(@cli).write_credentials
+      stub(@cli).retry_login? { false }
+      stub(@cli).ask_for_credentials.returns("username", "apikey")
+      stub(@cli).check { raise Mortar::API::Errors::Unauthorized.new("Login Failed", Excon::Response.new) }
+      mock.proxy(@cli).delete_credentials
+      lambda { @cli.ask_for_and_save_credentials }.should raise_error(SystemExit)
+    end
+
+    it "asks for login again when not authorized, for three times" do
+      stub(@cli).read_credentials
+      stub(@cli).write_credentials
+      stub(@cli).delete_credentials
+      #stub(@cli).ask_for_credentials.returns("username", "apikey")
+      stub(@cli).check { raise Mortar::API::Errors::Unauthorized.new("Login Failed", Excon::Response.new) }
+      mock(@cli).ask_for_credentials.times(3).returns("username", "apikey")
+      lambda { @cli.ask_for_and_save_credentials }.should raise_error(SystemExit)
+    end
+
+    it "writes the login information to the credentials file for the 'mortar login' command" do
+      stub(@cli).ask_for_credentials.returns(['one', 'two'])
+      stub(@cli).check
+      #@cli.should_receive(:check_for_associated_ssh_key)
+      @cli.reauthorize
+      Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should == (['one', 'two'])
+    end
+
+    it "prompts for github_username when user doesn't have one." do
+      user_id = "123456789"
+      new_github_username = "some_new_github_username"
+      task_id = "1a2b3c4d"
+      stub(@cli).polling_interval.returns(0.05)
+
+      mock(@cli).ask_for_credentials.returns("username", "apikey")
+      stub(@cli).write_credentials
+      mock(@cli.api).get_user() {Excon::Response.new(:body => {"user_id" => user_id, "user_email" => "foo@foo.com"})}
+      mock(@cli).ask_for_github_username.returns(new_github_username)
+
+      mock(@cli.api).update_user(user_id,{"user_github_username" => new_github_username}) {Excon::Response.new(:body => {"task_id" => task_id})}
+
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "QUEUED"})).ordered
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "PROGRESS"})).ordered
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "SUCCESS"})).ordered
+
+      @cli.ask_for_and_save_credentials
+    end
+
+    it "remove credentials when call to set github_username fails" do
+      user_id = "abcdef"
+      new_github_username = "some_new_github_username"
+      task_id = "1a2b3c4d5e"
+      stub(@cli).polling_interval.returns(0.05)
+      mock(@cli).retry_set_github_username?.returns(false)
+
+
+      mock(@cli).ask_for_credentials.returns("username", "apikey")
+      stub(@cli).write_credentials
+      mock(@cli.api).get_user() {Excon::Response.new(:body => {"user_id" => user_id, "user_email" => "foo@foo.com"})}
+      mock(@cli).ask_for_github_username.returns(new_github_username)
+
+      mock(@cli.api).update_user(user_id,{"user_github_username" => new_github_username}) {Excon::Response.new(:body => {"task_id" => task_id})}
+
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "QUEUED"})).ordered
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "PROGRESS"})).ordered
+      mock(@cli.api).get_task(task_id).returns(Excon::Response.new(:body => {"task_id" => task_id, "status_code" => "FAILURE"})).ordered
+
+      mock(@cli).delete_credentials
+
+      lambda { @cli.ask_for_and_save_credentials }.should raise_error(SystemExit)
+    end
+
+    it "try 3 times to get github username" do
+      user_id = "abcdefghijkl"
+
+      mock(@cli.api).get_user() {Excon::Response.new(:body => {"user_id" => user_id, "user_email" => "foo@foo.com"})}
+
+      stub(@cli).ask_for_and_save_github_username.times(3).returns { raise Mortar::CLI::Errors::InvalidGithubUsername.new }
+
+      lambda { @cli.check }.should raise_error(Mortar::CLI::Errors::InvalidGithubUsername)
+    end
+  end
+end