//export Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeCreate
func Java_io_v_v23_services_groups_PermissionsAuthorizer_nativeCreate(jenv *C.JNIEnv, jPermissionsAuthorizerClass C.jclass, jPermissions C.jobject, jTagType C.jobject) C.jobject {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
perms, err := jaccess.GoPermissions(env, jutil.Object(uintptr(unsafe.Pointer(jPermissions))))
if err != nil {
jutil.JThrowV(env, err)
return nil
}
tagType, err := jutil.GoVdlType(env, jutil.Object(uintptr(unsafe.Pointer(jTagType))))
authorizer, err := groups.PermissionsAuthorizer(perms, tagType)
if err != nil {
jutil.JThrowV(env, err)
return nil
}
ref := jutil.GoNewRef(&authorizer) // Un-refed when the Java PermissionsAuthorizer is finalized
jAuthorizer, err := jutil.NewObject(env, jutil.Class(uintptr(unsafe.Pointer(jPermissionsAuthorizerClass))), []jutil.Sign{jutil.LongSign}, int64(ref))
if err != nil {
jutil.GoDecRef(ref)
jutil.JThrowV(env, err)
return nil
}
return C.jobject(unsafe.Pointer(jAuthorizer))
}
//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))
}