public void AddProxyManager(IProxyManager proxyManager)
{
if (proxyManager == null)
{
string msg = "BehaviorTreeManager.AddProxyManager() \n proxyManager is null.";
LogError(msg);
throw new Exception(msg);
}
EProxyType proxyType = proxyManager.GetProxyType();
if (m_ProxyManagers.Count == 0)
{
m_ProxyManagers.Add(proxyManager);
}
else
{
//插入排序，EProxyType的枚举值越大，优先级越高
for (int i = 0; i < m_ProxyManagers.Count; i++)
{
IProxyManager tempProxyManager = m_ProxyManagers[i];
EProxyType tempProxyType = tempProxyManager.GetProxyType();
if (tempProxyType < proxyType)
{
m_ProxyManagers.Insert(i, proxyManager);
break;
}
}
}
}
private static IDisposable BindEditing(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
return(context.WhenAnyValue(c => c.SelectedProxy)
.SelectMany(sp =>
{
if (sp == null)
{
return Observable.Empty <ProxyModel>();
}
return Observable.Merge(
sp.WhenAnyValue(p => p.IsSocks5).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.IsHttp).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.IsMtProto).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.Server).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.Port).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.Username).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.Password).Skip(1).Select(_ => sp),
sp.WhenAnyValue(p => p.Secret).Skip(1).Select(_ => sp));
})
.Accept(sp =>
{
sp.IsSaved = false;
sp.IsServerInputVisible = true;
sp.IsUsernameInputVisible = sp.IsSocks5 || sp.IsHttp;
sp.IsPasswordInputVisible = sp.IsSocks5 || sp.IsHttp;
sp.IsSecretInputVisible = sp.IsMtProto;
}));
}
public LoggedProxyManager(IProxyManager proxyManager)
{
if (proxyManager == null)
throw new ArgumentNullException(nameof(proxyManager));
_proxyManager = proxyManager;
_logger = ServiceLocator.Current.GetInstance<ILogger>();
}
public Checker(ICaptchaService captchaService, IProxyManager proxyManager, IAccountManager accountManager)
{
_captchaService = captchaService;
_proxyManager = proxyManager;
_accountManager = accountManager;
_logger = ServiceLocator.Current.GetInstance <ILogger>();
_eventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>();
}
public Checker(ICaptchaService captchaService, IProxyManager proxyManager, IAccountManager accountManager)
{
_captchaService = captchaService;
_proxyManager = proxyManager;
_accountManager = accountManager;
_logger = ServiceLocator.Current.GetInstance<ILogger>();
_eventAggregator = ServiceLocator.Current.GetInstance<IEventAggregator>();
}
public void Initialize()
{
this.container = DependencyInjection.Instance().Initialize();
this.proxyManager = this.container.Resolve <IProxyManager>();
this.pubSubServicesHostingManager = this.container.Resolve <IPubSubServicesHostingManager>();
this.mockPubSubHost = this.container.Resolve <MockPubSubServerHost>();
}
public StateContext(ILogger logger, IProxyManager proxyManager, ICaptchaService captchaService)
{
_logger = logger;
ProxyManager = proxyManager;
CaptchaService = captchaService;
_restartState = new RestartState(this);
_validationState = new ValidationState(this);
}
public StateContext(ILogger logger, IProxyManager proxyManager, ICaptchaService captchaService)
{
_logger = logger;
ProxyManager = proxyManager;
CaptchaService = captchaService;
_restartState = new RestartState(this);
_validationState = new ValidationState(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="Publisher"/> class.
/// </summary>
/// <param name="proxyManager">The proxy manager.</param>
/// <param name="encryption">The encryption.</param>
public Publisher(IProxyManager proxyManager, IEncryption encryption)
{
this.SimpleEncryption = encryption;
this.ProxyManager = proxyManager;
this.InitializeComponent();
this.InitializeFormState();
this.CreateChannel();
}
public SpyService(IJobService jobService)
{
_jobService = jobService;
_spyAccountManager = new SpyAccountManager();
_accountManager = new AccountManager();
_accountSettingsManager = new AccountSettingsManager();
_proxyManager = new ProxyManager();
_seleniumManager = new SeleniumManager();
}
public LoggedProxyManager(IProxyManager proxyManager)
{
if (proxyManager == null)
{
throw new ArgumentNullException(nameof(proxyManager));
}
_proxyManager = proxyManager;
_logger = ServiceLocator.Current.GetInstance <ILogger>();
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
public InterfaceProxyFactory()
{
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName($"StardewModdingAPI.Proxies, Version={this.GetType().Assembly.GetName().Version}, Culture=neutral"), AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("StardewModdingAPI.Proxies");
this.ProxyManager = new ProxyManager <string>(moduleBuilder, new ProxyManagerConfiguration <string>(
proxyPrepareBehavior: ProxyManagerProxyPrepareBehavior.Eager,
proxyObjectInterfaceMarking: ProxyObjectInterfaceMarking.Disabled
));
}
public HomeService(IJobService jobService, IBackgroundJobService backgroundJobService)
{
_accountManager = new AccountManager();
_accountSettingsManager = new AccountSettingsManager();
_accountStatisticsManager = new StatisticsManager();
_proxyManager = new ProxyManager();
_jobService = jobService;
_jobQueueService = new JobQueueService();
_backgroundJobService = backgroundJobService;
}
public MocksController(IRequestManager requestManager,
IProxyManager proxyManager,
IResponseManager responseManager,
ILogger <MocksController> logger)
{
this._requestManager = requestManager;
this._proxyManager = proxyManager;
this._responseManager = responseManager;
this._logger = logger;
}
private IDisposable BindProxies(IProxyManager proxyManager)
{
return(proxyManager.GetAllProxies()
.SubscribeOn(TaskPoolScheduler.Default)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(proxies =>
{
var models = proxies.Select(ProxyModel.FromProxy);
Model.Proxies = new ObservableCollectionExtended <ProxyModel>(models);
}));
}
public BaseNodeProxy CreateProxy(BaseNode node)
{
if (node == null)
{
//组合节点必须有子节点
string msg = "BehaviorTreeManager.CreateProxy() \n Create nodeProxy failed,node is null.";
LogError(msg);
throw new Exception(msg);
}
//重置节点状态
if (node.Status != ENodeStatus.None)
{
node.Status = ENodeStatus.None;
}
IProxyManager proxyManager = null;
for (int i = 0; i < m_ProxyManagers.Count; i++)
{
IProxyManager tempProxyManager = m_ProxyManagers[i];
ProxyData proxyData = tempProxyManager.GetProxyData(node.ClassType);
if (proxyData != null)
{
proxyManager = tempProxyManager;
break;
}
}
if (proxyManager == null)
{
string msg = $"BehaviorTreeManager.CreateProxy() \n Create nodeProxy failed,proxyManager is null.";
LogError(msg);
throw new Exception(msg);
}
BaseNodeProxy nodeProxy = proxyManager.CreateProxy();
if (nodeProxy == null)
{
string msg = $"BehaviorTreeManager.CreateProxy() \n Create nodeProxy failed,ClassType:{node.ProxyData.ClassType}";
LogError(msg);
throw new Exception(msg);
}
nodeProxy.BeginInit();
nodeProxy.SetNode(node);
nodeProxy.SetData(node.NodeData);
nodeProxy.SetContext(node.Context);
nodeProxy.EndInit();
return(nodeProxy);
}
public static IDisposable BindProxyLogic(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
return(new CompositeDisposable(
context.BindRemoveAction(proxyManager),
context.BindEnableAction(proxyManager),
context.BindAddAction(proxyManager),
context.BindSaveAction(proxyManager),
context.BindList(proxyManager),
context.BindEditing(proxyManager)));
}
private void LoadProxies(IProxyManager proxyManager)
{
proxyManager.GetAllProxies()
.SubscribeOn(TaskPoolScheduler.Default)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(proxies =>
{
var models = proxies.Select(ProxyModel.FromProxy);
Proxies = new List <ProxyModel>(models);
})
.DisposeWith(_modelDisposable);
}
private static IObservable <ProxyModel> RemoveProxy(
this ProxyPopupContext context,
IProxyManager proxyManager,
ProxyModel proxyModel)
{
if (proxyModel.Proxy != null && proxyModel.Proxy.Id != 0)
{
return(proxyManager.RemoveProxy(proxyModel.Proxy)
.Select(_ => proxyModel));
}
return(Observable.Return(proxyModel));
}
private static IDisposable BindSaveAction(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
context.SaveProxyCommand = ReactiveCommand.CreateFromObservable(
(ProxyModel proxyModel) => context.SaveProxy(proxyManager, proxyModel),
null,
RxApp.MainThreadScheduler);
return(context.SaveProxyCommand
.Accept(proxyModel =>
{
proxyModel.IsSaved = true;
}));
}
private IObservable <Unit> RemoveProxy(IProxyManager proxyManager)
{
var proxyModel = Model.SelectedProxy;
if (proxyModel != null)
{
Model.Proxies.Remove(proxyModel);
if (proxyModel.Proxy.Id != 0)
{
return(proxyManager.RemoveProxy(proxyModel.Proxy));
}
}
return(Observable.Empty <Unit>());
}
/// <summary>
/// 加载指定类型的行为树
/// </summary>
/// <param name="path">行为树类型</param>
public IEnumerator InitializeAsync(string path, IProxyManager proxyManager)
{
_proxyManager = proxyManager ?? new CSharpProxyManager();
yield return(_proxyManager.InitializeAsync());
var handle = Addressables.LoadAssetsAsync <TextAsset>(path, t =>
{
var treeData = Serializer.Deserialize <BehaviorTreeData>(t.bytes);
if (treeData != null)
{
dataCache[t.name] = treeData;
}
});
yield return(handle);
}
public static IntPtr CreateOuterProxyInstance(IProxyManager proxyManager, ref Guid riid)
{
IntPtr zero = IntPtr.Zero;
IProxyProvider proxyProvider = proxySupport.GetProxyProvider();
if (proxyProvider == null)
{
throw Fx.AssertAndThrowFatal("Proxy Provider cannot be NULL");
}
Guid guid = riid;
int errorCode = proxyProvider.CreateOuterProxyInstance(proxyManager, ref guid, out zero);
Marshal.ReleaseComObject(proxyProvider);
if (errorCode != HR.S_OK)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(System.ServiceModel.SR.GetString("FailedProxyProviderCreation"), errorCode));
}
return zero;
}
private IDisposable BindActions(IProxyManager proxyManager)
{
Model.PopupTitle = "Proxy settings";
Model.AddProxyCommand = ReactiveCommand.CreateFromObservable(
() => AddProxy(proxyManager));
Model.RemoveProxyCommand = ReactiveCommand.CreateFromObservable(
() => RemoveProxy(proxyManager));
Model.SaveProxyCommand = ReactiveCommand.CreateFromObservable(
() => SaveProxy(proxyManager));
return(Model.WhenAnyValue(c => c.IsProxyEnabled)
.Select(isEnabled => ToggleProxy(proxyManager, isEnabled))
.Subscribe());
}
private static IObservable <ProxyModel> SaveProxy(
this ProxyPopupContext context,
IProxyManager proxyManager,
ProxyModel proxyModel)
{
if (proxyModel.Proxy.Id == 0)
{
return(proxyManager
.AddProxy(proxyModel.ToProxy())
.Do(proxy => proxyModel.Proxy = proxy)
.Select(_ => proxyModel));
}
return(proxyManager
.UpdateProxy(proxyModel.Proxy)
.Do(proxy => proxyModel.Proxy = proxy)
.Select(_ => proxyModel));
}
public Main()
{
InitializeComponent();
var eventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>();
eventAggregator.AddListener(this);
_logger = ServiceLocator.Current.GetInstance <ILogger>();
_captchaService = ServiceLocator.Current.GetInstance <ICaptchaService>();
_proxyManager = new LoggedProxyManager(new ProxyManager());
_accountManager = new AccountManager();
_accountsChecker = new Checker(_captchaService, _proxyManager, _accountManager);
_accountsChecker.OnCheckCompleted += AccountsCheckerOnCheckCompleted;
}
public static IntPtr CreateOuterProxyInstance(IProxyManager proxyManager, ref Guid riid)
{
IntPtr zero = IntPtr.Zero;
IProxyProvider proxyProvider = proxySupport.GetProxyProvider();
if (proxyProvider == null)
{
throw Fx.AssertAndThrowFatal("Proxy Provider cannot be NULL");
}
Guid guid = riid;
int errorCode = proxyProvider.CreateOuterProxyInstance(proxyManager, ref guid, out zero);
Marshal.ReleaseComObject(proxyProvider);
if (errorCode != HR.S_OK)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(System.ServiceModel.SR.GetString("FailedProxyProviderCreation"), errorCode));
}
return(zero);
}
private IObservable <Unit> ToggleProxy(
IProxyManager proxyManager,
bool isEnabled)
{
if (isEnabled)
{
if (Model.SelectedProxy != null)
{
return(proxyManager.DisableProxy()
.Concat(proxyManager.EnableProxy(Model.SelectedProxy.Proxy)));
}
}
else
{
proxyManager.DisableProxy();
}
return(Observable.Empty <Unit>());
}
private static IObservable <ProxyModel> AddProxy(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
var proxy = new TdApi.Proxy
{
Server = null,
Port = 0,
Type = new TdApi.ProxyType.ProxyTypeSocks5
{
Username = null,
Password = null
}
};
var proxyModel = ProxyModel.FromProxy(proxy);
return(Observable.Return(proxyModel));
}
private IObservable <Unit> AddProxy(IProxyManager proxyManager)
{
var proxy = new TdApi.Proxy
{
Server = null,
Port = 0,
Type = new TdApi.ProxyType.ProxyTypeSocks5
{
Username = null,
Password = null
}
};
var proxyModel = ProxyModel.FromProxy(proxy);
Model.Proxies.Add(proxyModel);
return(Observable.Empty <Unit>());
}
private static IDisposable BindAddAction(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
context.AddProxyCommand = ReactiveCommand.CreateFromObservable(
() => context.AddProxy(proxyManager),
null,
RxApp.MainThreadScheduler);
return(context.AddProxyCommand
.Accept(proxyModel =>
{
proxyModel.RemoveCommand = context.RemoveProxyCommand;
proxyModel.EnableCommand = context.EnableProxyCommand;
context.Proxies.Add(proxyModel);
context.SelectedProxy = proxyModel;
}));
}
private void ToggleProxy(IProxyManager proxyManager, bool isEnabled)
{
if (isEnabled)
{
if (SelectedProxy != null)
{
proxyManager.DisableProxy()
.Concat(proxyManager.EnableProxy(SelectedProxy.Proxy))
.Subscribe()
.DisposeWith(_modelDisposable);
}
}
else
{
proxyManager.DisableProxy()
.Subscribe()
.DisposeWith(_modelDisposable);
}
}
private IObservable <Unit> SaveProxy(IProxyManager proxyManager)
{
var proxyModel = Model.SelectedProxy;
if (proxyModel != null)
{
if (proxyModel.Proxy.Id != 0)
{
return(proxyManager.AddProxy(proxyModel.ToProxy())
.Do(proxy => proxyModel.Proxy = proxy)
.Select(_ => Unit.Default));
}
return(proxyManager.UpdateProxy(proxyModel.Proxy)
.Do(proxy => proxyModel.Proxy = proxy)
.Select(_ => Unit.Default));
}
return(Observable.Empty <Unit>());
}
private static IDisposable BindRemoveAction(
this ProxyPopupContext context,
IProxyManager proxyManager)
{
context.RemoveProxyCommand = ReactiveCommand.CreateFromObservable(
(ProxyModel proxyModel) => context.RemoveProxy(proxyManager, proxyModel),
null,
RxApp.MainThreadScheduler);
return(context.RemoveProxyCommand
.Accept(proxyModel =>
{
if (proxyModel == context.SelectedProxy)
{
context.SelectedProxy = context.Proxies.FirstOrDefault();
}
context.Proxies.Remove(proxyModel);
}));
}
public static IntPtr CreateOuterProxyInstance(IProxyManager proxyManager, ref Guid riid)
{
IntPtr pOuter = IntPtr.Zero;
IProxyProvider proxyProvider = proxySupport.GetProxyProvider();
if (proxyProvider == null)
{
throw Fx.AssertAndThrowFatal("Proxy Provider cannot be NULL");
}
Guid riid2 = riid;
int hr = proxyProvider.CreateOuterProxyInstance(proxyManager, ref riid2, out pOuter);
Marshal.ReleaseComObject(proxyProvider);
if (hr != HR.S_OK)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.FailedProxyProviderCreation), hr));
return pOuter;
}
