/// <summary>
/// Insert a Bin object
/// </summary>
public Acquire Create(int LogicalId, bool enabled, string name,
DateTime createdDate, string createdBy, DateTime modifiedDate, string modifiedBy)
{
var acquireEntity = new Acquire();
try
{
//acquireEntity._Acquire = acquire;
// acquireEntity.Id = id;
acquireEntity.name = name;
acquireEntity.LogicalId = LogicalId;
acquireEntity.Enabled = enabled;
acquireEntity.CreatedDate = createdDate;
acquireEntity.CreatedBy = createdBy;
acquireEntity.LastModifiedDate = modifiedDate;
acquireEntity.LastModifiedBy = modifiedBy;
acquireEntity.IsDeleted = false;
AquireRepo.DbContext.BeginTransaction();
AquireRepo.SaveOrUpdate(acquireEntity);
AquireRepo.DbContext.CommitTransaction();
}
catch (Exception ex)
{
LogManager.LogException(ex);
return(new Acquire());
}
return(acquireEntity);
}
private int ProcessAcquireRequest(Zeze.Net.Protocol p)
{
Acquire rpc = (Acquire)p;
if (rpc.Sender.UserState == null)
{
rpc.SendResultCode(AcquireNotLogin);
return(0);
}
switch (rpc.Argument.State)
{
case StateInvalid: // realease
Release(rpc.Sender.UserState as CacheHolder, rpc.Argument.GlobalTableKey);
rpc.Result = rpc.Argument;
rpc.SendResult();
return(0);
case StateShare:
return(AcquireShare(rpc));
case StateModify:
return(AcquireModify(rpc));
default:
rpc.Result = rpc.Argument;
rpc.SendResultCode(AcquireErrorState);
return(0);
}
}
public void KeyDoor()
{
var lookup = new Lookup();
var key1 = new Acquire(lookup, "key", "key");
var key2 = new Acquire(lookup, "key", "key");
var door1 = new Consume(lookup, "key", "door");
var door2 = new Consume(lookup, "key", "door");
const int numNodes = 3;
var process = new Process(numNodes);
process.AddScript(0, key1);
process.AddScript(0, key2); // removing this key fails EF(f)
process.AddTransition(0, 1, door1);
process.AddTransition(1, 2, door2); // changing this door to (0,1) passes EF(f) but not AG(EF(f))
using (var writer = new StringWriter())
{
process.ExportToGraphviz(writer);
Debug.Log(writer);
}
Debug.Log(lookup);
var variables = lookup.VariableNames.ToArray();
var ts = process.BuildTransitionSystem(variables, 0, 2, out int[] initialStates, out int[] finalStates, out IProposition[] propositions);
public bool UpdateAcquire(Acquire acquire)
{
try
{
AquireRepo.DbContext.BeginTransaction();
AquireRepo.SaveOrUpdate(acquire);
AquireRepo.DbContext.CommitTransaction();
return(true);
}
catch (Exception ex)
{
LogManager.LogException(ex);
return(false);
}
}
public Acquire GetAcquiredata(int Id)
{
var user = new Acquire();
try
{
AquireRepo.DbContext.BeginTransaction();
user = AquireRepo.GetAll().Single(u => u.Id == Id);
AquireRepo.DbContext.CommitTransaction();
return(user);
}
catch (Exception ex)
{
LogManager.LogException(ex);
return(new Acquire());
}
}
/****************************************************************************/
private static void WriteTilesToStream(Database objDatabase, DbCommand cmd, Stream objStream)
{
try
{
using (Acquire o = new Acquire(objDatabase))
{
using (DbDataReader objReader = objDatabase.ExecuteSelect(cmd))
{
if (objReader != null)
{
byte[] objBuffer = new byte[kBufferSize];
long iOffset = 0;
while (objReader.Read())
{
long iRead = objReader.GetBytes(0, iOffset, objBuffer, 0, kBufferSize);
if (iRead == 0)
{
break;
}
objStream.Write(objBuffer, 0, (int)iRead);
iOffset += iRead;
}
}
}
}
}
catch (Exception)
{
// Do nothing. Stream will just be empty
}
if (objStream.CanSeek)
{
objStream.Seek(0, SeekOrigin.Begin);
}
return;
}
public virtual Statement VisitAcquire(Acquire @acquire, Class scope)
{
if (@acquire == null)
{
return(null);
}
Class savedScope = this.scope;
this.scope = scope;
LocalDeclarationsStatement locDecs = @acquire.Target as LocalDeclarationsStatement;
if (locDecs != null)
{
locDecs.InitOnly = true;
@acquire.Target = this.VisitLocalDeclarationsStatement(locDecs);
}
@acquire.Body = this.VisitBlock(@acquire.Body);
this.scope = savedScope;
return(@acquire);
}
public bool Remove(int Id)
{
var user = new Acquire();
try
{
AquireRepo.DbContext.BeginTransaction();
user = AquireRepo.GetAll().Single(u => u.Id == Id);
AquireRepo.Delete(user);
AquireRepo.DbContext.CommitTransaction();
return(true);
}
catch (Exception ex)
{
LogManager.LogException(ex);
return(false);
}
}
public Nrsc5Layer1Decoder(float sampleRate)
{
//Create resampler and its buffer
resampler = new ComplexResamplerPipeline(sampleRate, TARGET_SAMPLE_RATE, 2048 * 8, ProcessBlock);
//Create compnents
acquire = new Acquire();
sync = new Sync();
decode = new Decode();
pids = new Pids();
frame = new Frame();
//Apply events
pids.OnPidsFrame += Pids_OnPidsFrame;
frame.OnAasFrame += Frame_OnAasFrame;
frame.OnPduFrame += Frame_OnPduFrame;
//Link components
acquire.SetComponents(acquire, sync, decode, pids, frame);
sync.SetComponents(acquire, sync, decode, pids, frame);
decode.SetComponents(acquire, sync, decode, pids, frame);
pids.SetComponents(acquire, sync, decode, pids, frame);
frame.SetComponents(acquire, sync, decode, pids, frame);
}
public override void Visit(Acquire node)
{
Mutex mutex = thread.Pop().Read().GetAsMutex();
mutex.Acquire(thread);
}
public override Statement VisitAcquire(Acquire acquire)
{
if (acquire == null) return null;
return base.VisitAcquire((Acquire)acquire.Clone());
}
public virtual void VisitAcquire(Acquire @acquire)
{
if (@acquire == null) return;
this.Visit(@acquire.Target);
this.VisitExpression(@acquire.Condition);
this.VisitExpression(@acquire.ConditionFunction);
this.VisitBlock(@acquire.Body);
}
private int AcquireModify(Acquire rpc)
{
CacheHolder sender = (CacheHolder)rpc.Sender.UserState;
rpc.Result = rpc.Argument;
while (true)
{
CacheState cs = global.GetOrAdd(rpc.Argument.GlobalTableKey, (tabkeKeyNotUsed) => new CacheState());
lock (cs)
{
if (cs.AcquireStatePending == StateRemoved)
{
continue;
}
while (cs.AcquireStatePending != StateInvalid)
{
switch (cs.AcquireStatePending)
{
case StateShare:
if (cs.Modify == sender)
{
logger.Debug("1 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireModifyDeadLockFound);
return(0);
}
break;
case StateModify:
if (cs.Modify == sender || cs.Share.Contains(sender))
{
logger.Debug("2 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireModifyDeadLockFound);
return(0);
}
break;
}
logger.Debug("3 {0} {1} {2}", sender, rpc.Argument.State, cs);
Monitor.Wait(cs);
}
cs.AcquireStatePending = StateModify;
if (cs.Modify != null)
{
if (cs.Modify == sender)
{
logger.Debug("4 {0} {1} {2}", sender, rpc.Argument.State, cs);
// 已经是Modify又申请，可能是sender异常关闭，又重启连上。
// 更新一下。应该是不需要的。
sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify;
rpc.SendResultCode(AcquireModifyAlreadyIsModify);
cs.AcquireStatePending = StateInvalid;
return(0);
}
int stateReduceResult = StateReduceException;
Zeze.Util.Task.Run(
() =>
{
stateReduceResult = cs.Modify.Reduce(rpc.Argument.GlobalTableKey, StateInvalid);
lock (cs)
{
Monitor.PulseAll(cs);
}
},
"GlobalCacheManager.AcquireModify.Reduce");
logger.Debug("5 {0} {1} {2}", sender, rpc.Argument.State, cs);
Monitor.Wait(cs);
switch (stateReduceResult)
{
case StateInvalid:
cs.Modify.Acquired.TryRemove(rpc.Argument.GlobalTableKey, out var _);
break; // reduce success
default:
// case StateReduceRpcTimeout:
// case StateReduceException:
// case StateReduceNetError:
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs);
logger.Error("XXX 9 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireModifyFaild);
return(0);
}
cs.Modify = sender;
sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify;
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs);
logger.Debug("6 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.SendResult();
return(0);
}
List <Util.KV <CacheHolder, Reduce> > reducePending
= new List <Util.KV <CacheHolder, Reduce> >();
HashSet <CacheHolder> reduceSuccessed = new HashSet <CacheHolder>();
bool senderIsShare = false;
// 先把降级请求全部发送给出去。
foreach (CacheHolder c in cs.Share)
{
if (c == sender)
{
senderIsShare = true;
reduceSuccessed.Add(sender);
continue;
}
Reduce reduce = c.ReduceWaitLater(rpc.Argument.GlobalTableKey, StateInvalid);
if (null != reduce)
{
reducePending.Add(Util.KV.Create(c, reduce));
}
else
{
// 网络错误不再认为成功。整个降级失败，要中断降级。
// 已经发出去的降级请求要等待并处理结果。后面处理。
break;
}
}
Zeze.Util.Task.Run(
() =>
{
// 一个个等待是否成功。WaitAll 碰到错误不知道怎么处理的，
// 应该也会等待所有任务结束（包括错误）。
foreach (var reduce in reducePending)
{
try
{
reduce.Value.Future.Task.Wait();
if (reduce.Value.Result.State == StateInvalid)
{
// 后面还有个成功的处理循环，但是那里可能包含sender，
// 在这里更新吧。
reduce.Key.Acquired.TryRemove(rpc.Argument.GlobalTableKey, out var _);
reduceSuccessed.Add(reduce.Key);
}
else
{
reduce.Key.SetError();
}
}
catch (Exception ex)
{
reduce.Key.SetError();
// 等待失败不再看作成功。
logger.Error(ex, "Reduce {0} {1} {2} {3}", sender, rpc.Argument.State, cs, reduce.Value.Argument);
}
}
lock (cs)
{
// 需要唤醒等待任务结束的，但没法指定，只能全部唤醒。
Monitor.PulseAll(cs);
}
},
"GlobalCacheManager.AcquireModify.WaitReduce");
logger.Debug("7 {0} {1} {2}", sender, rpc.Argument.State, cs);
Monitor.Wait(cs);
// 移除成功的。
foreach (CacheHolder successed in reduceSuccessed)
{
cs.Share.Remove(successed);
}
// 如果前面降级发生中断(break)，这里就不会为0。
if (cs.Share.Count == 0)
{
cs.Modify = sender;
sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify;
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs); // Pending 结束，唤醒一个进来就可以了。
logger.Debug("8 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.SendResult();
}
else
{
// senderIsShare 在失败的时候，Acquired 没有变化，不需要更新。
// 失败了，要把原来是share的sender恢复。先这样吧。
if (senderIsShare)
{
cs.Share.Add(sender);
}
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs); // Pending 结束，唤醒一个进来就可以了。
logger.Error("XXX 10 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireModifyFaild);
}
// 很好，网络失败不再看成成功，发现除了加break，
// 其他处理已经能包容这个改动，都不用动。
return(0);
}
}
}
private int AcquireShare(Acquire rpc)
{
CacheHolder sender = (CacheHolder)rpc.Sender.UserState;
rpc.Result = rpc.Argument;
while (true)
{
CacheState cs = global.GetOrAdd(rpc.Argument.GlobalTableKey,
(tabkeKeyNotUsed) => new CacheState());
lock (cs)
{
if (cs.AcquireStatePending == StateRemoved)
{
continue;
}
while (cs.AcquireStatePending != StateInvalid)
{
switch (cs.AcquireStatePending)
{
case StateShare:
if (cs.Modify == sender)
{
logger.Debug("1 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireShareDeadLockFound);
return(0);
}
break;
case StateModify:
if (cs.Modify == sender || cs.Share.Contains(sender))
{
logger.Debug("2 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireShareDeadLockFound);
return(0);
}
break;
}
logger.Debug("3 {0} {1} {2}", sender, rpc.Argument.State, cs);
Monitor.Wait(cs);
}
cs.AcquireStatePending = StateShare;
if (cs.Modify != null)
{
if (cs.Modify == sender)
{
cs.AcquireStatePending = StateInvalid;
logger.Debug("4 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateModify;
// 已经是Modify又申请，可能是sender异常关闭，
// 又重启连上。更新一下。应该是不需要的。
sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify;
rpc.SendResultCode(AcquireShareAlreadyIsModify);
return(0);
}
int stateReduceResult = StateReduceException;
Zeze.Util.Task.Run(
() =>
{
stateReduceResult = cs.Modify.Reduce(rpc.Argument.GlobalTableKey, StateShare);
lock (cs)
{
Monitor.PulseAll(cs);
}
},
"GlobalCacheManager.AcquireShare.Reduce");
logger.Debug("5 {0} {1} {2}", sender, rpc.Argument.State, cs);
Monitor.Wait(cs);
switch (stateReduceResult)
{
case StateShare:
cs.Modify.Acquired[rpc.Argument.GlobalTableKey] = StateShare;
cs.Share.Add(cs.Modify);
// 降级成功，有可能降到 Invalid，此时就不需要加入 Share 了。
break;
default:
// 包含协议返回错误的值的情况。
// case StateReduceRpcTimeout:
// case StateReduceException:
// case StateReduceNetError:
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs);
logger.Error("XXX 8 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.Result.State = StateInvalid;
rpc.SendResultCode(AcquireShareFaild);
return(0);
}
cs.Modify = null;
sender.Acquired[rpc.Argument.GlobalTableKey] = StateShare;
cs.Share.Add(sender);
cs.AcquireStatePending = StateInvalid;
Monitor.Pulse(cs);
logger.Debug("6 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.SendResult();
return(0);
}
sender.Acquired[rpc.Argument.GlobalTableKey] = StateShare;
cs.Share.Add(sender);
cs.AcquireStatePending = StateInvalid;
logger.Debug("7 {0} {1} {2}", sender, rpc.Argument.State, cs);
rpc.SendResult();
return(0);
}
}
}
public override Statement VisitAcquire(Acquire acquire){
if (@acquire == null) return null;
if (@acquire.Condition != null)
@acquire.ConditionFunction = new Construct(new Literal(SystemTypes.ThreadConditionDelegate, SystemTypes.Type), new ExpressionList(new AnonymousNestedFunction(null, new Block(new StatementList(new Return(@acquire.Condition))))));
Scope savedScope = this.scope;
Scope scope = this.scope = @acquire.ScopeForTemporaryVariable = new BlockScope(savedScope, @acquire.Body);
this.AddToAllScopes(this.scope);
Declarer declarer = new Declarer(this.ErrorHandler);
declarer.VisitAcquire(@acquire, scope);
@acquire.Target = (Statement) this.Visit(@acquire.Target);
@acquire.Condition = this.VisitExpression(@acquire.Condition);
@acquire.ConditionFunction = this.VisitExpression(@acquire.ConditionFunction);
@acquire.Body = this.VisitBlock(@acquire.Body);
this.scope = savedScope;
return @acquire;
}
public virtual Statement VisitAcquire(Acquire @acquire, Class scope){
if (@acquire == null) return null;
Class savedScope = this.scope;
this.scope = scope;
LocalDeclarationsStatement locDecs = @acquire.Target as LocalDeclarationsStatement;
if (locDecs != null){
locDecs.InitOnly = true;
@acquire.Target = this.VisitLocalDeclarationsStatement(locDecs);
}
@acquire.Body = this.VisitBlock(@acquire.Body);
this.scope = savedScope;
return @acquire;
}
public override Statement VisitAcquire(Acquire acquire) {
if (@acquire == null) return null;
this.requireInitializer = true;
@acquire.Target = (Statement)this.Visit(@acquire.Target);
this.requireInitializer = false;
TypeNode t = null;
ExpressionStatement estat = @acquire.Target as ExpressionStatement;
if (estat != null)
t = estat.Expression == null ? null : estat.Expression.Type;
else
t = ((LocalDeclarationsStatement)@acquire.Target).Type;
if (t != null) {
TypeNode tprime = TypeNode.StripModifiers(t);
if (tprime.Contract == null || tprime.Contract.FramePropertyGetter == null)
this.HandleError(@acquire.Target, Error.TypeOfExprMustBeGuardedClass);
}
@acquire.Condition = this.VisitExpression(@acquire.Condition);
@acquire.ConditionFunction = this.VisitExpression(@acquire.ConditionFunction);
bool savedInsideTryBlock = this.insideTryBlock;
this.insideTryBlock = true;
@acquire.Body = this.VisitBlock(@acquire.Body);
this.insideTryBlock = savedInsideTryBlock;
return @acquire;
}
public virtual Statement VisitAcquire(Acquire @acquire){
if (@acquire == null) return null;
@acquire.Target = (Statement)this.Visit(@acquire.Target);
@acquire.Condition = this.VisitExpression(@acquire.Condition);
@acquire.ConditionFunction = this.VisitExpression(@acquire.ConditionFunction);
@acquire.Body = this.VisitBlock(@acquire.Body);
return @acquire;
}
public override Statement VisitAcquire(Acquire acquire) {
if (@acquire == null)
return null;
Expression target;
TypeNode targetType;
Expression initialValue;
ExpressionStatement expr = @acquire.Target as ExpressionStatement;
if (expr != null){
if (expr.Expression == null)
return null;
targetType = expr.Expression.Type;
target = new Local(targetType);
initialValue = expr.Expression;
} else {
LocalDeclarationsStatement declsStmt = (LocalDeclarationsStatement) @acquire.Target;
LocalDeclaration decl = declsStmt.Declarations[0];
targetType = decl.Field.Type;
target = new MemberBinding(new ImplicitThis(), decl.Field);
initialValue = decl.InitialValue;
decl.Field.Flags &= ~FieldFlags.InitOnly;
}
targetType = this.typeSystem.Unwrap(targetType);
if (targetType == null || targetType.Contract == null || targetType.Contract.FramePropertyGetter == null)
return null;
StatementList statements = new StatementList();
Block block = new Block(statements);
statements.Add(new AssignmentStatement(target, initialValue, initialValue.SourceContext));
SourceContext acquireKeyword = acquire.SourceContext;
acquireKeyword.EndPos = acquireKeyword.StartPos + "acquire".Length;
String acquireMethodName;
String releaseMethodName;
if (@acquire.ReadOnly){
acquireMethodName = "AcquireForReading";
releaseMethodName = "ReleaseForReading";
} else {
acquireMethodName = "AcquireForWriting";
releaseMethodName = "ReleaseForWriting";
}
Method acquireMethod = SystemTypes.Guard.GetMethod(Identifier.For(acquireMethodName), SystemTypes.ThreadConditionDelegate);
Method releaseMethod = SystemTypes.Guard.GetMethod(Identifier.For(releaseMethodName));
Expression frame = new MethodCall(new MemberBinding(target, targetType.Contract.FramePropertyGetter), null, NodeType.Call, SystemTypes.Guard);
Expression cond = @acquire.Condition == null ? (Expression) new Literal(null, SystemTypes.ThreadConditionDelegate) : @acquire.ConditionFunction;
statements.Add(new ExpressionStatement(new MethodCall(new MemberBinding(frame, acquireMethod), new ExpressionList(cond), NodeType.Call, SystemTypes.Void), acquireKeyword));
statements.Add(new Try(@acquire.Body, null, null, null, new Finally(new Block(new StatementList(
new ExpressionStatement(new MethodCall(new MemberBinding(frame, releaseMethod), null, NodeType.Call, SystemTypes.Void), acquireKeyword))))));
return this.VisitBlock(block);
}
