ffi-vix_disk_lib 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8c43c07f9524fec53d769fc90299cde4868b8819
-  data.tar.gz: 165ccea6e0546c6b18cb6f2155adece6dd3efe79
+SHA256:
+  metadata.gz: cdb76ad123804d0fff4a0cc551c0c87bf2f19a55dd470d9b117a96d8a54fed41
+  data.tar.gz: 9f914959653282a5b4364b5e89ba22c6779e4ffe5bcbdabf9083e1a1590ace03
 SHA512:
-  metadata.gz: aabbfae2cb4f45024217ecdda2c70b6f6dd8e8e18e681aa366adeabc5f76562edf255f38d0cf7dae6ce2b38025b7d879f51a9bbd474e7ace69377b2234552a39
-  data.tar.gz: 580498a16f23a65fe838e5c4912492800a1df8f26307099e9ae190cfaddcba1fada74769bc30a563e99168dbcbca8a85091476c83936b463a0b33e2d22969eab
+  metadata.gz: 3d52ab24e0ca7a4af5e3c600b688de6fdec023fccfad5aeff57a2c7695276ee14ad61e54209ba24122ad5ba36493ac3373075d56d1702bf8152e7cef34e8b85e
+  data.tar.gz: bd798b4365d6914e2596cd3bc1ae0d4b5b88f9b8416136e479f3b306cedb7cf044246d92d8f7d83db9f84549baa5de11b297d8323fbe25bd3e8f69107954bfa2

data/lib/ffi-vix_disk_lib/api.rb

@@ -5,43 +5,37 @@ module FFI
     module API
       extend FFI::Library
 
-      def attach_function(*args)
+      def self.attach_function(*args)
         super
       rescue FFI::NotFoundError
         warn "unable to attach #{args.first}"
       end
 
+      #
+      # Maintain backwards compatibility with the previous method
+      # of loading libvixDiskLib
+      #
       def self.load_error
-        @load_error
+        nil
       end
 
-      #
-      # Make sure we load one and only one version of VixDiskLib
-      #
-      version_load_order = %w( 6.5.0 6.0.0 5.5.4 5.5.2 5.5.1 5.5.0 5.1.3 5.1.2 5.1.1 5.1.0 5.0.4 5.0.0 1.2.0 1.1.2 )
-      bad_versions       = {}
-      load_errors        = []
-      loaded_library     = ""
-      version_load_order.each do |version|
-        begin
-          loaded_library = ffi_lib ["vixDiskLib.so.#{version}"]
-          VERSION_MAJOR, VERSION_MINOR = loaded_library.first.name.split(".")[2, 2].collect(&:to_i)
-          if bad_versions.keys.include?(version)
-            loaded_library = ""
-            @load_error = "VixDiskLib #{version} is not supported: #{bad_versions[version]}"
-          end
-          break
-        rescue LoadError => err
-          load_errors << "ffi-vix_disk_lib: failed to load #{version} version with error: #{err.message}."
-          next
+      candidate_versions  = %w[7.0.1 7.0.0 6.7.3 6.7.2 6.7.1 6.7.0 6.5.4 6.5.3 6.5.2 6.5.1 6.5.0 6.0.3 6.0.2 6.0.1 6.0.0 5.5.4 5.5.2 5.5.1 5.5.0 5.1.3 5.1.2 5.1.1 5.1.0 5.0.4 5.0.0 1.2.0 1.1.2]
+      candidate_libraries = candidate_versions.map { |v| "vixDiskLib.so.#{v}" }
+
+      # LD_LIBRARY_PATH is not honored on Mac, so build our own rudimentary version
+      if RbConfig::CONFIG["host_os"] =~ /darwin/ && (env = ENV["LD_LIBRARY_PATH"] || ENV["DYLD_LIBRARY_PATH"])
+        candidate_libraries = candidate_libraries.product(env.split(":")).flat_map do |n, p|
+          [
+            File.join(p, n),
+            File.join(p, FFI.map_library_name(n).chomp(".dylib")),
+            File.join(p, FFI.map_library_name(n))
+          ]
         end
       end
 
