static void Power(PowerState state)
{
using (Form foo = new Form()) {
SendMessage(foo.Handle, WM_SYSCOMMAND,
(IntPtr)SC_MONITORPOWER, (IntPtr)state);
}
}
internal static void SuspendComputer(PowerState state, bool force)
{
string action;
switch (state)
{
case PowerState.Suspend:
action = "sleep";
break;
case PowerState.Hibernate:
action = "hybernate";
break;
default:
throw new RoomieRuntimeException("Unknown power state \"" + state + "\"");
}
try
{
bool ret = System.Windows.Forms.Application.SetSuspendState(state, force, false);
if (!ret)
throw new RoomieRuntimeException("Could not " + action + " computer.");
}
catch (Exception exception)
{
throw new RoomieRuntimeException("Could not " + action + " computer. " + exception.Message, exception);
}
}
public PowerUp(string name)
{
mSpriteName = name;
if (name.Equals("powerUpTest"))
{
mPower = PowerState.Chaos;
}
}
public void Draw(GameTime gameTime, SpriteBatch sptiteBatch)
{
if (time > 0.0f) time = Math.Max(0.0f, time - (float)gameTime.ElapsedGameTime.TotalSeconds);
if (time == 0.0f) { State = PowerState.Ground; sprite.PlayAnimation(ground); }
sprite.Draw(gameTime, sptiteBatch, position, SpriteEffects.None);
}
private string SetAppliancePower(PowerState powerState, IAppliance appliance)
{
if(powerState == PowerState.Off)
{
return appliance.TurnOff();
}
else
{
return appliance.TurnOn();
}
}
private string GetPowerStateName(PowerState powerState)
{
switch (powerState)
{
case PowerState.Off: return "Off";
case PowerState.LowPower: return "Low Power";
case PowerState.MediumPower: return "Medium Power";
case PowerState.HighPower: return "High Power";
default:return "Unknown Power";
}
}
private PowerState TogglePowerState(PowerState powerState)
{
if ((int)powerState < (int)PowerState.HighPower)
{
int intState = (int)powerState;
powerState = (PowerState)intState + 1;
}
else
{
powerState = PowerState.Off;
}
return powerState;
}
internal PowerInformation(byte[] data)
{
if (data == null)
return;
if (data.Length != 8)
return;
_recVersion = data[0];
_powerState = (PowerState)data[1];
_batteryVoltage = BitConverter.ToUInt16(new byte[] { data[3], data[2] }, 0);
_numberOfRecharges = BitConverter.ToUInt16(new byte[] { data[5], data[4] }, 0);
_timeSinceLastRecharge = BitConverter.ToUInt16(new byte[] { data[7], data[6] }, 0);
}
public void PowerOff()
{
List<Pixel> pixels;
pixels = LayoutBuilder.CreateLayout().Matrix.GetChangedPixels();
pixels.AddRange(LayoutBuilder.CreateLayout().Minutes.GetChangedPixels());
pixels.AddRange(LayoutBuilder.CreateAmbilight().LeftAmbilight.GetChangedPixels());
pixels.AddRange(LayoutBuilder.CreateAmbilight().RightAmbilight.GetChangedPixels());
foreach(Pixel p in pixels)
{
p.PixelColor = System.Drawing.Color.Empty;
}
m_RenderEngine.Render(pixels);
m_PowerState = PowerState.Off;
}
private void UpdatePowerState()
{
PowerState newState = GetPowerState();
if(newState != m_CurrentState)
{
if(newState == PowerState.On)
{
m_Notifier.PowerOn();
}
else
{
m_Notifier.PowerOff();
}
m_CurrentState = newState;
}
}
public void Activate()
{
IsActive = true;
State = PowerState.Active;
if (destPositon == Level.InvalidPositionVector)
{
Point blockIndex = new Point((blockNumber - 1) % 3, (blockNumber - 1) / 3);
destPositon = puzzlePosition + new Vector2(blockIndex.X * Tile.Width, blockIndex.Y * Tile.Height);
direction = new Vector2(destPositon.X != position.X ? destPositon.X < position.X ? -1 : 1 : 0,
destPositon.Y != position.Y ? destPositon.Y < position.Y ? -1 : 1 : 0);
if (direction.X != 0) { blockIndex = new Point(direction.X < 0 ? 0 : 2, blockIndex.Y); }
else { blockIndex = new Point(blockIndex.X, direction.Y < 0 ? 0 : 2); }
maxSlidePosition = puzzlePosition + new Vector2(blockIndex.X * Tile.Width, blockIndex.Y * Tile.Height);
}
}
private void OnReceive(IAsyncResult ar)
{
try {
UdpClient udp = (UdpClient)ar.AsyncState;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 0);
byte[] data = udp.EndReceive(ar, ref endpoint);
if (data[0] == 0) {
int n_dev = 20;
bool[] enabled = new bool[n_dev];
PowerState[] powerState = new PowerState[n_dev];
for (int i = 0; i < n_dev; i++) {
enabled[i] = (data[i+1] & 0x80) != 0;
powerState[i] = (PowerState)(data[i+1] & 0x7f);
}
OnStatusReceived(new MicroPowerStatusEventArgs(enabled, powerState));
}
udp.BeginReceive(OnReceive, udp);
}
catch (ObjectDisposedException) {
}
}
public void Flower()
{
PowerState.Flower();
}
public void SetPowerState(PowerState state)
{
Wordclock.RenderEngine.SetPowerState(state);
}
/// <summary>
/// Part of interface IAPCPowerable. Sets the griddle's state according to the given power state.
/// </summary>
/// <param name="state">The power state to set the griddle's state with.</param>
public void StateUpdate(PowerState state)
{
CurrentState.PowerStateUpdate(state);
}
private void GetData()
{
try
{
var epd = ApplicationContext.EndPointListTree.Find(r => r.EndpointId == _endpointId);
var comType = epd.ComputerType;
EndpointId = epd.EndpointId;
ID = epd.GUIID;
OSName = epd.OSName;
UserName = epd.UserName;
SystemManufacturer = epd.SystemManufacturer;
SystemName = epd.SystemName;
SystemType = epd.SystemType;
SystemModel = epd.SystemModel;
LastSync = epd.LastSync;
PowerState = Functions.UppercaseFirst(epd.PowerState);
Processor = epd.Processor;
TotalPhysicalMemory = (int)Math.Round(epd.TotalPhysicalMemory ?? 0);
ComputerType = string.IsNullOrWhiteSpace(ID) ? "" : Functions.UppercaseFirst(comType);
Domain = epd.Domain;
IPv4 = epd.IPv4;
IPv6 = epd.IPv6;
MACAddress = epd.MACAddress;
HDDCapacity = epd.HDDCapacity.Replace(";", " GB;");
FolderId = epd.FolderId;
ProductVersion = epd.ProductVersion;
FontColor = "#FFF";
if (PowerState.ToLower() == "offline")
{
FontColor = "#808e8f98";
}
else if (PowerState.ToLower() == "online")
{
FontColor = "#FFF";
}
//ImageHeader = string.IsNullOrEmpty(ID)
// ? "../../Images/logo_noagent.png"
// : string.IsNullOrWhiteSpace(ComputerType)? "../../Images/Notebook.png" : string.Format("../../Images/{0}.png", ComputerType);
Color = epd.Color;
ImageHeader = "../" + EndPoint.GetImages(ComputerType, Color);
var headerViewModel = _view.EndpointViewHeaderElement.DataContext as EndpointViewHeaderViewModel;
if (headerViewModel != null)
{
headerViewModel.SystemName = SystemName;
headerViewModel.ImageHeader = ImageHeader;
headerViewModel.ActivedButtonIndex = 1;
headerViewModel.ColorCodeMessageColor = Color;
headerViewModel.FontColor = FontColor;
//Reset color message
headerViewModel.ColorCodeMessage = "";
headerViewModel.TextStatusVisible = true;
if (string.IsNullOrEmpty(ID))
{
headerViewModel.ColorCodeMessage = "POC Agent not installed";
}
else if (!string.IsNullOrEmpty(epd.LastSyncDayText))
{
headerViewModel.ColorCodeMessage =
string.Concat(epd.AgentText, "\n", epd.LastSyncDayText).Trim();
}
else if (string.IsNullOrEmpty(epd.LastSyncDayText) &&
(Color == CommonConstants.GREEN_OFFLINE_COLOR ||
Color == CommonConstants.GREEN_ONLINE_COLOR) &&
!string.IsNullOrEmpty(ID)
)
{
headerViewModel.TextStatusVisible = false;
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
PageNavigatorHelper._MainWindow.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)(() =>
{
var messageDialog =
PageNavigatorHelper._MainWindow.MessageDialogContentControl.Content as MessageDialog;
messageDialog.TxtMessageText.Text =
"Cannot get endpoint due to exception occured, please see the log file under the Logs for more information";
messageDialog.Visibility = Visibility.Visible;
}));
}
}
static Color GetPowerColor(PowerState state)
{
if (state == PowerState.Critical) return Color.Red;
if (state == PowerState.Low) return Color.Orange;
return Color.LimeGreen;
}
public void Reboot()
{
PowerState.RebootDevice(false);
}
private static void SetSuspendState(PowerState state, object sender)
{
if (PowerActionConfirmed((ContentControl) sender))
System.Windows.Forms.Application.SetSuspendState(state,
SettingsManager.Instance.ForcePowerActions,
false);
}
public static void SetPowerState(PowerState newState, bool force = false, bool disableWakeupEvents = false)
{
Application.SetSuspendState(newState, force, disableWakeupEvents);
}
protected void Died()
{
State = PowerState.Die; sprite.PlayAnimation(dieAnimation);
}
/// <include file='doc\Application.uex' path='docs/doc[@for="Application.SetSuspendState"]/*' />
/// <devdoc>
/// Sets the suspend/hibernate state of the machine.
/// Returns true if the call succeeded, else false.
/// </devdoc>
public static bool SetSuspendState(PowerState state, bool force, bool disableWakeEvent) {
IntSecurity.AffectMachineState.Demand();
return UnsafeNativeMethods.SetSuspendState(state == PowerState.Hibernate, force, disableWakeEvent);
}
private static bool SetSuspendState(PowerState state, bool forceShutDown)
{
return (Application.SetSuspendState(state, forceShutDown, false));
}
public void Collision(Rectangle bounds)
{
State = PowerState.Die; IsActive = false;
if (direction.X != 0) { position.X = bounds.Left - direction.X * Tile.Width; }
else { position.Y = bounds.Top - direction.Y * Tile.Height; }
}
private static void SleepMode()
{
var ps = new PowerState();
ps.SetSuspendState(false, false, false);
}
public void Update(GameTime gameTime)
{
if (State == PowerState.Active)
{
Move(direction, maxSlidePosition);
if (position == maxSlidePosition) State = PowerState.Die;
}
else if (State == PowerState.Pick)
{
Vector2 oppDirection = direction * -1;
Move(oppDirection, oriPosition);
if (position == oriPosition) State = PowerState.Ground;
}
}
public void CanCreate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var GroupName = TestUtilities.GenerateName("rgfluentchash-");
var computeManager = TestHelper.CreateComputeManager();
var resourceManager = TestHelper.CreateResourceManager();
try
{
// Create
var vm = computeManager.VirtualMachines
.Define(VMName)
.WithRegion(Location)
.WithNewResourceGroup(GroupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012Datacenter)
.WithAdminUsername("Foo12")
.WithAdminPassword("BaR@12!Foo")
.WithUnmanagedDisks()
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithSize(VirtualMachineSizeTypes.StandardD3)
.WithOSDiskName("javatest")
.Create();
var foundedVM = computeManager.VirtualMachines.ListByResourceGroup(GroupName)
.FirstOrDefault(v => v.Name.Equals(VMName, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(foundedVM);
Assert.Equal(Location, foundedVM.RegionName);
// Get
foundedVM = computeManager.VirtualMachines.GetByResourceGroup(GroupName, VMName);
Assert.NotNull(foundedVM);
Assert.Equal(Location, foundedVM.RegionName);
// Fetch instance view
PowerState powerState = foundedVM.PowerState;
Assert.True(powerState == PowerState.Running);
VirtualMachineInstanceView instanceView = foundedVM.InstanceView;
Assert.NotNull(instanceView);
Assert.NotEmpty(instanceView.Statuses);
// Capture the VM [Requires VM to be Poweroff and generalized]
foundedVM.PowerOff();
foundedVM.Generalize();
var jsonResult = foundedVM.Capture("captured-vhds", "cpt", true);
Assert.NotNull(jsonResult);
// Delete VM
computeManager.VirtualMachines.DeleteById(foundedVM.Id);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(GroupName);
}
catch { }
}
}
}
/// <summary>
/// Sending a 0 to the comport will toggle the DC power supply.
/// Sending a 1 to the comport will toggle the usb power supply.
/// Sending a 255 to the comport will give you current status of the device.
/// The status of the device can be one of the four below:
/// 0x0 = DC & USB off
/// 0x1 = DC on
/// 0x2 = USB on
/// 0x3 = DC & USB on
/// </summary>
/// <param name="power">This parameter specifies the power state which can be on or off.</param>
/// <param name="ps">This parameter specifies the power source.</param>
internal static void Switch(PowerState power, PowerSource ps)
{
byte status;
switch (GetStatus())
{
case 0: // Both DC & USB off.
if (power == PowerState.Off)
{
return;
}
else
{
switch ((int)ps)
{
case 2:
status = Send(0);
CheckStatus(status, 0);
status = Send(1);
CheckStatus(status, 1);
break;
default:
byte b = Convert.ToByte((int)ps);
status = Send(b);
CheckStatus(status, b);
break;
}
}
break;
case 1: // Only DC is on.
if (power == PowerState.Off)
{
switch ((int)ps)
{
case 0:
status = Send(0);
CheckStatus(status, 0);
break;
default:
break;
}
}
else
{
switch ((int)ps)
{
case 0:
break;
default:
status = Send(1);
CheckStatus(status, 1);
break;
}
}
break;
case 2: // Only USB is on.
if (power == PowerState.Off)
{
switch ((int)ps)
{
case 1:
status = Send(1);
CheckStatus(status, 1);
break;
default:
break;
}
}
else
{
switch ((int)ps)
{
case 1:
break;
default:
status = Send(0);
CheckStatus(status, 0);
break;
}
}
break;
case 3: // Both DC & USB on.
if (power == PowerState.Off)
{
switch ((int)ps)
{
case 2:
status = Send(0);
CheckStatus(status, 0);
status = Send(1);
CheckStatus(status, 1);
break;
default:
byte b = Convert.ToByte((int)ps);
status = Send(b);
CheckStatus(status, b);
break;
}
}
else
{
return;
}
break;
}
}
/// <summary>
/// Sets power state. If powerState is ON, power on the blade; otherwise, power off the blade.
/// If bladeId is specified, change power state to that specific blade; otherwise, the change
/// will be made to all blades.
/// </summary>
protected bool SetPowerState(PowerState state, int bladeId = -1, [CallerMemberName]
string testName = null)
{
try
{
var message = string.Format("Set {1} to power state {0}", state,
bladeId > 0 ? string.Format("Blade {0}", bladeId) : "all blades");
CmTestLog.Info(string.Concat("Trying to ", message), testName);
ChassisResponse response;
if (bladeId > 0)
{
response = state == PowerState.ON
? this.Channel.SetPowerOn(bladeId)
: this.Channel.SetPowerOff(bladeId);
}
else
{
response = state == PowerState.ON
? this.Channel.SetAllPowerOn()
: this.Channel.SetAllPowerOff();
}
var result = ChassisManagerTestHelper.AreEqual(CompletionCode.Success,
response.completionCode, message, testName);
if (state == PowerState.OFF)
{
Thread.Sleep(TimeSpan.FromSeconds(CmConstants.BladePowerOffSeconds));
}
else
{
Thread.Sleep(TimeSpan.FromSeconds(CmConstants.BladePowerOnSeconds));
}
return result;
}
catch (Exception e)
{
CmTestLog.Exception(e, testName);
return false;
}
}
//NOT CORRECTLY IMPLEMENTED YET
public void Star()
{
PowerState.Star();
}
/// <summary>
/// Toggles the backlight.
/// </summary>
/// <param name="state">Power state to toggle too</param>
public void ToggleBacklight(PowerState state)
{
switch (state) {
case PowerState.On:
{
if (!m_BacklightIsOn) {
m_PiFaceCAD.BacklightOn ();
m_BacklightIsOn = true;
}
break;
}
case PowerState.Off:
{
if (m_BacklightIsOn) {
m_PiFaceCAD.BacklightOff ();
m_BacklightIsOn = false;
}
break;
}
}
}
public void ChangeToSuperMario()
{
PowerState.ChangeToSuperMario();
}
private void ProcessTweetSuspend(PowerState state)
{
Save();
InitSince_ID();
TweetShuttingDown = true;
Application.SetSuspendState(state, true, false);
}
public static bool SetSuspendState(PowerState state,
bool force,
bool disableWakeEvent)
{
return(false);
}
public static void UpdateRampPositions(float frameTime, PowerState state)
{
// Update supplies to move their ramp position towards target, if necessary.
foreach (var supply in state.Supplies.Values)
{
if (supply.Paused)
{
continue;
}
if (!supply.Enabled)
{
// If disabled, set ramp to 0.
supply.SupplyRampPosition = 0;
continue;
}
var rampDev = supply.SupplyRampTarget - supply.SupplyRampPosition;
if (Math.Abs(rampDev) > 0.001f)
{
float newPos;
if (rampDev > 0)
{
// Position below target, go up.
newPos = Math.Min(
supply.SupplyRampTarget,
supply.SupplyRampPosition + supply.SupplyRampRate * frameTime);
}
else
{
// Other way around, go down
newPos = Math.Max(
supply.SupplyRampTarget,
supply.SupplyRampPosition - supply.SupplyRampRate * frameTime);
}
supply.SupplyRampPosition = Math.Clamp(newPos, 0, supply.MaxSupply);
}
else
{
supply.SupplyRampPosition = supply.SupplyRampTarget;
}
}
// Batteries too.
foreach (var battery in state.Batteries.Values)
{
if (battery.Paused)
{
continue;
}
if (!battery.Enabled)
{
// If disabled, set ramp to 0.
battery.SupplyRampPosition = 0;
continue;
}
var rampDev = battery.SupplyRampTarget - battery.SupplyRampPosition;
if (Math.Abs(rampDev) > 0.001f)
{
float newPos;
if (rampDev > 0)
{
// Position below target, go up.
newPos = Math.Min(
battery.SupplyRampTarget,
battery.SupplyRampPosition + battery.SupplyRampRate * frameTime);
}
else
{
// Other way around, go down
newPos = Math.Max(
battery.SupplyRampTarget,
battery.SupplyRampPosition - battery.SupplyRampRate * frameTime);
}
battery.SupplyRampPosition = Math.Clamp(newPos, 0, battery.MaxSupply);
}
else
{
battery.SupplyRampPosition = battery.SupplyRampTarget;
}
}
}
/// <summary>
/// Triggered when a command has been given
/// </summary>
/// <param name="Shell">Reference to the shell</param>
/// <param name="Arguments">Command line arguments</param>
/// <param name="SuspressError">Set to 'true' if you could do anything with the command</param>
/// <param name="Time">Current timestamp</param>
private static void Shell_OnCommandReceived(ShellCore Shell, string[] Arguments, ref bool SuspressError, DateTime Time)
{
switch (Arguments[0].ToUpper())
{
case "CLS":
Shell.TelnetServer.ClearScreen();
SuspressError = true;
break;
case "MOTD":
_SendMotd(Shell.TelnetServer);
SuspressError = true;
break;
case "ECHO":
Shell.TelnetServer.Print(Shell.LastCommandline.Substring(5));
SuspressError = true;
break;
case "REBOOT":
Shell.TelnetServer.Print("Rebooting...");
Thread.Sleep(100);
Shell.TelnetServer.Close();
PowerState.RebootDevice(false);
SuspressError = true;
break;
case "QUIT":
Shell.TelnetServer.Print("Bye!");
Thread.Sleep(100);
Shell.TelnetServer.Close();
SuspressError = true;
break;
case "INFO":
Shell.TelnetServer.Print("Manufacturer: " + SystemInfo.OEMString);
Shell.TelnetServer.Print("Firmware version: " + SystemInfo.Version.ToString());
Shell.TelnetServer.Print("Memory available: " + Tools.MetricPrefix(Debug.GC(false), true) + "B");
if (PowerState.Uptime.Days == 0)
{
Shell.TelnetServer.Print("Uptime: " + PowerState.Uptime.ToString());
}
else
{
Shell.TelnetServer.Print("Uptime: " + PowerState.Uptime.Days.ToString() + " days, " + PowerState.Uptime.ToString());
}
Shell.TelnetServer.Print("Hardware provider: " + Tools.HardwareProvider);
Shell.TelnetServer.Print("System clock: " + Tools.MetricPrefix(Cpu.SystemClock) + "hz");
Shell.TelnetServer.Print("Endianness: " + (SystemInfo.IsBigEndian ? "Big Endian" : "Little Endian"));
Shell.TelnetServer.Print("Debugger: " + (System.Diagnostics.Debugger.IsAttached ? "attached" : "not attached"));
SuspressError = true;
break;
case "VER":
System.Reflection.Assembly[] Assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < Assemblies.Length; ++i)
{
Shell.TelnetServer.Print(Assemblies[i].FullName);
}
SuspressError = true;
break;
case "HELP":
bool PageFound = false;
if (Arguments.Length == 1)
{
PageFound = DoHelp(Shell.TelnetServer, "");
}
else
{
PageFound = DoHelp(Shell.TelnetServer, Arguments[1].ToUpper());
}
if (PageFound)
{
SuspressError = true;
}
break;
}
}
//actions that can be taken
public void Damage()
{
PowerState.Damage();
}
public List <PowerGame> Parse(bool createJsonFile, bool createCleanLog)
{
List <PowerGame> powerGames = new List <PowerGame>();
PowerState currentPowerState = PowerState.Start;
PowerGame currentPowerGame = null;
PowerType currentPowerType = 0;
Dictionary <string, int> currentNameToIdDict;
PowerHistoryEntry currentPowerHistoryEntry = null;
StringBuilder cleanLog = new StringBuilder();
string line;
while ((line = file.ReadLine()) != null)
{
Match matchLogRgx = logRgx.Match(line);
if (matchLogRgx.Success)
{
string entryType = matchLogRgx.Groups[1].Value;
string timestamp = matchLogRgx.Groups[2].Value;
string classType = matchLogRgx.Groups[3].Value;
string debugType = matchLogRgx.Groups[4].Value;
string content = matchLogRgx.Groups[5].Value;
if (!classType.Equals("GameState") || debugType.Equals("DebugPrintOptions"))
{
continue;
}
string contentLine = content.Trim();
cleanLog.AppendLine($"{("[" + debugType.ToString() + "] ").PadLeft(27)}{content}");
PowerType nextPowerType;
if (Enum.TryParse <PowerType>(contentLine.Split(' ')[0], out nextPowerType))
{
currentPowerType = nextPowerType;
}
;
switch (currentPowerType)
{
case PowerType.CREATE_GAME:
break;
}
}
else
{
Console.WriteLine("matchLogRgx: '" + line + "'");
}
}
if (createJsonFile)
{
string jsonStr = JsonConvert.SerializeObject(powerGames, Formatting.Indented,
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
});
File.WriteAllText(filePath + "powerLog.json", jsonStr);
}
if (createCleanLog)
{
File.WriteAllText(filePath + "cleanLog.log", cleanLog.ToString());
}
//while (powerGame.PowerHistory.Count > 0)
//{
// var powerHistoryEntry = powerGame.PowerHistory.Dequeue();
// powerHistoryEntry.Process(powerGame);
//}
//File.WriteAllText(filePath + "powerLogProc.json", JsonConvert.SerializeObject(powerGame, Formatting.Indented));
return(powerGames);
}
public void Mushroom()
{
PowerState.Mushroom();
}
public override string Toggle()
{
_powerState = TogglePowerState(_powerState);
return string.Format("PullChain->{0}->{1}", GetPowerStateName(_powerState), SetAppliancePower(_powerState, Appliance));
}
public void ChangeToSmallMario()
{
PowerState.ChangeToSmallMario();
}
public void PowerOn()
{
m_PowerState = PowerState.On;
Render(m_LastRenderedPixels);
}
public void ChangeToFireMario()
{
PowerState.ChangeToFireMario();
}
private void ProcessRequest()
{
const Int32 c_microsecondsPerSecond = 1000000;
try
{
using (m_clientSocket)
{
if (m_clientSocket.Poll(5 * c_microsecondsPerSecond,
SelectMode.SelectRead))
{
if (m_clientSocket.Available == 0)
{
return;
}
int bytesReceived = m_clientSocket.Available;
if (bytesReceived > 0)
{
byte[] buffer = new byte[bytesReceived];
int byteCount = m_clientSocket.Receive(buffer, bytesReceived, SocketFlags.None);
string request = new string(Encoding.UTF8.GetChars(buffer));
string firstLine = request.Substring(0, request.IndexOf('\n'));
string[] words = firstLine.Split(' ');
string command = string.Empty;
string response = string.Empty;
string header = string.Empty;
Logging.log_entry("ACCESS " + m_clientSocket.RemoteEndPoint.ToString() + " - " + '"' + firstLine.Trim() + '"');
//Debug.Print("Memory: " + Microsoft.SPOT.Debug.GC(true).ToString());
command = words[1].Substring(1).Trim();
if (command[0] == 63) // '?'
{
// pokud nam zustal otaznik na zacatku, tak oriznout o dva
command = words[1].Substring(2).Trim();
}
// bliknuti
m_ports[0].Write(true);
Thread.Sleep(10);
m_ports[0].Write(false);
// ocekavane url
// GET /?login=admin:admin&led=
if (command.Equals("favicon.ico"))
{
byte[] favicon = FileUtilities.file_get_contents_byte(@"\SD\setup\favicon.ico");
header = "HTTP/1.0 200 OK\r\nContent-Type: image/x-icon\r\nContent-Length: " + favicon.Length.ToString() + "\r\nConnection: close\r\n\r\n";
m_clientSocket.Send(Encoding.UTF8.GetBytes(header), header.Length, SocketFlags.None);
m_clientSocket.Send(favicon, favicon.Length, SocketFlags.None);
}
else
{
if (command.Length > 0)
{
bool authenticated = false;
try
{
string[] cmds = command.Split('&');
if (cmds.Length > 0)
{
for (int i = 0; i < cmds.Length; i++)
{
// zpracovani jednotlivych prikazu
string[] cmd_parsed = cmds[i].Split('=');
switch (cmd_parsed[0])
{
// login - prihlaseni ke sluzbam
// l=user:password
case "login":
string[] auth_data = cmd_parsed[1].Split(':');
authenticated = UserControl.authenticate(auth_data[0], auth_data[1]);
break;
// ports
case "led":
if (authenticated)
{
if (cmd_parsed[1].Length == 5)
{
controlLedStripe(cmd_parsed[1]);
}
else
{
SendResponse("500 Bad command params", "500 Internal Server Error");
}
}
else
{
SendResponse("401 Unauthorized");
}
break;
case "restart":
if (authenticated)
{
SendResponse("200 OK");
m_clientSocket.Close();
PowerState.RebootDevice(false);
}
break;
default:
SendResponse("500 Unknown command", "500 Internal Server Error");
break;
}
}
}
else
{
// stranka pokud nebyly predany parametry
SendResponse("200 HELLO * GIVE ME COMMAND :-)", "200 OK");
}
}
catch (Exception e)
{
Logging.log_entry(e.ToString());
}
}
else
{
// stranka pokud nebyl zadny request string
SendResponse("200 HELLO * GIVE ME COMMAND :-)", "200 OK");
}
}
m_clientSocket.Close();
}
}
}
}
catch (Exception e)
{
Logging.log_entry(e.ToString());
}
}
private void InsertVirtualMachineAvailabilityZoneRegionResults(string region, int availbilityZone, TraceWriter log)
{
try
{
var virtualMachineQuery = TableQuery.CombineFilters(TableQuery.GenerateFilterConditionForInt(
"AvailabilityZone",
QueryComparisons.Equal,
availbilityZone),
TableOperators.And,
TableQuery.GenerateFilterCondition("RegionName",
QueryComparisons.Equal,
region));
//TableQuery.GenerateFilterConditionForInt("AvailabilityZone", QueryComparisons.GreaterThanOrEqual, 0);
var virtualMachinesTableQuery = new TableQuery <VirtualMachineCrawlerResponse>().Where(virtualMachineQuery);
var crawledVirtualMachinesResults = StorageAccountProvider.GetEntities(
virtualMachinesTableQuery,
StorageTableNames.VirtualMachineCrawlerTableName);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
crawledVirtualMachinesResults = crawledVirtualMachinesResults.Where(x => PowerState.Parse(x.State) == PowerState.Running);
var virtualMachinesResults = crawledVirtualMachinesResults.ToList();
var meanTimeQuery = TableQuery.GenerateFilterConditionForDate("ScheduledExecutionTime",
QueryComparisons.GreaterThanOrEqual,
DateTimeOffset.UtcNow.AddMinutes(-azureClient.AzureSettings.Chaos.MeanTime));
var recentlyExecutedAvailabilityZoneRegionCombinationQuery = TableQuery.GenerateFilterCondition(
"ResourceType",
QueryComparisons.Equal,
VirtualMachineGroup.VirtualMachineScaleSets.ToString());
var recentlyExecutedVMScaleSetsQuery = TableQuery.CombineFilters(meanTimeQuery,
TableOperators.And,
recentlyExecutedAvailabilityZoneRegionCombinationQuery);
var scheduledQuery = new TableQuery <ScheduledRules>().Where(recentlyExecutedVMScaleSetsQuery);
//Will get the executed query results.
var executedVMScaleSetsResults = StorageAccountProvider.GetEntities(scheduledQuery,
StorageTableNames.ScheduledRulesTableName);
List <VirtualMachineCrawlerResponse> executedVMAvailabilityZones = null;
if (virtualMachinesResults.Count() != 0 && executedVMScaleSetsResults.Count() != 0)
{
foreach (var virtualMachineResult in virtualMachinesResults)
{
foreach (var executedVMScaleSetsResult in executedVMScaleSetsResults)
{
if ((executedVMScaleSetsResult.RowKey.ToLowerInvariant().Contains(virtualMachineResult.ResourceName.ToLowerInvariant())) &&
(executedVMScaleSetsResult.RowKey.ToLowerInvariant().Contains(virtualMachineResult.ResourceGroupName.ToLowerInvariant())) &&
(executedVMScaleSetsResult.RowKey.ToLowerInvariant().Contains(virtualMachineResult.AvailabilityZone.ToString()))
//&& (executedVMScaleSetsResult.RowKey.ToLowerInvariant().Contains(executedVMScaleSetsResult..ToLowerInvariant()))
)
{
executedVMAvailabilityZones.Add(virtualMachineResult);
}
}
}
if (executedVMAvailabilityZones != null && executedVMAvailabilityZones.Count() != 0)
{
virtualMachinesResults = virtualMachinesResults.Except(executedVMAvailabilityZones).ToList();
}
}
if (!virtualMachinesResults.Any())
{
return;
}
var batchTasks = new List <Task>();
var table = StorageAccountProvider.CreateOrGetTable(StorageTableNames.ScheduledRulesTableName);
if (table == null)
{
return;
}
for (var i = 0; i < virtualMachinesResults.Count; i += TableConstants.TableServiceBatchMaximumOperations)
{
var batchItems = virtualMachinesResults.Skip(i)
.Take(TableConstants.TableServiceBatchMaximumOperations).ToList();
var scheduledRulesbatchOperation = VirtualMachineHelper
.CreateScheduleEntityForAvailabilityZone(
batchItems,
azureClient.AzureSettings.Chaos.SchedulerFrequency,
azureClient.AzureSettings.Chaos.AzureFaultInjectionActions);
if (scheduledRulesbatchOperation.Count <= 0)
{
return;
}
batchTasks.Add(table.ExecuteBatchAsync(scheduledRulesbatchOperation));
}
if (batchTasks.Count > 0)
{
Task.WhenAll(batchTasks);
}
}
catch (Exception ex)
{
log.Error("AvailabilityZone RuleEngine: thrown exception", ex);
log.Error(ex.Source);
log.Error(ex.Message);
}
}
public static bool SetSuspendState (PowerState state, bool force, bool disableWakeEvent)
{
return false;
}
public static extern int SetSystemPowerState(String stateName, PowerState powerState, DevicePowerFlags flags);
public void SmallMario()
{
PowerState.SmallMario(this);
}
private static void HibernateMode()
{
var ps = new PowerState();
ps.SetSuspendState(true, true, false);
}
public void SuperMario()
{
PowerState.SuperMario(this);
}
public abstract void PowerStateUpdate(PowerState state);
public void FireMario()
{
PowerState.FireMario(this);
}
public void WaitForReady()
{
TimeSpan waitBetweenChecks = TimeSpan.FromSeconds(5);
OnUpdateStatus("Waiting for device to come to ready...");
PowerState[] rejectedPowerStates = new PowerState[] { PowerState.Off, PowerState.None };
OnUpdateStatus($" Waiting for device to return a responsive power state...");
int powerCheckCount = 0;
bool success =
Wait.ForTrue(
() =>
{
var state = _device.PowerManagement.GetPowerState();
OnUpdateStatus($" Device Power State: {state}");
bool ok = !rejectedPowerStates.Contains(state);
if (ok)
{
++powerCheckCount;
}
return(ok);
}
, TimeSpan.FromSeconds(240)
, waitBetweenChecks);
if (!success)
{
throw new DeviceInvalidOperationException($"Device did not come to an acceptable power state. ({_device.Address})");
}
DeviceStatus[] acceptedDeviceStatus = new DeviceStatus[] { DeviceStatus.Running, DeviceStatus.Warning };
OnUpdateStatus($" Waiting for device status reflecting readiness...");
success =
Wait.ForTrue(
() =>
{
var state = _device.GetDeviceStatus();
OnUpdateStatus($" Device Status: {state}");
return(acceptedDeviceStatus.Contains(state));
}
, TimeSpan.FromSeconds(240)
, waitBetweenChecks);
if (!success)
{
throw new DeviceInvalidOperationException($"Device did not return an acceptable status. ({_device.Address})");
}
OnUpdateStatus($" Waiting for device web services and OXP services to come online...");
const int MaxCreateCreateDeviceAttempts = 10;
int createDeviceAttempts = 0;
const int ConsecutiveSuccessfulDeviceInfoCallsRequired = 2;
int consecutiveSuccessfulDeviceInfoCalls = 0;
StringBuilder statusMessages = new StringBuilder();
do
{
JediDevice tempDevice = null;
try
{
using (tempDevice = (JediDevice)DeviceConstructor.Create(_deviceInfo))
{
var deviceInfo = tempDevice.GetDeviceInfo();
if (++consecutiveSuccessfulDeviceInfoCalls >= ConsecutiveSuccessfulDeviceInfoCallsRequired)
{
string message = $"Device is ready. (FirmwareRevision {deviceInfo.FirmwareRevision}; FirmwareDateCode: {deviceInfo.FirmwareDateCode})";
OnUpdateStatus($" {message}");
break;
}
else
{
string message = $"Device is responding. (ModelName {deviceInfo.ModelName}; ModelNumber: {deviceInfo.ModelNumber}; SerialNumber: {deviceInfo.SerialNumber})";
OnUpdateStatus($" {message}");
statusMessages.AppendLine(message);
waitBetweenChecks = TimeSpan.FromSeconds(3);
}
}
}
catch (InvalidCastException castX)
{
// Might encounter exception: Unable to cast object of type 'HP.DeviceAutomation.Phoenix.PhoenixDevice' to type 'HP.DeviceAutomation.Jedi.JediDevice'.
// Device is still initializing operate a different web service which looks like a Phoenix device.
OnUpdateStatus($" Device is still initializing and hosting a rudimentary EWS landing page on a Phoenix-y web server. ({castX.Message})");
statusMessages.AppendLine(castX.ToString());
}
catch (DeviceCommunicationException comX)
{
// HP.DeviceAutomation.DeviceCommunicationException: OXP UI Configuration service could not be found at 15.86.229.141
// HP.DeviceAutomation.DeviceCommunicationException: OXP UI Configuration service at 15.86.229.141 did not respond.
OnUpdateStatus($" Device OXP services not yet ready. ({comX.Message})");
statusMessages.AppendLine(comX.ToString());
}
catch (Exception x)
{
OnUpdateStatus($" {x.Message}");
statusMessages.AppendLine(x.ToString());
}
Thread.Sleep(waitBetweenChecks);
} while (++createDeviceAttempts <= MaxCreateCreateDeviceAttempts);
if (createDeviceAttempts >= MaxCreateCreateDeviceAttempts)
{
OnUpdateStatus(statusMessages.ToString());
throw new DeviceInvalidOperationException($"Device web services and/or OXP services did not respond as expected after {MaxCreateCreateDeviceAttempts} attempts.");
}
}
public void DeadMario()
{
PowerState.DeadMario(this);
}
public void CannotUpdateProximityPlacementGroupForVirtualMachine()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var GroupName1 = TestUtilities.GenerateName("rgfluentchash-");
var GroupName2 = TestUtilities.GenerateName("rgfluentchash-");
var AvailName1 = TestUtilities.GenerateName("availset1");
var AvailName2 = TestUtilities.GenerateName("availset2");
var ProxyGroupName1 = TestUtilities.GenerateName("testproxgroup1");
var ProxyGroupName2 = TestUtilities.GenerateName("testproxgroup1");
var ProxyGroupType = ProximityPlacementGroupType.Standard;
var RegionPPG1 = Region.USWestCentral;
var RegionPPG2 = Region.USSouthCentral;
var computeManager = TestHelper.CreateComputeManager();
var resourceManager = TestHelper.CreateResourceManager();
try
{
var setCreated1 = computeManager.AvailabilitySets
.Define(AvailName1)
.WithRegion(RegionPPG1)
.WithNewResourceGroup(GroupName1)
.WithNewProximityPlacementGroup(ProxyGroupName1, ProxyGroupType)
.Create();
Assert.Equal(AvailName1, setCreated1.Name);
Assert.NotNull(setCreated1.ProximityPlacementGroup);
Assert.Equal(ProxyGroupType, setCreated1.ProximityPlacementGroup.ProximityPlacementGroupType);
Assert.NotNull(setCreated1.ProximityPlacementGroup.AvailabilitySetIds);
Assert.False(setCreated1.ProximityPlacementGroup.AvailabilitySetIds.Count == 0);
Assert.Equal(setCreated1.Id, setCreated1.ProximityPlacementGroup.AvailabilitySetIds[0], true);
Assert.Equal(setCreated1.RegionName, setCreated1.ProximityPlacementGroup.Location);
var setCreated2 = computeManager.AvailabilitySets
.Define(AvailName2)
.WithRegion(RegionPPG2)
.WithNewResourceGroup(GroupName2)
.WithNewProximityPlacementGroup(ProxyGroupName2, ProxyGroupType)
.Create();
Assert.Equal(AvailName2, setCreated2.Name);
Assert.NotNull(setCreated2.ProximityPlacementGroup);
Assert.Equal(ProxyGroupType, setCreated2.ProximityPlacementGroup.ProximityPlacementGroupType);
Assert.Equal(ProxyGroupType, setCreated2.ProximityPlacementGroup.ProximityPlacementGroupType);
Assert.NotNull(setCreated2.ProximityPlacementGroup.AvailabilitySetIds);
Assert.False(setCreated2.ProximityPlacementGroup.AvailabilitySetIds.Count == 0);
Assert.Equal(setCreated2.Id, setCreated2.ProximityPlacementGroup.AvailabilitySetIds[0], true);
Assert.Equal(setCreated2.RegionName, setCreated2.ProximityPlacementGroup.Location);
// Create
computeManager.VirtualMachines
.Define(VMName)
.WithRegion(RegionPPG1)
.WithExistingResourceGroup(GroupName1)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithProximityPlacementGroup(setCreated1.ProximityPlacementGroup.Id)
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012Datacenter)
.WithAdminUsername("Foo12")
.WithAdminPassword("abc!@#F0orL")
.WithUnmanagedDisks()
.WithSize(VirtualMachineSizeTypes.StandardDS3V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithOSDiskName("javatest")
.WithLicenseType("Windows_Server")
.Create();
IVirtualMachine foundVM = null;
var vms = computeManager.VirtualMachines.ListByResourceGroup(GroupName1);
foreach (IVirtualMachine vm1 in vms)
{
if (vm1.Name.Equals(VMName))
{
foundVM = vm1;
break;
}
}
Assert.NotNull(foundVM);
Assert.Equal(RegionPPG1, foundVM.Region);
// Get
foundVM = computeManager.VirtualMachines.GetByResourceGroup(GroupName1, VMName);
Assert.NotNull(foundVM);
Assert.Equal(RegionPPG1, foundVM.Region);
Assert.Equal("Windows_Server", foundVM.LicenseType);
// Fetch instance view
PowerState powerState = foundVM.PowerState;
Assert.Equal(powerState, PowerState.Running);
VirtualMachineInstanceView instanceView = foundVM.InstanceView;
Assert.NotNull(instanceView);
Assert.True(instanceView.Statuses.Count > 0);
Assert.NotNull(foundVM.ProximityPlacementGroup);
Assert.Equal(ProxyGroupType, foundVM.ProximityPlacementGroup.ProximityPlacementGroupType);
Assert.NotNull(foundVM.ProximityPlacementGroup.AvailabilitySetIds);
Assert.True(foundVM.ProximityPlacementGroup.AvailabilitySetIds.Count > 0);
Assert.Equal(setCreated1.Id, foundVM.ProximityPlacementGroup.AvailabilitySetIds[0], true);
Assert.NotNull(foundVM.ProximityPlacementGroup.VirtualMachineIds);
Assert.True(foundVM.ProximityPlacementGroup.VirtualMachineIds.Count > 0);
Assert.Equal(foundVM.Id, setCreated1.ProximityPlacementGroup.VirtualMachineIds[0], true);
try
{
//Update Vm to remove it from proximity placement group
IVirtualMachine updatedVm = foundVM.Update()
.WithProximityPlacementGroup(setCreated2.ProximityPlacementGroup.Id)
.Apply();
}
catch (Microsoft.Rest.Azure.CloudException clEx)
{
Assert.Equal("Changing property 'proximityPlacementGroup.id' is not allowed.", clEx.Message, true);
}
// Delete resources
computeManager.VirtualMachines.DeleteById(foundVM.Id);
computeManager.AvailabilitySets.DeleteById(setCreated1.Id);
computeManager.AvailabilitySets.DeleteById(setCreated2.Id);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(GroupName1);
resourceManager.ResourceGroups.DeleteByName(GroupName2);
}
catch { }
}
}
}
/// <summary>
/// Set power to an explicit state (on/off).
/// </summary>
/// <param name="powerState">On or off.</param>
/// <param name="duration">How long in seconds you want the power action to take. Range: 0.0 – 3155760000.0 (100 years).</param>
/// <returns></returns>
public async Task <ApiResult> SetPower(PowerState powerState, double duration = LifxClient.DEFAULT_DURATION)
{
return((await Client.SetPower(this, powerState, duration)).Results.First());
}
public static extern int SetSystemPowerState(String stateName, PowerState powerState, DevicePowerFlags flags);
/// <summary>
/// Set an explicit state. As documented here: https://api.developer.lifx.com/docs/set-state.
/// </summary>
/// <param name="powerState">On or off.</param>
/// <param name="color">The color to set the light to.</param>
/// <param name="brightness">The brightness level from 0.0 to 1.0. Overrides any brightness set in color (if any).</param>
/// <param name="duration">How long in seconds you want the power action to take. Range: 0.0 – 3155760000.0 (100 years).</param>
/// <param name="infrared">The maximum brightness of the infrared channel.</param>
/// <returns></returns>
public async Task <ApiResult> SetState(PowerState powerState, LifxColor color, double brightness, double duration = LifxClient.DEFAULT_DURATION, double infrared = LifxClient.DEFAULT_INFRARED)
{
return((await Client.SetState(this, powerState, color, brightness, duration, infrared)).Results.First());
}
/// <summary>
/// Verifies that all BladeStateResponses in the given collection are the same as the expectedState.
/// If a blade is a server, this method verifies the server has the same state as the expectedState; if a blade
/// is a jbod, this method ignores the expectedState parameter and verifies the blade returns CommandNotValidForBlade.
/// If there is only one response in the collection and it is from an empty slot, the method returns false;
/// in other cases, empty slots in the collection will just be ignored.
/// </summary>
protected bool VerifyBladeState(PowerState expectedState, IEnumerable<BladeStateResponse> bladeStates,
[CallerMemberName]
string testName = null)
{
GetAllBladesInfoResponse allBlades;
if (!this.GetAllBladesInfo(out allBlades, testName))
{
return false;
}
try
{
var bladeStateCollection = new List<BladeStateResponse>(bladeStates);
bool serverResult = true, jbodResult = true;
foreach (var state in bladeStateCollection)
{
// current blade info
var bladeInfo = allBlades.bladeInfoResponseCollection.Single(info => info.bladeNumber == state.bladeNumber);
if (string.IsNullOrEmpty(bladeInfo.bladeType))
{
// for empty slot, if it is the only blade to be vefiried, return false;
// or just ignore it, not counting into result.
if (bladeStateCollection.Count == 1)
{
return false;
}
else
{
continue;
}
}
// verify server blade
if (bladeInfo.bladeType.Equals(CmConstants.ServerBladeType) && state.bladeState != expectedState)
{
serverResult = false;
CmTestLog.Failure(string.Format("Server Blade #{0} state is not as expected (Expected: {1}, Actual: {2})",
state.bladeNumber, expectedState, state.bladeState), testName);
}
// verify jbod blade
else if (bladeInfo.bladeType.Equals(CmConstants.JbodBladeType) && state.completionCode != CompletionCode.CommandNotValidForBlade)
{
jbodResult = false;
CmTestLog.Failure(string.Format("JBOD Blade #{0} completion code is not correct (Expected: {1}, Actual: {2})",
state.bladeNumber, CompletionCode.CommandNotValidForBlade, state.completionCode), testName);
}
}
if (serverResult)
{
CmTestLog.Success(string.Format("Verified server blades are {0}", expectedState), testName);
}
if (jbodResult)
{
CmTestLog.Success("Verified JBODs return CommandNotValidForBlade", testName);
}
return serverResult && jbodResult;
}
catch (Exception e)
{
CmTestLog.Exception(e, testName);
return false;
}
}
/// <summary>
/// Toggles the display.
/// </summary>
/// <param name="state">Power state to toggle too</param>
public void ToggleDisplay(PowerState state)
{
switch (state) {
case PowerState.On:
{
if (!m_DisplayIsOn) {
m_PiFaceCAD.DisplayOn ();
m_DisplayIsOn = true;
}
break;
}
case PowerState.Off:
{
if (m_DisplayIsOn) {
if (m_BacklightIsOn) {
ToggleBacklight (PowerState.Off);
}
m_PiFaceCAD.DisplayOff ();
m_DisplayIsOn = false;
}
break;
}
}
}
