Exemple #1
0
  public static void createPKeyDSA(Ruby runtime, RubyModule mPKey) {
    RubyClass cDSA = mPKey.defineClassUnder("DSA", mPKey.getClass("PKey"), PKEYDSA_ALLOCATOR);
    RubyClass pkeyError = mPKey.getClass("PKeyError");
    mPKey.defineClassUnder("DSAError", pkeyError, pkeyError.getAllocator());

    cDSA.defineAnnotatedMethods(PKeyDSA.class);
  }
Exemple #2
0
  public static RubyClass createConverterTypeClass(Ruby runtime, RubyModule ffiModule) {
    RubyClass convClass =
        ffiModule
            .getClass("Type")
            .defineClassUnder(
                "Mapped", ffiModule.getClass("Type"), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
    convClass.defineAnnotatedMethods(MappedType.class);
    convClass.defineAnnotatedConstants(MappedType.class);

    return convClass;
  }
Exemple #3
0
  public static RubyClass createPointerClass(Ruby runtime, RubyModule module) {
    RubyClass pointerClass =
        module.defineClassUnder(
            "Pointer",
            module.getClass(AbstractMemory.ABSTRACT_MEMORY_RUBY_CLASS),
            RubyInstanceConfig.REIFY_RUBY_CLASSES
                ? new ReifyingAllocator(Pointer.class)
                : PointerAllocator.INSTANCE);

    pointerClass.defineAnnotatedMethods(Pointer.class);
    pointerClass.defineAnnotatedConstants(Pointer.class);
    pointerClass.setReifiedClass(Pointer.class);
    pointerClass.kindOf =
        new RubyModule.KindOf() {
          @Override
          public boolean isKindOf(IRubyObject obj, RubyModule type) {
            return obj instanceof Pointer && super.isKindOf(obj, type);
          }
        };

    module.defineClassUnder(
        "NullPointerError", runtime.getRuntimeError(), runtime.getRuntimeError().getAllocator());

    // Add Pointer::NULL as a constant
    Pointer nullPointer = new Pointer(runtime, pointerClass, new NullMemoryIO(runtime));
    pointerClass.setConstant("NULL", nullPointer);

    runtime
        .getNilClass()
        .addMethod("to_ptr", new NilToPointerMethod(runtime.getNilClass(), nullPointer));

    return pointerClass;
  }
Exemple #4
0
 public static void createConfig(Ruby runtime, RubyModule mOSSL) {
   RubyClass cConfig =
       mOSSL.defineClassUnder("Config", runtime.getObject(), runtime.getObject().getAllocator());
   cConfig.defineAnnotatedMethods(Config.class);
   RubyClass openSSLError = mOSSL.getClass("OpenSSLError");
   mOSSL.defineClassUnder("ConfigError", openSSLError, openSSLError.getAllocator());
   // TODO: we should define this constant with proper path. (see above)
   // cConfig.setConstant("DEFAULT_CONFIG_FILE", runtime.newString(DEFAULT_CONFIG_FILE));
 }
Exemple #5
0
  /**
   * @param runtime
   * @param driver
   * @return
   */
  public static RubyClass createResultClass(final Ruby runtime, DriverDefinition driver) {
    RubyModule doModule = runtime.getModule(DATA_OBJECTS_MODULE_NAME);
    RubyClass superClass = doModule.getClass(RUBY_CLASS_NAME);
    RubyModule driverModule = (RubyModule) doModule.getConstant(driver.getModuleName());
    RubyClass resultClass =
        driverModule.defineClassUnder(RUBY_CLASS_NAME, superClass, RESULT_ALLOCATOR);

    resultClass.defineAnnotatedMethods(Result.class);
    return resultClass;
  }
Exemple #6
0
  public static RubyClass createBufferClass(Ruby runtime, RubyModule module) {
    RubyClass result =
        module.defineClassUnder(
            "Buffer",
            module.getClass(AbstractMemory.ABSTRACT_MEMORY_RUBY_CLASS),
            ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
    result.defineAnnotatedMethods(Buffer.class);
    result.defineAnnotatedConstants(Buffer.class);

    return result;
  }
Exemple #7
0
 /**
  * @param runtime
  * @param factory
  * @return
  */
 public static RubyClass createCommandClass(final Ruby runtime, DriverDefinition factory) {
   RubyModule doModule = runtime.getModule(DATA_OBJECTS_MODULE_NAME);
   RubyClass superClass = doModule.getClass(RUBY_CLASS_NAME);
   RubyModule driverModule = (RubyModule) doModule.getConstant(factory.getModuleName());
   RubyClass commandClass =
       runtime.defineClassUnder("Command", superClass, COMMAND_ALLOCATOR, driverModule);
   commandClass.setInstanceVariable("@__factory", JavaEmbedUtils.javaToRuby(runtime, factory));
   commandClass.defineAnnotatedMethods(Command.class);
   setDriverDefinition(commandClass, runtime, factory);
   return commandClass;
 }
Exemple #8
0
  public static void createPKey(Ruby runtime, RubyModule ossl) {
    RubyModule _PKey = ossl.defineModuleUnder("PKey");
    _PKey.defineAnnotatedMethods(PKeyModule.class);
    // PKey is abstract
    RubyClass _PKeyPkey =
        _PKey.defineClassUnder(
            "PKey", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
    RubyClass _OpenSSLError = ossl.getClass("OpenSSLError");
    _PKey.defineClassUnder("PKeyError", _OpenSSLError, _OpenSSLError.getAllocator());

    _PKeyPkey.defineAnnotatedMethods(PKey.class);

    PKeyRSA.createPKeyRSA(runtime, _PKey);
    PKeyDSA.createPKeyDSA(runtime, _PKey);
    PKeyDH.createPKeyDH(runtime, _PKey, _PKeyPkey);
  }
Exemple #9
0
  /**
   * Output a log message
   *
   * @param logMessage
   * @param executionTime
   */
  private void debug(String logMessage, Long executionTime) {
    Ruby runtime = getRuntime();
    Connection connection_instance = (Connection) api.getInstanceVariable(this, "@connection");
    RubyModule doModule = runtime.getModule(DATA_OBJECTS_MODULE_NAME);
    RubyClass loggerClass = doModule.getClass("Logger");
    RubyClass messageClass = loggerClass.getClass("Message");

    IRubyObject loggerMsg =
        messageClass.newInstance(
            runtime.getCurrentContext(),
            runtime.newString(logMessage), // query
            runtime.newString(""), // start
            runtime.newFixnum(executionTime), // duration
            Block.NULL_BLOCK);

    api.callMethod(connection_instance, "log", loggerMsg);
  }
Exemple #10
0
 public static RubyClass createCommandClass(
     final Ruby runtime,
     final String moduleName,
     final String errorName,
     final DriverDefinition driverDefinition) {
   RubyModule doModule = runtime.getModule(DATA_OBJECTS_MODULE_NAME);
   RubyClass superClass = doModule.getClass(RUBY_CLASS_NAME);
   RubyModule driverModule = (RubyModule) doModule.getConstant(moduleName);
   RubyClass commandClass =
       runtime.defineClassUnder("Command", superClass, COMMAND_ALLOCATOR, driverModule);
   Command.api = JavaEmbedUtils.newObjectAdapter();
   Command.driver = driverDefinition;
   Command.moduleName = moduleName;
   Command.errorName = errorName;
   commandClass.defineAnnotatedMethods(Command.class);
   return commandClass;
 }
Exemple #11
0
  /**
   * instantiateClass
   *
   * @param runtime
   * @param module
   * @param name
   * @param args
   * @return
   */
  public static IRubyObject instantiateClass(
      Ruby runtime, String module, String name, IRubyObject... args) {
    ThreadContext threadContext = runtime.getCurrentContext();
    IRubyObject result = null;

    // try to load the module
    RubyModule rubyModule = runtime.getModule(module);

    if (rubyModule != null) {
      // now try to load the class
      RubyClass rubyClass = rubyModule.getClass(name);

      // instantiate it, if it exists
      if (rubyClass != null) {
        result = rubyClass.newInstance(threadContext, args, Block.NULL_BLOCK);
      }
    }

    return result;
  }
Exemple #12
0
  /**
   * Registers FFI ruby classes/modules
   *
   * @param module the module to register the classes under
   */
  public void init(Ruby runtime, RubyModule ffi) {
    synchronized (ffi) {
      if (ffi.getClass("Type") == null) {
        Type.createTypeClass(runtime, ffi);
      }
      DataConverter.createDataConverterModule(runtime, ffi);

      if (ffi.getClass(AbstractMemory.ABSTRACT_MEMORY_RUBY_CLASS) == null) {
        AbstractMemory.createAbstractMemoryClass(runtime, ffi);
      }
      if (ffi.getClass("Buffer") == null) {
        Buffer.createBufferClass(runtime, ffi);
      }
      if (ffi.getClass("Pointer") == null) {
        Pointer.createPointerClass(runtime, ffi);
      }
      if (ffi.getClass("AutoPointer") == null) {
        AutoPointer.createAutoPointerClass(runtime, ffi);
      }
      if (ffi.getClass("MemoryPointer") == null) {
        MemoryPointer.createMemoryPointerClass(runtime, ffi);
      }
      if (ffi.getClass("Struct") == null) {
        Struct.createStructClass(runtime, ffi);
      }
      if (ffi.getClass(StructLayout.CLASS_NAME) == null) {
        StructLayout.createStructLayoutClass(runtime, ffi);
      }
      if (ffi.getClass("StructByValue") == null) {
        StructByValue.createStructByValueClass(runtime, ffi);
      }
      if (ffi.getClass(AbstractInvoker.CLASS_NAME) == null) {
        AbstractInvoker.createAbstractInvokerClass(runtime, ffi);
      }
      if (ffi.getClass(CallbackInfo.CLASS_NAME) == null) {
        CallbackInfo.createCallbackInfoClass(runtime, ffi);
      }
      if (ffi.getClass("Enum") == null) {
        Enum.createEnumClass(runtime, ffi);
      }
      if (ffi.getClass("Type").getClass("Mapped") == null) {
        MappedType.createConverterTypeClass(runtime, ffi);
      }
      if (ffi.getClass(FileDescriptorIO.CLASS_NAME) == null) {
        FileDescriptorIO.createFileDescriptorIOClass(runtime, ffi);
      }

      ffi.setConstant("TypeDefs", RubyHash.newHash(runtime));

      Platform.createPlatformModule(runtime, ffi);
      IOModule.createIOModule(runtime, ffi);

      StructByReference.createStructByReferenceClass(runtime, ffi);
    }
  }