-      unless @load_error || loaded_library.length > 0
-        STDERR.puts load_errors.join("\n")
-        @load_error = "ffi-vix_disk_lib: failed to load any version of VixDiskLib!"
-      end
-      LOADED_LIBRARY = loaded_library
+      LOADED_LIBRARY = ffi_lib(candidate_libraries)
+      VERSION = LOADED_LIBRARY.first.name.chomp(".dylib").split(".").last(3).join(".")
+      VERSION_MAJOR, VERSION_MINOR, = VERSION.split(".").map(&:to_i)
 
       # An error is a 64-bit value. If there is no error, then the value is
       # set to VIX_OK. If there is an error, then the least significant bits
@@ -61,6 +55,12 @@ module FFI
         err != VixErrorType[:VIX_OK]
       end
 
+      def self.evaluate_versioned_connect_params
+        Gem::Version.new(VERSION) >= Gem::Version.new("6.5.0") ? ConnectParams_6_5_0 : ConnectParams_1_0_0
+      end
+
+      ConnectParams = evaluate_versioned_connect_params
+
       callback :GenericLogFunc, [:string, :pointer], :void
 
       # Prototype for the progress function called by VixDiskLib.

data/lib/ffi-vix_disk_lib/struct.rb

@@ -57,14 +57,26 @@ module FFI
       #
       # Example VM spec:
       # "MyVm/MyVm.vmx?dcPath=Path/to/MyDatacenter&dsName=storage1"
-      class ConnectParams < FFI::Struct
-        layout :vmxSpec,    :pointer,
-               :serverName, :pointer,
-               :thumbPrint, :pointer,
-               :privateUse, :long,
+      class ConnectParams_1_0_0 < FFI::Struct
+        layout :vmxSpec,    :pointer, # URL like spec of the VM.
+               :serverName, :pointer, # Name or IP address of VC / ESX.
+               :thumbPrint, :pointer, # SSL Certificate thumb print.
+               :privateUse, :long,    # This value is ignored.
                :credType,   CredType,
                :creds,      Creds,
-               :port,       :uint32
+               :port,       :uint32   # port to use for authenticating with VC/ESXi host
+      end
+
+      class ConnectParams_6_5_0 < FFI::Struct
+        layout :vmxSpec,     :pointer, # URL like spec of the VM.
+               :serverName,  :pointer, # Name or IP address of VC / ESX.
+               :thumbPrint,  :pointer, # SSL Certificate thumb print.
+               :privateUse,  :long,    # This value is ignored.
+               :credType,    CredType,
+               :creds,       Creds,
+               :port,        :uint32,  # port to use for authenticating with VC/ESXi host
+               :nfcHostPort, :uint32,  # port to use for establishing NFC connection to ESXi host
+               :vimApiVer,   :pointer  # VIM API version to use, private
       end
 
       class Info < FFI::Struct

data/lib/ffi-vix_disk_lib/version.rb

@@ -1,5 +1,5 @@
 module FFI
   module VixDiskLib
-    VERSION = "1.0.3"
+    VERSION = "1.2.0"
   end
 end

data/spec/ext/.gitignore

@@ -0,0 +1,3 @@
+*.o
+*.d
+*.so*

data/spec/ext/Makefile

@@ -0,0 +1,30 @@
+CC=gcc
+CFLAGS=-I.
+CFLAGS = -fPIC -O0 -g
+LDFLAGS = -shared
+LN = ln -sf
+SRCS = vixDiskLib.c
+OBJS = ${SRCS:.c=.o}
+TARGET_LIB = libvixDiskLib.so
+MAJOR_VERSION = $(shell echo ${VDDK_VERSION} | cut -f1 -d.)
+VDDK_VERSION ?= 6.7.0
+
+.PHONY: all
+all: ${TARGET_LIB}.${VDDK_VERSION}
+
+${SRCS:.c=.d}:%.d:%.c
+	${CC} ${CFLAGS} -MM $< >$@
+
+${TARGET_LIB}.${MAJOR_VERSION}: ${TARGET_LIB}
+	${LN} $^ $@
+${TARGET_LIB}.${VDDK_VERSION}: ${TARGET_LIB}.${MAJOR_VERSION}
+	${LN} $^ $@
+
+${TARGET_LIB}: ${OBJS}
+	${CC} ${LDFLAGS} -o $@ $^
+
+include ${SRCS:.c=.d}
+
+.PHONY: clean
+clean:
+	-${RM} ${TARGET_LIB} ${TARGET_LIB}.${MAJOR_VERSION} ${TARGET_LIB}.${VDDK_VERSION} ${OBJS} ${SRCS:.c=.d}

