ffi-vix_disk_lib 1.0.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 55bf41c744a9a5340104836576424de5d2b6f55a
-  data.tar.gz: 2940e7622e4a526283de0e2f0f43b2fdcf57672c
+SHA256:
+  metadata.gz: ac1c3cd0e843538159ebfd0eafd97daa38f110c2a23e40189a398cd186bda36f
+  data.tar.gz: fa9ff1758564340eba7ad155c227228456d0a1b6baa3465020131cfce39c57cf
 SHA512:
-  metadata.gz: f5b854a5899cacd6893a419068d3788c767aef28ba36644db5296e0aa4809549c9590079497ba7a73ceca5966d07c3fb04eeee2f727689dd7692cee5da17966f
-  data.tar.gz: 274f8c957c268da2dd9808d1a9faa70aa28e29923beac0dece47700781937739a2bb3291434e3b4b282470819bff0a3acc2c97be8d7280def6912259072be01b
+  metadata.gz: 4d5ae132b933ce99634f7889d9b1e741f7afefb81020ad431375dec9fe782aab6a6d6d5ef59cee00ef14a64c6fa80bbcc3bcd2fab20c63e9a3a00e6077b48831
+  data.tar.gz: f761743edd3559fbed1a797ff844703d660fb0ab396055c08c9862d58438f02eb3005587417d1db5b33f726e541bc1a654aa23abb5dc53cc0e255a751d745551

data/lib/ffi-vix_disk_lib/api.rb

@@ -5,44 +5,29 @@ 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
 
-      def self.load_error
-        @load_error
-      end
-
-      #
-      # Make sure we load one and only one version of VixDiskLib
-      #
-      version_load_order = %w( 6.7.0 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)
-          VERSION = version
-          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[6.7.0 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]
+      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
@@ -63,12 +48,7 @@ module FFI
       end
 
       def self.evaluate_versioned_connect_params
-        case VERSION
-        when "6.5.0"
-          ConnectParams_6_5_0
-        else
-          ConnectParams_1_0_0
-        end
+        Gem::Version.new(VERSION) >= Gem::Version.new("6.5.0") ? ConnectParams_6_5_0 : ConnectParams_1_0_0
       end
 
       ConnectParams = evaluate_versioned_connect_params

data/lib/ffi-vix_disk_lib/version.rb

@@ -1,5 +1,5 @@
 module FFI
   module VixDiskLib
-    VERSION = "1.0.5"
+    VERSION = "1.1.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

@@ -1,25 +1,37 @@
 describe FFI::VixDiskLib::API do
-  let(:major_version) { described_class::VERSION_MAJOR }
-  let(:minor_version) { described_class::VERSION_MINOR }
-  let(:log)           { lambda { |_string, _pointer| } }
-  let(:lib_dir)       { nil }
+  let(:log)     { lambda { |_string, _pointer| } }
+  let(:lib_dir) { nil }
+  let(:version) { ENV.fetch("VDDK_VERSION", "6.7.0") }
 
-  context "init" do
+  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(major_version, minor_version, log, log, log, lib_dir)
+      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
 
-  context "ConnectParams" do
-    case described_class::VERSION
-    when "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)
+  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

data/spec/spec_helper.rb

@@ -1,17 +1,6 @@
-begin
-  require 'ffi-vix_disk_lib'
-rescue LoadError
-  STDERR.puts <<-EOMSG
+ENV["LD_LIBRARY_PATH"] ||= File.expand_path("ext", __dir__)
 
-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
-end
+require 'ffi-vix_disk_lib'
 
 RSpec.configure do |config|
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-vix_disk_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors:
 - Jerry Keselman
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-11 00:00:00.000000000 Z
+date: 2020-01-22 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: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -41,7 +41,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -91,13 +91,15 @@ 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/ffi-vix_disk_lib/version_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/ManageIQ/ffi-vix_disk_lib
 licenses:
-- APL 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -114,13 +116,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.1.2
 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/ffi-vix_disk_lib/version_spec.rb
 - spec/spec_helper.rb

data/spec/ffi-vix_disk_lib/version_spec.rb

@@ -1,5 +0,0 @@
-describe FFI::VixDiskLib::VERSION do
-  it "must be defined" do
-    expect(FFI::VixDiskLib::VERSION).to_not be_nil
-  end
-end