//export Java_io_v_impl_google_lib_discovery_UpdateImpl_nativeAttachment func Java_io_v_impl_google_lib_discovery_UpdateImpl_nativeAttachment(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jName C.jstring, jCbObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return } update := *(*discovery.Update)(jutil.GoRefValue(jutil.Ref(goRef))) name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) jCb := jutil.Object(uintptr(unsafe.Pointer(jCbObj))) jutil.DoAsyncCall(env, jCb, func() (jutil.Object, error) { dataOrErr := <-update.Attachment(ctx, name) if dataOrErr.Error != nil { return jutil.NullObject, err } env, freeFunc := jutil.GetEnv() defer freeFunc() jData, err := jutil.JByteArray(env, dataOrErr.Data) if err != nil { return jutil.NullObject, err } // Must grab a global reference as we free up the env and all local references that come // along with it. return jutil.NewGlobalRef(env, jData), nil // Un-refed in DoAsyncCall }) }
//export Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate func Java_io_v_v23_security_PublicKeyThirdPartyCaveatValidator_nativeValidate(jenv *C.JNIEnv, jThirdPartyValidatorClass C.jclass, jContext C.jobject, jCall C.jobject, jCaveatParam C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) param, err := jutil.GoVomCopyValue(env, jutil.Object(uintptr(unsafe.Pointer(jCaveatParam)))) if err != nil { jutil.JThrowV(env, err) return } ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return } call, err := GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall)))) if err != nil { jutil.JThrowV(env, err) return } caveat, err := security.NewCaveat(security.PublicKeyThirdPartyCaveat, param) if err != nil { jutil.JThrowV(env, err) return } if err := caveat.Validate(ctx, call); err != nil { jutil.JThrowV(env, err) return } }
//export Java_io_v_v23_security_VSecurity_nativeGetSigningBlessingNames func Java_io_v_v23_security_VSecurity_nativeGetSigningBlessingNames(jenv *C.JNIEnv, jVSecurityClass C.jclass, jCtx C.jobject, jPrincipal C.jobject, jBlessings C.jobject) C.jobjectArray { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return nil } principal, err := GoPrincipal(env, jutil.Object(uintptr(unsafe.Pointer(jPrincipal)))) if err != nil { jutil.JThrowV(env, err) return nil } blessings, err := GoBlessings(env, jutil.Object(uintptr(unsafe.Pointer(jBlessings)))) if err != nil { jutil.JThrowV(env, err) return nil } blessingStrs, _ := security.SigningBlessingNames(ctx, principal, blessings) jArr, err := jutil.JStringArray(env, blessingStrs) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobjectArray(unsafe.Pointer(jArr)) }
//export Java_io_v_impl_google_lib_discovery_GlobalDiscovery_nativeNewDiscovery func Java_io_v_impl_google_lib_discovery_GlobalDiscovery_nativeNewDiscovery(jenv *C.JNIEnv, jRuntime C.jclass, jContext C.jobject, jPath C.jstring, jMountTTL, jScanInterval C.jobject) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return nil } path := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jPath)))) mountTTL, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jMountTTL)))) if err != nil { jutil.JThrowV(env, err) return nil } scanInterval, err := jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jScanInterval)))) if err != nil { jutil.JThrowV(env, err) return nil } discovery, err := gdiscovery.NewWithTTL(ctx, path, mountTTL, scanInterval) if err != nil { jutil.JThrowV(env, err) return nil } jDiscovery, err := JavaDiscovery(env, discovery) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jDiscovery)) }
//export Java_io_v_impl_google_lib_discovery_FactoryUtil_injectMockPlugin func Java_io_v_impl_google_lib_discovery_FactoryUtil_injectMockPlugin(jenv *C.JNIEnv, _ C.jclass, jCtx C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return } injectMockPlugin(ctx) }
func unmountArgs(env jutil.Env, jName, jServer C.jstring, jContext, jOptions C.jobject) (name, server string, context *context.T, options []naming.NamespaceOpt, err error) { name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) server = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jServer)))) context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) return }
//export Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise func Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeAdvertise(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jAdObj C.jobject, jVisibilityObj C.jobject, jCbObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return } d := *(*discovery.T)(jutil.GoRefValue(jutil.Ref(goRef))) jAd := jutil.Object(uintptr(unsafe.Pointer(jAdObj))) jVisibility := jutil.Object(uintptr(unsafe.Pointer(jVisibilityObj))) var ad discovery.Advertisement if err := jutil.GoVomCopy(env, jAd, jAdvertisementClass, &ad); err != nil { jutil.JThrowV(env, err) return } jVisibilityList, err := jutil.GoObjectList(env, jVisibility) if err != nil { jutil.JThrowV(env, err) return } visibility := make([]security.BlessingPattern, len(jVisibilityList)) for i, jPattern := range jVisibilityList { if err := jutil.GoVomCopy(env, jPattern, jBlessingPatternClass, &visibility[i]); err != nil { jutil.JThrowV(env, err) return } } done, err := d.Advertise(ctx, &ad, visibility) if err != nil { jutil.JThrowV(env, err) return } // Copy back the advertisement id. jId, err := jutil.JVomCopy(env, &ad.Id, jAdIdClass) if err != nil { jutil.JThrowV(env, err) return } if err = jutil.CallVoidMethod(env, jAd, "setId", []jutil.Sign{adIdSign}, jId); err != nil { jutil.JThrowV(env, err) return } jCb := jutil.Object(uintptr(unsafe.Pointer(jCbObj))) jutil.DoAsyncCall(env, jCb, func() (jutil.Object, error) { <-done return jutil.NullObject, nil }) }
func globArgs(env jutil.Env, jContext C.jobject, jPattern C.jstring, jOptions C.jobject) (context *context.T, cancel func(), pattern string, opts []naming.NamespaceOpt, err error) { context, cancel, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } opts, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } pattern = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jPattern)))) return }
func getPermissionsArgs(env jutil.Env, jContext C.jobject, jName C.jstring, jOptions C.jobject) (context *context.T, name string, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) return }
func resolveToMountTableArgs(env jutil.Env, jContext, jOptions C.jobject, jName C.jstring) (context *context.T, options []naming.NamespaceOpt, name string, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) return }
func deleteArgs(env jutil.Env, jContext, jOptions C.jobject, jName C.jstring, jDeleteSubtree C.jboolean) (context *context.T, options []naming.NamespaceOpt, name string, deleteSubtree bool, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) deleteSubtree = jDeleteSubtree == C.JNI_TRUE return }
//export Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites func Java_io_v_v23_syncbase_DatabaseImpl_nativeListenForInvites(jenv *C.JNIEnv, jDatabase C.jobject, jContext C.jobject, jInviteHandler C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) database := jutil.Object(uintptr(unsafe.Pointer(jDatabase))) handler := jutil.Object(uintptr(unsafe.Pointer(jInviteHandler))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return } jDbId, err := jutil.CallObjectMethod(env, database, "id", nil, idSign) if err != nil { jutil.JThrowV(env, err) return } dbName, err := jutil.CallStringMethod(env, jDbId, "getName", nil) if err != nil { jutil.JThrowV(env, err) return } dbBlessing, err := jutil.CallStringMethod(env, jDbId, "getBlessing", nil) if err != nil { jutil.JThrowV(env, err) return } dbId := wire.Id{Name: dbName, Blessing: dbBlessing} // Note: There is no need to use a buffered channel here. ListenForInvites // spawns a goroutine for this listener that acts as an infinite buffer so we can // process invites at our own pace. ch := make(chan discovery.Invite) if err := discovery.ListenForInvites(ctx, dbId, ch); err != nil { jutil.JThrowV(env, err) return } handler = jutil.NewGlobalRef(env, handler) go func() { for invite := range ch { if err := handleInvite(invite, handler); err != nil { // TODO(mattr): We should cancel the stream and return an error to // the user here. ctx.Errorf("couldn't call invite handler: %v", err) } } env, free := jutil.GetEnv() jutil.DeleteGlobalRef(env, handler) free() }() }
func setPermissionsArgs(env jutil.Env, jContext, jPermissions C.jobject, jName, jVersion C.jstring, jOptions C.jobject) (context *context.T, permissions access.Permissions, name, version string, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } err = jutil.GoVomCopy(env, jutil.Object(uintptr(unsafe.Pointer(jPermissions))), jPermissionsClass, &permissions) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) version = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jVersion)))) return }
func mountArgs(env jutil.Env, jContext C.jobject, jName, jServer C.jstring, jDuration, jOptions C.jobject) (context *context.T, name, server string, duration time.Duration, options []naming.NamespaceOpt, err error) { context, _, err = jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { return } name = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) server = jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jServer)))) duration, err = jutil.GoDuration(env, jutil.Object(uintptr(unsafe.Pointer(jDuration)))) if err != nil { return } options, err = goNamespaceOptions(env, jutil.Object(uintptr(unsafe.Pointer(jOptions)))) return }
func (c *callImpl) Context() *context.T { env, freeFunc := jutil.GetEnv() defer freeFunc() contextSign := jutil.ClassSign("io.v.v23.context.VContext") jCtx, err := jutil.CallObjectMethod(env, c.jCall, "context", nil, contextSign) if err != nil { log.Printf("Couldn't get Java Vanadium context: %v", err) } ctx, _, err := jcontext.GoContext(env, jCtx) if err != nil { log.Printf("Couldn't convert Java Vanadium context to Go: %v", err) } return ctx }
//export Java_io_v_impl_google_namespace_NamespaceImpl_nativeFlushCacheEntry func Java_io_v_impl_google_namespace_NamespaceImpl_nativeFlushCacheEntry(jenv *C.JNIEnv, jNamespaceClass C.jclass, goRef C.jlong, jContext C.jobject, jName C.jstring) C.jboolean { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) n := *(*namespace.T)(jutil.GoRefValue(jutil.Ref(goRef))) context, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return C.JNI_FALSE } result := n.FlushCacheEntry(context, jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))) if result { return C.JNI_TRUE } else { return C.JNI_FALSE } }
//export Java_io_v_v23_security_access_AccessList_nativeAuthorize func Java_io_v_v23_security_access_AccessList_nativeAuthorize(jenv *C.JNIEnv, jAccessList C.jobject, goRef C.jlong, jCtx C.jobject, jCall C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return } call, err := jsecurity.GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall)))) if err != nil { jutil.JThrowV(env, err) } if err := (*(*access.AccessList)(jutil.GoRefValue(jutil.Ref(goRef)))).Authorize(ctx, call); err != nil { jutil.JThrowV(env, err) return } }
//export Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeAuthorize func Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeAuthorize(jenv *C.JNIEnv, jPermissionsAuthorizer C.jobject, goRef C.jlong, jContext C.jobject, jCall C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return } call, err := jsecurity.GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall)))) if err != nil { jutil.JThrowV(env, err) return } if err := (*(*security.Authorizer)(jutil.GoRefValue(jutil.Ref(goRef)))).Authorize(ctx, call); err != nil { jutil.JThrowV(env, err) return } }
//export Java_io_v_android_util_Vango_nativeGoContextCall func Java_io_v_android_util_Vango_nativeGoContextCall(jenv *C.JNIEnv, jVango C.jobject, jContext C.jobject, jKey C.jstring, jOutput C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) key := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jKey)))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.JThrowV(env, err) return } f, ok := vangoFuncs[key] if !ok { jutil.JThrowV(env, fmt.Errorf("vangoFunc key %q doesn't exist", key)) return } if err := f(ctx, newJavaOutputWriter(env, jutil.Object(uintptr(unsafe.Pointer(jOutput))))); err != nil { jutil.JThrowV(env, err) return } }
//export Java_io_v_v23_security_VSecurity_nativeGetLocalBlessingNames func Java_io_v_v23_security_VSecurity_nativeGetLocalBlessingNames(jenv *C.JNIEnv, jVSecurityClass C.jclass, jCtx C.jobject, jCall C.jobject) C.jobjectArray { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return nil } call, err := GoCall(env, jutil.Object(uintptr(unsafe.Pointer(jCall)))) if err != nil { jutil.JThrowV(env, err) return nil } blessingStrs := security.LocalBlessingNames(ctx, call) jArr, err := jutil.JStringArray(env, blessingStrs) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobjectArray(unsafe.Pointer(jArr)) }
//export Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeScan func Java_io_v_impl_google_lib_discovery_DiscoveryImpl_nativeScan(jenv *C.JNIEnv, _ C.jobject, goRef C.jlong, jCtx C.jobject, jQuery C.jstring) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) ctx, _, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jCtx)))) if err != nil { jutil.JThrowV(env, err) return nil } d := *(*discovery.T)(jutil.GoRefValue(jutil.Ref(goRef))) query := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jQuery)))) scanCh, err := d.Scan(ctx, query) if err != nil { jutil.JThrowV(env, err) return nil } jChannel, err := jchannel.JavaInputChannel(env, ctx, nil, func() (jutil.Object, error) { update, ok := <-scanCh if !ok { return jutil.NullObject, verror.NewErrEndOfFile(ctx) } env, freeFunc := jutil.GetEnv() defer freeFunc() jUpdate, err := javaUpdate(env, update) if err != nil { return jutil.NullObject, err } // Must grab a global reference as we free up the env and all local references that come // along with it. return jutil.NewGlobalRef(env, jUpdate), nil // un-refed by InputChannelImpl_nativeRecv }) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jChannel)) }
//export Java_io_v_impl_google_rpc_ClientImpl_nativeStartCall func Java_io_v_impl_google_rpc_ClientImpl_nativeStartCall(jenv *C.JNIEnv, jClientObj C.jobject, goRef C.jlong, jContext C.jobject, jName C.jstring, jMethod C.jstring, jVomArgs C.jobjectArray, jOptionsObj C.jobject, jCallbackObj C.jobject) { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName)))) method := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jMethod)))) jOptions := jutil.Object(uintptr(unsafe.Pointer(jOptionsObj))) jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj))) ctx, cancel, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext)))) if err != nil { jutil.CallbackOnFailure(env, jCallback, err) return } args, err := decodeArgs(env, jVomArgs) if err != nil { jutil.CallbackOnFailure(env, jCallback, err) return } opts, err := jopts.GoRpcOpts(env, jOptions) if err != nil { jutil.CallbackOnFailure(env, jCallback, err) return } // Create a global reference to the client object for the duration of the call // so that the java object doesn't get garbage collected while the async call // is happening. This is an issue because if the java object is garbage collected, // the go ref will also be collected causing doStartCall to panic. jClient := jutil.NewGlobalRef(env, jutil.Object(uintptr(unsafe.Pointer(jClientObj)))) jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) { obj, err := doStartCall(ctx, cancel, name, method, opts, goRef, args) env, freeFunc := jutil.GetEnv() jutil.DeleteGlobalRef(env, jClient) freeFunc() return obj, err }) }
//export Java_io_v_impl_google_services_groups_GroupServer_nativeWithNewServer func Java_io_v_impl_google_services_groups_GroupServer_nativeWithNewServer(jenv *C.JNIEnv, jGroupServerClass C.jclass, jContext C.jobject, jGroupServerParams C.jobject) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCtx := jutil.Object(uintptr(unsafe.Pointer(jContext))) jParams := jutil.Object(uintptr(unsafe.Pointer(jGroupServerParams))) // Read and translate all of the server params. name, err := jutil.CallStringMethod(env, jParams, "getName", nil) if err != nil { jutil.JThrowV(env, err) return nil } rootDir, err := jutil.CallStringMethod(env, jParams, "getStorageRootDir", nil) if err != nil { jutil.JThrowV(env, err) return nil } if rootDir == "" { rootDir = filepath.Join(os.TempDir(), "groupserver") if err := os.Mkdir(rootDir, 0755); err != nil && !os.IsExist(err) { jutil.JThrowV(env, err) return nil } } jEngine, err := jutil.CallObjectMethod(env, jParams, "getStorageEngine", nil, storageEngineSign) if err != nil { jutil.JThrowV(env, err) return nil } engine, err := GoStorageEngine(env, jEngine) if err != nil { jutil.JThrowV(env, err) return nil } // Start the server. ctx, cancel, err := jcontext.GoContext(env, jCtx) if err != nil { jutil.JThrowV(env, err) return nil } dispatcher, err := lib.NewGroupsDispatcher(rootDir, engine) if err != nil { jutil.JThrowV(env, err) return nil } newCtx, s, err := v23.WithNewDispatchingServer(ctx, name, dispatcher) if err != nil { jutil.JThrowV(env, err) return nil } jNewCtx, err := jcontext.JavaContext(env, newCtx, cancel) if err != nil { jutil.JThrowV(env, err) return nil } jServer, err := jrpc.JavaServer(env, s) if err != nil { jutil.JThrowV(env, err) return nil } // Attach a server to the new context. jServerAttCtx, err := jutil.CallStaticObjectMethod(env, jVRuntimeImplClass, "withServer", []jutil.Sign{contextSign, serverSign}, contextSign, jNewCtx, jServer) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jServerAttCtx)) }
//export Java_io_v_impl_google_services_mounttable_MountTableServer_nativeWithNewServer func Java_io_v_impl_google_services_mounttable_MountTableServer_nativeWithNewServer(jenv *C.JNIEnv, jMountTableServerClass C.jclass, jContext C.jobject, jMountTableServerParams C.jobject) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCtx := jutil.Object(uintptr(unsafe.Pointer(jContext))) jParams := jutil.Object(uintptr(unsafe.Pointer(jMountTableServerParams))) // Read and translate all of the server params. mountName, err := jutil.CallStringMethod(env, jParams, "getName", nil) if err != nil { jutil.JThrowV(env, err) return nil } rootDir, err := jutil.CallStringMethod(env, jParams, "getStorageRootDir", nil) if err != nil { jutil.JThrowV(env, err) return nil } permsJMap, err := jutil.CallMapMethod(env, jParams, "getPermissions", nil) if err != nil { jutil.JThrowV(env, err) return nil } permsMap := make(map[string]access.Permissions) for jPath, jPerms := range permsJMap { path := jutil.GoString(env, jPath) perms, err := jaccess.GoPermissions(env, jPerms) if err != nil { jutil.JThrowV(env, err) return nil } permsMap[path] = perms } // Write JSON-encoded permissions to a file. jsonPerms, err := json.Marshal(permsMap) if err != nil { jutil.JThrowV(env, fmt.Errorf("Couldn't JSON-encode path-permissions: %v", err)) return nil } permsFile, err := ioutil.TempFile(rootDir, "jni_permissions") if err != nil { jutil.JThrowV(env, fmt.Errorf("Couldn't create permissions file: %v", err)) return nil } w := bufio.NewWriter(permsFile) if _, err := w.Write(jsonPerms); err != nil { jutil.JThrowV(env, fmt.Errorf("Couldn't write to permissions file: %v", err)) return nil } if err := w.Flush(); err != nil { jutil.JThrowV(env, fmt.Errorf("Couldn't flush to permissions file: %v", err)) } statsPrefix, err := jutil.CallStringMethod(env, jParams, "getStatsPrefix", nil) if err != nil { jutil.JThrowV(env, err) return nil } // Start the mounttable server. ctx, cancel, err := jcontext.GoContext(env, jCtx) if err != nil { jutil.JThrowV(env, err) return nil } d, err := mounttablelib.NewMountTableDispatcher(ctx, permsFile.Name(), rootDir, statsPrefix) if err != nil { jutil.JThrowV(env, err) return nil } newCtx, s, err := v23.WithNewDispatchingServer(ctx, mountName, d, options.ServesMountTable(true)) if err != nil { jutil.JThrowV(env, err) return nil } jNewCtx, err := jcontext.JavaContext(env, newCtx, cancel) if err != nil { jutil.JThrowV(env, err) return nil } jServer, err := jrpc.JavaServer(env, s) if err != nil { jutil.JThrowV(env, err) return nil } // Attach a server to the new context. jServerAttCtx, err := jutil.CallStaticObjectMethod(env, jVRuntimeImplClass, "withServer", []jutil.Sign{contextSign, serverSign}, contextSign, jNewCtx, jServer) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jServerAttCtx)) }
//export Java_io_v_impl_google_services_syncbase_SyncbaseServer_nativeWithNewServer func Java_io_v_impl_google_services_syncbase_SyncbaseServer_nativeWithNewServer(jenv *C.JNIEnv, jSyncbaseServerClass C.jclass, jContext C.jobject, jSyncbaseServerParams C.jobject) C.jobject { env := jutil.Env(uintptr(unsafe.Pointer(jenv))) jCtx := jutil.Object(uintptr(unsafe.Pointer(jContext))) jParams := jutil.Object(uintptr(unsafe.Pointer(jSyncbaseServerParams))) // Read and translate all of the server params. jPerms, err := jutil.CallObjectMethod(env, jParams, "getPermissions", nil, permissionsSign) if err != nil { jutil.JThrowV(env, err) return nil } perms, err := jaccess.GoPermissions(env, jPerms) if err != nil { jutil.JThrowV(env, err) return nil } name, err := jutil.CallStringMethod(env, jParams, "getName", nil) if err != nil { jutil.JThrowV(env, err) return nil } rootDir, err := jutil.CallStringMethod(env, jParams, "getStorageRootDir", nil) if err != nil { jutil.JThrowV(env, err) return nil } if rootDir == "" { rootDir = filepath.Join(os.TempDir(), "syncbaseserver") if err := os.Mkdir(rootDir, 0755); err != nil && !os.IsExist(err) { jutil.JThrowV(env, err) return nil } } jEngine, err := jutil.CallObjectMethod(env, jParams, "getStorageEngine", nil, storageEngineSign) if err != nil { jutil.JThrowV(env, err) return nil } engine, err := GoStorageEngine(env, jEngine) if err != nil { jutil.JThrowV(env, err) return nil } ctx, cancel, err := jcontext.GoContext(env, jCtx) if err != nil { jutil.JThrowV(env, err) return nil } // Create the rpc server before the service so that connections are shared between // clients in the service and the rpc server. (i.e. connections are shared if the // context returned from WithNewDispatchingServer is used for client calls). d := dispatcher.NewDispatcherWrapper() ctx, s, err := v23.WithNewDispatchingServer(ctx, name, d, options.ChannelTimeout(vsync.NeighborConnectionTimeout)) if err != nil { cancel() jutil.JThrowV(env, err) return nil } service, err := server.NewService(ctx, server.ServiceOptions{ Perms: perms, RootDir: rootDir, Engine: engine, }) if err != nil { cancel() jutil.JThrowV(env, err) return nil } // Set the dispatcher in the dispatcher wrapper for the server to start responding // to incoming rpcs. d.SetDispatcher(server.NewDispatcher(service)) if err := service.AddNames(ctx, s); err != nil { cancel() jutil.JThrowV(env, err) return nil } jNewCtx, err := jcontext.JavaContext(env, ctx, cancel) if err != nil { jutil.JThrowV(env, err) return nil } jServer, err := jrpc.JavaServer(env, s) if err != nil { jutil.JThrowV(env, err) return nil } // Attach a server to the new context. jServerAttCtx, err := jutil.CallStaticObjectMethod(env, jVRuntimeImplClass, "withServer", []jutil.Sign{contextSign, serverSign}, contextSign, jNewCtx, jServer) if err != nil { jutil.JThrowV(env, err) return nil } return C.jobject(unsafe.Pointer(jServerAttCtx)) }