Esempio n. 1
0
        /// <summary>
        /// 保存编译好的服务组件或视图运行时代码
        /// </summary>
        /// <param name="asmName">eg: sys.HelloService or sys.CustomerView</param>
        internal static ValueTask UpsertAssemblyAsync(bool isService, string asmName, byte[] asmData, Transaction txn)
        {
            IntPtr keyPtr;
            int    keySize = EntityStoreWriter.CalcStringUtf8Size(asmName) + 1;
            IntPtr dataPtr = IntPtr.Zero;

            unsafe
            {
                byte *pk = stackalloc byte[keySize];
                KeyUtil.WriteAssemblyKey(isService, pk, asmName);
                keyPtr = new IntPtr(pk);

                dataPtr = NativeApi.NewNativeString(asmData.Length, out byte *destDataPtr);
                fixed(byte *srcDataPtr = asmData)
                {
                    Buffer.MemoryCopy(srcDataPtr, destDataPtr, asmData.Length, asmData.Length);
                }
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = KeyUtil.META_RAFTGROUP_ID,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(keySize),
                DataPtr          = dataPtr,
                SchemaVersion    = 0,
                OverrideIfExists = true,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            return(HostApi.ExecKVInsertAsync(txn.Handle, reqPtr));
        }
Esempio n. 2
0
        /// <summary>
        /// Insert or Update模型相关的代码,目前主要用于服务模型及视图模型
        /// </summary>
        /// <param name="codeData">已经压缩编码过</param>
        internal static async ValueTask UpsertModelCodeAsync(ulong modelId, byte[] codeData, Transaction txn)
        {
            IntPtr keyPtr;
            int    keySize = 9;
            IntPtr dataPtr = IntPtr.Zero;

            unsafe
            {
                byte *pk = stackalloc byte[keySize];
                KeyUtil.WriteModelCodeKey(pk, modelId);
                keyPtr = new IntPtr(pk);

                dataPtr = NativeApi.NewNativeString(codeData.Length, out byte *destDataPtr);
                fixed(byte *srcDataPtr = codeData)
                {
                    Buffer.MemoryCopy(srcDataPtr, destDataPtr, codeData.Length, codeData.Length);
                }
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = KeyUtil.META_RAFTGROUP_ID,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(keySize),
                DataPtr          = dataPtr,
                SchemaVersion    = 0,
                OverrideIfExists = true,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            await HostApi.ExecKVInsertAsync(txn.Handle, reqPtr);
        }
Esempio n. 3
0
        /// <summary>
        /// 插入或更新文件夹
        /// </summary>
        internal static async ValueTask UpsertFolderAsync(ModelFolder folder, Transaction txn)
        {
            if (folder.Parent != null)
            {
                throw new InvalidOperationException("Can't save none root folder.");
            }

            //TODO:check need add version

            IntPtr keyPtr;
            IntPtr dataPtr = SerializeModel(folder, out _);

            unsafe
            {
                byte *pk = stackalloc byte[KeyUtil.FOLDER_KEY_SIZE];
                KeyUtil.WriteFolderKey(pk, folder.AppId, folder.TargetModelType);
                keyPtr = new IntPtr(pk);
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = KeyUtil.META_RAFTGROUP_ID,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(KeyUtil.FOLDER_KEY_SIZE),
                DataPtr          = dataPtr,
                SchemaVersion    = 0,
                OverrideIfExists = true,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            await HostApi.ExecKVInsertAsync(txn.Handle, reqPtr);
        }
Esempio n. 4
0
        internal static async ValueTask InsertModelAsync(ModelBase model, Transaction txn)
        {
            IntPtr keyPtr;
            IntPtr dataPtr = SerializeModel(model, out int dataSize);

            unsafe
            {
                byte *pk = stackalloc byte[KeyUtil.MODEL_KEY_SIZE];
                KeyUtil.WriteModelKey(pk, model.Id);
                keyPtr = new IntPtr(pk);
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = KeyUtil.META_RAFTGROUP_ID,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(KeyUtil.MODEL_KEY_SIZE),
                DataPtr          = dataPtr,
                SchemaVersion    = 0,
                OverrideIfExists = false,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            await HostApi.ExecKVInsertAsync(txn.Handle, reqPtr);
        }
Esempio n. 5
0
        private ValueTask KVInsertAsync(IntPtr txnPtr)
        {
            IntPtr keyPtr;
            IntPtr valuePtr;

            unsafe
            {
                var  keyData = stackalloc byte[19];
                var  idx     = Interlocked.Increment(ref keyIndex);
                int *ptr     = (int *)keyData;
                *    ptr     = idx;
                keyPtr   = new IntPtr(keyData);
                valuePtr = NativeApi.NewNativeString(50, out byte *dataPtr);
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = 0,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(19),
                DataPtr          = valuePtr,
                SchemaVersion    = 0,
                OverrideIfExists = true,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            return(Store.StoreApi.Api.ExecKVInsertAsync(txnPtr, reqPtr));
        }
Esempio n. 6
0
        /// <summary>
        /// 保存视图模型路由表
        /// </summary>
        /// <param name="viewName">eg: sys.CustomerList</param>
        /// <param name="path">无自定义路由为空,有上级路由;分隔</param>
        internal static ValueTask UpsertViewRoute(string viewName, string path, Transaction txn)
        {
            //TODO:简化Key与Value编码,直接utf8,各减去3字节字符数标记
            IntPtr keyPtr;
            int    keySize   = EntityStoreWriter.CalcStringUtf8Size(viewName) + 1;
            IntPtr dataPtr   = IntPtr.Zero;
            int    valueSize = EntityStoreWriter.CalcStringUtf8Size(path);

            unsafe
            {
                byte *pk = stackalloc byte[keySize];
                KeyUtil.WriteViewRouteKey(pk, viewName);
                keyPtr = new IntPtr(pk);

                if (!string.IsNullOrEmpty(path))
                {
                    dataPtr = NativeApi.NewNativeString(valueSize, out byte *destDataPtr);
                    var sr = new EntityStoreWriter(destDataPtr, 0);
                    sr.WriteString(path, null);
                }
            }

            var req = new ClrInsertRequire
            {
                RaftGroupId      = KeyUtil.META_RAFTGROUP_ID,
                KeyPtr           = keyPtr,
                KeySize          = new IntPtr(keySize),
                DataPtr          = dataPtr,
                SchemaVersion    = 0,
                OverrideIfExists = true,
                DataCF           = -1
            };
            IntPtr reqPtr;

            unsafe { reqPtr = new IntPtr(&req); }
            return(HostApi.ExecKVInsertAsync(txn.Handle, reqPtr));
        }