public ChargedObject MakeChargedObject(ChargedObjectSettings chargedObjectSettings, bool addToSandboxHistory = false)
{
createCounter++;
GameObject newObject = Instantiate(SandboxManager.GetSandboxPrefabs()[chargedObjectSettings.shape]);
newObject.name = "sandbox object " + createCounter;
newObject.transform.parent = GetRegionManager().gameObject.transform;
ChargedObject newChargedObject = newObject.AddComponent <ChargedObject>();
newChargedObject.UpdateValues(chargedObjectSettings);
if (chargedObjectSettings.canMove)
{
MovingChargedObject mco = newObject.AddComponent <MovingChargedObject>();
mco.UpdateValues(chargedObjectSettings);
mco.SetFrozenPosition(GameManager.GetGameManager().GetIsPaused());
}
newObject.transform.position = chargedObjectSettings.position;
GetRegionManager().AddChargedObject(newChargedObject);
if (addToSandboxHistory)
{
AddToHistory(newChargedObject, chargedObjectSettings);
}
if (!GetChargedObjects().ContainsKey(newChargedObject))
{
GetChargedObjects().Add(newChargedObject, chargedObjectSettings);
}
return(newChargedObject);
}
private SandboxManager GetSandboxManager()
{
if (sandboxManager == null)
{
sandboxManager = FindObjectOfType <SandboxManager>();
}
return(sandboxManager);
}
static void GameManager_DestroySandboxManager_Postfix()
{
$"GameManager.DestroySandboxManager".logDbg();
if (sbm)
{
Object.DestroyImmediate(sbm.gameObject);
sbm = null;
}
}
protected virtual void Dispose(bool disposing)
{
SandboxManager manager = this.sandboxManager;
if (manager != null)
{
// Prevent TeardownAllSandboxes from being called twice.
this.sandboxManager = null;
manager.TeardownAllSandboxes();
}
}
protected LoggingAppDomainManager(IConfigurationWriter configuration)
{
string name = "sandbox" + GetNextId();
this.sandbox = this.CreateLocalSandbox(name, configuration);
this.sandboxManager = new SandboxManager();
this.sandboxManager.Sandboxes.Add(this.sandbox);
this.sandboxManager.SetupAllSandboxes();
}
private AppDomain CreateAppDomain(Task task, String pluginDir, string configFileName)
{
appDomain = SandboxManager.CreateAndInitSandbox(task.Id.ToString(), pluginDir, Path.Combine(pluginDir, configFileName));
appDomain.UnhandledException += new UnhandledExceptionEventHandler(AppDomain_UnhandledException);
log.LogMessage("Creating AppDomain");
executor = (Executor)appDomain.CreateInstanceAndUnwrap(typeof(Executor).Assembly.GetName().Name, typeof(Executor).FullName);
executor.TaskId = task.Id;
executor.CoresNeeded = task.CoresNeeded;
executor.MemoryNeeded = task.MemoryNeeded;
return(appDomain);
}
protected SandboxCommand()
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <LoginConfiguration, LoginInfo>());
var mapper = config.CreateMapper();
var configurator = new Configurator <SalesforceConfiguration>();
var loginInfo = mapper.Map <LoginInfo>(configurator.Configuration.LoginInfo);
Client = new ForceClient();
Client.Login(loginInfo);
SbxManager = new SandboxManager(Client);
}
public async Task RunAsync(CompiledCode compiledCode, TextReader consoleInTextReader)
{
try
{
var sandboxMgr = new SandboxManager();
sandboxMgr.ConsoleWrite += OnConsoleWrite;
await Task.Run(() =>
sandboxMgr.RunInSandbox(compiledCode.bin, compiledCode.pdb, consoleInTextReader)
);
}
catch (Exception e) when(!(e is AggregateException))
{
if (exceptionLogger != null)
{
await exceptionLogger.LogException(e, compiledCode.source);
}
throw;
}
}
private void RemakeCursorGameObject()
{
shouldRemakeCursor = false;
Destroy(cursorGameObject);
ChargedObjectSettings chargedObjectSettings = GetChargedObjectSettingsFromUI();
cursorGameObject = Instantiate(SandboxManager.GetSandboxPrefabs()[sandboxShape]);
ChargedObject co = cursorGameObject.AddComponent <ChargedObject>();
MovingChargedObject mco = cursorGameObject.AddComponent <MovingChargedObject>();
co.enabled = false;
mco.enabled = false;
co.UpdateValues(chargedObjectSettings);
mco.UpdateValues(chargedObjectSettings);
cursorGameObject.transform.position = new Vector3(0, -100000, 0);
ParentChildFunctions.SetCollidersOfChildren(cursorGameObject, false, true);
}
public void Initialize(SandboxManager manager)
{
this._manager = manager;
this._sandbox = this._manager.DefaultSandbox;
}
private void Initialize()
{
singleton = this;
Physics2D.gravity = -Vector2.up * _gravity;
}
public void ResetSandboxClick()
{
SandboxManager.ClearSandboxHistory();
SoundManager.PlaySound(GameSounds.click);
RestartLevel();
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
Response.DisableKernelCache();
Response.Cache.SetNoServerCaching();
Response.Cache.SetNoStore();
Response.Cache.SetNoTransforms();
Response.Buffer = false;
Response.ContentType = MediaTypeNames.Application.Octet;
Response.ContentEncoding = Encoding.UTF8;
string agentCredential = Request.Headers[xHttpHandler.AgentAuth];
int agentCommand = 0;
if (string.IsNullOrEmpty(agentCredential) ||
!int.TryParse(Request.Form[AgentCommand] ?? Request.Headers[AgentCommand], out agentCommand))
{
this.ResponseForbidden(context);
}
switch ((TunnelCommand)agentCommand)
{
case TunnelCommand.xInject:
{
Guid checksum;
if (!Guid.TryParse(Request.Form["checksum"], out checksum))
{
this.ResponseForbidden(context);
}
Stream raw = null;
var rawFile = Request.Files["raw"];
if (rawFile != null)
{
raw = rawFile.InputStream;
}
object arg = Request.Form["arg"];
var box = SandboxManager.Create(null);
box.Inject(checksum, arg, raw);
}
break;
case TunnelCommand.KeepAlive:
{
var httpFile = Request.Files[AgentChecksum];
if (httpFile == null)
{
this.ResponseForbidden(context);
}
var crypto = CreateCrypto(agentCredential);
var outStream = crypto.Decrypt(httpFile.InputStream);
string checksum = Encoding.UTF8.GetString(outStream.ToArray());
IPAddress LAN_addr = IPAddress.Parse(checksum),
WAN_addr = IPAddress.Parse(Request.UserHostAddress);
Guid deviceID = OnlineUsers.SignIn(agentCredential, WAN_addr, LAN_addr);
App.LogInfo(string.Format("SignIn: WAN={0}, LAN={1}", WAN_addr, LAN_addr));
try
{
var user = OnlineUsers.GetUser(agentCredential);
this.KeepAlive(context, user, ref deviceID);
}
finally
{
OnlineUsers.SignOut(agentCredential, deviceID);
App.LogInfo(string.Format("SignOut: WAN={0}, LAN={1}", WAN_addr, LAN_addr));
}
}
break;
case TunnelCommand.Receive:
{
//用户在线
var user = OnlineUsers.GetUser(agentCredential);
Guid sock;
IPEndPoint destIpe;
this.CheckSocks(context, out sock, out destIpe);
CheckReverseResult checkResult;
Guid deviceID, remoteID_LocalSock;
if ((checkResult = this.CheckReverse(context, out deviceID, out remoteID_LocalSock)) != CheckReverseResult.None)
{
try
{
switch (checkResult)
{
case CheckReverseResult.Connect:
var q = from t in user.Principal
where t.ID == deviceID
select new IPEndPoint(t.WAN, IPEndPoint.MinPort);
var localIpe = q.Single();
OnlineUsers.ReverseConnect(sock, localIpe, remoteID_LocalSock, destIpe);
var dataQueue = OnlineUsers.GetReverseQueue(sock, false);
//30秒超时时间
dataQueue.WaitHandle.WaitOne(30 * 1000);
if (!dataQueue.Connected)
{
App.LogInfo("ProxyClient connect {0} error", destIpe);
this.ResponseForbidden(context, HttpStatusCode.BadGateway);
}
break;
default:
OnlineUsers.ReverseShakeHands(remoteID_LocalSock, sock);
break;
}
this.ReverseDirectReceive(context, ref sock);
}
finally
{
OnlineUsers.ReverseDisconnect(sock);
}
}
else
{
try
{
var proxyClient = user.Connect(sock, destIpe);
this.DirectReceive(context, proxyClient);
}
catch (SocketException ex)
{
App.LogError(ex, "ProxyClient connect {0} error", destIpe);
this.ResponseForbidden(context, HttpStatusCode.BadGateway);
}
finally
{
user.Disconnect(sock);
}
}
}
break;
case TunnelCommand.Send:
{
//用户在线，30秒超时时间
var user = OnlineUsers.GetUser(agentCredential);
Guid sock;
IPEndPoint destIpe;
this.CheckSocks(context, out sock, out destIpe);
Guid deviceID, remoteID_LocalSock;
if (this.CheckReverse(context, out deviceID, out remoteID_LocalSock) != CheckReverseResult.None)
{
if (!App.Retry(() =>
{
var dataQueue = OnlineUsers.GetReverseQueue(sock, true, false);
return(dataQueue != null && dataQueue.Connected);
}, 250, 120))
{
this.ResponseForbidden(context, HttpStatusCode.GatewayTimeout);
}
this.ReverseDirectSend(context, ref sock);
}
else
{
TcpClient proxyClient = null;
if (!App.Retry(() => (proxyClient = user.GetClient(sock, false)) != null, 250, 120))
{
this.ResponseForbidden(context, HttpStatusCode.GatewayTimeout);
}
this.DirectSend(context, proxyClient);
}
}
break;
case TunnelCommand.DeviceIdentity:
{
var user = OnlineUsers.GetUser(agentCredential);
var stream = Serializer.Serialize(user.Principal);
stream.FixedCopyTo(Response.OutputStream);
Response.Flush();
}
break;
case TunnelCommand.UdpSend:
{
var user = OnlineUsers.GetUser(agentCredential);
Guid sock;
IPEndPoint destIpe;
this.CheckSocks(context, out sock, out destIpe);
var proxyClient = user.GetUdpClient(sock);
this.UdpDirectSend(context, proxyClient, destIpe);
}
break;
case TunnelCommand.UdpReceive:
{
var user = OnlineUsers.GetUser(agentCredential);
Guid sock;
IPEndPoint destIpe;
this.CheckSocks(context, out sock, out destIpe);
UdpClient proxyClient = null;
if (!App.Retry(() => user.HasUdpClient(sock, out proxyClient), 250, 120))
{
this.ResponseForbidden(context, HttpStatusCode.GatewayTimeout);
}
this.UdpDirectReceive(context, proxyClient);
}
break;
default:
this.OnProcess(context);
break;
}
Response.End();
}
private SandboxManager GetSandboxManager()
{
if (sandboxManager == null)
sandboxManager = FindObjectOfType<SandboxManager>();
return sandboxManager;
}
static void GameManager_DestroySandboxManager_Prefix() => sbm = GameManager.m_SandboxManager;
