private void ValidateConstructorParameters(Type contractInterface, Type realProxyType, String channelId, AddressEndPoint remoteEp)
{
if (contractInterface == null)
{
ThrowHelper.ThrowArgumentNullException("contractInterface");
}
if (realProxyType == null)
{
ThrowHelper.ThrowArgumentNullException("realProxyType");
}
if (string.IsNullOrEmpty(channelId))
{
ThrowHelper.ThrowArgumentNullException("channelId");
}
if (!contractInterface.IsAssignableFrom(realProxyType))
{
ThrowHelper.ThrowArgumentException("Provided client proxy does not implements the provided contract interface.", "realProxyType");
}
if (remoteEp == null)
{
ThrowHelper.ThrowArgumentNullException("remoteEp");
}
if (!ChannelServices.IsChannelRegistered(channelId))
{
throw new ChannelNotFoundException(channelId);
}
ContractValidator.ValidateContractIntegrity(contractInterface);
ImplementationValidator.ValidateProxyIntegration(realProxyType);
this.mContractInterface = contractInterface;
this.mRealProxyType = realProxyType;
this.mChannel = ChannelServices.GetChannelById(channelId);
this.mRemoteEndPoint = remoteEp;
}
/// <summary>
/// Registers the contract.
/// </summary>
/// <param name="contractType">Type of the contract.</param>
/// <param name="defaultChannelId">The default channel id.</param>
/// <param name="defaultProxyType">Default type of the proxy.</param>
/// <exception cref="System.InvalidOperationException">Contract has already registered.</exception>
public static void RegisterContract(Type contractType, string defaultChannelId, Type defaultProxyType)
{
DoInitializeCheck();
if (contractType == null)
{
ThrowHelper.ThrowArgumentNullException("contractType");
}
ContractValidator.ValidateContractIntegrity(contractType);
if (!ChannelServices.IsChannelRegistered(defaultChannelId))
{
ThrowHelper.ThrowArgumentException("Default channel identifier has not found.");
}
if (defaultProxyType != null)
{
ImplementationValidator.ValidateProxyIntegration(defaultProxyType);
}
lock (mContractDescriptors)
{
if (mContractDescriptors.ContainsKey(contractType))
{
throw new InvalidOperationException("Contract has already registered.");
}
ContractClientSideDescriptor descriptor = new ContractClientSideDescriptor(contractType, defaultChannelId, defaultProxyType);
mContractDescriptors.Add(contractType, descriptor);
}
}
private void OnGUI()
{
#if GOTOUDON_DEV
ReleaseHelper.DrawReleaseHelper();
#endif
#if GOTOUDON_SIMULATION_LEGACY
UpdaterEditor.Instance.DrawVersionInformation();
ImplementationValidator.DrawValidationErrors(ImplementationValidator.ValidateEmulator());
SimpleGUI.WarningBox(true,
"NETWORK AND VRCHAT PHYSICS ARE NOT SIMULATED, NETWORK RELATED SETTINGS ONLY AFFECT RETURNED VALUES IN SCRIPTS, DEFAULT UNITY PHYSICS APPLIES (might be improved later)");
_scroll = GUILayout.BeginScrollView(_scroll, GUIStyle.none);
if (EditorApplication.isPlaying)
{
DrawPlayersEditor();
}
else
{
DrawTemplatesEditor();
}
#else
_scroll = GUILayout.BeginScrollView(_scroll, GUIStyle.none);
#endif
if (GUILayout.Button(
$"============ IMPORTANT ============\nFor emulation use CyanEmu instead: https://github.com/CyanLaser/CyanEmu",
EditorStyles.helpBox))
{
Application.OpenURL("https://github.com/CyanLaser/CyanEmu");
}
if (SimpleGUI.DrawFoldout("Unsafe Simulation", "UNSAFE") &&
SimpleGUI.DrawFoldout("Unsafe Simulation", "VERY UNSAFE"))
{
if (!EditorApplication.isPlaying)
{
DrawGlobalOptions(GotoUdonSettings.Instance);
}
}
SimpleGUI.DrawFooterInformation();
GUILayout.EndScrollView();
}
/// <summary>
/// Registers the implementation for channel.
/// </summary>
/// <param name="contractType">Type of the contract.</param>
/// <param name="channelId">The channel id.</param>
/// <param name="defaultImplementationType">Default type of the implementation.</param>
public static void RegisterImplementationForChannel(Type contractType, string channelId, Type defaultImplementationType)
{
DoInitializeCheck();
if (contractType == null)
{
ThrowHelper.ThrowArgumentNullException("contractType");
}
if (!ChannelServices.IsChannelRegistered(channelId))
{
ThrowHelper.ThrowArgumentException("Default channel identifier has not found.");
}
lock (mContractDescriptors)
{
if (mContractDescriptors.ContainsKey(contractType))
{
ContractClientSideDescriptor descriptor = mContractDescriptors[contractType];
if (defaultImplementationType == null)
{
if (descriptor.ImplementationPerChannel.ContainsKey(channelId))
{
descriptor.ImplementationPerChannel.Remove(channelId);
}
}
else
{
ImplementationValidator.ValidateProxyIntegration(defaultImplementationType);
if (descriptor.ImplementationPerChannel.ContainsKey(channelId))
{
descriptor.ImplementationPerChannel[channelId] = defaultImplementationType;
}
else
{
descriptor.ImplementationPerChannel.Add(channelId, defaultImplementationType);
}
}
}
else
{
ThrowHelper.ThrowArgumentException("Contract type has not been registered.");
}
}
}
/// <summary>
/// Registers the contract.
/// </summary>
/// <param name="contractType">Type of the contract.</param>
/// <param name="defaultImplementationType">Default type of the implementation.</param>
public static void RegisterContract(Type contractType, Type defaultImplementationType)
{
DoInitializeCheck();
if (contractType == null)
{
ThrowHelper.ThrowArgumentNullException("contractType");
}
ContractValidator.ValidateContractIntegrity(contractType);
if (defaultImplementationType != null)
{
ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType);
}
lock (mContractDescriptors)
{
if (mContractDescriptors.ContainsKey(contractType))
{
ThrowHelper.ThrowArgumentException("Contract type has already registered.");
}
mContractDescriptors.Add(contractType, new ContractServiceSideDescriptor(contractType, defaultImplementationType));
}
}
public static void Initialize()
{
if (!mInitialized)
{
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.Before) });
ChannelServices.Initialize();
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("Initializing ServiceBase services.");
}
CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, "Services");
if (pi != null)
{
IEnumerator <CategoryPropertyItem> iterator = pi.GetEnumerator();
try
{
while (iterator.MoveNext())
{
pi = iterator.Current;
if (string.IsNullOrEmpty(pi.Id))
{
throw new InvalidConfigurationException("Contract type not definied. Empty item found in configuration.");
}
Type contractType = null;
Type defaultImplementationType = null;
try
{
contractType = TypeHelper.GetTypeFromString(pi.Id);
if (ContractDescriptors.ContainsKey(contractType))
{
throw new InvalidConfigurationException(String.Format("Duplicated contract type configuration found in services. Contract: {0}", contractType.FullName));
}
ContractValidator.ValidateContractIntegrity(contractType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve contract type: {0}", pi.Id), ex);
}
if (!string.IsNullOrEmpty(pi.EntryValue))
{
try
{
defaultImplementationType = TypeHelper.GetTypeFromString(pi.EntryValue);
if (!contractType.IsAssignableFrom(defaultImplementationType))
{
throw new InvalidProxyImplementationException(String.Format("Provided default implementation type '{0}' does not implement contract interface '{1}'.", defaultImplementationType.FullName, contractType.FullName));
}
ImplementationValidator.ValidateImplementationIntegrity(defaultImplementationType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve implementation type: {0}", pi.EntryValue), ex);
}
}
ContractServiceSideDescriptor descriptor = new ContractServiceSideDescriptor(contractType, defaultImplementationType);
IEnumerator <CategoryPropertyItem> channelIterator = pi.GetEnumerator();
while (channelIterator.MoveNext())
{
CategoryPropertyItem channelImplementationItem = channelIterator.Current;
if (string.IsNullOrEmpty(channelImplementationItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Channel identifier is missing from a configuration item of the contract '{0}'", pi.Id));
}
if (string.IsNullOrEmpty(channelImplementationItem.EntryValue))
{
throw new InvalidConfigurationValueException(String.Format("Implementation type is missing from a configuration item of the contract '{0}'", pi.Id));
}
if (!ChannelServices.IsChannelRegistered(channelImplementationItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Unregistered channel provided '{0}' in configuration section of the contract: {1}.", channelImplementationItem.Id, pi.Id));
}
Type type = null;
try
{
type = TypeHelper.GetTypeFromString(channelImplementationItem.EntryValue);
if (!contractType.IsAssignableFrom(type))
{
throw new InvalidProxyImplementationException(String.Format("Provided implementation type '{0}' does not implement contract interface '{1}'.", type.FullName, contractType.FullName));
}
ImplementationValidator.ValidateImplementationIntegrity(type);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve non-default implementation type: {0} for contract: {1} for the channel: {2}", channelImplementationItem.EntryValue, pi.Id, channelImplementationItem.Id), ex);
}
if (descriptor.ImplementationPerChannel.ContainsKey(channelImplementationItem.Id))
{
throw new InvalidConfigurationException(String.Format("Duplicated channel identifier at contract '{0}'.", pi.Id));
}
descriptor.ImplementationPerChannel.Add(channelImplementationItem.Id, type);
}
ContractDescriptors.Add(contractType, descriptor);
}
ChannelServices.StartListeningChannels();
}
catch (Exception ex)
{
ContractDescriptors.Clear();
throw ex;
}
}
mInitialized = true;
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("ServiceBase services successfully initialized.");
}
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.After) });
}
}
/// <summary>
/// Prevents a default instance of the <see cref="ServiceFactory<TContract>"/> class from being created.
/// </summary>
/// <param name="channelId">The channel id.</param>
/// <param name="implementationType">Type of the implementation.</param>
private ServiceFactory(String channelId, Type implementationType)
{
if (string.IsNullOrEmpty(channelId))
{
ThrowHelper.ThrowArgumentNullException("channelId");
}
if (implementationType == null)
{
ThrowHelper.ThrowArgumentNullException("implementationType");
}
if (!ServiceContract.IsAssignableFrom(implementationType))
{
throw new ArgumentException("Provided implementation does not implements the contract interface.", "implementationType");
}
ContractValidator.ValidateContractIntegrity(ServiceContract);
ImplementationValidator.ValidateImplementationIntegrity(implementationType);
this.mChannel = ChannelServices.GetChannelById(channelId);
if (this.mChannel == null)
{
throw new ChannelNotFoundException(channelId);
}
this.mImplementationType = implementationType;
// adatstruktúra adminisztrációja
// egy factory csak azt adhatja hozzá, ami nincs és csak azt veheti el, ami még nem volt.
ContractServiceSideDescriptor descriptor = null;
Dictionary <Type, ContractServiceSideDescriptor> contractDescriptors = ServiceBaseServices.ContractDescriptors;
lock (contractDescriptors)
{
if (contractDescriptors.ContainsKey(ServiceContract))
{
// ismert contract
descriptor = contractDescriptors[ServiceContract];
}
else
{
// ilyen contract még nincs
mControlServiceContract = true;
mControlChannel = true;
}
}
if (descriptor != null)
{
lock (descriptor)
{
if (!descriptor.ImplementationPerChannel.ContainsKey(channelId))
{
mControlChannel = true;
}
else
{
if (descriptor.ImplementationPerChannel.ContainsKey(channelId))
{
// ehhez a csatornához és contracthoz már egy másik implementáció van rendelve
Type currentImplType = descriptor.ImplementationPerChannel[channelId];
if (!currentImplType.Equals(implementationType))
{
throw new ArgumentException(String.Format("Unable to register provided implementation type: '{0}'. An other implementation type '{1}' has already definied for channel '{2}' and contract '{3}'.", implementationType.FullName, currentImplType.FullName, channelId, ServiceContract.FullName));
}
}
}
}
}
ChannelServices.UnregisterChannelEvent += new EventHandler <ChannelRegistrationEventArgs>(ChannelUnregisteredEventHandler);
}
public static void Initialize()
{
if (!mInitialized)
{
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.Before) });
ChannelServices.Initialize();
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("Initializing client proxy services.");
}
CategoryPropertyItem pi = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, "Clients");
if (pi != null)
{
try
{
IEnumerator <CategoryPropertyItem> iterator = pi.GetEnumerator();
while (iterator.MoveNext())
{
pi = iterator.Current;
if (string.IsNullOrEmpty(pi.Id))
{
throw new InvalidConfigurationException("Contract type not definied. Empty item found in configuration.");
}
Type contractType = null;
String defaultChannelId = null;
Type defaultProxyType = null;
try
{
contractType = TypeHelper.GetTypeFromString(pi.Id);
if (mContractDescriptors.ContainsKey(contractType))
{
throw new InvalidConfigurationException(String.Format("Duplicated contract type configuration found in clients. Contract: {0}", contractType.FullName));
}
ContractValidator.ValidateContractIntegrity(contractType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve contract type: {0}", pi.Id), ex);
}
{
CategoryPropertyItem defaultChannelIdPropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/Defaults/DefaultChannelId", pi.Id));
if (defaultChannelIdPropertyItem != null)
{
defaultChannelId = defaultChannelIdPropertyItem.EntryValue;
if (string.Empty.Equals(defaultChannelId))
{
defaultChannelId = null;
}
}
}
{
CategoryPropertyItem defaultProxyTypePropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/Defaults/DefaultProxyType", pi.Id));
if (defaultProxyTypePropertyItem != null)
{
if (defaultProxyTypePropertyItem.EntryValue != null && !string.Empty.Equals(defaultProxyTypePropertyItem.EntryValue))
{
try
{
defaultProxyType = TypeHelper.GetTypeFromString(defaultProxyTypePropertyItem.EntryValue);
ImplementationValidator.ValidateProxyIntegration(defaultProxyType);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve proxy type: {0} for contract: {1}", defaultProxyTypePropertyItem.EntryValue, pi.Id), ex);
}
}
}
}
if (!(defaultChannelId == null && defaultProxyType == null))
{
if (defaultChannelId == null || defaultProxyType == null)
{
throw new InvalidConfigurationException(String.Format("Both of 'DefaultChannelId' and 'DefaultProxyType' values are must be filled in configuration. Contract type: {0}", pi.Id));
}
if (!contractType.IsAssignableFrom(defaultProxyType))
{
throw new InvalidProxyImplementationException(String.Format("Provided default proxy type '{0}' does not implement contract interface '{1}'.", defaultProxyType.FullName, contractType.FullName));
}
}
ContractClientSideDescriptor descriptor = new ContractClientSideDescriptor(contractType, defaultChannelId, defaultProxyType);
{
CategoryPropertyItem customDefinitionsPropertyItem = ConfigurationAccessHelper.GetCategoryPropertyByPath(RemotingConfiguration.Settings.CategoryPropertyItems, String.Format("Clients/{0}/CustomDefinitions", pi.Id));
if (customDefinitionsPropertyItem != null)
{
IEnumerator <CategoryPropertyItem> customDefinitionsIterator = customDefinitionsPropertyItem.GetEnumerator();
while (customDefinitionsIterator.MoveNext())
{
CategoryPropertyItem channelProxyItem = customDefinitionsIterator.Current;
if (string.IsNullOrEmpty(channelProxyItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Channel identifier is missing from a configuration item at the CustomDefinitions of the contract '{0}'", pi.Id));
}
if (string.IsNullOrEmpty(channelProxyItem.EntryValue))
{
throw new InvalidConfigurationValueException(String.Format("Proxy type is missing from a configuration item at the CustomDefinitions of the contract '{0}'", pi.Id));
}
if (!ChannelServices.IsChannelRegistered(channelProxyItem.Id))
{
throw new InvalidConfigurationValueException(String.Format("Unregistered channel provided '{0}' in CustomDefinitions configuration section of the contract: {1}.", channelProxyItem.Id, pi.Id));
}
Type type = null;
try
{
type = TypeHelper.GetTypeFromString(channelProxyItem.EntryValue);
if (!contractType.IsAssignableFrom(type))
{
throw new InvalidProxyImplementationException(String.Format("Provided proxy type '{0}' does not implement contract interface '{1}'.", type.FullName, contractType.FullName));
}
ImplementationValidator.ValidateProxyIntegration(type);
}
catch (Exception ex)
{
throw new InvalidConfigurationValueException(String.Format("Unable to resolve non-default proxy type: {0} for contract: {1} for the channel: {2}", channelProxyItem.EntryValue, pi.Id, channelProxyItem.Id), ex);
}
if (descriptor.ImplementationPerChannel.ContainsKey(channelProxyItem.Id))
{
throw new InvalidConfigurationException(String.Format("Duplicated channel identifier in CustomDefinitions section at contract '{0}'.", pi.Id));
}
descriptor.ImplementationPerChannel.Add(channelProxyItem.Id, type);
}
}
}
mContractDescriptors.Add(contractType, descriptor);
}
mSingletonInstance = new ProxyServices();
//if (mContractDescriptors.Count > 0)
//{
// mSingletonInstance = new ProxyServices();
//}
}
catch (Exception ex)
{
mContractDescriptors.Clear();
throw ex;
}
}
//ChannelServices.startListeningChannels();
mInitialized = true;
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("Client proxy services successfully initialized.");
}
Raiser.CallDelegatorBySync(EventInitialization, new object[] { null, new ServiceInitializationStateEventArgs(ServiceInitializationStateEnum.After) });
}
}