data/spec/ext/vixDiskLib.c

@@ -0,0 +1,456 @@
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+typedef uint64_t uint64;
+typedef  int64_t  int64;
+typedef uint32_t uint32;
+typedef  int32_t  int32;
+typedef uint16_t uint16;
+typedef  int16_t  int16;
+typedef  uint8_t  uint8;
+typedef   int8_t   int8;
+typedef     char   Bool;
+typedef uint64 VixError;
+
+enum {
+   VIX_OK = 0,
+};
+
+typedef struct VixDiskLibHandleStruct VixDiskLibHandleStruct;
+typedef VixDiskLibHandleStruct *VixDiskLibHandle;
+typedef void (VixDiskLibGenericLogFunc)(const char *fmt, va_list args);
+struct VixDiskLibConnectParam;
+typedef struct VixDiskLibConnectParam *VixDiskLibConnection;
+typedef Bool (*VixDiskLibProgressFunc)(void *progressData,
+                                       int percentCompleted);
+typedef void (*VixDiskLibCompletionCB)(void *cbData, VixError result);
+typedef enum {
+   VIXDISKLIB_DISK_UNKNOWN = 256
+} VixDiskLibDiskType;
+
+typedef enum {
+   VIXDISKLIB_ADAPTER_UNKNOWN = 256
+} VixDiskLibAdapterType;
+
+typedef uint64 VixDiskLibSectorType;
+
+typedef struct {
+   VixDiskLibDiskType           diskType;
+   VixDiskLibAdapterType        adapterType;
+   uint16                       hwVersion;
+   VixDiskLibSectorType         capacity;
+} VixDiskLibCreateParams;
+
+typedef enum {
+   VIXDISKLIB_CRED_UNKNOWN = 256
+} VixDiskLibCredType;
+
+typedef struct {
+   uint32 cylinders;
+   uint32 heads;
+   uint32 sectors;
+} VixDiskLibGeometry;
+
+typedef struct {
+   VixDiskLibGeometry   biosGeo;      // BIOS geometry for booting and partitioning
+   VixDiskLibGeometry   physGeo;      // physical geometry
+   VixDiskLibSectorType capacity;     // total capacity in sectors
+   VixDiskLibAdapterType adapterType; // adapter type
+   int numLinks;                      // number of links (i.e. base disk + redo logs)
+   char *parentFileNameHint;          // parent file for a redo log
+   char *uuid;                        // disk UUID
+} VixDiskLibInfo;
+
+typedef struct VixDiskLibConnectParamsState VixDiskLibConnectParamsState;
+
+typedef struct {
+   VixDiskLibSectorType offset;   // offset in sectors
+   VixDiskLibSectorType length;
+} VixDiskLibBlock;
+
+typedef struct {
+   uint32 numBlocks;
+   VixDiskLibBlock blocks[1];
+} VixDiskLibBlockList;
+
+typedef struct {
+   char *id;
+   char *datastoreMoRef;
+   char *ssId;
+} VixDiskLibVStorageObjectSpec;
+
+typedef enum {
+   VIXDISKLIB_SPEC_UNKNOWN = 2
+} VixDiskLibSpecType;
+
+typedef struct {
+   char *vmxSpec;     // URL like spec of the VM.
+   char *serverName;  // Name or IP address of VC / ESX.
+   char *thumbPrint;  // SSL Certificate thumb print.
+   long privateUse;   // This value is ignored.
+   VixDiskLibCredType credType;
+
+   union VixDiskLibCreds {
+      struct VixDiskLibUidPasswdCreds {
+         char *userName; // User id and password on the
+         char *password; // VC/ESX host.
+      } uid;
+      struct VixDiskLibSessionIdCreds { // Not supported in 1.0
+         char *cookie;
+         char *userName;
+         char *key;
+      } sessionId;
+      struct VixDiskLibTicketIdCreds *ticketId; // Internal use only.
+   } creds;
+
+   uint32 port;        // port to use for authenticating with VC/ESXi host
+   uint32 nfcHostPort; // port to use for establishing NFC connection to ESXi host
+
+   char *vimApiVer;    // not used
+   char reserved[8];   // internal use only
+   VixDiskLibConnectParamsState *state; // internal use only
+
+   union {
+      VixDiskLibVStorageObjectSpec vStorageObjSpec;
+   } spec;
+   VixDiskLibSpecType specType;  // disk or VM spec
+} VixDiskLibConnectParams;
+
+VixError
+VixDiskLib_InitEx(uint32 majorVersion,
+                  uint32 minorVersion,
+                  VixDiskLibGenericLogFunc *log,
+                  VixDiskLibGenericLogFunc *warn,
+                  VixDiskLibGenericLogFunc *panic,
+                  const char* libDir,
+                  const char* configFile)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Init(uint32 majorVersion,
+                uint32 minorVersion,
+                VixDiskLibGenericLogFunc *log,
+                VixDiskLibGenericLogFunc *warn,
+                VixDiskLibGenericLogFunc *panic,
+                const char* libDir)
+{
+	return VIX_OK;
+}
+
+void
+VixDiskLib_Exit(void)
+{
+}
+
+const char *
+VixDiskLib_ListTransportModes(void)
+{
+	return "";
+}
+
+VixError
+VixDiskLib_Cleanup(const VixDiskLibConnectParams *connectParams,
+                   uint32 *numCleanedUp, uint32 *numRemaining)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Connect(const VixDiskLibConnectParams *connectParams,
+                   VixDiskLibConnection *connection)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_PrepareForAccess(const VixDiskLibConnectParams *connectParams,
+                            const char *identity)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_ConnectEx(const VixDiskLibConnectParams *connectParams,
+                     Bool readOnly,
+                     const char *snapshotRef,
+                     const char *transportModes,
+                     VixDiskLibConnection *connection)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Disconnect(VixDiskLibConnection connection)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_EndAccess(const VixDiskLibConnectParams *connectParams,
+                     const char *identity)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Create(const VixDiskLibConnection connection,
+                  const char *path,
+                  const VixDiskLibCreateParams *createParams,
+                  VixDiskLibProgressFunc progressFunc,
+                  void *progressCallbackData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_CreateChild(VixDiskLibHandle diskHandle,
+                       const char *childPath,
+                       VixDiskLibDiskType diskType,
+                       VixDiskLibProgressFunc progressFunc,
+                       void *progressCallbackData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Open(const VixDiskLibConnection connection,
+                const char *path,
+                uint32 flags,
+                VixDiskLibHandle *diskHandle)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_QueryAllocatedBlocks(VixDiskLibHandle diskHandle,
+                                VixDiskLibSectorType startSector,
+                                VixDiskLibSectorType numSectors,
+                                VixDiskLibSectorType chunkSize,
+                                VixDiskLibBlockList **blockList)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_FreeBlockList(VixDiskLibBlockList *blockList)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_GetInfo(VixDiskLibHandle diskHandle,
+                   VixDiskLibInfo **info)
+{
+	return VIX_OK;
+}
+
+void
+VixDiskLib_FreeInfo(VixDiskLibInfo *info)
+{
+}
+
+const char *
+VixDiskLib_GetTransportMode(VixDiskLibHandle diskHandle)
+{
+	return "";
+}
+
+VixError
+VixDiskLib_Close(VixDiskLibHandle diskHandle)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Read(VixDiskLibHandle diskHandle,
+                VixDiskLibSectorType startSector,
+                VixDiskLibSectorType numSectors,
+                uint8 *readBuffer)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_ReadAsync(VixDiskLibHandle diskHandle,
+                     VixDiskLibSectorType startSector,
+                     VixDiskLibSectorType numSectors,
+                     uint8 *readBuffer,
+                     VixDiskLibCompletionCB callback,
+                     void *cbData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Write(VixDiskLibHandle diskHandle,
+                 VixDiskLibSectorType startSector,
+                 VixDiskLibSectorType numSectors,
+                 const uint8 *writeBuffer)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_WriteAsync(VixDiskLibHandle diskHandle,
+                      VixDiskLibSectorType startSector,
+                      VixDiskLibSectorType numSectors,
+                      const uint8 *writeBuffer,
+                      VixDiskLibCompletionCB callback,
+                      void *cbData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Flush(VixDiskLibHandle diskHandle)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Wait(VixDiskLibHandle diskHandle)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_ReadMetadata(VixDiskLibHandle diskHandle,
+                        const char *key,
+                        char *buf,
+                        size_t bufLen,
+                        size_t *requiredLen)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_WriteMetadata(VixDiskLibHandle diskHandle,
+                         const char *key,
+                         const char *val)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_GetMetadataKeys(VixDiskLibHandle diskHandle,
+                           char *keys,
+                           size_t maxLen,
+                           size_t *requiredLen)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Unlink(VixDiskLibConnection connection,
+                  const char *path)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Grow(VixDiskLibConnection connection,
+                const char *path,
+                VixDiskLibSectorType capacity,
+                Bool updateGeometry,
+                VixDiskLibProgressFunc progressFunc,
+                void *progressCallbackData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Shrink(VixDiskLibHandle diskHandle,
+                  VixDiskLibProgressFunc progressFunc,
+                  void *progressCallbackData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Defragment(VixDiskLibHandle diskHandle,
+                      VixDiskLibProgressFunc progressFunc,
+                      void *progressCallbackData)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Rename(const char *srcFileName,
+                  const char *dstFileName)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Clone(const VixDiskLibConnection dstConnection,
+                 const char *dstPath,
+                 const VixDiskLibConnection srcConnection,
+                 const char *srcPath,
+                 const VixDiskLibCreateParams *vixCreateParams,
+                 VixDiskLibProgressFunc progressFunc,
+                 void *progressCallbackData,
+                 Bool overWrite)
+{
+	return VIX_OK;
+}
+
+char *
+VixDiskLib_GetErrorText(VixError err, const char *locale)
+{
+	return NULL;
+}
+
+void
+VixDiskLib_FreeErrorText(char* errMsg)
+{
+}
+
+VixError
+VixDiskLib_IsAttachPossible(VixDiskLibHandle parent, VixDiskLibHandle child)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_Attach(VixDiskLibHandle parent, VixDiskLibHandle child)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_SpaceNeededForClone(VixDiskLibHandle diskHandle,
+                               VixDiskLibDiskType cloneDiskType,
+                               uint64* spaceNeeded)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_CheckRepair(const VixDiskLibConnection connection,
+                       const char *filename,
+                       Bool repair)
+{
+	return VIX_OK;
+}
+
+VixError
+VixDiskLib_GetConnectParams(const VixDiskLibConnection connection,
+                            VixDiskLibConnectParams** connectParams)
+{
+	return VIX_OK;
+}
+
+void
+VixDiskLib_FreeConnectParams(VixDiskLibConnectParams* connectParams)
+{
+}
+
+VixDiskLibConnectParams *
+VixDiskLib_AllocateConnectParams()
+{
+	return NULL;
+}

data/spec/ffi-vix_disk_lib/api_spec.rb

@@ -0,0 +1,38 @@
+describe FFI::VixDiskLib::API do
+  let(:log)     { lambda { |_string, _pointer| } }
+  let(:lib_dir) { nil }
+  let(:version) { ENV.fetch("VDDK_VERSION", "6.7.0") }
+
+  it "VERSION" do
+    expect(described_class::VERSION).to eq version
+  end
+
+  it "VERSION_MAJOR" do
+    expect(described_class::VERSION_MAJOR).to eq Gem::Version.new(version).segments[0]
+  end
+
+  it "VERSION_MINOR" do
+    expect(described_class::VERSION_MINOR).to eq Gem::Version.new(version).segments[1]
+  end
+
+  describe ".init" do
+    it "initializes successfully" do
+      err = described_class.init(described_class::VERSION_MAJOR, described_class::VERSION_MINOR, log, log, log, lib_dir)
+      expect(err).to eq(described_class::VixErrorType[:VIX_OK])
+    end
+  end
+
+  describe "ConnectParams" do
+    context "with #{described_class::VERSION}" do
+      if Gem::Version.new(described_class::VERSION) >= Gem::Version.new("6.5.0")
+        it "has vimApiVer" do
+          expect(described_class::ConnectParams.members).to include(:vimApiVer)
+        end
+      else
+        it "doesn't have vimApiVer" do
+          expect(described_class::ConnectParams.members).to_not include(:vimApiVer)
+        end
+      end
+    end
+  end
+end

data/spec/ffi-vix_disk_lib/api_wrapper_spec.rb

@@ -0,0 +1,15 @@
+require 'ffi-vix_disk_lib/api_wrapper'
+
+describe FFI::VixDiskLib::ApiWrapper do
+  context "connect" do
+    before do
+      described_class.init
+    end
+
+    it "returns a connection" do
+      connect_params = {}
+      connection = described_class.connect(connect_params)
+      expect(connection).not_to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,17 +1,6 @@
-require 'minitest'
-require 'minitest/autorun'
+ENV["LD_LIBRARY_PATH"] ||= File.expand_path("ext", __dir__)
 
-begin
-  require 'ffi-vix_disk_lib'
-rescue LoadError
-  STDERR.puts <<-EOMSG
+require 'ffi-vix_disk_lib'
 
-The VMware VDDK must be installed in order to run specs.
-
-The VMware VDDK is not redistributable, and not available on MacOSX.
-See https://www.vmware.com/support/developer/vddk/ for more information.
-
-EOMSG
-
-  exit 1
+RSpec.configure do |config|
 end

metadata

@@ -1,31 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: ffi-vix_disk_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Jerry Keselman
 - Rich Oliveri
 - Jason Frey
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-04-06 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: manageiq-style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -41,7 +55,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -91,13 +105,17 @@ files:
 - lib/ffi-vix_disk_lib/safe_create_params.rb
 - lib/ffi-vix_disk_lib/struct.rb
 - lib/ffi-vix_disk_lib/version.rb
+- spec/ext/.gitignore
+- spec/ext/Makefile
+- spec/ext/vixDiskLib.c
+- spec/ffi-vix_disk_lib/api_spec.rb
+- spec/ffi-vix_disk_lib/api_wrapper_spec.rb
 - spec/spec_helper.rb
-- spec/version_spec.rb
 homepage: http://github.com/ManageIQ/ffi-vix_disk_lib
 licenses:
-- APL 2.0
+- Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,11 +130,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.2.5
+signing_key:
 specification_version: 4
 summary: Ruby FFI Binding to VMware VixDiskLib.
 test_files:
+- spec/ext/.gitignore
+- spec/ext/Makefile
+- spec/ext/vixDiskLib.c
+- spec/ffi-vix_disk_lib/api_spec.rb
+- spec/ffi-vix_disk_lib/api_wrapper_spec.rb
 - spec/spec_helper.rb
-- spec/version_spec.rb

data/spec/version_spec.rb

@@ -1,7 +0,0 @@
-require_relative './spec_helper'
-
-describe FFI::VixDiskLib::VERSION do
-  it "must be defined" do
-    FFI::VixDiskLib::VERSION.wont_be_nil
-  end
-end