public static ITriggerBindingProvider Create(INameResolver nameResolver,
IStorageAccountProvider storageAccountProvider,
IExtensionTypeLocator extensionTypeLocator,
IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
IContextSetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
IContextSetter<IBlobWrittenWatcher> blobWrittenWatcherSetter,
ISharedContextProvider sharedContextProvider,
IExtensionRegistry extensions,
SingletonManager singletonManager,
TraceWriter trace)
{
List<ITriggerBindingProvider> innerProviders = new List<ITriggerBindingProvider>();
innerProviders.Add(new QueueTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
queueConfiguration, backgroundExceptionDispatcher, messageEnqueuedWatcherSetter,
sharedContextProvider, trace));
innerProviders.Add(new BlobTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
extensionTypeLocator, hostIdProvider, queueConfiguration, backgroundExceptionDispatcher,
blobWrittenWatcherSetter, messageEnqueuedWatcherSetter, sharedContextProvider, singletonManager, trace));
// add any registered extension binding providers
foreach (ITriggerBindingProvider provider in extensions.GetExtensions(typeof(ITriggerBindingProvider)))
{
innerProviders.Add(provider);
}
return new CompositeTriggerBindingProvider(innerProviders);
}
public SingletonListener(MethodInfo method, SingletonAttribute attribute, SingletonManager singletonManager, IListener innerListener)
{
_method = method;
_attribute = attribute;
_singletonManager = singletonManager;
_innerListener = innerListener;
}
public async Task CreateAsync_SkipsDisabledFunctions(Type jobType, string methodName)
{
Environment.SetEnvironmentVariable("EnvironmentSettingTrue", "True");
Mock<IFunctionDefinition> mockFunctionDefinition = new Mock<IFunctionDefinition>();
Mock<IFunctionInstanceFactory> mockInstanceFactory = new Mock<IFunctionInstanceFactory>(MockBehavior.Strict);
Mock<IListenerFactory> mockListenerFactory = new Mock<IListenerFactory>(MockBehavior.Strict);
SingletonManager singletonManager = new SingletonManager();
TestTraceWriter traceWriter = new TestTraceWriter(TraceLevel.Verbose);
// create a bunch of function definitions that are disabled
List<FunctionDefinition> functions = new List<FunctionDefinition>();
FunctionDescriptor descriptor = new FunctionDescriptor
{
Method = jobType.GetMethod(methodName, BindingFlags.Public | BindingFlags.Static),
ShortName = string.Format("{0}.{1}", jobType.Name, methodName)
};
FunctionDefinition definition = new FunctionDefinition(descriptor, mockInstanceFactory.Object, mockListenerFactory.Object);
functions.Add(definition);
// Create the composite listener - this will fail if any of the
// function definitions indicate that they are not disabled
HostListenerFactory factory = new HostListenerFactory(functions, singletonManager, DefaultJobActivator.Instance, null, traceWriter);
IListener listener = await factory.CreateAsync(CancellationToken.None);
Assert.Equal(1, traceWriter.Traces.Count);
Assert.Equal(TraceLevel.Info, traceWriter.Traces[0].Level);
Assert.Equal(TraceSource.Host, traceWriter.Traces[0].Source);
Assert.Equal(string.Format("Function '{0}' is disabled", descriptor.ShortName), traceWriter.Traces[0].Message);
Environment.SetEnvironmentVariable("EnvironmentSettingTrue", null);
}
public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager();
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, _attribute.Scope);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public SingletonValueProviderTests()
{
_attribute = new SingletonAttribute("TestScope");
SingletonManager singletonManager = new SingletonManager(null, null, null, null, new FixedHostIdProvider(TestHostId));
_method = GetType().GetMethod("TestJob", BindingFlags.Static | BindingFlags.Public);
_lockId = SingletonManager.FormatLockId(_method, SingletonScope.Function, TestHostId, _attribute.ScopeId);
_valueProvider = new SingletonValueProvider(_method, "TestScope", TestInstanceId, _attribute, singletonManager);
}
public HostListenerFactory(IEnumerable<IFunctionDefinition> functionDefinitions, SingletonManager singletonManager, IJobActivator activator, INameResolver nameResolver, TraceWriter trace)
{
_functionDefinitions = functionDefinitions;
_singletonManager = singletonManager;
_activator = activator;
_nameResolver = nameResolver;
_trace = trace;
}
public FunctionIndexProvider(ITypeLocator typeLocator,
ITriggerBindingProvider triggerBindingProvider,
IBindingProvider bindingProvider,
IJobActivator activator,
IFunctionExecutor executor,
IExtensionRegistry extensions,
SingletonManager singletonManager,
TraceWriter trace)
{
if (typeLocator == null)
{
throw new ArgumentNullException("typeLocator");
}
if (triggerBindingProvider == null)
{
throw new ArgumentNullException("triggerBindingProvider");
}
if (bindingProvider == null)
{
throw new ArgumentNullException("bindingProvider");
}
if (activator == null)
{
throw new ArgumentNullException("activator");
}
if (executor == null)
{
throw new ArgumentNullException("executor");
}
if (extensions == null)
{
throw new ArgumentNullException("extensions");
}
if (singletonManager == null)
{
throw new ArgumentNullException("singletonManager");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
_typeLocator = typeLocator;
_triggerBindingProvider = triggerBindingProvider;
_bindingProvider = bindingProvider;
_activator = activator;
_executor = executor;
_extensions = extensions;
_singletonManager = singletonManager;
_trace = trace;
}
public SingletonListener(MethodInfo method, SingletonAttribute attribute, SingletonManager singletonManager, IListener innerListener)
{
_attribute = attribute;
_singletonManager = singletonManager;
_singletonConfig = _singletonManager.Config;
_innerListener = innerListener;
string boundScopeId = _singletonManager.GetBoundScopeId(_attribute.ScopeId);
_lockId = singletonManager.FormatLockId(method, _attribute.Scope, boundScopeId);
_lockId += ".Listener";
}
public void ToInvokeString_ReturnsExpectedValue()
{
SingletonManager singletonManager = new SingletonManager(null, null, null, null, new FixedHostIdProvider(TestHostId));
SingletonAttribute attribute = new SingletonAttribute();
SingletonValueProvider localValueProvider = new SingletonValueProvider(_method, attribute.ScopeId, TestInstanceId, attribute, singletonManager);
SingletonLock singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal("ScopeId: default", localValueProvider.ToInvokeString());
attribute = new SingletonAttribute(@"{Region}\{Zone}");
localValueProvider = new SingletonValueProvider(_method, @"Central\3", TestInstanceId, attribute, singletonManager);
singletonLock = (SingletonLock)localValueProvider.GetValue();
Assert.Equal(@"ScopeId: Central\3", localValueProvider.ToInvokeString());
}
public static FunctionIndexer Create(CloudStorageAccount account = null, INameResolver nameResolver = null, IExtensionRegistry extensionRegistry = null)
{
Mock<IServiceProvider> services = new Mock<IServiceProvider>(MockBehavior.Strict);
StorageClientFactory clientFactory = new StorageClientFactory();
services.Setup(p => p.GetService(typeof(StorageClientFactory))).Returns(clientFactory);
IStorageAccount storageAccount = account != null ? new StorageAccount(account, services.Object) : null;
IStorageAccountProvider storageAccountProvider = new SimpleStorageAccountProvider(services.Object)
{
StorageAccount = account
};
IExtensionTypeLocator extensionTypeLocator = new NullExtensionTypeLocator();
ContextAccessor<IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor =
new ContextAccessor<IMessageEnqueuedWatcher>();
ContextAccessor<IBlobWrittenWatcher> blobWrittenWatcherAccessor =
new ContextAccessor<IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
TestTraceWriter logger = new TestTraceWriter(TraceLevel.Verbose);
SingletonManager singletonManager = new SingletonManager();
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator,
new FixedHostIdProvider("test"), new SimpleQueueConfiguration(maxDequeueCount: 5),
BackgroundExceptionDispatcher.Instance, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor,
sharedContextProvider, new DefaultExtensionRegistry(), singletonManager, logger);
IBindingProvider bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider,
extensionTypeLocator, messageEnqueuedWatcherAccessor,
blobWrittenWatcherAccessor, new DefaultExtensionRegistry());
TraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
IFunctionOutputLoggerProvider outputLoggerProvider = new NullFunctionOutputLoggerProvider();
IFunctionOutputLogger outputLogger = outputLoggerProvider.GetAsync(CancellationToken.None).Result;
IFunctionExecutor executor = new FunctionExecutor(new NullFunctionInstanceLogger(), outputLogger, BackgroundExceptionDispatcher.Instance, trace, null);
if (extensionRegistry == null)
{
extensionRegistry = new DefaultExtensionRegistry();
}
return new FunctionIndexer(triggerBindingProvider, bindingProvider, DefaultJobActivator.Instance, executor, extensionRegistry, new SingletonManager(), trace);
}
public SingletonManagerTests()
{
_mockAccountProvider = new Mock<IStorageAccountProvider>(MockBehavior.Strict);
_mockBlobDirectory = new Mock<IStorageBlobDirectory>(MockBehavior.Strict);
_mockSecondaryBlobDirectory = new Mock<IStorageBlobDirectory>(MockBehavior.Strict);
_mockStorageAccount = new Mock<IStorageAccount>(MockBehavior.Strict);
_mockSecondaryStorageAccount = new Mock<IStorageAccount>(MockBehavior.Strict);
Mock<IStorageBlobClient> mockBlobClient = new Mock<IStorageBlobClient>(MockBehavior.Strict);
Mock<IStorageBlobClient> mockSecondaryBlobClient = new Mock<IStorageBlobClient>(MockBehavior.Strict);
Mock<IStorageBlobContainer> mockBlobContainer = new Mock<IStorageBlobContainer>(MockBehavior.Strict);
mockBlobContainer.Setup(p => p.GetDirectoryReference(HostDirectoryNames.SingletonLocks)).Returns(_mockBlobDirectory.Object);
mockBlobClient.Setup(p => p.GetContainerReference(HostContainerNames.Hosts)).Returns(mockBlobContainer.Object);
Mock<IStorageBlobContainer> mockSecondaryBlobContainer = new Mock<IStorageBlobContainer>(MockBehavior.Strict);
mockSecondaryBlobContainer.Setup(p => p.GetDirectoryReference(HostDirectoryNames.SingletonLocks)).Returns(_mockSecondaryBlobDirectory.Object);
mockSecondaryBlobClient.Setup(p => p.GetContainerReference(HostContainerNames.Hosts)).Returns(mockSecondaryBlobContainer.Object);
_mockStorageAccount.Setup(p => p.CreateBlobClient(null)).Returns(mockBlobClient.Object);
_mockSecondaryStorageAccount.Setup(p => p.CreateBlobClient(null)).Returns(mockSecondaryBlobClient.Object);
_mockAccountProvider.Setup(p => p.GetAccountAsync(ConnectionStringNames.Storage, It.IsAny<CancellationToken>()))
.ReturnsAsync(_mockStorageAccount.Object);
_mockAccountProvider.Setup(p => p.GetAccountAsync(Secondary, It.IsAny<CancellationToken>()))
.ReturnsAsync(_mockSecondaryStorageAccount.Object);
_mockExceptionDispatcher = new Mock<IBackgroundExceptionDispatcher>(MockBehavior.Strict);
_mockStorageBlob = new Mock<IStorageBlockBlob>(MockBehavior.Strict);
_mockBlobMetadata = new Dictionary<string, string>();
_mockBlobDirectory.Setup(p => p.GetBlockBlobReference(TestLockId)).Returns(_mockStorageBlob.Object);
_singletonConfig = new SingletonConfiguration();
// use reflection to bypass the normal validations (so tests can run fast)
TestHelpers.SetField(_singletonConfig, "_lockAcquisitionPollingInterval", TimeSpan.FromMilliseconds(25));
TestHelpers.SetField(_singletonConfig, "_lockPeriod", TimeSpan.FromMilliseconds(500));
_singletonConfig.LockAcquisitionTimeout = TimeSpan.FromMilliseconds(200);
_nameResolver = new TestNameResolver();
_singletonManager = new SingletonManager(_mockAccountProvider.Object, _mockExceptionDispatcher.Object, _singletonConfig, _trace, new FixedHostIdProvider(TestHostId), _nameResolver);
_singletonManager.MinimumLeaseRenewalInterval = TimeSpan.FromMilliseconds(250);
}
public SingletonManagerTests()
{
_mockBlobDirectory = new Mock<IStorageBlobDirectory>(MockBehavior.Strict);
Mock<IStorageBlobClient> mockBlobClient = new Mock<IStorageBlobClient>(MockBehavior.Strict);
Mock<IStorageBlobContainer> mockBlobContainer = new Mock<IStorageBlobContainer>(MockBehavior.Strict);
mockBlobContainer.Setup(p => p.GetDirectoryReference(HostDirectoryNames.SingletonLocks)).Returns(_mockBlobDirectory.Object);
mockBlobClient.Setup(p => p.GetContainerReference(HostContainerNames.Hosts)).Returns(mockBlobContainer.Object);
_mockExceptionDispatcher = new Mock<IBackgroundExceptionDispatcher>(MockBehavior.Strict);
_mockStorageBlob = new Mock<IStorageBlockBlob>(MockBehavior.Strict);
_mockBlobMetadata = new Dictionary<string, string>();
_mockBlobDirectory.Setup(p => p.GetBlockBlobReference(TestLockId)).Returns(_mockStorageBlob.Object);
_singletonConfig = new SingletonConfiguration();
// use reflection to bypass the normal validations (so tests can run fast)
TestHelpers.SetField(_singletonConfig, "_lockAcquisitionPollingInterval", TimeSpan.FromMilliseconds(25));
TestHelpers.SetField(_singletonConfig, "_lockPeriod", TimeSpan.FromMilliseconds(500));
_singletonConfig.LockAcquisitionTimeout = TimeSpan.FromMilliseconds(200);
_singletonManager = new SingletonManager(mockBlobClient.Object, _mockExceptionDispatcher.Object, _singletonConfig, _trace);
_singletonManager.MinimumLeaseRenewalInterval = TimeSpan.FromMilliseconds(250);
}
private void Awake()
{
SingletonManager.Register <ActionMana>(this, SingletonType.Occasional);
}
public override void Execute()
{
try
{
SingletonManager.Get <DurationHelp>().ProfileStart(CustomProfilerStep.UserPrediction);
//UserCmd Seq是不通用的，以客户端生成为准，每个客户端不同
foreach (IPlayerUserCmdGetter owner in _handler.UserCmdOwnerList)
{
_currentPlayerUserCmdGetter = owner;
if (!owner.IsEnable())
{
_logger.ErrorFormat("player {0}is destroyed", owner.OwnerEntityKey);
continue;
}
if (owner.UpdateList.Count > 100)
{
_logger.ErrorFormat("!!!!!!!!!!!!!!!!!!!Too Many cmd:{0} {1}", owner.OwnerEntityKey,
owner.UpdateList.Count);
owner.UpdateList.RemoveRange(0, owner.UpdateList.Count - 100);
}
int executeCount = 0;
//一次updatePackage代表一次UserCmd
foreach (UpdateLatestPacakge updatePackage in owner.UpdateList)
{
try
{
_syncToEntityProfile.BeginProfileOnlyEnableProfile();
_syncUpdateLatestMsgHandler.SyncToEntity(_currentPlayerUserCmdGetter, updatePackage);
}
finally
{
_syncToEntityProfile.EndProfileOnlyEnableProfile();
}
//实际UserCmd只有一次而已
foreach (var userCmd in owner.UserCmdList)
{
_currentCmd = userCmd;
if (_currentCmd.Seq != owner.LastCmdSeq + 1)
{
_logger.ErrorFormat("{2} lost user cmd last {0}, cur {1}", owner.LastCmdSeq,
_currentCmd.Seq, owner.OwnerEntityKey);
}
_logger.DebugFormat("processing user cmd {0}", _currentCmd);
try
{
_filtedInputProfile.BeginProfileOnlyEnableProfile();
userCmd.FilteredInput = owner.GetFiltedInput(userCmd);
}
finally
{
_filtedInputProfile.EndProfileOnlyEnableProfile();
}
// _logger.InfoFormat("{0} execute cmd {1} ", update.Head.UserCmdSeq, userCmd.Seq);
ExecuteSystems();
userCmd.FilteredInput = null;
owner.LastCmdSeq = userCmd.Seq;
}
owner.LastestExecuteUserCmdSeq = updatePackage.Head.LastUserCmdSeq;
executeCount++;
if (executeCount > MaxEcecutePreFrame)
{
break;
}
}
}
}
finally
{
SingletonManager.Get <DurationHelp>().ProfileEnd(CustomProfilerStep.UserPrediction);
}
}
public BlobListenerFactory(IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
IWebJobsExceptionHandler exceptionHandler,
IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
TraceWriter trace,
string functionId,
IStorageAccount hostAccount,
IStorageAccount dataAccount,
IStorageBlobContainer container,
IBlobPathSource input,
ITriggeredFunctionExecutor executor,
SingletonManager singletonManager)
{
if (hostIdProvider == null)
{
throw new ArgumentNullException("hostIdProvider");
}
if (queueConfiguration == null)
{
throw new ArgumentNullException("queueConfiguration");
}
if (exceptionHandler == null)
{
throw new ArgumentNullException("exceptionHandler");
}
if (blobWrittenWatcherSetter == null)
{
throw new ArgumentNullException("blobWrittenWatcherSetter");
}
if (messageEnqueuedWatcherSetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherSetter");
}
if (sharedContextProvider == null)
{
throw new ArgumentNullException("sharedContextProvider");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
if (hostAccount == null)
{
throw new ArgumentNullException("hostAccount");
}
if (dataAccount == null)
{
throw new ArgumentNullException("dataAccount");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
if (input == null)
{
throw new ArgumentNullException("input");
}
if (executor == null)
{
throw new ArgumentNullException("executor");
}
if (singletonManager == null)
{
throw new ArgumentNullException("singletonManager");
}
_hostIdProvider = hostIdProvider;
_queueConfiguration = queueConfiguration;
_exceptionHandler = exceptionHandler;
_blobWrittenWatcherSetter = blobWrittenWatcherSetter;
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter;
_sharedContextProvider = sharedContextProvider;
_trace = trace;
_functionId = functionId;
_hostAccount = hostAccount;
_dataAccount = dataAccount;
_container = container;
_input = input;
_executor = executor;
_singletonManager = singletonManager;
}
public ServerRoom Create(RequestCreateRoomMessage message)
{
_logger.InfoFormat("Handle CreateRoom Message");
var contextsServerWrapper = new ContextsServerWrapper(_contexts, _assetMananger, _coRouitneManager);
var serverRoom = new ServerRoom(new RoomId(1), contextsServerWrapper, _dispatcher, _tokenGenerator);
ResetEventDispacther();
if (message != null)
{
HallRoom hallRoom = new HallRoom(_dispatcher, _contexts);
hallRoom.HallRoomId = message.HallRoomId;
hallRoom.ModeId = message.ModeId;
hallRoom.TeamCapacity = message.TeamCapacity;
hallRoom.MapId = message.MapId;
hallRoom.RevivalTime = message.RevivalTime;
hallRoom.MultiAngleStatus = message.MultiAngleStatus;
hallRoom.WatchStatus = message.WatchStatus;
hallRoom.HelpStatus = message.HelpStatus;
hallRoom.HasFriendHarm = message.HasFriendHarm;
hallRoom.WaitTimeNum = message.WaitTimeNum;
hallRoom.OverTime = message.OverTime;
hallRoom.ConditionValue = message.ConditionValue;
hallRoom.ConditionType = message.ConditionType;
hallRoom.ChannelName = message.ChannelName;
hallRoom.RoomName = message.CustomRoomName;
hallRoom.RoomCapacity = message.CustomRoomCapacity;
hallRoom.RoomDisplayId = (int)message.CustomRoomDisplayId;
hallRoom.AllowReConnect = message.AllowReConnect;
hallRoom.Init();
serverRoom.SetHallRoom(hallRoom);
serverRoom.SetRoomInfo(hallRoom);
serverRoom.SetGameMode(message.ModeId, message.MapId);
_logger.InfoFormat("Create Room {0}", message);
}
else
{
HallRoom hallRoom = new DummyHallRoom(_dispatcher, _contexts);
serverRoom.SetGameMode(RuleMap.GetRuleId(SingletonManager.Get <ServerFileSystemConfigManager>().BootConfig.Rule), SingletonManager.Get <ServerFileSystemConfigManager>().BootConfig.MapId);
//hallRoom.Init(); //本地测试无需发战报
serverRoom.SetHallRoom(hallRoom);
}
return(serverRoom);
}
public IList <SceneRequest> LoadInitialScene()
{
return(SingletonManager.Get <LevelController>().SceneRequest());
}
private void timerCheckReporter_Tick(object sender, System.EventArgs e)
{
SynchronizeBO sbo = (SynchronizeBO)SingletonManager.GetSingleton(typeof(SynchronizeBO));
WriteReport(sbo.Reporter);
}
public static void SetSeed(SeedData data)
{
new DynData <DungeonGenerator2>(SingletonManager.Get <DungeonGenerator2>(false)).Set("randomSeed", data.DungeonSeed);
RandomGenerator.SetSeed(data.RandomGeneratorSeed);
UnityEngine.Random.seed = data.UnityEngineSeed;
}
public void ClientOperation(object config, Action callBack)
{
_callBack = callBack;
SingletonManager.Get <LevelController>().SetConfig(config as LevelConfig);
SingletonManager.Get <LevelController>().AllSceneLoaded = LevelInitDone;
}
private async Task <IReadOnlyDictionary <string, IValueProvider> > BindCoreAsync(ValueBindingContext context, object value, IDictionary <string, object> parameters)
{
Dictionary <string, IValueProvider> valueProviders = new Dictionary <string, IValueProvider>();
IValueProvider triggerProvider;
IReadOnlyDictionary <string, object> bindingData;
try
{
ITriggerData triggerData = await _triggerBinding.BindAsync(value, context);
triggerProvider = triggerData.ValueProvider;
bindingData = triggerData.BindingData;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
triggerProvider = new BindingExceptionValueProvider(_triggerParameterName, exception);
bindingData = null;
}
valueProviders.Add(_triggerParameterName, triggerProvider);
BindingContext bindingContext = new BindingContext(context, bindingData);
// Bind Singleton if specified
SingletonAttribute singletonAttribute = SingletonManager.GetFunctionSingletonOrNull(_descriptor.Method, isTriggered: true);
if (singletonAttribute != null)
{
string boundScopeId = _singletonManager.GetBoundScopeId(singletonAttribute.ScopeId, bindingData);
IValueProvider singletonValueProvider = new SingletonValueProvider(_descriptor.Method, boundScopeId, context.FunctionInstanceId.ToString(), singletonAttribute, _singletonManager);
valueProviders.Add(SingletonValueProvider.SingletonParameterName, singletonValueProvider);
}
foreach (KeyValuePair <string, IBinding> item in _nonTriggerBindings)
{
string name = item.Key;
IBinding binding = item.Value;
IValueProvider valueProvider;
try
{
if (parameters != null && parameters.ContainsKey(name))
{
valueProvider = await binding.BindAsync(parameters[name], context);
}
else
{
valueProvider = await binding.BindAsync(bindingContext);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception exception)
{
valueProvider = new BindingExceptionValueProvider(name, exception);
}
valueProviders.Add(name, valueProvider);
}
return(valueProviders);
}
public FunctionBinding(FunctionDescriptor descriptor, IReadOnlyDictionary<string, IBinding> bindings, SingletonManager singletonManager)
{
_descriptor = descriptor;
_bindings = bindings;
_singletonManager = singletonManager;
}
public TriggeredFunctionBinding(FunctionDescriptor descriptor, string triggerParameterName, ITriggerBinding triggerBinding,
IReadOnlyDictionary <string, IBinding> nonTriggerBindings, SingletonManager singletonManager)
{
_descriptor = descriptor;
_triggerParameterName = triggerParameterName;
_triggerBinding = triggerBinding;
_nonTriggerBindings = nonTriggerBindings;
_singletonManager = singletonManager;
}
public ParachuteStateUiAdapter(Contexts contexts)
{
this.contexts = contexts;
_myTerrain = SingletonManager.Get <TerrainManager>().GetCurrentTerrain();
}
public BoneRigging()
{
_mainInfo = SingletonManager.Get <DurationHelp>().GetCustomProfileInfo("BoneRigging");
}
static void Init()
{
mockFactory = new Mock <IFactory>();
mockLogger = new Mock <ILogger>();
testObject = new SingletonManager(mockLogger.Object, mockFactory.Object);
}
// Do the full runtime intitialization. This includes static initialization.
// This mainly means:
// - indexing the functions
// - spinning up the listeners (so connecting to the services)
public static async Task <JobHostContext> CreateJobHostContextAsync(
this JobHostConfiguration config,
ServiceProviderWrapper services, // Results from first phase
JobHost host,
CancellationToken shutdownToken,
CancellationToken cancellationToken)
{
FunctionExecutor functionExecutor = services.GetService <FunctionExecutor>();
IFunctionIndexProvider functionIndexProvider = services.GetService <IFunctionIndexProvider>();
ITriggerBindingProvider triggerBindingProvider = services.GetService <ITriggerBindingProvider>();
IBindingProvider bindingProvider = services.GetService <IBindingProvider>();
SingletonManager singletonManager = services.GetService <SingletonManager>();
IJobActivator activator = services.GetService <IJobActivator>();
IHostIdProvider hostIdProvider = services.GetService <IHostIdProvider>();
INameResolver nameResolver = services.GetService <INameResolver>();
IExtensionRegistry extensions = services.GetExtensions();
IStorageAccountProvider storageAccountProvider = services.GetService <IStorageAccountProvider>();
ILoggerFactory loggerFactory = services.GetService <ILoggerFactory>();
IFunctionResultAggregatorFactory aggregatorFactory = services.GetService <IFunctionResultAggregatorFactory>();
IAsyncCollector <FunctionInstanceLogEntry> functionEventCollector = null;
SharedQueueHandler hostSharedQueue = services.GetService <SharedQueueHandler>();
// Create the aggregator if all the pieces are configured
IAsyncCollector <FunctionInstanceLogEntry> aggregator = null;
if (loggerFactory != null && aggregatorFactory != null && config.Aggregator.IsEnabled)
{
aggregator = aggregatorFactory.Create(config.Aggregator.BatchSize, config.Aggregator.FlushTimeout, loggerFactory);
}
IQueueConfiguration queueConfiguration = services.GetService <IQueueConfiguration>();
var blobsConfiguration = config.Blobs;
IAsyncCollector <FunctionInstanceLogEntry> registeredFunctionEventCollector = services.GetService <IAsyncCollector <FunctionInstanceLogEntry> >();
if (registeredFunctionEventCollector != null && aggregator != null)
{
// If there are both an aggregator and a registered FunctionEventCollector, wrap them in a composite
functionEventCollector = new CompositeFunctionEventCollector(new[] { registeredFunctionEventCollector, aggregator });
}
else
{
// Otherwise, take whichever one is null (or use null if both are)
functionEventCollector = aggregator ?? registeredFunctionEventCollector;
}
IWebJobsExceptionHandler exceptionHandler = services.GetService <IWebJobsExceptionHandler>();
if (exceptionHandler != null)
{
exceptionHandler.Initialize(host);
}
bool hasFastTableHook = services.GetService <IAsyncCollector <FunctionInstanceLogEntry> >() != null;
bool noDashboardStorage = config.DashboardConnectionString == null;
// Only testing will override these interfaces.
IHostInstanceLoggerProvider hostInstanceLoggerProvider = services.GetService <IHostInstanceLoggerProvider>();
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = services.GetService <IFunctionInstanceLoggerProvider>();
IFunctionOutputLoggerProvider functionOutputLoggerProvider = services.GetService <IFunctionOutputLoggerProvider>();
if (hostInstanceLoggerProvider == null && functionInstanceLoggerProvider == null && functionOutputLoggerProvider == null)
{
if (hasFastTableHook && noDashboardStorage)
{
var loggerProvider = new FastTableLoggerProvider(loggerFactory);
hostInstanceLoggerProvider = loggerProvider;
functionInstanceLoggerProvider = loggerProvider;
functionOutputLoggerProvider = loggerProvider;
}
else
{
var loggerProvider = new DefaultLoggerProvider(storageAccountProvider, loggerFactory);
hostInstanceLoggerProvider = loggerProvider;
functionInstanceLoggerProvider = loggerProvider;
functionOutputLoggerProvider = loggerProvider;
}
}
using (CancellationTokenSource combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, shutdownToken))
{
CancellationToken combinedCancellationToken = combinedCancellationSource.Token;
await WriteSiteExtensionManifestAsync(combinedCancellationToken);
IStorageAccount dashboardAccount = await storageAccountProvider.GetDashboardAccountAsync(combinedCancellationToken);
IHostInstanceLogger hostInstanceLogger = await hostInstanceLoggerProvider.GetAsync(combinedCancellationToken);
IFunctionInstanceLogger functionInstanceLogger = await functionInstanceLoggerProvider.GetAsync(combinedCancellationToken);
IFunctionOutputLogger functionOutputLogger = await functionOutputLoggerProvider.GetAsync(combinedCancellationToken);
loggerFactory.AddProvider(new FunctionOutputLoggerProvider());
if (functionExecutor == null)
{
var extensionRegistry = config.GetService <IExtensionRegistry>();
var globalFunctionFilters = extensionRegistry.GetFunctionFilters();
functionExecutor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, exceptionHandler, functionEventCollector, loggerFactory, globalFunctionFilters);
services.AddService(functionExecutor);
}
if (functionIndexProvider == null)
{
var defaultTimeout = config.FunctionTimeout?.ToAttribute();
functionIndexProvider = new FunctionIndexProvider(
services.GetService <ITypeLocator>(),
triggerBindingProvider,
bindingProvider,
activator,
functionExecutor,
extensions,
singletonManager,
loggerFactory,
hostSharedQueue,
defaultTimeout);
// Important to set this so that the func we passed to DynamicHostIdProvider can pick it up.
services.AddService <IFunctionIndexProvider>(functionIndexProvider);
}
IFunctionIndex functions = await functionIndexProvider.GetAsync(combinedCancellationToken);
IListenerFactory functionsListenerFactory = new HostListenerFactory(functions.ReadAll(), singletonManager, activator, nameResolver, loggerFactory);
IFunctionExecutor hostCallExecutor;
IListener listener;
HostOutputMessage hostOutputMessage;
string hostId = await hostIdProvider.GetHostIdAsync(cancellationToken);
if (string.Compare(config.HostId, hostId, StringComparison.OrdinalIgnoreCase) != 0)
{
// if this isn't a static host ID, provide the HostId on the config
// so it is accessible
config.HostId = hostId;
}
if (dashboardAccount == null)
{
hostCallExecutor = new ShutdownFunctionExecutor(shutdownToken, functionExecutor);
IListener factoryListener = new ListenerFactoryListener(functionsListenerFactory, hostSharedQueue);
IListener shutdownListener = new ShutdownListener(shutdownToken, factoryListener);
listener = shutdownListener;
hostOutputMessage = new DataOnlyHostOutputMessage();
}
else
{
string sharedQueueName = HostQueueNames.GetHostQueueName(hostId);
IStorageQueueClient dashboardQueueClient = dashboardAccount.CreateQueueClient();
IStorageQueue sharedQueue = dashboardQueueClient.GetQueueReference(sharedQueueName);
IListenerFactory sharedQueueListenerFactory = new HostMessageListenerFactory(sharedQueue,
queueConfiguration, exceptionHandler, loggerFactory, functions,
functionInstanceLogger, functionExecutor);
Guid hostInstanceId = Guid.NewGuid();
string instanceQueueName = HostQueueNames.GetHostQueueName(hostInstanceId.ToString("N"));
IStorageQueue instanceQueue = dashboardQueueClient.GetQueueReference(instanceQueueName);
IListenerFactory instanceQueueListenerFactory = new HostMessageListenerFactory(instanceQueue,
queueConfiguration, exceptionHandler, loggerFactory, functions,
functionInstanceLogger, functionExecutor);
HeartbeatDescriptor heartbeatDescriptor = new HeartbeatDescriptor
{
SharedContainerName = HostContainerNames.Hosts,
SharedDirectoryName = HostDirectoryNames.Heartbeats + "/" + hostId,
InstanceBlobName = hostInstanceId.ToString("N"),
ExpirationInSeconds = (int)HeartbeatIntervals.ExpirationInterval.TotalSeconds
};
IStorageBlockBlob blob = dashboardAccount.CreateBlobClient()
.GetContainerReference(heartbeatDescriptor.SharedContainerName)
.GetBlockBlobReference(heartbeatDescriptor.SharedDirectoryName + "/" + heartbeatDescriptor.InstanceBlobName);
IRecurrentCommand heartbeatCommand = new UpdateHostHeartbeatCommand(new HeartbeatCommand(blob));
IEnumerable <MethodInfo> indexedMethods = functions.ReadAllMethods();
Assembly hostAssembly = GetHostAssembly(indexedMethods);
string displayName = hostAssembly != null?AssemblyNameCache.GetName(hostAssembly).Name : "Unknown";
hostOutputMessage = new DataOnlyHostOutputMessage
{
HostInstanceId = hostInstanceId,
HostDisplayName = displayName,
SharedQueueName = sharedQueueName,
InstanceQueueName = instanceQueueName,
Heartbeat = heartbeatDescriptor,
WebJobRunIdentifier = WebJobRunIdentifier.Current
};
hostCallExecutor = CreateHostCallExecutor(instanceQueueListenerFactory, heartbeatCommand,
exceptionHandler, shutdownToken, functionExecutor);
IListenerFactory hostListenerFactory = new CompositeListenerFactory(functionsListenerFactory,
sharedQueueListenerFactory, instanceQueueListenerFactory);
listener = CreateHostListener(hostListenerFactory, hostSharedQueue, heartbeatCommand, exceptionHandler, shutdownToken);
// Publish this to Azure logging account so that a web dashboard can see it.
await LogHostStartedAsync(functions, hostOutputMessage, hostInstanceLogger, combinedCancellationToken);
}
functionExecutor.HostOutputMessage = hostOutputMessage;
IEnumerable <FunctionDescriptor> descriptors = functions.ReadAllDescriptors();
int descriptorsCount = descriptors.Count();
ILogger startupLogger = loggerFactory?.CreateLogger(LogCategories.Startup);
if (config.UsingDevelopmentSettings)
{
string msg = "Development settings applied";
startupLogger?.LogDebug(msg);
}
if (descriptorsCount == 0)
{
string msg = string.Format("No job functions found. Try making your job classes and methods public. {0}",
Constants.ExtensionInitializationMessage);
startupLogger?.LogWarning(msg);
}
else
{
StringBuilder functionsTrace = new StringBuilder();
functionsTrace.AppendLine("Found the following functions:");
foreach (FunctionDescriptor descriptor in descriptors)
{
functionsTrace.AppendLine(descriptor.FullName);
}
string msg = functionsTrace.ToString();
startupLogger?.LogInformation(msg);
}
return(new JobHostContext(
functions,
hostCallExecutor,
listener,
functionEventCollector,
loggerFactory));
}
}
public LevelInit(ISceneListener sceneListener)
{
_sceneListener = sceneListener;
SingletonManager.Get <LevelController>().SetSceneListener(_sceneListener.OnSceneLoaded, _sceneListener.OnSceneUnloaded);
}
public static string ProcessGameSettingCommnands(DebugCommand message, SessionStateMachine stateMachine)
{
if (message.Command == DebugCommands.SetFrameRate)
{
string target = message.Args[0].ToLower();
var frameRate = int.Parse(message.Args[1]);
GameSettingUtility.SetFrameRate(target, frameRate);
return("ok");
}
else if (message.Command == DebugCommands.GetQuality)
{
var qualityName = GameSettingUtility.GetQualityName();
message.Args = new string[1];
message.Args[0] = qualityName;
return("ok");
}
else if (message.Command == DebugCommands.GetQualityList)
{
message.Args = GameSettingUtility.GetQualityNameList();
return("ok");
}
else if (message.Command == DebugCommands.SetQuality)
{
int levelIndex = int.Parse(message.Args[0]);
GameSettingUtility.SetQuality(levelIndex);
return("ok");
}
else if (message.Command == DebugCommands.Quality)
{
int levelIndex = int.Parse(message.Args[0]);
SettingManager.GetInstance().SetQuality((QualityLevel)levelIndex);
return("ok");
}
else if (message.Command == DebugCommands.LodBias)
{
if (message.Args.Length > 0)
{
float val;
if (float.TryParse(message.Args[0], out val))
{
QualitySettings.lodBias = val;
}
else
{
return("参数不合法，需要能转为float类型");
}
}
else
{
return(QualitySettings.lodBias.ToString());
}
return("ok");
}
else if (message.Command == DebugCommands.TreeDistance)
{
if (message.Args.Length > 1)
{
float val;
if (float.TryParse(message.Args[0], out val))
{
SingletonManager.Get <DynamicScenesController>().SetTreeDistance(val);
}
else
{
return("参数不合法，需要能转为float类型");
}
if (float.TryParse(message.Args[1], out val))
{
SingletonManager.Get <DynamicScenesController>().SetGrassDensity(val);
}
else
{
return("参数不合法，需要能转为float类型");
}
}
else if (message.Args.Length > 0)
{
float val;
if (float.TryParse(message.Args[0], out val))
{
SingletonManager.Get <DynamicScenesController>().SetTreeDistance(val);
}
else
{
return("参数不合法，需要能转为float类型");
}
}
else
{
return(string.Format("tree {0}, grass {1}", SingletonManager.Get <DynamicScenesController>().GetTreeDistance(),
SingletonManager.Get <DynamicScenesController>().GetGrassDensity()));
}
return("ok");
}
else if (message.Command == DebugCommands.PermitSystem)
{
if (stateMachine.PermitSystem(message.Args[0]))
{
return("ok");
}
return("wrong path");
}
else if (message.Command == DebugCommands.ForbidSystem)
{
if (stateMachine.ForbidSystems(message.Args[0]))
{
return("ok");
}
return("wrong path");
}
else if (message.Command == DebugCommands.ShowSystem)
{
var treeNode = stateMachine.GetUpdateSystemTree();
return(TransSystemTreeToString(treeNode));
}
return(String.Empty);
}
private void LevelInitDone()
{
SingletonManager.Get <LevelController>().AllSceneLoaded = null;
_callBack();
}
void UserCenter_Loaded(object sender, RoutedEventArgs e)
{
this.TextBlock_xuliehao.Text = SingletonManager.Get <UserProcesser>().GetUser().CPUID.ToString();
}
public CreatePlaybackPlayerLifeStateDataSystem(Contexts contexts) : base(contexts)
{
_info = SingletonManager.Get <DurationHelp>().GetCustomProfileInfo("CreatePlaybackPlayerLifeStateDataSystem");
}
public HostListenerFactory(IEnumerable <IFunctionDefinition> functionDefinitions, SingletonManager singletonManager, IJobActivator activator, INameResolver nameResolver, TraceWriter trace)
{
_functionDefinitions = functionDefinitions;
_singletonManager = singletonManager;
_activator = activator;
_nameResolver = nameResolver;
_trace = trace;
}
public void Handle(SimpleProto data)
{
Contexts contexts = SingletonManager.Get <FreeUiManager>().Contexts1;
if (data.Key == FreeMessageConstant.BlastScoreUI)
{
var ui = contexts.ui.uI;
if (data.Ks[0] == -1)
{
ui.PlayerCapacity = data.Ins[0];
ui.ScoreForWin = data.Ins[1];
ui.ScoreByCampTypeDict[(int)Core.Enums.EUICampType.T] = data.Ins[2];
ui.ScoreByCampTypeDict[(int)Core.Enums.EUICampType.CT] = data.Ins[3];
ui.PlayerCountByCampTypeDict[(int)Core.Enums.EUICampType.T].PlayerCount = data.Ins[4];
ui.PlayerCountByCampTypeDict[(int)Core.Enums.EUICampType.CT].PlayerCount = data.Ins[5];
ui.PlayerCountByCampTypeDict[(int)Core.Enums.EUICampType.T].DeadPlayerCount = data.Ins[6];
ui.PlayerCountByCampTypeDict[(int)Core.Enums.EUICampType.CT].DeadPlayerCount = data.Ins[7];
}
if (data.Ks[0] == -2)
{
ui.GameTime = data.Ins[0];
}
if (data.Ks[0] == 1)
{
ui.C4InstallState = (Core.Enums.EUIBombInstallState)data.Ins[0];
}
if (data.Ks[0] == 2)
{
ui.IsPause = data.Bs[0];
}
}
if (data.Key == FreeMessageConstant.ChangeWeapon)
{
contexts.player.flagSelfEntity.WeaponController().PureSwitchIn((EWeaponSlotType)data.Ins[0]);
}
if (data.Key == FreeMessageConstant.BombAreaMarkUI)
{
var blast = contexts.ui.blast;
if (data.Ks[0] == 0)
{
blast.BlastAPosition = new MapFixedVector3(data.Fs[0], data.Fs[1] + 2.0f, data.Fs[2]);
}
if (data.Ks[0] == 1)
{
blast.BlastBPosition = new MapFixedVector3(data.Fs[0], data.Fs[1] + 2.0f, data.Fs[2]);
}
if (data.Ks[0] == 2)
{
blast.IsC4Droped = data.Bs[0];
if (data.Bs[0])
{
blast.C4DropPosition = new MapFixedVector3(data.Fs[0], data.Fs[1], data.Fs[2]);
}
}
if (data.Ks[0] == 3)
{
blast.C4SetStatus = data.Ins[0];
}
}
if (data.Key == FreeMessageConstant.BombDropTipUI)
{
if (data.Bs[0])
{
contexts.player.flagSelfEntity.tip.Content = data.Ss[0] + " 携带的C4掉落在了地上";
}
else
{
contexts.player.flagSelfEntity.tip.Content = data.Ss[0] + " 拾取了C4";
}
contexts.player.flagSelfEntity.tip.Location = TipComponent.TipLocation.Top;
}
}
private ProofShowProcessor()
{
proofManager = SingletonManager.Get <ProofManager>();
}
static void Init()
{
mockFactory = new Mock<IFactory>();
mockReflection = new Mock<IReflection>();
mockLogger = new Mock<ILogger>();
testObject = new SingletonManager(mockReflection.Object, mockLogger.Object, mockFactory.Object);
}
public static string ProcessPlayerCommands(DebugCommand message, PlayerEntity player, ICommonSessionObjects sessionObjects, ICurrentTime currentTime)
{
var result = "";
WeaponBagLogic bagLogicImp;
switch (message.Command)
{
case DebugCommands.ClientMove:
var pos = new Vector3(0, 1000, 0);
var yaw = 0f;
switch (message.Args.Length)
{
case 2:
break;
case 3:
break;
case 4:
break;
}
if (message.Args.Length > 0)
{
float x;
if (float.TryParse(message.Args[0], out x))
{
pos.x = x;
}
}
if (message.Args.Length == 2)
{
pos.y = 10000;
float z;
if (float.TryParse(message.Args[1], out z))
{
pos.z = z;
}
}
if (message.Args.Length == 3)
{
float y;
if (float.TryParse(message.Args[1], out y))
{
pos.y = y;
}
float z;
if (float.TryParse(message.Args[2], out z))
{
pos.z = z;
}
}
var ray = new Ray(pos, Vector3.down);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
player.position.Value = hit.point;
result = "ok";
}
else
{
player.position.Value = pos;
result = "没有检测到碰撞，资源未加载完成或此位置没有碰撞，请指定y值";
}
break;
case DebugCommands.KillMe:
player.gamePlay.CurHp = 0;
player.gamePlay.ChangeLifeState(Components.Player.EPlayerLifeState.Dead, currentTime.CurrentTime);
break;
case DebugCommands.ShowAniInfo:
result = string.Format("{0}\n{1}", player.state, player.thirdPersonAnimator.DebugJumpInfo());
break;
case DebugCommands.TestMap:
result = BigMapDebug.HandleCommand(player, message.Args);
break;
case DebugCommands.ChangeHp:
player.gamePlay.CurHp = int.Parse(message.Args[0]);
break;
case DebugCommands.SetCurBullet:
player.GetBagLogicImp().SetWeaponBullet(int.Parse(message.Args[0]));
break;
case DebugCommands.SetReservedBullet:
if (message.Args.Length > 1)
{
int slot = int.Parse(message.Args[0]);
int count = int.Parse(message.Args[1]);
player.GetBagLogicImp().SetReservedBullet((EWeaponSlotType)slot, count);
}
else
{
int count = int.Parse(message.Args[0]);
player.GetBagLogicImp().SetReservedBullet(player.GetBagLogicImp().GetCurrentWeaponSlot(), count);
}
break;
case DebugCommands.SetWeapon:
{
int weaponIdToSet = 0;
int avatarId = 0;
var weaponSlotToSet = 0;
if (message.Args.Length > 0)
{
weaponIdToSet = int.Parse(message.Args[0].Trim());
}
if (message.Args.Length > 2)
{
avatarId = int.Parse(message.Args[1].Trim());
}
if (message.Args.Length > 3)
{
weaponSlotToSet = int.Parse(message.Args[2].Trim());
}
var weaponInfo = new WeaponInfo
{
Id = weaponIdToSet,
AvatarId = avatarId > 0 ? avatarId : 0,
};
if (weaponSlotToSet != 0)
{
player.playerAction.Logic.ReplaceWeaponToSlot((EWeaponSlotType)weaponSlotToSet, weaponInfo);
}
else
{
player.playerAction.Logic.PickUpWeapon(weaponInfo);
}
}
break;
case DebugCommands.DropWeapon:
var dropSlot = int.Parse(message.Args[0]);
player.playerAction.Logic.DropWeapon((EWeaponSlotType)dropSlot);
break;
case DebugCommands.TestWeaponAssemble:
if (null == _twaRootGo)
{
_twaRootGo = new GameObject("TwaRoot");
_twaRootGo.transform.parent = Camera.main.transform;
_twaRootGo.transform.localPosition = new Vector3(0, 0, 2);
_twaRootGo.transform.localEulerAngles = new Vector3(0, 90, 0);
}
if (null == _weaponModelController)
{
_weaponModelController = new WeaponModelController(
SingletonManager.Get <WeaponConfigManager>(),
SingletonManager.Get <WeaponPartsConfigManager>(),
SingletonManager.Get <WeaponAvatarConfigManager>(),
new WeaponModelLoadController <object>(
new WeaponModelLoader(sessionObjects.LoadRequestManager),
new WeaponModelAssemblyController(_twaRootGo))
);
}
var operate = int.Parse(message.Args[0]);
var dataId = int.Parse(message.Args[1]);
switch (operate)
{
case 0:
_weaponModelController.SetWeapon(dataId);
break;
case 1:
_weaponModelController.SetPart(dataId);
break;
case 2:
_weaponModelController.RemovePart(dataId);
break;
}
break;
case DebugCommands.SetAttachment:
var res = Core.Enums.EFuncResult.Failed;
var id = 0;
if (message.Args.Length == 2)
{
var slot = int.Parse(message.Args[0]);
id = int.Parse(message.Args[1]);
res = player.GetBagLogicImp().SetWeaponPart((EWeaponSlotType)slot, id);
}
else
{
id = int.Parse(message.Args[0]);
res = player.GetBagLogicImp().SetCurrentWeaponPart(id);
}
switch (res)
{
case Core.Enums.EFuncResult.Exception:
result = "exception occurs";
break;
case Core.Enums.EFuncResult.Failed:
result = "attachment doesn't match";
break;
case Core.Enums.EFuncResult.Success:
result = "attach " + id + " to weapon";
break;
}
break;
case DebugCommands.ClearAttachment:
var weaponSlot = (EWeaponSlotType)int.Parse(message.Args[0]);
var part = (EWeaponPartType)int.Parse(message.Args[1]);
player.GetBagLogicImp().DeleteWeaponPart(weaponSlot, part);
break;
case DebugCommands.SwitchAttachment:
break;
case DebugCommands.SetEquip:
player.appearanceInterface.Appearance.ChangeAvatar(int.Parse(message.Args[0]));
break;
case DebugCommands.ShowAvaliablePartType:
var weapon = player.GetBagLogicImp().GetCurrentWeaponInfo();
if (weapon.Id > 0)
{
var list = SingletonManager.Get <WeaponPartsConfigManager>().GetAvaliablePartTypes(weapon.Id);
for (int i = 0; i < list.Count; i++)
{
result += list[i] + ",";
}
}
break;
case DebugCommands.ReloadConfig:
ConfigReloadSystem.Reload = true;
break;
case DebugCommands.ShowArtTools:
GameObject.Instantiate(Resources.Load <GameObject>("RuntimeTestTools"));
result = "RuntimeTestTools";
break;
case DebugCommands.ShowTerrainTrace:
SharedConfig.IsShowTerrainTrace = !SharedConfig.IsShowTerrainTrace;
break;
}
return(result);
}
public HostListenerFactory(IEnumerable<IFunctionDefinition> functionDefinitions, SingletonManager singletonManager)
{
_functionDefinitions = functionDefinitions;
_singletonManager = singletonManager;
}
public void OnLoadSucc(PlayerEntity player, UnityObject unityObj)
{
GameObject go = unityObj;
player.AddThirdPersonModel(go);
var provider = SingletonManager.Get <HitBoxTransformProviderCache>()
.GetProvider(player.thirdPersonModel.Value);
HitBoxComponentUtility.InitHitBoxComponent(player.entityKey.Value, player, provider);
RemoveRagdollOnServerSide(go, provider.GetHitBoxColliders().Values.ToList());
HandleLoadedModel(player, go);
player.AddAsset(unityObj);
go.name = go.name.Replace("(Clone)", "");
go.transform.SetParent(player.RootGo().transform);
go.transform.localPosition = new Vector3(0, -PlayerEntityUtility.CcSkinWidth, 0);
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
_logger.InfoFormat("P3 loaded: {0}", player.entityKey);
BoneTool.CacheTransform(go);
if (!player.hasBones)
{
player.AddBones(null, null, null);
}
player.bones.Head = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterHeadBoneName);
player.bones.Spine = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterSpineName);
player.AddThirdPersonAnimator(go.GetComponent <Animator>());
var ik = go.AddComponent <PlayerIK>();
ik.SetAnimator(AvatarIKGoal.LeftHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.LeftHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
ik.SetAnimator(AvatarIKGoal.RightHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.RightHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
if (player.isFlagSelf)
{
var animationEvent = go.AddComponent <AnimationClipEvent>();
animationEvent.Player = player;
player.animatorClip.ClipManager.SetAnimationCleanEventCallback(animationEvent.InterruptAnimationEventFunc);
}
else
{
go.AddComponent <ThirdPersonAnimationClipEvent>();
}
// 设置大厅传入的roleId和avatarId
player.appearanceInterface.Appearance.SetRoleModelIdAndInitAvatar(player.playerInfo.RoleModelId, player.playerInfo.AvatarIds);
player.characterControllerInterface.CharacterController.SetCharacterRoot(player.characterContoller.Value.gameObject);
player.appearanceInterface.Appearance.SetThirdPersonCharacter(go);
player.thirdPersonAnimator.UnityAnimator.Update(0);
player.characterControllerInterface.CharacterController.SetThirdModel(player.thirdPersonModel.Value);
player.characterBoneInterface.CharacterBone.SetCharacterRoot(player.characterContoller.Value.gameObject);
player.characterBoneInterface.CharacterBone.SetThirdPersonCharacter(go);
player.characterBoneInterface.CharacterBone.SetStablePelvisRotation();
player.appearanceInterface.Appearance.SetAnimatorP3(player.thirdPersonAnimator.UnityAnimator);
player.appearanceInterface.Appearance.PlayerReborn();
player.characterControllerInterface.CharacterController.PlayerReborn();
// 实际应该使用SharedConfig.IsServer，但离线模式中其值为false
if (!player.hasNetworkAnimator)
{
player.AddNetworkAnimator(NetworkAnimatorUtil.CreateAnimatorLayers(player.thirdPersonAnimator.UnityAnimator),
NetworkAnimatorUtil.GetAnimatorParams(player.thirdPersonAnimator.UnityAnimator));
player.networkAnimator.SetEntityName(player.entityKey.ToString());
}
if (!player.hasOverrideNetworkAnimator)
{
player.AddOverrideNetworkAnimator();
}
if (SharedConfig.IsServer)
{
player.AddNetworkAnimatiorServerTime(0);
}
// 禁用非可见状态下的动画更新，在获取Stable状态之后
if (SharedConfig.IsServer || !player.isFlagSelf)
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
}
else
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
// _assetManager.LoadAssetAsync(player, AssetConfig.GetCharacterHitboxAssetInfo(player.playerInfo.ModelName), new HitboxLoadResponseHandler().OnLoadSucc);
}
private void Awake()
{
_singletonManager = SingletonManager.Instance;
_playerController = GetComponent <PlayerController>();
_animator = GetComponentInChildren <Animator>();
}
private static IServiceProvider CreateServiceProvider <TResult>(IStorageAccount storageAccount, Type programType,
IExtensionTypeLocator extensionTypeLocator, IJobActivator activator,
TaskCompletionSource <TResult> taskSource, IFunctionInstanceLogger functionInstanceLogger, IExtensionRegistry extensions = null)
{
IStorageAccountProvider storageAccountProvider = new FakeStorageAccountProvider
{
StorageAccount = storageAccount
};
IHostIdProvider hostIdProvider = new FakeHostIdProvider();
INameResolver nameResolver = null;
IQueueConfiguration queueConfiguration = new FakeQueueConfiguration(storageAccountProvider);
JobHostBlobsConfiguration blobsConfiguration = new JobHostBlobsConfiguration();
IWebJobsExceptionHandler exceptionHandler =
new TaskBackgroundExceptionHandler <TResult>(taskSource);
ContextAccessor <IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor =
new ContextAccessor <IMessageEnqueuedWatcher>();
ContextAccessor <IBlobWrittenWatcher> blobWrittenWatcherAccessor =
new ContextAccessor <IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
SingletonConfiguration singletonConfig = new SingletonConfiguration();
TestTraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
SingletonManager singletonManager = new SingletonManager(storageAccountProvider, exceptionHandler, singletonConfig, trace, hostIdProvider);
if (extensions == null)
{
extensions = new DefaultExtensionRegistry();
}
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider,
queueConfiguration, blobsConfiguration, exceptionHandler, messageEnqueuedWatcherAccessor,
blobWrittenWatcherAccessor, sharedContextProvider, extensions, singletonManager, new TestTraceWriter(TraceLevel.Verbose));
IBindingProvider bindingProvider = DefaultBindingProvider.Create(nameResolver, null, storageAccountProvider,
extensionTypeLocator, messageEnqueuedWatcherAccessor,
blobWrittenWatcherAccessor, extensions);
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = new NullFunctionInstanceLoggerProvider();
IFunctionOutputLoggerProvider functionOutputLoggerProvider = new NullFunctionOutputLoggerProvider();
IFunctionOutputLogger functionOutputLogger = functionOutputLoggerProvider.GetAsync(CancellationToken.None).Result;
FunctionExecutor executor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, exceptionHandler, new TestTraceWriter(TraceLevel.Verbose));
ITypeLocator typeLocator = new FakeTypeLocator(programType);
FunctionIndexProvider functionIndexProvider = new FunctionIndexProvider(
typeLocator, triggerBindingProvider, bindingProvider,
activator, executor, extensions, singletonManager, trace);
IJobHostContextFactory contextFactory = new FakeJobHostContextFactory
{
TypeLocator = typeLocator,
FunctionIndexProvider = functionIndexProvider,
StorageAccountProvider = storageAccountProvider,
BackgroundExceptionDispatcher = exceptionHandler,
BindingProvider = bindingProvider,
ConsoleProvider = new NullConsoleProvider(),
HostInstanceLoggerProvider = new NullHostInstanceLoggerProvider(),
FunctionExecutor = executor,
FunctionInstanceLoggerProvider = functionInstanceLoggerProvider,
FunctionOutputLoggerProvider = functionOutputLoggerProvider,
HostIdProvider = hostIdProvider,
QueueConfiguration = queueConfiguration
};
return(new FakeServiceProvider
{
ContextFactory = contextFactory
});
}
// Static initialization. Returns a service provider with some new services initialized.
// The new services:
// - can retrieve static config like binders and converters; but the listeners haven't yet started.
// - can be flowed into the runtime initialization to get a JobHost spun up and running.
// This is just static initialization and should not need to make any network calls,
// and so this method should not need to be async.
// This can be called multiple times on a config, which is why it returns a new ServiceProviderWrapper
// instead of modifying the config.
public static ServiceProviderWrapper CreateStaticServices(this JobHostConfiguration config)
{
var services = new ServiceProviderWrapper(config);
var nameResolver = services.GetService <INameResolver>();
IWebJobsExceptionHandler exceptionHandler = services.GetService <IWebJobsExceptionHandler>();
IQueueConfiguration queueConfiguration = services.GetService <IQueueConfiguration>();
var blobsConfiguration = config.Blobs;
IStorageAccountProvider storageAccountProvider = services.GetService <IStorageAccountProvider>();
IBindingProvider bindingProvider = services.GetService <IBindingProvider>();
SingletonManager singletonManager = services.GetService <SingletonManager>();
IHostIdProvider hostIdProvider = services.GetService <IHostIdProvider>();
var hostId = config.HostId;
if (hostId != null)
{
hostIdProvider = new FixedHostIdProvider(hostId);
}
// Need a deferred getter since the IFunctionIndexProvider service isn't created until later.
Func <IFunctionIndexProvider> deferredGetter = () => services.GetService <IFunctionIndexProvider>();
if (hostIdProvider == null)
{
hostIdProvider = new DynamicHostIdProvider(storageAccountProvider, deferredGetter);
}
services.AddService <IHostIdProvider>(hostIdProvider);
AzureStorageDeploymentValidator.Validate();
IExtensionTypeLocator extensionTypeLocator = services.GetService <IExtensionTypeLocator>();
if (extensionTypeLocator == null)
{
extensionTypeLocator = new ExtensionTypeLocator(services.GetService <ITypeLocator>());
services.AddService <IExtensionTypeLocator>(extensionTypeLocator);
}
ContextAccessor <IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor = new ContextAccessor <IMessageEnqueuedWatcher>();
services.AddService(messageEnqueuedWatcherAccessor);
ContextAccessor <IBlobWrittenWatcher> blobWrittenWatcherAccessor = new ContextAccessor <IBlobWrittenWatcher>();
services.AddService(blobWrittenWatcherAccessor);
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
// Add built-in extensions
var metadataProvider = new JobHostMetadataProvider(deferredGetter);
metadataProvider.AddAttributesFromAssembly(typeof(TableAttribute).Assembly);
var converterManager = (ConverterManager)config.ConverterManager;
var exts = config.GetExtensions();
bool builtinsAdded = exts.GetExtensions <IExtensionConfigProvider>().OfType <TableExtension>().Any();
if (!builtinsAdded)
{
AddStreamConverters(extensionTypeLocator, converterManager);
config.AddExtension(new TableExtension());
config.AddExtension(new QueueExtension());
config.AddExtension(new Blobs.Bindings.BlobExtensionConfig());
config.AddExtension(new BlobTriggerExtensionConfig());
}
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
PerHostServices = services
};
InvokeExtensionConfigProviders(context);
// After this point, all user configuration has been set.
if (singletonManager == null)
{
var logger = config.LoggerFactory?.CreateLogger(LogCategories.Singleton);
IDistributedLockManager lockManager = services.GetService <IDistributedLockManager>();
if (lockManager == null)
{
var sas = config.InternalStorageConfiguration;
if (sas != null && sas.InternalContainer != null)
{
lockManager = new BlobLeaseDistributedLockManager.SasContainer(
sas.InternalContainer,
logger);
}
else
{
lockManager = new BlobLeaseDistributedLockManager.DedicatedStorage(
storageAccountProvider,
logger);
}
services.AddService <IDistributedLockManager>(lockManager);
}
singletonManager = new SingletonManager(
lockManager,
config.Singleton,
exceptionHandler,
config.LoggerFactory,
hostIdProvider,
services.GetService <INameResolver>());
services.AddService <SingletonManager>(singletonManager);
}
IExtensionRegistry extensions = services.GetExtensions();
services.AddService <SharedQueueHandler>(new SharedQueueHandler(storageAccountProvider, hostIdProvider, exceptionHandler,
config.LoggerFactory, queueConfiguration, sharedContextProvider, messageEnqueuedWatcherAccessor));
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider, queueConfiguration, blobsConfiguration, exceptionHandler,
messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, sharedContextProvider, extensions, singletonManager, config.LoggerFactory);
services.AddService <ITriggerBindingProvider>(triggerBindingProvider);
if (bindingProvider == null)
{
bindingProvider = DefaultBindingProvider.Create(nameResolver, config.LoggerFactory, storageAccountProvider, extensionTypeLocator, blobWrittenWatcherAccessor, extensions);
services.AddService <IBindingProvider>(bindingProvider);
}
metadataProvider.Initialize(bindingProvider, converterManager, exts);
services.AddService <IJobHostMetadataProvider>(metadataProvider);
return(services);
}
public static string ProcessDebugCommand(DebugCommand message)
{
var result = string.Empty;
switch (message.Command)
{
case DebugCommands.ShowConfig:
var config = message.Args[0] as string;
switch (config)
{
case "camera":
result = SingletonManager.Get <CameraConfigManager>().XMLContent;
break;
}
break;
case DebugCommands.EnableRecordProfiler:
{
var isClient = true;
var enabled = false;
if (message.Args.Length == 1)
{
enabled = int.Parse(message.Args[0]) != 0;
}
else if (message.Args.Length == 2)
{
isClient = message.Args[0].ToLower().Equals("c");
enabled = int.Parse(message.Args[1]) != 0;
}
if (isClient && !SharedConfig.IsServer ||
!isClient && SharedConfig.IsServer)
{
if (enabled)
{
SingletonManager.Get <MyProfilerManager>().EnableProfiler();
}
else
{
SingletonManager.Get <MyProfilerManager>().DisableProfiler();
}
}
break;
}
case DebugCommands.EnableProfiler:
{
var cmdargs = CmdParser.ParseCommandLine(message.Args, "-");
var isClient = false;
var isServer = false;
var value = 0;
isClient = TryGetArgs <int>(cmdargs, "c", out value);
if (!isClient)
{
isServer = TryGetArgs <int>(cmdargs, "s", out value);
}
var enabled = value != 0;
var isProfileGpu = TryGetArgs <int>(cmdargs, "g", out value);
var profileGpu = value != 0;
//profilegpu is only valid on client
profileGpu = !SharedConfig.IsServer && profileGpu;
if (isClient && !SharedConfig.IsServer ||
isServer && SharedConfig.IsServer)
{
if (enabled)
{
UnityProfiler.EnableProfiler(profileGpu);
result = String.Format("ok, start {0} profiler profile gpu {1}", SharedConfig.IsServer ? "server" : "client", profileGpu ? "enabled" : "disabled");
}
else
{
UnityProfiler.DisableProfiler();
result = "ok, stop profiler";
}
}
else if (isProfileGpu)
{
UnityProfiler.EnableProfileGpu(profileGpu);
result = String.Format("ok, profile gpu {0}", (profileGpu ? "enabled" : "disabled"));
}
else if (!isServer)
{
result = "Invalid Argument.";
}
break;
}
}
return(result);
}
public void HostId_InvokesHostIdProvider_AndCachesResult()
{
Mock<IHostIdProvider> mockHostIdProvider = new Mock<IHostIdProvider>(MockBehavior.Strict);
mockHostIdProvider.Setup(p => p.GetHostIdAsync(CancellationToken.None)).ReturnsAsync(TestHostId);
SingletonManager singletonManager = new SingletonManager(null, null, null, null, mockHostIdProvider.Object);
Assert.Equal(TestHostId, singletonManager.HostId);
Assert.Equal(TestHostId, singletonManager.HostId);
Assert.Equal(TestHostId, singletonManager.HostId);
mockHostIdProvider.Verify(p => p.GetHostIdAsync(It.IsAny<CancellationToken>()), Times.Once);
}
public static async Task <JobHostContext> CreateAndLogHostStartedAsync(
JobHost host,
IStorageAccountProvider storageAccountProvider,
IQueueConfiguration queueConfiguration,
ITypeLocator typeLocator,
IJobActivator activator,
INameResolver nameResolver,
IConsoleProvider consoleProvider,
JobHostConfiguration config,
CancellationToken shutdownToken,
CancellationToken cancellationToken,
IWebJobsExceptionHandler exceptionHandler,
IHostIdProvider hostIdProvider = null,
FunctionExecutor functionExecutor = null,
IFunctionIndexProvider functionIndexProvider = null,
IBindingProvider bindingProvider = null,
IHostInstanceLoggerProvider hostInstanceLoggerProvider = null,
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = null,
IFunctionOutputLoggerProvider functionOutputLoggerProvider = null,
SingletonManager singletonManager = null,
IAsyncCollector <FunctionInstanceLogEntry> fastLogger = null)
{
if (hostIdProvider == null)
{
hostIdProvider = new DynamicHostIdProvider(storageAccountProvider, () => functionIndexProvider);
}
IExtensionTypeLocator extensionTypeLocator = new ExtensionTypeLocator(typeLocator);
ContextAccessor <IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor = new ContextAccessor <IMessageEnqueuedWatcher>();
ContextAccessor <IBlobWrittenWatcher> blobWrittenWatcherAccessor = new ContextAccessor <IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
// Create a wrapper TraceWriter that delegates to both the user
// TraceWriters specified via config (if present), as well as to Console
TraceWriter trace = new ConsoleTraceWriter(config.Tracing, consoleProvider.Out);
// Register system services with the service container
config.AddService <INameResolver>(nameResolver);
if (exceptionHandler != null)
{
exceptionHandler.Initialize(host);
}
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
Trace = trace,
Host = host
};
InvokeExtensionConfigProviders(context);
if (singletonManager == null)
{
singletonManager = new SingletonManager(storageAccountProvider, exceptionHandler, config.Singleton, trace, hostIdProvider, config.NameResolver);
}
IExtensionRegistry extensions = config.GetExtensions();
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider, queueConfiguration, exceptionHandler,
messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, sharedContextProvider, extensions, singletonManager, trace);
if (bindingProvider == null)
{
bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider, extensionTypeLocator, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, extensions);
}
bool hasFastTableHook = config.GetService <IAsyncCollector <FunctionInstanceLogEntry> >() != null;
bool noDashboardStorage = config.DashboardConnectionString == null;
if (hasFastTableHook && noDashboardStorage)
{
var loggerProvider = new FastTableLoggerProvider(trace);
hostInstanceLoggerProvider = loggerProvider;
functionInstanceLoggerProvider = loggerProvider;
functionOutputLoggerProvider = loggerProvider;
}
else
{
var loggerProvider = new DefaultLoggerProvider(storageAccountProvider, trace);
hostInstanceLoggerProvider = loggerProvider;
functionInstanceLoggerProvider = loggerProvider;
functionOutputLoggerProvider = loggerProvider;
}
using (CancellationTokenSource combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, shutdownToken))
{
CancellationToken combinedCancellationToken = combinedCancellationSource.Token;
await WriteSiteExtensionManifestAsync(combinedCancellationToken);
IStorageAccount dashboardAccount = await storageAccountProvider.GetDashboardAccountAsync(combinedCancellationToken);
IHostInstanceLogger hostInstanceLogger = await hostInstanceLoggerProvider.GetAsync(combinedCancellationToken);
IFunctionInstanceLogger functionInstanceLogger = await functionInstanceLoggerProvider.GetAsync(combinedCancellationToken);
IFunctionOutputLogger functionOutputLogger = await functionOutputLoggerProvider.GetAsync(combinedCancellationToken);
if (functionExecutor == null)
{
functionExecutor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, exceptionHandler, trace, fastLogger);
}
if (functionIndexProvider == null)
{
functionIndexProvider = new FunctionIndexProvider(typeLocator, triggerBindingProvider, bindingProvider, activator, functionExecutor, extensions, singletonManager, trace);
}
IFunctionIndex functions = await functionIndexProvider.GetAsync(combinedCancellationToken);
IListenerFactory functionsListenerFactory = new HostListenerFactory(functions.ReadAll(), singletonManager, activator, nameResolver, trace);
IFunctionExecutor hostCallExecutor;
IListener listener;
HostOutputMessage hostOutputMessage;
string hostId = await hostIdProvider.GetHostIdAsync(cancellationToken);
if (string.Compare(config.HostId, hostId, StringComparison.OrdinalIgnoreCase) != 0)
{
// if this isn't a static host ID, provide the HostId on the config
// so it is accessible
config.HostId = hostId;
}
if (dashboardAccount != null)
{
string sharedQueueName = HostQueueNames.GetHostQueueName(hostId);
IStorageQueueClient dashboardQueueClient = dashboardAccount.CreateQueueClient();
IStorageQueue sharedQueue = dashboardQueueClient.GetQueueReference(sharedQueueName);
IListenerFactory sharedQueueListenerFactory = new HostMessageListenerFactory(sharedQueue,
queueConfiguration, exceptionHandler, trace, functions,
functionInstanceLogger, functionExecutor);
Guid hostInstanceId = Guid.NewGuid();
string instanceQueueName = HostQueueNames.GetHostQueueName(hostInstanceId.ToString("N"));
IStorageQueue instanceQueue = dashboardQueueClient.GetQueueReference(instanceQueueName);
IListenerFactory instanceQueueListenerFactory = new HostMessageListenerFactory(instanceQueue,
queueConfiguration, exceptionHandler, trace, functions,
functionInstanceLogger, functionExecutor);
HeartbeatDescriptor heartbeatDescriptor = new HeartbeatDescriptor
{
SharedContainerName = HostContainerNames.Hosts,
SharedDirectoryName = HostDirectoryNames.Heartbeats + "/" + hostId,
InstanceBlobName = hostInstanceId.ToString("N"),
ExpirationInSeconds = (int)HeartbeatIntervals.ExpirationInterval.TotalSeconds
};
IStorageBlockBlob blob = dashboardAccount.CreateBlobClient()
.GetContainerReference(heartbeatDescriptor.SharedContainerName)
.GetBlockBlobReference(heartbeatDescriptor.SharedDirectoryName + "/" + heartbeatDescriptor.InstanceBlobName);
IRecurrentCommand heartbeatCommand = new UpdateHostHeartbeatCommand(new HeartbeatCommand(blob));
IEnumerable <MethodInfo> indexedMethods = functions.ReadAllMethods();
Assembly hostAssembly = GetHostAssembly(indexedMethods);
string displayName = hostAssembly != null?hostAssembly.GetName().Name : "Unknown";
hostOutputMessage = new DataOnlyHostOutputMessage
{
HostInstanceId = hostInstanceId,
HostDisplayName = displayName,
SharedQueueName = sharedQueueName,
InstanceQueueName = instanceQueueName,
Heartbeat = heartbeatDescriptor,
WebJobRunIdentifier = WebJobRunIdentifier.Current
};
hostCallExecutor = CreateHostCallExecutor(instanceQueueListenerFactory, heartbeatCommand,
exceptionHandler, shutdownToken, functionExecutor);
IListenerFactory hostListenerFactory = new CompositeListenerFactory(functionsListenerFactory,
sharedQueueListenerFactory, instanceQueueListenerFactory);
listener = CreateHostListener(hostListenerFactory, heartbeatCommand, exceptionHandler, shutdownToken);
// Publish this to Azure logging account so that a web dashboard can see it.
await LogHostStartedAsync(functions, hostOutputMessage, hostInstanceLogger, combinedCancellationToken);
}
else
{
hostCallExecutor = new ShutdownFunctionExecutor(shutdownToken, functionExecutor);
IListener factoryListener = new ListenerFactoryListener(functionsListenerFactory);
IListener shutdownListener = new ShutdownListener(shutdownToken, factoryListener);
listener = shutdownListener;
hostOutputMessage = new DataOnlyHostOutputMessage();
}
functionExecutor.HostOutputMessage = hostOutputMessage;
IEnumerable <FunctionDescriptor> descriptors = functions.ReadAllDescriptors();
int descriptorsCount = descriptors.Count();
if (config.UsingDevelopmentSettings)
{
trace.Verbose(string.Format("Development settings applied"));
}
if (descriptorsCount == 0)
{
trace.Warning(string.Format("No job functions found. Try making your job classes and methods public. {0}",
Constants.ExtensionInitializationMessage), TraceSource.Indexing);
}
else
{
StringBuilder functionsTrace = new StringBuilder();
functionsTrace.AppendLine("Found the following functions:");
foreach (FunctionDescriptor descriptor in descriptors)
{
functionsTrace.AppendLine(descriptor.FullName);
}
trace.Info(functionsTrace.ToString(), TraceSource.Indexing);
}
return(new JobHostContext(functions, hostCallExecutor, listener, trace, fastLogger));
}
}
void checkObjectVisible(GameObject obj, StreamingObject data)
{
string qualityName = GameSettingUtility.GetQualityName();
var allMaps = SingletonManager.Get <MapsDescription>();
if (allMaps.CurrentLevelType != LevelType.BigMap)
{
return;
}
MultiTagBase mul = obj.GetComponentInChildren <MultiTagBase>();
if (mul == null)
{
return;
}
if (mul.btags[(int)MultiTagBase.TagEnum.House])
{
return;
}
mul.importantLevel = data.importantLevel;
SceneConfig config = allMaps.BigMapParameters;
if (config.PreMapName != "004")
{
return;
}
int level = 0;
//TEST Code
/*
* int level = 0;
* if(qualitDic.Count <= 0)
* {
* qualitDic.Add("QL_Low", 0);
* qualitDic.Add("QL_MediumLow", 1);
* qualitDic.Add("QL_Medium", 2);
* qualitDic.Add("QL_MediumHigh", 3);
* qualitDic.Add("QL_High", 4);
* }
*
* if(!qualitDic.ContainsKey(qualityName))
* {
* return;
* }
*
* level = qualitDic[qualityName];
*/
if (mul.importantLevel <= level)
{
obj.SetActive(true);
}
else
{
obj.SetActive(false);
}
}
public BlobListenerFactory(IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
IContextSetter<IBlobWrittenWatcher> blobWrittenWatcherSetter,
IContextSetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
TraceWriter trace,
string functionId,
IStorageAccount hostAccount,
IStorageAccount dataAccount,
IStorageBlobContainer container,
IBlobPathSource input,
ITriggeredFunctionExecutor executor,
SingletonManager singletonManager)
{
if (hostIdProvider == null)
{
throw new ArgumentNullException("hostIdProvider");
}
if (queueConfiguration == null)
{
throw new ArgumentNullException("queueConfiguration");
}
if (backgroundExceptionDispatcher == null)
{
throw new ArgumentNullException("backgroundExceptionDispatcher");
}
if (blobWrittenWatcherSetter == null)
{
throw new ArgumentNullException("blobWrittenWatcherSetter");
}
if (messageEnqueuedWatcherSetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherSetter");
}
if (sharedContextProvider == null)
{
throw new ArgumentNullException("sharedContextProvider");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
if (hostAccount == null)
{
throw new ArgumentNullException("hostAccount");
}
if (dataAccount == null)
{
throw new ArgumentNullException("dataAccount");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
if (input == null)
{
throw new ArgumentNullException("input");
}
if (executor == null)
{
throw new ArgumentNullException("executor");
}
if (singletonManager == null)
{
throw new ArgumentNullException("singletonManager");
}
_hostIdProvider = hostIdProvider;
_queueConfiguration = queueConfiguration;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_blobWrittenWatcherSetter = blobWrittenWatcherSetter;
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter;
_sharedContextProvider = sharedContextProvider;
_trace = trace;
_functionId = functionId;
_hostAccount = hostAccount;
_dataAccount = dataAccount;
_container = container;
_input = input;
_executor = executor;
_singletonManager = singletonManager;
}
public static async Task<JobHostContext> CreateAndLogHostStartedAsync(
JobHost host,
IStorageAccountProvider storageAccountProvider,
IQueueConfiguration queueConfiguration,
ITypeLocator typeLocator,
IJobActivator activator,
INameResolver nameResolver,
IConsoleProvider consoleProvider,
JobHostConfiguration config,
CancellationToken shutdownToken,
CancellationToken cancellationToken,
IHostIdProvider hostIdProvider = null,
FunctionExecutor functionExecutor = null,
IFunctionIndexProvider functionIndexProvider = null,
IBindingProvider bindingProvider = null,
IHostInstanceLoggerProvider hostInstanceLogerProvider = null,
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = null,
IFunctionOutputLoggerProvider functionOutputLoggerProvider = null,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher = null,
SingletonManager singletonManager = null)
{
if (hostIdProvider == null)
{
hostIdProvider = new DynamicHostIdProvider(storageAccountProvider, () => functionIndexProvider);
}
IExtensionTypeLocator extensionTypeLocator = new ExtensionTypeLocator(typeLocator);
if (backgroundExceptionDispatcher == null)
{
backgroundExceptionDispatcher = BackgroundExceptionDispatcher.Instance;
}
ContextAccessor<IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor = new ContextAccessor<IMessageEnqueuedWatcher>();
ContextAccessor<IBlobWrittenWatcher> blobWrittenWatcherAccessor = new ContextAccessor<IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
// Create a wrapper TraceWriter that delegates to both the user
// TraceWriter specified on Config (if present), as well as to Console
TraceWriter trace = new ConsoleTraceWriter(config.Tracing, consoleProvider.Out);
// Register system services with the service container
config.AddService<INameResolver>(nameResolver);
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
Trace = trace,
Host = host
};
InvokeExtensionConfigProviders(context);
IExtensionRegistry extensions = config.GetExtensions();
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider, queueConfiguration, backgroundExceptionDispatcher,
messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, sharedContextProvider, extensions, trace);
if (bindingProvider == null)
{
bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider, extensionTypeLocator, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, extensions);
}
DefaultLoggerProvider loggerProvider = new DefaultLoggerProvider(storageAccountProvider, trace);
if (singletonManager == null)
{
singletonManager = new SingletonManager(storageAccountProvider, backgroundExceptionDispatcher, config.Singleton, trace, config.NameResolver);
}
using (CancellationTokenSource combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, shutdownToken))
{
CancellationToken combinedCancellationToken = combinedCancellationSource.Token;
await WriteSiteExtensionManifestAsync(combinedCancellationToken);
IStorageAccount dashboardAccount = await storageAccountProvider.GetDashboardAccountAsync(combinedCancellationToken);
IHostInstanceLogger hostInstanceLogger = null;
if (hostInstanceLogerProvider != null)
{
hostInstanceLogger = await hostInstanceLogerProvider.GetAsync(combinedCancellationToken);
}
else
{
hostInstanceLogger = await((IHostInstanceLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken);
}
IFunctionInstanceLogger functionInstanceLogger = null;
if (functionInstanceLoggerProvider != null)
{
functionInstanceLogger = await functionInstanceLoggerProvider.GetAsync(combinedCancellationToken);
}
else
{
functionInstanceLogger = (IFunctionInstanceLogger)(await((IFunctionInstanceLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken));
}
IFunctionOutputLogger functionOutputLogger = null;
if (functionOutputLoggerProvider != null)
{
functionOutputLogger = await functionOutputLoggerProvider.GetAsync(combinedCancellationToken);
}
else
{
functionOutputLogger = (IFunctionOutputLogger)(await((IFunctionOutputLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken));
}
if (functionExecutor == null)
{
functionExecutor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, backgroundExceptionDispatcher, trace);
}
if (functionIndexProvider == null)
{
functionIndexProvider = new FunctionIndexProvider(typeLocator, triggerBindingProvider, bindingProvider, activator, functionExecutor, extensions, singletonManager);
}
IFunctionIndex functions = await functionIndexProvider.GetAsync(combinedCancellationToken);
IListenerFactory functionsListenerFactory = new HostListenerFactory(functions.ReadAll(), singletonManager, activator, nameResolver, trace);
IFunctionExecutor hostCallExecutor;
IListener listener;
HostOutputMessage hostOutputMessage;
if (dashboardAccount != null)
{
string hostId = await hostIdProvider.GetHostIdAsync(cancellationToken);
string sharedQueueName = HostQueueNames.GetHostQueueName(hostId);
IStorageQueueClient dashboardQueueClient = dashboardAccount.CreateQueueClient();
IStorageQueue sharedQueue = dashboardQueueClient.GetQueueReference(sharedQueueName);
IListenerFactory sharedQueueListenerFactory = new HostMessageListenerFactory(sharedQueue,
queueConfiguration, backgroundExceptionDispatcher, trace, functions,
functionInstanceLogger, functionExecutor);
Guid hostInstanceId = Guid.NewGuid();
string instanceQueueName = HostQueueNames.GetHostQueueName(hostInstanceId.ToString("N"));
IStorageQueue instanceQueue = dashboardQueueClient.GetQueueReference(instanceQueueName);
IListenerFactory instanceQueueListenerFactory = new HostMessageListenerFactory(instanceQueue,
queueConfiguration, backgroundExceptionDispatcher, trace, functions,
functionInstanceLogger, functionExecutor);
HeartbeatDescriptor heartbeatDescriptor = new HeartbeatDescriptor
{
SharedContainerName = HostContainerNames.Hosts,
SharedDirectoryName = HostDirectoryNames.Heartbeats + "/" + hostId,
InstanceBlobName = hostInstanceId.ToString("N"),
ExpirationInSeconds = (int)HeartbeatIntervals.ExpirationInterval.TotalSeconds
};
IStorageBlockBlob blob = dashboardAccount.CreateBlobClient()
.GetContainerReference(heartbeatDescriptor.SharedContainerName)
.GetBlockBlobReference(heartbeatDescriptor.SharedDirectoryName + "/" + heartbeatDescriptor.InstanceBlobName);
IRecurrentCommand heartbeatCommand = new UpdateHostHeartbeatCommand(new HeartbeatCommand(blob));
IEnumerable<MethodInfo> indexedMethods = functions.ReadAllMethods();
Assembly hostAssembly = GetHostAssembly(indexedMethods);
string displayName = hostAssembly != null ? hostAssembly.GetName().Name : "Unknown";
hostOutputMessage = new DataOnlyHostOutputMessage
{
HostInstanceId = hostInstanceId,
HostDisplayName = displayName,
SharedQueueName = sharedQueueName,
InstanceQueueName = instanceQueueName,
Heartbeat = heartbeatDescriptor,
WebJobRunIdentifier = WebJobRunIdentifier.Current
};
hostCallExecutor = CreateHostCallExecutor(instanceQueueListenerFactory, heartbeatCommand,
backgroundExceptionDispatcher, shutdownToken, functionExecutor);
IListenerFactory hostListenerFactory = new CompositeListenerFactory(functionsListenerFactory,
sharedQueueListenerFactory, instanceQueueListenerFactory);
listener = CreateHostListener(hostListenerFactory, heartbeatCommand, backgroundExceptionDispatcher, shutdownToken);
// Publish this to Azure logging account so that a web dashboard can see it.
await LogHostStartedAsync(functions, hostOutputMessage, hostInstanceLogger, combinedCancellationToken);
}
else
{
hostCallExecutor = new ShutdownFunctionExecutor(shutdownToken, functionExecutor);
IListener factoryListener = new ListenerFactoryListener(functionsListenerFactory);
IListener shutdownListener = new ShutdownListener(shutdownToken, factoryListener);
listener = shutdownListener;
hostOutputMessage = new DataOnlyHostOutputMessage();
}
functionExecutor.HostOutputMessage = hostOutputMessage;
IEnumerable<FunctionDescriptor> descriptors = functions.ReadAllDescriptors();
int descriptorsCount = descriptors.Count();
if (descriptorsCount == 0)
{
trace.Warning("No functions found. Try making job classes and methods public.", TraceSource.Indexing);
}
else
{
StringBuilder functionsTrace = new StringBuilder();
functionsTrace.AppendLine("Found the following functions:");
foreach (FunctionDescriptor descriptor in descriptors)
{
functionsTrace.AppendLine(descriptor.FullName);
}
trace.Info(functionsTrace.ToString(), TraceSource.Indexing);
}
return new JobHostContext(functions, hostCallExecutor, listener, trace);
}
}
public BlobTriggerBinding(ParameterInfo parameter,
IArgumentBinding<IStorageBlob> argumentBinding,
IStorageAccount hostAccount,
IStorageAccount dataAccount,
IBlobPathSource path,
IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
IContextSetter<IBlobWrittenWatcher> blobWrittenWatcherSetter,
IContextSetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
SingletonManager singletonManager,
TraceWriter trace)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
if (argumentBinding == null)
{
throw new ArgumentNullException("argumentBinding");
}
if (hostAccount == null)
{
throw new ArgumentNullException("hostAccount");
}
if (dataAccount == null)
{
throw new ArgumentNullException("dataAccount");
}
if (path == null)
{
throw new ArgumentNullException("path");
}
if (hostIdProvider == null)
{
throw new ArgumentNullException("hostIdProvider");
}
if (queueConfiguration == null)
{
throw new ArgumentNullException("queueConfiguration");
}
if (backgroundExceptionDispatcher == null)
{
throw new ArgumentNullException("backgroundExceptionDispatcher");
}
if (blobWrittenWatcherSetter == null)
{
throw new ArgumentNullException("blobWrittenWatcherSetter");
}
if (messageEnqueuedWatcherSetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherSetter");
}
if (sharedContextProvider == null)
{
throw new ArgumentNullException("sharedContextProvider");
}
if (singletonManager == null)
{
throw new ArgumentNullException("singletonManager");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
_parameter = parameter;
_argumentBinding = argumentBinding;
_hostAccount = hostAccount;
_dataAccount = dataAccount;
StorageClientFactoryContext context = new StorageClientFactoryContext
{
Parameter = parameter
};
_blobClient = dataAccount.CreateBlobClient(context);
_accountName = BlobClient.GetAccountName(_blobClient);
_path = path;
_hostIdProvider = hostIdProvider;
_queueConfiguration = queueConfiguration;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_blobWrittenWatcherSetter = blobWrittenWatcherSetter;
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter;
_sharedContextProvider = sharedContextProvider;
_singletonManager = singletonManager;
_trace = trace;
_converter = CreateConverter(_blobClient);
_bindingDataContract = CreateBindingDataContract(path);
}
