public async Task <bool> UpdateTokenAsync(string id, UpdateToken body, CancellationToken cancellationToken = default)
{
var response = await GetTokensUrl()
.AppendPathSegment(id)
.PutJsonAsync(body, cancellationToken)
.ConfigureAwait(false);
return(response.IsSuccessStatusCode);
}
public async Task CanDisableApiKey()
{
var token = await SendRequestAsAsync <ViewToken>(r => r
.Post()
.AsGlobalAdminUser()
.AppendPath("tokens")
.Content(new NewToken {
OrganizationId = SampleDataService.TEST_ORG_ID,
ProjectId = SampleDataService.TEST_PROJECT_ID,
Scopes = new HashSet <string> {
AuthorizationRoles.Client, AuthorizationRoles.User
}
})
.StatusCodeShouldBeCreated()
);
Assert.NotNull(token.Id);
Assert.False(token.IsDisabled);
Assert.Equal(2, token.Scopes.Count);
var updateToken = new UpdateToken {
IsDisabled = true,
Notes = "Disabling until next release"
};
var updatedToken = await SendRequestAsAsync <ViewToken>(r => r
.Patch()
.BearerToken(token.Id)
.AppendPath($"tokens/{token.Id}")
.Content(updateToken)
.StatusCodeShouldBeOk()
);
Assert.True(updatedToken.IsDisabled);
Assert.Equal(updateToken.Notes, updatedToken.Notes);
await SendRequestAsync(r => r
.BearerToken(token.Id)
.AppendPath($"tokens/{token.Id}")
.StatusCodeShouldBeUnauthorized()
);
var repository = GetService <ITokenRepository>();
var actualToken = await repository.GetByIdAsync(token.Id);
Assert.NotNull(actualToken);
actualToken.IsDisabled = false;
await repository.SaveAsync(actualToken);
token = await SendRequestAsAsync <ViewToken>(r => r
.BearerToken(token.Id)
.AppendPath($"tokens/{token.Id}")
.StatusCodeShouldBeOk()
);
Assert.False(token.IsDisabled);
}
public object Put(UpdateToken request)
{
var entity = request.ConvertTo <Token>();
return(InTransaction(db => {
Logic.Update(entity);
return new CommonResponse(Logic.GetById(entity.Id));
}));
}
// Functions
//---------------------------------------------------
//Update에서 호출하는 함수와
//LateUpdate에서 호출하는 함수 2개로 나뉜다.
/// <summary>
/// 이 함수를 Update에서 호출하자
/// 토큰이 없다면 null로 하되, 리턴값을 멤버로 가지고 있자
/// </summary>
/// <param name="token"></param>
/// <param name="fps"></param>
/// <returns></returns>
public UpdateToken AddRequest(UpdateToken token, int fps, float deltaTime)
{
//상태가 바뀌면 초기화를 해야한다.
if (_state != STATE.Update)
{
#if UNITY_EDITOR
Profiler.BeginSample("AddRequest > Reset");
#endif
//_fps2Tokens.Clear();
foreach (KeyValuePair <int, TokenList> keyValuePair in _fps2Tokens)
{
keyValuePair.Value.Reset(deltaTime);
}
_state = STATE.Update;
#if UNITY_EDITOR
Profiler.EndSample();
#endif
}
fps = Mathf.Clamp(fps, MIN_FPS, MAX_FPS);
if (token == null)
{
token = new UpdateToken(fps);
}
else
{
token.SetFPS(fps);
}
token.UpdateTime(deltaTime);
token.ReadyToCalculate();
if (token.IsUpdatable())
{
//업데이트될 수 있다면 토큰을 리스트에 넣자
if (_fps2Tokens.ContainsKey(fps))
{
_fps2Tokens[fps].AddRequest(token);
}
else
{
TokenList newTokenList = new TokenList(fps);
newTokenList.Reset(deltaTime);
_fps2Tokens.Add(fps, newTokenList);
newTokenList.AddRequest(token);
//Debug.Log("New Token List : " + fps);
}
}
return(token);
}
private void Stop()
{
UpdateToken?.Cancel();
Server?.Stop();
if (NATForwardingEnabled)
{
NatDiscoverer.ReleaseAll();
}
}
/// <summary>
/// 이 함수를 LateUpdate에서 호출하자. True면 업데이트 할 수 있다.
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public bool GetUpdatable(UpdateToken token)
{
if (token == null)
{
return(false);
}
if (_state != STATE.LateUpdate)
{
#if UNITY_EDITOR
Profiler.BeginSample("Calculate > Reset");
#endif
//_fps2Tokens.Clear();
bool isAnyRemovableList = false;
List <int> removalbeFPS = null;
foreach (KeyValuePair <int, TokenList> keyValuePair in _fps2Tokens)
{
if (keyValuePair.Value.Calculate())
{
//삭제할 게 있다.
isAnyRemovableList = true;
if (removalbeFPS == null)
{
removalbeFPS = new List <int>();
}
removalbeFPS.Add(keyValuePair.Key);
}
}
//삭제해야할 때도 있다.
if (isAnyRemovableList)
{
for (int i = 0; i < removalbeFPS.Count; i++)
{
Debug.Log("Token List 삭제 : " + removalbeFPS[i]);
_fps2Tokens.Remove(removalbeFPS[i]);
}
}
_state = STATE.LateUpdate;
#if UNITY_EDITOR
Profiler.EndSample();
#endif
}
//return token._result;
return(token.IsSuccess);
}
public HttpResponseMessage UpdateDeviceToken(UpdateToken token)
{
try
{
var userID = User.Identity.GetUserId();
var isAdmin = User.IsInRole("Admin");
var tbl_DeviceIds = db.tbl_DeviceIds.FirstOrDefault(d => d.col_UserID == userID);
if (tbl_DeviceIds != null)
{
tbl_DeviceIds.col_UserID = userID;
tbl_DeviceIds.col_DeviceToken = token.token;
tbl_DeviceIds.col_Version = token.appVersion;
tbl_DeviceIds.col_DateTime = DateTime.Now;
if (isAdmin)
{
tbl_DeviceIds.col_UserType = "Admin";
}
else
{
tbl_DeviceIds.col_UserType = "User";
}
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Updated"));
}
else
{
tbl_DeviceIds ids = new tbl_DeviceIds();
ids.col_UserID = userID;
ids.col_DeviceToken = token.token;
ids.col_Version = token.appVersion;
if (isAdmin)
{
ids.col_UserType = "Admin";
}
else
{
ids.col_UserType = "User";
}
ids.col_DateTime = DateTime.Now;
db.tbl_DeviceIds.Add(ids);
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "Added"));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.NotAcceptable, ex.Message));
}
}
public void Dispose()
{
Logger.LogMessage -= Logger_LogMessage;
Server?.Dispose();
if (UpdateToken?.IsCancellationRequested == false)
{
UpdateToken.Cancel();
UpdateLock.Wait();
}
UpdateLock?.Dispose();
UpdateToken?.Dispose();
}
public void Should_RotateTheSameSecretKey_When_OldSecretKeyAndUpdateTokenAreGiven()
{
var a = ByteString.CopyFrom(Bytes.FromString("T20buheJjFOg+rsxP5ADIS7G3htdY/MUt9VozMOgEfA=", StringEncoding.BASE64));
var b = ByteString.CopyFrom(Bytes.FromString("UbXPXPtmKuudthZXXjJTE9AxBEgZB7mTFD+TGViCgHU=", StringEncoding.BASE64));
var skC = Bytes.FromString("YOCs/LOx6hll3nUBC29xpNJuLXofpKaBUNHPDBMA7JI=", StringEncoding.BASE64);
var skC1 = Bytes.FromString("Zd+YJUvpXKQIjMaeZiad4vFOoU+mH2Qldx/yqwmGg2I=", StringEncoding.BASE64);
var phe = new PheCrypto();
var pheSkC = phe.DecodeSecretKey(skC);
var token1 = new UpdateToken()
{
A = a,
B = b,
};
var pheSkC1 = phe.RotateSecretKey(pheSkC, token1.ToByteArray());
Assert.Equal(skC1, pheSkC1.Encode());
}
protected void OnReceiveServerToken(short state, UpdateToken down = null)
{
if (state != 0)
{
StateManager.Instance.StateShow(state, 0);
return;
}
if (down == null)
{
return;
}
if (down.seq == 1)
{
Debug.Log("OnReceiveServerToken: " + down.token);
this.ServerToken = down.token;
this.SendClientToken();
}
}
public override bool Stop()
{
Logger.Log(LogType.Debug, "Stopping UpdateThread...");
if (UpdateToken?.IsCancellationRequested == false)
{
UpdateToken.Cancel();
UpdateLock.Wait();
}
Logger.Log(LogType.Debug, "Stopped UpdateThread.");
Logger.Log(LogType.Debug, "Stopping Modules...");
foreach (var module in Modules)
{
module.Stop();
}
Logger.Log(LogType.Debug, "Stopped Modules.");
return(true);
}
public void AddRequest(UpdateToken token)
{
//token._result = false;//<<일단 False로 설정
//token.ReadyToCalculate();//계산 준비 //<< AddRequest가 호출되기 전에 이미 호출되었다.
if (_isLowSceneFPS)
{
//만약, 현재 Scene의 FPS가 낮다면,
//이 토큰의 업데이트 여부를 한번더 체크해야한다.
if (token.IsUpdatableInLowSceneFPS(_lowFPSRatio))
{
_nRequest++;
_tokens.Add(token);
}
}
else
{
_nRequest++;
_tokens.Add(token);
}
}
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
AppDomain.CurrentDomain.AssemblyResolve -= AppDomain_AssemblyResolve;
ClientJoined?.Dispose();
ClientLeaved?.Dispose();
if (UpdateToken?.IsCancellationRequested == false)
{
UpdateToken.Cancel();
UpdateLock.Wait();
}
}
IsDisposed = true;
}
base.Dispose(disposing);
}
/// <summary>
/// Upserts the document type async.
/// </summary>
/// <returns>The document type async.</returns>
/// <param name="instance">Instance.</param>
/// <param name="documentTypeId">Document type identifier token.</param>
/// <param name="meta">Meta.</param>
/// <param name="transformations">Transformations.</param>
async Task <Entities.DocumentType> UpsertDocumentTypeAsync(string instance, DocumentTypeIdentifierToken documentTypeId, UpdateToken <dynamic> meta, UpdateToken <string> transformations)
{
if (transformations == null)
{
throw new ArgumentNullException(nameof(transformations));
}
if (meta == null)
{
throw new ArgumentNullException(nameof(meta));
}
if (documentTypeId == null)
{
throw new ArgumentNullException(nameof(documentTypeId));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
var projectUri = documentTypeId.ProjectId.ToKotoriProjectUri();
var documentTypeUri = documentTypeId.ProjectId.ToKotoriDocumentTypeUri(documentTypeId.DocumentType, documentTypeId.DocumentTypeId);
var project = await FindProjectAsync(instance, projectUri).ConfigureAwait(false);
if (project == null)
{
throw new KotoriProjectException(documentTypeId.ProjectId, "Project does not exist.")
{
StatusCode = System.Net.HttpStatusCode.NotFound
}
}
;
var documentType = await FindDocumentTypeAsync(instance, projectUri, documentTypeUri).ConfigureAwait(false);
if (documentType == null)
{
var indexes = new List <DocumentTypeIndex>();
if (!meta.Ignore)
{
indexes = _metaAnalyzer.GetUpdatedDocumentTypeIndexes(indexes, meta.Value);
}
var trans = new List <DocumentTypeTransformation>();
if (!transformations.Ignore)
{
trans = new Transformation(documentTypeId.DocumentTypeId, transformations.Value).Transformations;
}
var dt = new Entities.DocumentType
(
instance,
documentTypeUri.ToString(),
projectUri.ToString(),
documentTypeId.DocumentType,
indexes,
trans
);
dt.Hash = dt.ToHash();
dt = await _repoDocumentType.CreateAsync(dt).ConfigureAwait(false);
return(dt);
}
else
{
var indexes = documentType.Indexes ?? new List <DocumentTypeIndex>();
if (!meta.Ignore)
{
indexes = _metaAnalyzer.GetUpdatedDocumentTypeIndexes(indexes, meta.Value);
}
documentType.Indexes = indexes;
var trans = documentType.Transformations ?? new List <DocumentTypeTransformation>();
if (!transformations.Ignore)
{
trans = new Transformation(documentTypeId.DocumentTypeId, transformations.Value).Transformations;
}
var oldTransformationsHash = documentType.Transformations.ToHash();
documentType.Transformations = trans;
var newTransformationsHash = documentType.Transformations.ToHash();
documentType.Hash = documentType.ToHash();
documentType = await _repoDocumentType.ReplaceAsync(documentType).ConfigureAwait(false);
// new transformations, update all documents because of new transformations
if (!oldTransformationsHash.Equals(newTransformationsHash, StringComparison.Ordinal))
{
var sql = CreateDynamicQueryForDocumentSearch
(
instance,
projectUri,
documentTypeUri,
null,
null,
null,
null,
true,
true
);
var documents = await GetDocumentsAsync(sql).ConfigureAwait(false);
foreach (var document in documents)
{
var documentToken = new Uri(document.Identifier).ToKotoriDocumentIdentifier();
await UpsertDocumentHelperAsync
(
false,
instance,
documentTypeId.ProjectId,
documentType.Type,
documentTypeId.DocumentTypeId,
documentToken.DocumentId,
documentToken.Index,
document.ToOriginalJsonString(),
document.Date?.DateTime,
document.Draft
).ConfigureAwait(false);
}
}
return(documentType);
}
}
}
public bool Calculate()
{
//이게 핵심.
//- maxCount 결정 + curCount = 0
//- 요청된 토큰의 각각의 가중치를 보고 처리할 수 있는지 여부를 결정
//1. DelayedFrame이 divide를 넘었으면 무조건 처리 => Sort 필요 없음
//2. DelayedFrame이 큰것 부터 처리. curCount가 maxCount보다 크면 종료
//- result가 true인 토큰은 delayedFrame을 0으로 초기화
//- result가 false인 토큰은 delayedFrame을 1 증가
if (_nRequest == 0)
{
if (!_isRemovable)
{
_nNoRequestFrames++;
if (_nNoRequestFrames > REMOVABLE_COUNT)
{
_isRemovable = true;
}
}
return(_isRemovable);
}
_isRemovable = false;
_nNoRequestFrames = 0;
UpdateToken token = null;
//프레임이 너무 낮은 경우 전부 OverDelayed를 하고 처리하자
if (_sceneFPS < MIN_FPS)
{
for (int i = 0; i < _tokens.Count; i++)
{
token = _tokens[i];
if (token == null)
{
return(false);
}
token.SetSuccess(true);
_successCount++;
}
_cycle_totalFailed += _nRequest;
return(false);
}
//Slot의 크기를 구하자
//- 기본 : 전체 요청 / (현재 프레임 / FPS) => (전체 요청 * FPS) / 현재 프레임
if (_isLowSceneFPS)
{
_maxCount = ((_nRequest * _lowFPS) / _sceneFPS) + 1;
}
else
{
_maxCount = ((_nRequest * _FPS) / _sceneFPS) + 1;
}
_maxCount = (int)(_maxCount * _countBias + 0.5f); //<<알아서 바뀌는 보정값으로 변경
_successCount = 0;
//1차로 : 무조건 처리해야하는거 찾기
for (int i = 0; i < _tokens.Count; i++)
{
token = _tokens[i];
if (token == null)
{
continue;
}
if (token._delayedFrame >= _maxDelay)
{
//한계치를 넘었다. > 무조건 성공
//token._result = true;
token.SetSuccess(true);
_successCount++;
}
else
{
//일단 뒤로 미루자
_delayedTokens[token._delayedFrame].Add(token);
}
}
if (_successCount < _maxCount)
{
//아직 더 처리할 수 있다면
//delayedFrame이 큰것부터 처리하자
List <UpdateToken> delayedList = null;
for (int iDelay = _maxDelay - 1; iDelay >= 0; iDelay--)
{
delayedList = _delayedTokens[iDelay];
for (int i = 0; i < delayedList.Count; i++)
{
token = delayedList[i];
//token._result = true;
token.SetSuccess(false);
_successCount++;
//처리가 모두 끝났으면 리턴
if (_successCount >= _maxCount)
{
break;
}
}
//처리가 모두 끝났으면 리턴
if (_successCount >= _maxCount)
{
break;
}
}
}
int nFailed = 0;
for (int i = 0; i < _tokens.Count; i++)
{
token = _tokens[i];
//<<처리되지 않았다면 Fail 처리
if (token.SetFailIfNotCalculated())
{
nFailed++;
}
}
_cycle_totalRequests += _nRequest;
//실패값
if (_nRequest > _maxCount)
{
_cycle_totalFailed += _nRequest - _maxCount;
}
//잉여값
if (_nRequest < _maxCount)
{
_cycle_totalMargin += _maxCount - _nRequest;
}
return(false);
}
