public void Upgrade()
{
UpgradeEnergy();
switch (ActiveUpgrade)
{
case UpgradeState.NoUpgrade:
AnimationController.Upgrade();
ActiveUpgrade = UpgradeState.Upgrade1;
if (GetComponentInChildren <SmallRobot>(true) is SmallRobot robot)
{
robot.gameObject.SetActive(true);
}
else if (IsRobot)
{
if (RobotUpgradeParticleEffect != null)
{
RobotUpgradeParticleEffect.SetActive(true);
}
}
else
{
if (CowboyUpgradeParticleEffect != null)
{
CowboyUpgradeParticleEffect.SetActive(true);
}
}
break;
case UpgradeState.Upgrade1:
AnimationController.Upgrade();
ActiveUpgrade = UpgradeState.Upgrade2;
if (IsRobot)
{
if (RobotUpgradeParticleEffect != null)
{
RobotUpgradeParticleEffect.SetActive(true);
}
}
else
{
if (CowboyUpgradeParticleEffect != null)
{
CowboyUpgradeParticleEffect.SetActive(true);
}
}
break;
case UpgradeState.Upgrade2:
break;
}
}
public void RecalculateUpgradeState()
{
upgradeState = new UpgradeState();
List <PurchasedUpgrade> purchasedUpgrades = GameManager.Instance.GameState.PurchasedUpgrades;
for (int i = 0; i < purchasedUpgrades.Count; i++)
{
Upgrade upgrade = UpgradeFromId(purchasedUpgrades[i].UpgradeId);
// Should only really happen on devices used for development. Caused by moving upgrades around tiers,
// and the ID being modified.
if (upgrade == null)
{
Debug.Log("Failed to find UpgradeFromId: " + purchasedUpgrades[i].UpgradeId);
continue;
}
float value = upgrade.Value * purchasedUpgrades[i].QuantityPurchased;
switch (upgrade.Type)
{
case UpgradeType.Automation:
upgradeState.AdditionalBitValuePerLitNode += value;
break;
case UpgradeType.Botnet:
upgradeState.OutboundBPSForAttack -= value;
break;
case UpgradeType.Network:
upgradeState.OutboundBPS += value;
break;
case UpgradeType.Compression:
upgradeState.StorageCapacity += value;
break;
case UpgradeType.Replication:
upgradeState.InboundBPS += value;
break;
case UpgradeType.Computation:
upgradeState.BitValue += value;
break;
}
}
Debug.Log(upgradeState);
}
public async Task SaveStateAsync(IUpgradeContext context, CancellationToken token)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
var state = new UpgradeState
{
EntryPoints = context.EntryPoints.Select(e => NormalizePath(e.FileInfo)),
CurrentProject = NormalizePath(context.CurrentProject?.FileInfo),
Properties = context.Properties.GetPersistentPropertyValues().ToDictionary(k => k.Key, v => v.Value)
};
if (state is { Empty : true })
public void Upgrade()
{
switch (CurrentUpgrade)
{
case UpgradeState.NoUpgrade:
AnimationController.runtimeAnimatorController = Upgrade1Controller;
CurrentUpgrade = UpgradeState.Upgrade1;
break;
case UpgradeState.Upgrade1:
AnimationController.runtimeAnimatorController = Upgrade2Controller;
CurrentUpgrade = UpgradeState.Upgrade2;
break;
}
}
void UpdateUpgradeState()
{
if (_upgradeState == UpgradeState.Weapon)
{
_upgradeState = UpgradeState.Armor;
}
else if (_upgradeState == UpgradeState.Armor)
{
_upgradeState = UpgradeState.Accessory;
}
else if (_upgradeState == UpgradeState.Accessory)
{
_upgradeState = UpgradeState.Finished;
}
}
//Upgrades stuff
public static void SaveUpgradeState(UpgradeState state, string _name)
{
string path = Path.Combine(Application.persistentDataPath, "UpgradeStates");
DirectoryInfo dir = new DirectoryInfo(path);
if (dir.Exists == false)
{
dir.Create();
}
BinaryFormatter bf = new BinaryFormatter();
FileStream stream = File.Create(Path.Combine(path, _name + ".ustate"));
bf.Serialize(stream, state);
stream.Close();
}
public async Task NoErrors_RunAsync_LogsSuccess(UpgradeState upgradeState)
{
var appInfo = new ApplicationUpgradeProgressInfo(
_item.ApplicationName,
_item.ApplicationTypeName,
_item.ApplicationTypeVersion,
upgradeState: upgradeState);
_appClient
.Setup(c => c.GetApplicationUpgradeAsync(_item.ApplicationId, 60, CancellationToken.None))
.Returns(Task.FromResult(appInfo));
await _command.RunAsync();
ShouldContainsLogMessage($"Upgraded application {_item.ApplicationName} successfully");
}
private void UpgradeMethod()
{
try
{
/*
* // get upgrade file
* byte[] upgradeBlock = BlockTransferManager.GetResourceFromUri(mFirmwarePath);
* if (upgradeBlock == null)
* {
* mStatus = UpgradeState.UnableToAquireResource;
* CNXLog.WarnFormat("Self upgrade failed - {0}", mStatus);
* }
*/
ResumableResourceDownload downloader = new ResumableResourceDownload(mFirmwarePath);
byte[] upgradeBlock = null;
while (upgradeBlock == null)
{
upgradeBlock = downloader.AquireResource();
if (upgradeBlock == null)
{
Thread.Sleep(30000);
}
}
// now save the block
string path = string.Format("{0}blk{1}", ((Environment.OSVersion.Platform == PlatformID.Unix) ? BaseBlockReciever.LinuxBlockFilePath : BaseBlockReciever.MSBlockFilePath), TrackingService.ProductCode);
using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.Read, 8192, FileOptions.RandomAccess))
{
fs.Write(upgradeBlock, 0, upgradeBlock.Length);
fs.Flush();
fs.Close();
}
// Go for the upgrade
mStatus = UpgradeState.UpgradeInProgress;
UpdateSystem(path);
}
catch (Exception e)
{
mStatus = UpgradeState.UpgradeFailed;
CNXLog.WarnFormat("Self upgrade failed - {0}", e.ToString());
}
mStatus = UpgradeState.UpgradeComplete;
}
public static UpgradeState LoadUpgradeState(string _name)
{
string path = Path.Combine(Application.persistentDataPath, "UpgradeStates");
string file = Path.Combine(path, _name + ".ustate");
FileInfo info = new FileInfo(file);
if (info.Exists == false)
{
return(new UpgradeState());
}
BinaryFormatter bf = new BinaryFormatter();
FileStream stream = File.Open(file, FileMode.Open);
UpgradeState state = new UpgradeState();
state = bf.Deserialize(stream) as UpgradeState;
stream.Close();
return(state);
}
internal static string ToSerializedValue(this UpgradeState value)
{
switch (value)
{
case UpgradeState.RollingForward:
return("RollingForward");
case UpgradeState.Cancelled:
return("Cancelled");
case UpgradeState.Completed:
return("Completed");
case UpgradeState.Faulted:
return("Faulted");
}
return(null);
}
public async Task SaveStateAsync(IUpgradeContext context, CancellationToken token)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
_logger.LogInformation("Saving upgrade progress file at {Path}", _path);
using var stream = File.OpenWrite(_path);
stream.SetLength(0);
var state = new UpgradeState
{
EntryPoint = NormalizePath(context.EntryPoint?.FilePath),
CurrentProject = NormalizePath(context.CurrentProject?.FilePath),
};
await JsonSerializer.SerializeAsync(stream, state, cancellationToken : token).ConfigureAwait(false);
}
public async Task SaveStateAsync(IUpgradeContext context, CancellationToken token)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
_logger.LogInformation("Saving upgrade progress file at {Path}", _path);
using var stream = File.OpenWrite(_path);
stream.SetLength(0);
var state = new UpgradeState
{
EntryPoints = context.EntryPoints.Select(e => NormalizePath(e.FileInfo)),
CurrentProject = NormalizePath(context.CurrentProject?.FileInfo),
Properties = context.Properties.GetPersistentPropertyValues().ToDictionary(k => k.Key, v => v.Value)
};
await JsonSerializer.SerializeAsync(stream, state, cancellationToken : token).ConfigureAwait(false);
}
public static GameState CreateNew()
{
var lGameState = new GameState();
if (Debug.isDebugBuild)
{
lGameState.Seed = 42;
}
else
{
lGameState.Seed = Random.Range(int.MinValue, int.MaxValue);
}
lGameState.Attributes = new AttributeSet();
lGameState.World = WorldState.CreateNew(lGameState.Seed);
lGameState.Hive = HiveState.CreateNew();
lGameState.Statistics = StatisticsSet.CreateDefault();
lGameState.Upgrades = UpgradeState.CreateNew();
lGameState.ChangeDayManager();
return(lGameState);
}
public void UpdateState()
{
_logger.Info("Updating Upgrade state");
var config = _configManager.Load();
if (_doorstopManager.IsLoaderInstalled() && !config.UpgradeInProgress)
{
State = _doorstopManager.CheckLoaderVersionVersion() ? UpgradeState.Latest : UpgradeState.Outdated;
}
else if (Directory.Exists(_doorstopManager.TempDirName))
{
State = UpgradeState.Phase1;
}
else if (_configManager.Load().UpgradeInProgress)
{
State = UpgradeState.Phase2;
}
else
{
State = UpgradeState.Error;
}
_logger.Info($"Updated state to [{State}]");
}
public UpgradeState chooseNothing()
{
currentUpgradeState = UpgradeState.None;
return(currentUpgradeState);
}
public void UpdateState()
{
State = UpgradeState.Latest;
}
public UpgradeState chooseGravityBoots()
{
currentUpgradeState = UpgradeState.GravityBoots;
return(currentUpgradeState);
}
public UpgradeState chooseGrapplingHook()
{
currentUpgradeState = UpgradeState.GrapplingHook;
return(currentUpgradeState);
}
public void Upgrade()
{
switch (upgradeState)
{
case UpgradeState.first:
if (buildManager.totalMoney < firstUpgradeMoney)
{
return;
}
buildManager.totalMoney -= firstUpgradeMoney;
L_Units.powerUpHP += HpUpgrade;
L_Units.powerUpSpeed += speedUpgrade;
foreach (var unit in Units)
{
unit.health += HpUpgrade;
unit.speed += speedUpgrade;
}
upgradeLevel.text = "Level: 1";
upgradeState = UpgradeState.second;
break;
case UpgradeState.second:
if (buildManager.totalMoney < secondUpgradeMoney)
{
return;
}
buildManager.totalMoney -= secondUpgradeMoney;
L_Units.powerUpHP += HpUpgrade;
L_Units.powerUpSpeed += speedUpgrade;
foreach (var unit in Units)
{
unit.health += HpUpgrade;
unit.speed += speedUpgrade;
}
upgradeLevel.text = "Level: 2";
upgradeState = UpgradeState.third;
break;
case UpgradeState.third:
if (buildManager.totalMoney < thirdUpgradeMoney)
{
return;
}
buildManager.totalMoney -= thirdUpgradeMoney;
L_Units.powerUpHP += HpUpgrade;
L_Units.powerUpSpeed += speedUpgrade;
foreach (var unit in Units)
{
unit.health += HpUpgrade;
unit.speed += speedUpgrade;
}
upgradeLevel.text = "Level: 3";
upgradeState = UpgradeState.fourth;
break;
case UpgradeState.fourth:
if (buildManager.totalMoney < fourthUpgradeMoney)
{
return;
}
buildManager.totalMoney -= fourthUpgradeMoney;
L_Units.powerUpHP += HpUpgrade;
L_Units.powerUpSpeed += speedUpgrade;
foreach (var unit in Units)
{
unit.health += HpUpgrade;
unit.speed += speedUpgrade;
}
upgradeLevel.text = "Level: max";
upgradeState = UpgradeState.max;
break;
}
}
public UpgradeState chooseJetpack()
{
currentUpgradeState = UpgradeState.Jetpack;
return(currentUpgradeState);
}
void ChangeUpgradeState(ref UpgradeState currentState, UpgradeState newState)
{
switch (newState)
{
case UpgradeState.None:
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
case UpgradeState.VerifyingUpgradeRequest:
if (currentState != UpgradeState.None && //starting first upgrade
currentState != UpgradeState.UpgradeComplete) //completing one upgrade and starting another
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.WritingUpgradeAck:
if (currentState != UpgradeState.VerifyingUpgradeRequest)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.UpgradeAckSent:
if (currentState != UpgradeState.WritingUpgradeAck)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.BeginUpgrade:
if (currentState != UpgradeState.UpgradeAckSent)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.EndUpgrade:
if (currentState != UpgradeState.BeginUpgrade)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.UpgradeComplete:
if (currentState != UpgradeState.EndUpgrade)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.WritingPreambleEnd:
if (currentState != UpgradeState.None && //no upgrade being used
currentState != UpgradeState.UpgradeComplete) //upgrades are now complete, end the preamble handshake.
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
case UpgradeState.PreambleEndSent:
if (currentState != UpgradeState.WritingPreambleEnd)
{
throw Fx.AssertAndThrow("Invalid State Transition: currentState=" + currentState + ", newState=" + newState);
}
break;
default:
throw Fx.AssertAndThrow("Unexpected Upgrade State: " + newState);
}
currentState = newState;
}
public static UpgradeState ReduceSetUpgradeStateAction(UpgradeState state, SetUpgradeStateAction action)
{
return(action.UpgradeState);
}
public async Task OnConnectedAsync(FramingConnection connection)
{
var receiveTimeout = connection.ServiceDispatcher.Binding.ReceiveTimeout;
var timeoutHelper = new TimeoutHelper(receiveTimeout);
bool success = false;
try
{
var decoder = connection.FramingDecoder as ServerSingletonDecoder;
Fx.Assert(decoder != null, "FramingDecoder must be non-null and an instance of ServerSessionDecoder");
// first validate our content type
//ValidateContentType(connection, decoder);
UpgradeState upgradeState = UpgradeState.None;
// next read any potential upgrades and finish consuming the preamble
ReadOnlySequence <byte> buffer = ReadOnlySequence <byte> .Empty;
while (true)
{
if (buffer.Length == 0 && CanReadAndDecode(upgradeState))
{
var readResult = await connection.Input.ReadAsync();
buffer = readResult.Buffer;
if (readResult.IsCompleted)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(decoder.CreatePrematureEOFException());
}
}
while (true)
{
if (CanReadAndDecode(upgradeState))
{
Fx.Assert(buffer.Length > 0, "There must be something in the buffer to decode");
int bytesDecoded = decoder.Decode(buffer);
if (bytesDecoded > 0)
{
buffer = buffer.Slice(bytesDecoded);
if (buffer.Length == 0)
{
connection.Input.AdvanceTo(buffer.Start);
}
}
}
switch (decoder.CurrentState)
{
case ServerSingletonDecoder.State.UpgradeRequest:
switch (upgradeState)
{
case UpgradeState.None:
//change the state so that we don't read/decode until it is safe
ChangeUpgradeState(ref upgradeState, UpgradeState.VerifyingUpgradeRequest);
break;
case UpgradeState.VerifyingUpgradeRequest:
if (connection.StreamUpgradeAcceptor == null)
{
await connection.SendFaultAsync(FramingEncodingString.UpgradeInvalidFault, timeoutHelper.RemainingTime(), TransportDefaults.MaxDrainSize);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(SR.Format(SR.UpgradeRequestToNonupgradableService, decoder.Upgrade)));
}
if (!connection.StreamUpgradeAcceptor.CanUpgrade(decoder.Upgrade))
{
await connection.SendFaultAsync(FramingEncodingString.UpgradeInvalidFault, timeoutHelper.RemainingTime(), TransportDefaults.MaxDrainSize);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.Format(SR.UpgradeProtocolNotSupported, decoder.Upgrade)));
}
ChangeUpgradeState(ref upgradeState, UpgradeState.WritingUpgradeAck);
// accept upgrade
await connection.Output.WriteAsync(ServerSingletonEncoder.UpgradeResponseBytes, timeoutHelper.GetCancellationToken());
await connection.Output.FlushAsync(timeoutHelper.GetCancellationToken());
ChangeUpgradeState(ref upgradeState, UpgradeState.UpgradeAckSent);
break;
case UpgradeState.UpgradeAckSent:
// This state was used to capture any extra read bytes into PreReadConnection but we don't need to do that when using pipes.
// This extra state transition has been left here to maintain the same state transitions as on .NET Framework to make comparison easier.
ChangeUpgradeState(ref upgradeState, UpgradeState.BeginUpgrade);
break;
case UpgradeState.BeginUpgrade:
// Set input pipe so that the next read will return all the unconsumed bytes.
// If all bytes have already been consumed so the buffer has 0 length, AdvanceTo would throw
// as it's already been called.
if (buffer.Length > 0)
{
connection.Input.AdvanceTo(buffer.Start);
}
buffer = ReadOnlySequence <byte> .Empty;
try
{
await UpgradeConnectionAsync(connection);
ChangeUpgradeState(ref upgradeState, UpgradeState.EndUpgrade);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
throw;
}
break;
case UpgradeState.EndUpgrade:
//Must be a different state here than UpgradeComplete so that we don't try to read from the connection
ChangeUpgradeState(ref upgradeState, UpgradeState.UpgradeComplete);
break;
case UpgradeState.UpgradeComplete:
//Client is doing more than one upgrade, reset the state
ChangeUpgradeState(ref upgradeState, UpgradeState.VerifyingUpgradeRequest);
break;
}
break;
case ServerSingletonDecoder.State.Start:
SetupSecurityIfNecessary(connection);
if (upgradeState == UpgradeState.UpgradeComplete || //We have done at least one upgrade, but we are now done.
upgradeState == UpgradeState.None) //no upgrade, just send the preample end bytes
{
ChangeUpgradeState(ref upgradeState, UpgradeState.WritingPreambleEnd);
// we've finished the preamble. Ack and return.
await connection.Output.WriteAsync(ServerSessionEncoder.AckResponseBytes);
await connection.Output.FlushAsync();
//terminal state
ChangeUpgradeState(ref upgradeState, UpgradeState.PreambleEndSent);
}
// If all bytes have already been consumed so the buffer has 0 length, AdvanceTo would throw
// as it's already been called.
if (buffer.Length > 0)
{
connection.Input.AdvanceTo(buffer.Start);
}
success = true;
await _next(connection);
return;
}
if (buffer.Length == 0)
{
break;
}
}
}
}
finally
{
if (!success)
{
connection.Abort();
}
}
}
public static string ToSerialString(this UpgradeState value) => value switch
{
public SetUpgradeStateAction(UpgradeState upgradeState)
{
this.UpgradeState = upgradeState;
}
public static UpgradeState ReduceUnlockUpgradeAction(UpgradeState state, UnlockUpgradeAction action)
{
return(state with {
PurchasedUpgradeIds = state.PurchasedUpgradeIds.Concat(new[] { action.Id })
});
}
public async Task <IConnection> CompletePreambleAsync(TimeSpan timeout)
{
var timeoutHelper = new TimeoutHelper(timeout);
var parent = this;
if (!transportSettings.MessageEncoderFactory.Encoder.IsContentTypeSupported(Decoder.ContentType))
{
SendFault(FramingEncodingString.ContentTypeInvalidFault, ref timeoutHelper);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.Format(
SR.ContentTypeMismatch, Decoder.ContentType, parent.transportSettings.MessageEncoderFactory.Encoder.ContentType)));
}
IStreamUpgradeChannelBindingProvider channelBindingProvider = null;
StreamUpgradeAcceptor upgradeAcceptor = null;
if (transportSettings.Upgrade != null)
{
channelBindingProvider = transportSettings.Upgrade.GetProperty <IStreamUpgradeChannelBindingProvider>();
upgradeAcceptor = transportSettings.Upgrade.CreateUpgradeAcceptor();
}
var currentConnection = Connection;
UpgradeState upgradeState = UpgradeState.None;
while (true)
{
if (size == 0 && CanReadAndDecode(upgradeState))
{
size = await currentConnection.ReadAsync(0, connectionBuffer.Length, timeoutHelper.RemainingTime());
if (size == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Decoder.CreatePrematureEOFException());
}
}
while (true)
{
if (CanReadAndDecode(upgradeState))
{
int bytesRead = Decoder.Decode(connectionBuffer, offset, size);
if (bytesRead > 0)
{
offset += bytesRead;
size -= bytesRead;
}
}
switch (Decoder.CurrentState)
{
case ServerSingletonDecoder.State.UpgradeRequest:
switch (upgradeState)
{
case UpgradeState.None:
//change the state so that we don't read/decode until it is safe
ChangeUpgradeState(ref upgradeState, UpgradeState.VerifyingUpgradeRequest);
break;
case UpgradeState.VerifyingUpgradeRequest:
if (upgradeAcceptor == null)
{
SendFault(FramingEncodingString.UpgradeInvalidFault, ref timeoutHelper);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(SR.Format(SR.UpgradeRequestToNonupgradableService, Decoder.Upgrade)));
}
if (!upgradeAcceptor.CanUpgrade(Decoder.Upgrade))
{
SendFault(FramingEncodingString.UpgradeInvalidFault, ref timeoutHelper);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.Format(SR.UpgradeProtocolNotSupported, Decoder.Upgrade)));
}
ChangeUpgradeState(ref upgradeState, UpgradeState.WritingUpgradeAck);
// accept upgrade
await currentConnection.WriteAsync(ServerSingletonEncoder.UpgradeResponseBytes, 0, ServerSingletonEncoder.UpgradeResponseBytes.Length,
true, timeoutHelper.RemainingTime());
ChangeUpgradeState(ref upgradeState, UpgradeState.UpgradeAckSent);
break;
case UpgradeState.UpgradeAckSent:
IConnection connectionToUpgrade = currentConnection;
if (size > 0)
{
connectionToUpgrade = new PreReadConnection(connectionToUpgrade, connectionBuffer, offset, size);
}
ChangeUpgradeState(ref upgradeState, UpgradeState.BeginUpgrade);
break;
case UpgradeState.BeginUpgrade:
try
{
currentConnection = await InitialServerConnectionReader.UpgradeConnectionAsync(currentConnection, upgradeAcceptor, transportSettings);
connectionBuffer = currentConnection.AsyncReadBuffer;
if (channelBindingProvider != null &&
channelBindingProvider.IsChannelBindingSupportEnabled &&
channelBindingToken == null) //first one wins in the case of multiple upgrades.
{
channelBindingToken = channelBindingProvider.GetChannelBinding(upgradeAcceptor, ChannelBindingKind.Endpoint);
}
ChangeUpgradeState(ref upgradeState, UpgradeState.EndUpgrade);
ChangeUpgradeState(ref upgradeState, UpgradeState.UpgradeComplete);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
WriteAuditFailure(upgradeAcceptor as StreamSecurityUpgradeAcceptor, exception);
throw;
}
break;
case UpgradeState.UpgradeComplete:
//Client is doing more than one upgrade, reset the state
ChangeUpgradeState(ref upgradeState, UpgradeState.VerifyingUpgradeRequest);
break;
}
break;
case ServerSingletonDecoder.State.Start:
SetupSecurityIfNecessary(upgradeAcceptor);
if (upgradeState == UpgradeState.UpgradeComplete || //We have done at least one upgrade, but we are now done.
upgradeState == UpgradeState.None) //no upgrade, just send the preample end bytes
{
ChangeUpgradeState(ref upgradeState, UpgradeState.WritingPreambleEnd);
// we've finished the preamble. Ack and return.
await currentConnection.WriteAsync(ServerSessionEncoder.AckResponseBytes, 0, ServerSessionEncoder.AckResponseBytes.Length,
true, timeoutHelper.RemainingTime());
//terminal state
ChangeUpgradeState(ref upgradeState, UpgradeState.PreambleEndSent);
}
//we are done, this.currentConnection is the upgraded connection
return(currentConnection);
}
if (size == 0)
{
break;
}
}
}
}
