/// <summary>
/// 发送消息
/// </summary>
public void SendMessage(ServerPackage serverPackage)
{
//PlazaSessionCode sessionCode = new PlazaSessionCode(mainCmd, subCmd, buffer.ToBytes());
byte[] bytes = Serial.GetInstance.Encode(serverPackage);
SessionSend(bytes);
//buffer.Close();
}
public void SendPackage(EventType eventType, ServerPackage serverPackage)
{
if (Package.ContainsKey(eventType))
{
Package[eventType](serverPackage);
}
}
public void ReceivePackage()
{
AsyncCallback callback = null;
callback = ar =>
{
int bytesRead = _stream.EndRead(ar);
var data = new byte[bytesRead];
Array.Copy(_buffer, data, bytesRead);
if (_isNotMoreToRead)
{
_stream.BeginRead(_buffer, _offset, _count, callback, null);
}
using (var stream = new MemoryStream(data))
{
ServerPackage package = null;
do
{
package = _factory.GetNextPackage(stream);
if (package != null)
{
_game.SetPackage(package);
}
} while (package != null);
}
};
_stream.BeginRead(_buffer, _offset, _count, callback, null);
}
public void InstallServerPackage(ServerPackage package)
{
Console.WriteLine("installing: " + package.PackageName);
var process = Process.Start("dotnet.exe", $"add package {package.PackageName}");
process.WaitForExit();
}
public void AsODataPackage_PicksCorrectLatestProperties(
bool v1AbsLatest,
bool v1Latest,
bool v2AbsLatest,
bool v2Latest,
int level,
bool expectedAbsLatest,
bool expectedLatest)
{
// Arrange
var package = new ServerPackage
{
Version = new SemanticVersion("0.1.0-rc.1"),
Authors = Enumerable.Empty <string>(),
Owners = Enumerable.Empty <string>(),
SemVer1IsAbsoluteLatest = v1AbsLatest,
SemVer1IsLatest = v1Latest,
SemVer2IsAbsoluteLatest = v2AbsLatest,
SemVer2IsLatest = v2Latest,
};
var semVerLevel = new SemanticVersion(level, minor: 0, build: 0, specialVersion: null);
// Act
var actual = package.AsODataPackage(new ClientCompatibility(semVerLevel));
// Assert
Assert.Equal(expectedAbsLatest, actual.IsAbsoluteLatestVersion);
Assert.Equal(expectedLatest, actual.IsLatestVersion);
}
public void IsSemVer2_CanBeDeterminedByDependencyVersionRange(string versionRange, bool isSemVer2)
{
// Arrange
var package = new Mock <IPackage>();
package
.Setup(x => x.Version)
.Returns(new SemanticVersion("1.0.0"));
package
.Setup(x => x.DependencySets)
.Returns(new[]
{
new PackageDependencySet(
new FrameworkName(".NETFramework,Version=v4.5"),
new[]
{
new PackageDependency("OtherPackage", VersionUtility.ParseVersionSpec(versionRange))
})
}.AsEnumerable());
var packageDerivedData = new PackageDerivedData();
// Act
var serverPackage = new ServerPackage(package.Object, packageDerivedData);
// Assert
Assert.Equal(isSemVer2, serverPackage.IsSemVer2);
}
public void SendServerPackage(ServerPackageType serverPackageType, byte[] data, bool redirectPackage,
ushort administrationId)
{
var serverPackage = new ServerPackage
{
Data = data,
ServerPackageType = serverPackageType,
RedirectPackage = redirectPackage ? new RedirectPackage {
Administration = administrationId
} : null
};
var package = new Serializer(typeof(ServerPackage)).Serialize(serverPackage);
lock (SendLock)
{
try
{
BinaryWriter.Write((byte)FromClientPackage.ServerPackage);
BinaryWriter.Write(package.Length);
BinaryWriter.Write(package);
BinaryWriter.Flush();
}
catch (ObjectDisposedException)
{
}
}
}
public void GetNextPackageByArrayEmptyTest()
{
var data = new byte[] { 0, 0, 0, 0 };
ServerPackage package = _factory.GetNextPackage(data);
Assert.Null(package);
}
void OnReceivedMessage(MemoryStream ms)
{
BinaryReader r = new BinaryReader(ms);
byte[] message = r.ReadBytes((int)(ms.Length - ms.Position));
ServerPackage serverPackage = (ServerPackage)Serial.GetInstance.Decode(message, 0, message.Length);
ServerEvent.GetInstance.SendPackage(ServerEvent.EventType.EVENT_SEND_PACKAGE, serverPackage);
}
public void GetPongPackageTest()
{
var data = _pongPackage.ToByteArray();
ServerPackage package = _factory.GetNextPackage(data);
Assert.NotNull(package);
Assert.AreEqual(data, package.ToByteArray());
Assert.AreEqual(_pongPackage.Type, package.Type);
}
public void GetSetRoomPackageTest()
{
var data = _setRoomPackage.ToByteArray();
ServerPackage clientPackage = _factory.GetNextPackage(data);
Assert.NotNull(clientPackage);
Assert.AreEqual(data, clientPackage.ToByteArray());
Assert.AreEqual(_setRoomPackage.Type, clientPackage.Type);
}
public PaymentWindow(ServerPackage receivedPackage)
{
InitializeComponent();
lb_accountHasExpired.Text = String.Format("Your account has expired!");
receivedPackage.locked = true;
package = receivedPackage;
lb_addressBtc.Text = package.wallet;
this.Enabled = true;
btn_checkStatus.Enabled = true;
}
public void UpdatePositionsPackageTest()
{
var data = _updatePositionsPackage.ToByteArray();
ServerPackage package = _factory.GetNextPackage(data);
Assert.NotNull(package);
Assert.AreEqual(_updatePositionsPackage.Type, package.Type);
Assert.AreEqual(_updatePositionsPackage.Units.Length, ((UpdatePositionsPackage)package).Units.Length);
Assert.AreEqual(data, package.ToByteArray());
}
public void GetAcceptLoginPackageTest()
{
var data = _acceptLoginPackage.ToByteArray();
ServerPackage package = _factory.GetNextPackage(data);
Assert.NotNull(package);
Assert.AreEqual(data, package.ToByteArray());
Assert.AreEqual(_acceptLoginPackage.Type, package.Type);
Assert.AreEqual(_acceptLoginPackage.ClientId, ((AcceptLoginPackage)package).ClientId);
}
public void UpdateToolStripUpdates(ServerPackage package)
{
var currentVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
if (System.String.Compare(package.newestVersion, currentVersion, System.StringComparison.Ordinal) > 0)
{
UpdateToolStripUpdates(true);
}
else
{
UpdateToolStripUpdates(false);
}
}
public void onSendMsg()
{
Console.Write("发送消息:");
string str = Console.ReadLine();
outStream = client.GetStream();
ByteBuffer buff = new ByteBuffer();
buff.WriteString(str);
ServerPackage serverPackage = new ServerPackage(0, 1, 1, buff.ToBytes());
SendMessage(serverPackage);
}
private static List <ServerPackage> GenerateServerPackages(int count)
{
var originalPackages = new List <ServerPackage>();
for (var i = 0; i < count; i++)
{
var package = new ServerPackage
{
Id = "Package" + i,
Version = new SemanticVersion(1, 0, i, 0),
Title = "Title" + i,
Authors = new[] { "Author" + i },
Owners = new[] { "Owner" + i },
IconUrl = new Uri("urn:icon"),
LicenseUrl = new Uri("urn:license"),
ProjectUrl = new Uri("urn:project"),
RequireLicenseAcceptance = true,
DevelopmentDependency = true,
Description = "Description" + i,
Summary = "Summary" + i,
ReleaseNotes = "ReleaseNotes" + i,
Language = "Language" + i,
Tags = "Tags" + i,
Copyright = "Copyright" + i,
MinClientVersion = null,
ReportAbuseUrl = new Uri("urn:abuse"),
DownloadCount = 0,
SemVer1IsAbsoluteLatest = true,
SemVer1IsLatest = true,
SemVer2IsAbsoluteLatest = true,
SemVer2IsLatest = true,
Listed = true,
Dependencies = string.Empty,
SupportedFrameworks = string.Empty,
PackageSize = 1234,
PackageHash = "Hash" + i,
PackageHashAlgorithm = "HashAlgorithm" + i,
LastUpdated = DateTimeOffset.UtcNow,
Created = DateTimeOffset.UtcNow,
FullPath = "FullPath" + i
};
// Preload collections
package.DependencySets.Any();
package.SupportedFrameworks.Any();
originalPackages.Add(package);
}
return(originalPackages);
}
public void IsSemVer2_CanBeDeterminedByPackageVersion(string version, bool isSemVer2)
{
// Arrange
var package = new Mock <IPackage>();
package.Setup(x => x.Version).Returns(new SemanticVersion(version));
var packageDerivedData = new PackageDerivedData();
// Act
var serverPackage = new ServerPackage(package.Object, packageDerivedData);
// Assert
Assert.Equal(isSemVer2, serverPackage.IsSemVer2);
}
public MainWindow(ServerPackage package)
{
InitializeComponent();
background = new DataCollector();
toolStripStatusInfo.Text = Resources.Ready;
dataGridView1.AllowUserToAddRows = false;
dataGridView1.ColumnHeadersVisible = false;
dataGridView1.Visible = false;
LoadOptions();
InitTimerValidation();
UpdateSettings();
UpdateCurrencies();
UpdateToolStripUpdates(package);
}
public ServerPackage AddServer(ServerPackageAdd serverPackage, int createdbyId)
{
var toAdd = new ServerPackage
{
CreatedById = createdbyId,
CreatedOn = DateTime.Now,
PackageName = serverPackage.PackageName,
PackageId = serverPackage.PackageId
};
context.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public void GetNextPackageEmptyTest()
{
var data = new byte[] { 0, 0, 0, 0 };
ServerPackage package = null;
using (var stream = new MemoryStream(data))
{
Console.WriteLine(stream.Length);
package = _factory.GetNextPackage(stream);
}
Assert.Null(package);
}
//Packs everything so that server can understand
private string GetResponce(PackageType sendType, PackageType receivedType, string data)
{
while (true)
{
Connected = true;
ServerPackage serverPackage = new ServerPackage(sendType, data, this.udpServerPort);
string json = JsonConvert.SerializeObject(serverPackage, Formatting.Indented);
SendToServer(json);
string message = "";
int attempts = 0;
while (true)
{
message += ReadFromServer();
message = message.Replace("\0", "");
if (attempts < 15)
{
attempts++;
}
else
{
break;
}
if (message.Length > 1)
{
ServerPackage package = JsonConvert.DeserializeObject <ServerPackage>(message);
if (package.Type == receivedType)
{
tcp.Close();
Connected = false;
return(package.Message);
}
else
{
continue;
}
}
}
}
}
public ODataPackage(ServerPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (package.Version == null)
{
throw new ArgumentException("server package version is null");
}
Version = package.Version.OriginalVersion;
NormalizedVersion = package.Version.ToNormalizedString();
Authors = package.Authors;
Owners = package.Owners;
IconUrl = package.IconUrl;
LicenseUrl = package.LicenseUrl;
ProjectUrl = package.ProjectUrl;
Dependencies = package.Dependencies;
Id = package.Id;
Title = package.Title;
RequireLicenseAcceptance = package.RequireLicenseAcceptance;
Description = package.Description;
Summary = package.Summary;
ReleaseNotes = package.ReleaseNotes;
Language = package.Language;
Tags = package.Tags;
PackageHash = package.PackageHash;
PackageHashAlgorithm = package.PackageHashAlgorithm;
LastUpdated = package.LastUpdated.UtcDateTime;
Published = package.Published.GetValueOrDefault().UtcDateTime;
IsAbsoluteLatestVersion = package.IsAbsoluteLatestVersion;
IsLatestVersion = package.IsLatestVersion;
IsPrerelease = !package.IsReleaseVersion();
Listed = package.Listed;
DownloadCount = package.DownloadCount;
if (package.MinClientVersion != null)
{
MinClientVersion = package.MinClientVersion.ToNormalizedString();
}
//PackageSize = package.PackageSize;
//Created = package.Created.UtcDateTime;
//VersionDownloadCount = package.VersionDownloadCount;
}
private static List <ServerPackage> GenerateServerPackages(int count)
{
var originalPackages = new List <ServerPackage>();
for (int i = 0; i < count; i++)
{
var package = new ServerPackage(
id: "Package" + i,
version: new SemanticVersion(1, 0, i, 0),
title: "Title" + i,
authors: new [] { "Author" + i },
owners: new [] { "Owner" + i },
iconUrl: new Uri("urn:icon"),
licenseUrl: new Uri("urn:license"),
projectUrl: new Uri("urn:project"),
requireLicenseAcceptance: true,
developmentDependency: true,
description: "Description" + i,
summary: "Summary" + i,
releaseNotes: "ReleaseNotes" + i,
language: "Language" + i,
tags: "Tags" + i,
copyright: "Copyright" + i,
minClientVersion: null,
reportAbuseUrl: new Uri("urn:abuse"),
downloadCount: 0,
isAbsoluteLatestVersion: true,
isLatestVersion: true,
listed: true,
published: null,
dependencies: string.Empty,
supportedFrameworks: string.Empty,
packageSize: 1234,
packageHash: "Hash" + i,
packageHashAlgorithm: "HashAlorithm" + i,
lastUpdated: DateTimeOffset.UtcNow,
created: DateTimeOffset.UtcNow,
path: "Path" + i,
fullPath: "FullPath" + i
);
originalPackages.Add(package);
}
return(originalPackages);
}
public async void SendPackage(ServerPackage package)
{
var data = package.ToByteArray();
try
{
await _stream.WriteAsync(data, 0, data.Length, _tokenSource.Token);
}
catch (IOException)
{
Logger.Info($"Disconnect client {ClientId} by exception");
Disconnect();
}
catch (TaskCanceledException)
{
Logger.Info($"Disconnect client {ClientId} by exception");
Disconnect();
}
}
public static PackageHandler GetPackageHandler(Game game, ServerPackage package)
{
switch (package.Type)
{
case ServerPackageType.Pong:
return(new PongPackageHandler(game, package));
case ServerPackageType.AcceptLogin:
return(new AcceptLoginPackageHandler(game, package));
case ServerPackageType.SetRoom:
return(new SetRoomPackageHandler(game, package));
case ServerPackageType.UpdatePositions:
return(new UpdatePositionsPackageHandler(game, package));
}
return(null);
}
private void btn_checkStatus_Click(object sender, EventArgs e)
{
try
{
this.Enabled = false;
btn_checkStatus.Enabled = false;
AuthUser auth = new AuthUser();
var serverpackage = auth.ValidateUser();
if (serverpackage.validationResult == ValidationResult.actual)
{
lb_accountHasExpired.Text = String.Format("Account active for {0} day(s)",
serverpackage.GetDaysToExpire());
serverpackage.locked = false;
}
else if (serverpackage.validationResult == ValidationResult.expired)
{
lb_accountHasExpired.Text = String.Format("Your account has expired!");
serverpackage.locked = true;
}
else if (serverpackage.validationResult == ValidationResult.temporary)
{
lb_accountHasExpired.Text = String.Format("Right now, you use it for free!");
serverpackage.locked = false;
label9.Visible = true;
button2.Visible = true;
lb_accountHasExpired.Location = new System.Drawing.Point(36, 9);
label1.Visible = label2.Visible = label3.Visible = label4.Visible =
label5.Visible = label6.Visible = label7.Visible =
label8.Visible = btn_checkStatus.Visible = false;
}
package = serverpackage;
lb_addressBtc.Text = package.wallet;
this.Enabled = true;
btn_checkStatus.Enabled = true;
}
catch (Exception ee)
{
//Log.Error(ee);
//HandleError.CloseProgram();
}
}
public void AsODataPackage_UsesCreatedForListedPublished()
{
// Arrange
var package = new ServerPackage
{
Version = new SemanticVersion("0.1.0"),
Authors = Enumerable.Empty <string>(),
Owners = Enumerable.Empty <string>(),
Listed = true,
Created = new DateTimeOffset(2017, 11, 29, 21, 21, 32, TimeSpan.FromHours(-8)),
};
// Act
var actual = package.AsODataPackage(ClientCompatibility.Max);
// Assert
Assert.Equal(
new DateTime(2017, 11, 30, 5, 21, 32, DateTimeKind.Utc),
actual.Published);
}
public void Send(ServerPackage serverPackage)
{
MemoryStream ms = null;
byte[] bytes = Serial.GetInstance.Encode(serverPackage);
using (ms = new MemoryStream())
{
ms.Position = 0;
BinaryWriter writer = new BinaryWriter(ms);
ushort msglen = (ushort)bytes.Length;
writer.Write(msglen);
writer.Write(bytes);
writer.Flush();
if (client != null && client.Connected)
{
outStream = client.GetStream();
byte[] payload = ms.ToArray();
outStream.BeginWrite(payload, 0, payload.Length, null, null);
}
}
}
public void InvokeValidation(object o, EventArgs arg)
{
bool shouldClose = false;
var auth = new AuthUser();
_authPackage = auth.ValidateUser();
if (_authPackage == null)
{
MessageBox.Show("Could not connect to server. Application will be closed immediately.");
Application.Exit();
shouldClose = true;
}
if (_authPackage != null && _authPackage.validationResult == ValidationResult.expired)
{
MessageBox.Show(
@"Your account has expired. Please Upgrade your account.\nNow, program will be closed immediately.",
@"CryptoDelivery",
MessageBoxButtons.OK,
MessageBoxIcon.Warning);
shouldClose = true;
}
if (shouldClose)
{
try
{
Process[] proc = Process.GetProcessesByName("CryptoTriangular");
foreach (Process prog in proc)
{
prog.Kill();
}
}
catch (Exception)
{
Environment.Exit(0);
}
}
UpdateToolStripUpdates(_authPackage);
}
public ServerPackage ValidateUser(Options options = null)
{
try
{
var uniqueId = getUniqueID();
WebClient client = new WebClient();
var Server = "http://cryptocurrencyworld.eu/crypto/webservice.php";
var data = String.Format("cpuid={0}", uniqueId);
var response = client.UploadString(Server, "POST", data);
const string a = "45287112549354892144548565456541";
const string b = "5AUjfdWTz9g57dbVGSVLBb2bZycT18Hi";
var c = response;
var temp = read(ParsBytes(c), b, a);
var deseralizedResponse = JsonConvert.DeserializeObject<JsonResponse>(temp);
ServerPackage sp = new ServerPackage();
if (uniqueId != deseralizedResponse.cpuid)
{
throw new Exception("incorrect uniqueId in relation to id which was get from server.");
}
else
{
sp.cpuid = uniqueId;
}
sp.locked = Convert.ToBoolean(deseralizedResponse.locked);
sp.date_added = Convert.ToDateTime(deseralizedResponse.date_added);
sp.date_expired = Convert.ToDateTime(deseralizedResponse.date_expired);
sp.date_current_on_server = Convert.ToDateTime(deseralizedResponse.date_current_on_server);
sp.wallet = deseralizedResponse.wallet;
TimeSpan ts = sp.date_expired - sp.date_current_on_server;
if (ts.TotalDays < 0)
{
sp.validationResult = ValidationResult.expired;
sp.locked = true;
}
else if (ts.TotalDays > 0 && sp.locked==false)
{
sp.validationResult = ValidationResult.actual;
sp.locked = false;
}
return sp;
}
catch (Exception e)
{
bool timeout = e is WebException;
Log.Error(e,timeout);
if (timeout == true)
return null;
}
return new ServerPackage();
}
