private static void CreateInstanceLogger()
{
ToastServiceZone zone;
switch (GamebaseUnitySDK.ZoneType.ToLower())
{
case "alpha":
{
zone = ToastServiceZone.ALPHA;
break;
}
case "beta":
{
zone = ToastServiceZone.BETA;
break;
}
default:
{
zone = ToastServiceZone.REAL;
break;
}
}
logger = new InstanceLogger(stability.appKey, zone);
}
private static void SkinDefApply(Action <SkinDef, GameObject> orig, SkinDef self, GameObject modelObject)
{
orig(self, modelObject);
try
{
RemoveInvalidModelObjects();
appliedModificatons.TryGetValue(modelObject, out var modificatons);
if (self != SkinDef)
{
if (modificatons != null)
{
appliedModificatons.Remove(modelObject);
ClearSkinModifications(modificatons);
}
return;
}
if (modificatons == null)
{
appliedModificatons[modelObject] = ApplySkinModifications(modelObject);
}
}
catch (Exception e)
{
InstanceLogger.LogWarning("An error occured while adding accessories to a Mercenary2B skin");
InstanceLogger.LogError(e);
}
}
public static void Main(string[] args)
{
var settings = new AcmeSettings()
{
EmailAddress = "*****@*****.**",
StorageLocation = LagoVista.Net.LetsEncrypt.Interfaces.StorageLocation.FileSystem,
//StorageLocation = LagoVista.Net.LetsEncrypt.Interfaces.StorageLocation.BlobStorage,
StorageAccountName = "nuviotdev",
StorageContainerName = "tempcert",
StorageKey = "Za6PpxUbXjXic8rhK3lbcWyUQyVY2NVsgXRRD1rVj2LAjXUnji5/ooJx7u0ob9cPKTkPu/woa74DBE6IVKsLQA==",
Development = true,
Diagnostics = true,
PfxPassword = "******",
StoragePath = @"L:\Certs"
};
var acmeHost = new WebHostBuilder()
.ConfigureLogging((factory) =>
{
factory.AddConsole();
})
.ConfigureServices(services => services.AddAcmeCertificateManager(settings))
// .UseUrls("http://*:8008/.well-known/acme-challenge/")
.UseUrls("http://*:8008")
.Configure(app => app.UseAcmeResponse())
.UseKestrel()
.Build();
acmeHost.Start();
var host = new WebHostBuilder()
.ConfigureLogging((factory) =>
{
factory.AddConsole();
})
.UseStartup <Startup>()
.ConfigureServices(services => services.AddAcmeCertificateManager(settings))
.UseKestrel(async(options) =>
{
// Request a new certificate with Let's Encrypt and store it for next time
var certificateManager = options.ApplicationServices.GetService(typeof(ICertificateManager)) as ICertificateManager;
var instanceLogger = new InstanceLogger(new LogWriter(), "host", "1.0", "instance");
var certificate = await certificateManager.GetCertificate(instanceLogger, URI);
if (certificate != null)
{
options.Listen(IPAddress.Loopback, 443,
listenOptions =>
{
listenOptions.UseHttps(certificate);
});
}
})
.UseContentRoot(Directory.GetCurrentDirectory())
//.UseUrls($"https://{URI}:9001")
.UseApplicationInsights()
.Build();
host.Run();
}
public HttpServer(HttpServerSettings settings, InstanceLogger logger)
{
this.setttings = settings;
server = new TcpServer(settings.TcpSettings);
bindToServer();
this.logger = logger;
}
/// <inheritdoc/>
public InstancePack CreateInstance(InstanceLogger logger, InstanceType type)
{
IInstance instance;
switch (type)
{
case InstanceType.Server:
instance = createServer();
break;
case InstanceType.Client:
instance = createClient();
break;
default:
instance = createProxy();
break;
}
if (instance == null)
{
throw new SetupAbortedByUserException();
}
// for now set manual driver to everything
var view = new DefaultInstanceView();
var cont = new DefaultInstanceController(view, instance, logger, loader);
view.SetController(cont);
return(new InstancePack(view, cont, type));
}
/// <summary>
/// Initializes controller with active instance and custom channel view factory.
/// </summary>
/// <param name="view"></param>
/// <param name="instance"></param>
/// <param name="logger"></param>
/// <param name="detailFactory"></param>
public DefaultInstanceController(IInstanceView view, IInstance instance, InstanceLogger logger, IChannelViewFactory detailFactory)
{
this.view = view;
this.instance = instance;
view.SetInstance(instance);
if (this.instance is IClient)
{
((IClient)this.instance).ChannelCreated += handleConnectionCreated;
}
else if (this.instance is IServer)
{
((IServer)this.instance).ChannelCreated += handleConnectionCreated;
}
else if (this.instance is IProxy)
{
((IProxy)this.instance).ChannelCreated += handleConnectionCreated;
}
this.logger = logger;
this.view.SetLogger(logger);
this.detailFactory = detailFactory;
this.Active = true;
this.instanceName = logger.ReadInstanceName();
}
/// <inheritdoc/>
public InstancePack CreateInstance(InstanceLogger logger, InstanceType type)
{
IInstance instance;
switch (type)
{
case InstanceType.Server:
instance = createServer(logger);
break;
case InstanceType.Client:
instance = createClient(logger);
break;
default:
instance = createProxy(logger);
break;
}
if (instance == null)
{
throw new SetupAbortedByUserException();
}
var view = new DefaultInstanceView();
var cont = new DefaultInstanceController(view, instance, logger, createChannelViewFactory());
view.SetController(cont);
return(new InstancePack(view, cont, type));
}
/// <inheritdoc/>
public InstancePack RestoreInstance(InstanceLogger logger)
{
var view = new DefaultInstanceView();
var cont = new DefaultInstanceController(view, logger, loader);
view.SetController(cont);
return(new InstancePack(view, cont, cont.GetInstanceType()));
}
internal bool Contains(string key)
{
var ret = _plugin.Contains(key);
InstanceLogger.Log(this, "Contains", key, ret);
return(ret);
}
public HttpClient(HttpClientSettings settings, InstanceLogger logger)
{
this.setttings = settings;
client = new TcpClient(settings.TcpSettings);
client.ChannelCreated += channelCreatedHandler;
client.ErrorOccured += client_ErrorOccured;
this.logger = logger;
}
internal IList <T> Get <T>()
{
var list = _plugin.Get <T>();
InstanceLogger.Log(this, "Get", list);
return(list);
}
internal object GetData(string key)
{
var ret = _plugin.GetData(key);
InstanceLogger.Log(this, "GetData", key, ret);
return(ret);
}
internal void SetLogger(InstanceLogger logger)
{
if (this.logger != null)
{
throw new InvalidOperationException("Logger already set!");
}
this.logger = logger;
}
internal bool Exists(string container, string identifier)
{
var ret = _plugin.Exists(container, identifier);
InstanceLogger.Log(this, "Exists", container, identifier, ret);
return(ret);
}
internal T1 Translate <T, T1>(T p0, T1 obj1)
{
var ret = _plugin.Translate(p0, obj1);
InstanceLogger.Log(this, "Translate", typeof(T).Name, p0, typeof(T1).Name, ret);
return(ret);
}
internal IEnumerable <string> List(string container)
{
var ret = _plugin.List(container);
InstanceLogger.Log(this, "List", container, ret);
return(ret);
}
internal IList <T> Get <T>(object example)
{
var list = _plugin.Get <T>(example);
InstanceLogger.Log(this, "Get", example, list);
return(list);
}
/// <inheritdoc/>
public InstancePack RestoreInstance(InstanceLogger logger)
{
var view = new DefaultInstanceView();
var cont = new DefaultInstanceController(view, logger, createChannelViewFactory(true));
view.SetController(cont);
return(new InstancePack(view, cont, cont.GetInstanceType()));
}
internal List <string> GetMessages <T>(T entity)
{
var ret = _plugin.Validate(entity);
InstanceLogger.Log(this, "GetMessages", entity, ret);
return(ret);
}
public BaseWebSocket(InstanceLogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
dataBuilder = new ThresholdedDataBuilder(logger);
}
/// <summary>
/// Returns resulting IDataStream, the builder cannot be used anymore after calling this method.
/// </summary>
/// <returns></returns>
public IDataStream Close()
{
logger = null;
if (length >= threshold)
{
return(fileBuilder.Close());
}
list.Freeze();
return(list);
}
public HttpMessageParser(InstanceLogger logger, bool isResponse)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.logger = logger;
this.isResponse = isResponse;
dataBuilder = new ThresholdedDataBuilder(logger);
}
internal void Register <T, T1>() where T1 : T
{
if (!typeof(T).IsInterface)
{
throw new NotInterfaceException();
}
_plugin.Register <T, T1>();
InstanceLogger.Log(this, "Register", typeof(T).Name, typeof(T1).Name);
}
internal void IsValid <T>(T entity)
{
var messages = _plugin.Validate(entity);
InstanceLogger.Log(this, "IsValid", entity, messages);
if (messages.Count != 0)
{
throw new InvalidEntityException(messages.ToArray());
}
}
/// <summary>
/// Initializes controller with logged instance and custom channel view factory.
/// </summary>
/// <param name="view"></param>
/// <param name="logger"></param>
/// <param name="detailFactory"></param>
public DefaultInstanceController(IInstanceView view, InstanceLogger logger, IChannelViewFactory detailFactory)
{
this.view = view;
instance = logger.ReadInstanceData();
view.SetInstance(instance);
view.SetLogger(logger);
this.logger = logger;
this.detailFactory = detailFactory;
this.Active = false;
this.instanceName = logger.ReadInstanceName();
}
/// <inheritdoc/>
public InstancePack CreateInstance(InstanceLogger logger, InstanceType type, object settings)
{
IInstance instance;
if (settings == null)
{
throw new ArgumentNullException("settings");
}
switch (type)
{
case InstanceType.Server:
var s = settings as HttpServerSettings;
if (s == null)
{
throw new InvalidSettingsTypeException();
}
instance = new HttpServer(s, logger);
break;
case InstanceType.Client:
var c = settings as HttpClientSettings;
if (c == null)
{
throw new InvalidSettingsTypeException();
}
instance = new HttpClient(c, logger);
break;
default:
var p = settings as DefaultProxySettings;
if (p == null)
{
throw new InvalidSettingsTypeException();
}
var srv = p.Server as HttpServer;
if (srv != null)
{
srv.SetLogger(logger);
}
var factory = p.ClientFactory as HttpClientFactory;
if (factory != null)
{
factory.SetLogger(logger);
}
instance = new DefaultProxy(p);
break;
}
var view = new DefaultInstanceView();
var cont = new DefaultInstanceController(view, instance, logger, createChannelViewFactory());
view.SetController(cont);
return(new InstancePack(view, cont, type));
}
public WebSocketClientChannel(IClientChannel innerChannel, InstanceLogger logger)
{
this.id = innerChannel.ID;
this.name = innerChannel.Name;
this.innerChannel = innerChannel;
innerChannel.ChannelClosed += innerChannel_ChannelClosed;
innerChannel.ErrorOccured += innerChannel_ErrorOccured;
innerChannel.ResponseReceived += innerChannel_ResponseReceived;
innerChannel.RequestSent += innerChannel_RequestSent;
webSocket = new BaseWebSocket(logger);
webSocket.MessageParsed += webSocket_MessageParsed;
}
private static SkillFamily[] ExtendSurvivor(SurvivorDef survivorDef)
{
var survivorName = survivorDef.displayNameToken;
try
{
var bodyPrefab = survivorDef.bodyPrefab;
if (bodyPrefab.GetComponent <ExtraSkillLocator>())
{
return(Array.Empty <SkillFamily>());
}
var skillMap = new SkillMapConfigSection(Instance.Config, english.GetLocalizedStringByToken(survivorDef.displayNameToken));
var skillLocator = bodyPrefab.GetComponent <SkillLocator>();
var extraSkillLocator = bodyPrefab.AddComponent <ExtraSkillLocator>();
extraSkillLocator.extraFirst = CopySkill(bodyPrefab, survivorName, "First", skillLocator.primary, skillMap.FirstRowSkills.Value);
extraSkillLocator.extraSecond = CopySkill(bodyPrefab, survivorName, "Second", skillLocator.secondary, skillMap.SecondRowSkills.Value);
extraSkillLocator.extraThird = CopySkill(bodyPrefab, survivorName, "Third", skillLocator.utility, skillMap.ThirdRowSkills.Value);
extraSkillLocator.extraFourth = CopySkill(bodyPrefab, survivorName, "Fourth", skillLocator.special, skillMap.FourthRowSkills.Value);
var families = new List <SkillFamily>();
if (extraSkillLocator.extraFirst)
{
families.Add(extraSkillLocator.extraFirst.skillFamily);
}
if (extraSkillLocator.extraSecond)
{
families.Add(extraSkillLocator.extraSecond.skillFamily);
}
if (extraSkillLocator.extraThird)
{
families.Add(extraSkillLocator.extraThird.skillFamily);
}
if (extraSkillLocator.extraFourth)
{
families.Add(extraSkillLocator.extraFourth.skillFamily);
}
return(families.ToArray());
}
catch (Exception e)
{
InstanceLogger.LogWarning($"Failed adding extra skill slots for \"{survivorName}\"");
InstanceLogger.LogError(e);
}
return(Array.Empty <SkillFamily>());
}
private async Task LogBody(string fmtText, HttpContent content)
{
// This buffers the body content within the HttpContent if required.
var bodyBytes = content != null ? await content.ReadAsByteArrayAsync().ConfigureAwait(false) : new byte[0];
char[] bodyChars = new char[bodyBytes.Length];
for (int i = 0; i < bodyBytes.Length; i++)
{
var b = bodyBytes[i];
bodyChars[i] = b >= 32 && b <= 126 ? (char)b : '.';
}
InstanceLogger.Debug(fmtText, new string(bodyChars));
}
internal T Resolve <T>()
{
if (!typeof(T).IsInterface)
{
throw new NotInterfaceException();
}
var ret = _plugin.Resolve <T>();
InstanceLogger.Log(this, "Resolve", typeof(T).Name, ret.GetType().Name);
return(ret);
}
