public APIControllerBase(IConfigProvider configProvider, ILogr logger)
{
config = configProvider;
logr = logger;
DCCConnectionString = config.CnnString(Constants.DCC_CNN_STRING);
repo = new DBDCCRepository(DCCConnectionString, logr);
}
public ServiceCallerWrapper(IConfigProvider configProvider)
: base(configProvider)
{
var factory = new BoolPropertyMockFactory();
factory.SetReturnValues(true, false);
MainLoopRunningMock = factory.Create();
}
public ServiceCaller(IConfigProvider configProvider)
{
_configProvider = configProvider;
_dateTimeNow = () => DateTime.Now;
_threadSleep = (x) => Thread.Sleep(x);
MainLoopRunning = true;
}
public HomeModule(IConfigProvider configProvider, IJwtWrapper jwtWrapper)
{
Get["/login"] = _ => View["Login"];
Post["/login"] = _ =>
{
var user = this.Bind<UserCredentials>();
//Verify user/pass
if (user.User != "fred" && user.Password != "securepwd")
{
return 401;
}
var jwttoken = new JwtToken()
{
Issuer = "http://issuer.com",
Audience = "http://mycoolwebsite.com",
Claims =
new List<Claim>(new[]
{
new Claim("http://schemas.microsoft.com/ws/2008/06/identity/claims/role", "Administrator"),
new Claim(ClaimTypes.Name, "Fred")
}),
Expiry = DateTime.UtcNow.AddDays(7)
};
var token = jwtWrapper.Encode(jwttoken, configProvider.GetAppSetting("securekey"), JwtHashAlgorithm.HS256);
return Negotiate.WithModel(token);
};
Get["/"] = _ => "Hello Secure World!";
}
public SeriesProvider(IDiskProvider diskProvider, IConfigProvider configProvider, IRepository dataRepository, ITvDbProvider tvDbProvider)
{
_diskProvider = diskProvider;
_config = configProvider;
_sonioRepo = dataRepository;
_tvDb = tvDbProvider;
}
public HarmonicKeyConverterFactory(IConfigProvider configProvider) : this(
new TraditionalTextHarmonicKeyConverter(),
new TraditionalSymbolsHarmonicKeyConverter(),
new KeyCodeHarmonicKeyCoverter(),
new Id3v2TkeyHarmonicKeyConverter(),
new OpenKeyNotationHarmonicKeyConverter(),
new BeatportHarmonicKeyConverter(),
configProvider) {}
public ConfigSwitchingBpmRangeChecker(
IConfigProvider configProvider,
IBpmRangeChecker impl)
{
if (configProvider == null) throw new ArgumentNullException("configProvider");
if (impl == null) throw new ArgumentNullException("impl");
this.configProvider = configProvider;
this.impl = impl;
}
public ConfigSwitchingFilenameParser(
IConfigProvider configProvider,
IFilenameParser impl)
{
if (configProvider == null) throw new ArgumentNullException("configProvider");
if (impl == null) throw new ArgumentNullException("impl");
this.configProvider = configProvider;
this.impl = impl;
}
public virtual void SetUp()
{
var factory = ConnectionFactory.GetDefault();
_connectionPool = new DefaultConnectionPool(_defaultClientConfig.ConnectionPoolConfiguration, Node.GetEndPoint(Server), factory);
_connectionPool.Initialize();
_provider = new FileSystemConfigProvider(_defaultClientConfig, ConnectionFactory.GetDefault());
_configInfo = _provider.GetCached();
_vBucket = _configInfo.HashToVBucket(Key);
}
public void ConfigurePlugins(IConfigProvider configProvider)
{
var config = configProvider.GetRootConfig();
//for each enabled plugin
foreach (var plugin in GetConfigPlugins())
{
plugin.Config(configProvider);
}
}
public void SetUp()
{
var configuration = ClientConfigUtil.GetConfiguration();
_provider = new HttpStreamingProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
new ManualByteConverter(),
new DefaultTranscoder(new ManualByteConverter()));
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigSource"/> class.
/// </summary>
/// <param name="provider">The provider this source encapsulates.</param>
/// <param name="alias">The alias of the source, i.e. short friendly name the user can potentially supply.</param>
/// <param name="iconUri">The icon URI associated with the source. this will most likely be the same as its creating <see cref="IProvideConfigSource"/>.</param>
/// <exception cref="System.ArgumentNullException">provider;A provider cannot be null.</exception>
public ConfigSource(IConfigProvider provider, string alias = null, Uri iconUri = null)
{
if (provider == null)
{
throw new ArgumentNullException("provider", "A provider cannot be null.");
}
this.Provider = provider;
this.Alias = alias;
this.IconUri = iconUri;
}
public void SetUp()
{
var configuration = new ClientConfiguration();
_provider = new HttpStreamingProvider(
configuration,
(pool) => new DefaultIOStrategy(pool),
(config, endpoint) => new ConnectionPool<EapConnection>(config, endpoint),
SaslFactory.GetFactory3(),
new ManualByteConverter(),
new TypeSerializer(new ManualByteConverter()));
}
public NzbImportProvider(IDiskProvider disk, IHttpProvider http, IDecompressProvider decompress, INzbParseProvider parse, INzbQueueProvider queue, INntpProvider nntp, IPreQueueProvider preQueue, IConfigProvider config)
{
_disk = disk;
_http = http;
_decompress = decompress;
_parse = parse;
_queue = queue;
_list = new List<NzbImportModel>();
_nntp = nntp;
_preQueue = preQueue;
_config = config;
}
public void Config(IConfigProvider provider)
{
var config = provider.GetPluginConfigPart("redis");
foreach (var child in config.Children())
{
string hostName = ((JProperty) child).Name;
string host = child.First["Host"].Value<string>();
int port = child.First["Port"].Value<int>();
int timeout = child.First["Timeout"].Value<int>();
connections.Add(hostName, ConnectionUtils.Connect(string.Format("{0}:{1}", host, port), false));
}
}
public void SetUp()
{
var configuration = ClientConfigUtil.GetConfiguration();
_provider = new HttpStreamingProvider(
configuration,
(pool) => new PooledIOService(pool),
(config, endpoint) => new ConnectionPool<Connection>(config, endpoint),
SaslFactory.GetFactory(),
#pragma warning disable 618
new DefaultConverter(),
new DefaultTranscoder(new ManualByteConverter()));
#pragma warning restore 618
}
/// <summary>
/// Tries to get a section of this type from the config.
/// </summary>
/// <param name="mgr">The config manager.</param>
/// <param name="provider">The provider to redirect to, if found.</param>
/// <returns><see langword="true"/> if found, otherwise <see langword="false"/></returns>
internal static bool TryGetRedirect(IConfigManager mgr, out IConfigProvider provider)
{
var cfgRedir = mgr.GetSettings<ConfigurationRedirect>();
provider = null;
if (cfgRedir != null)
{
provider = cfgRedir.ActualProvider;
}
return (provider != null);
}
public void TestFixtureSetup()
{
_config = new ConnectionPoolConfig(10, 5, 1000, 1000, 1000, 1000);
var factory = ConnectionFactory.GetDefault();
_connectionPool = new DefaultConnectionPool(_config, Node.GetEndPoint(Server), factory);
_connectionPool.Initialize();
_provider = new FileSystemConfigProvider(_defaultClientConfig, ConnectionFactory.GetDefault());
_configInfo = _provider.GetCached();
_ioStrategy = new AwaitableIOStrategy(_connectionPool, null);
_state = _state = new ClusterState(_defaultClientConfig);
}
public WebLogger(IConfigProvider configurationProvider)
: base(configurationProvider)
{
try
{
if (config[CONFIG_KEY_LOG_TO_ELMAH] == "true")
{
logToElmah = true;
}
}
catch { } // ignore
}
public RssAggregator(IRssService rssService, IConfigProvider urlProvider)
{
if (rssService == null)
{
throw new ArgumentNullException("rssService");
}
if (urlProvider == null)
{
throw new ArgumentNullException("urlProvider");
}
this.rssService = rssService;
this.urlProvider = urlProvider;
}
public TwitterAggregator(ITwitterService twitterService, IConfigProvider queryProvider)
{
if (twitterService == null)
{
throw new ArgumentNullException("twitterService");
}
if (queryProvider == null)
{
throw new ArgumentNullException("queryProvider");
}
this.twitterService = twitterService;
this.queryProvider = queryProvider;
}
public void Config(IConfigProvider provider)
{
var config = provider.GetPluginConfigPart("network");
var server = config["server"].Value<string>();
int idx = server.IndexOf(':');
if (idx > 0)
{
host = server.Substring(0, idx);
port = int.Parse(server.Substring(idx + 1));
}
else
{
host = server;
port = 25826;
}
}
public UsersModule(IConfigProvider configProvider, IJwtWrapper jwtWrapper)
: base("/users")
{
_configProvider = configProvider;
_jwtWrapper = jwtWrapper;
Post["/"] = r => CreateUser();
Post["/login"] = r => Login();
Post["/clientkey"] = r => SaveKey();
Post["/devicetoken"] = r => SaveAppleToken();
Post["/clearkey"] = r => ClearKey();
Post["/forgot"] = r => ForgotPassword();
Post["/updateEmail"] = r => UpdateEmail();
Post["/updatePassword"] = r => UpdatePassword();
Post["/saveAvatar"] = r => UpdateUserAvatar();
Post["/saveuser"] = r => UpdateUserProfile();
}
private void Construct(IBadgeService badgeService,
IAciEventManager eventManager,
IBot bot,
IWorkflowService workflowService,
ITimeTrackingRepository timeTracker,
IAdaptivityService adaptivityService,
FeedbackActivityFactory activityFactory,
IConfigProvider configProvider)
{
m_BadgeService = badgeService;
m_EventManager = eventManager;
m_Factory = activityFactory;
m_Bot = bot;
m_TimeTracker = timeTracker;
m_WorkflowService = workflowService;
m_AdaptivityService = adaptivityService;
m_ConfigProvider = configProvider;
}
public AuthModule(IConfigProvider config) : base("/api/v1/auth")
{
Post["/"] = p =>
{
LoginModel model = this.Bind <LoginModel>();
User user = null;
using (var cnn = Connection)
{
user = cnn.Query <User>(
"select * from users where email = @username",
new { username = model.Username }).FirstOrDefault();
}
if (user == null)
{
return(HttpStatusCode.Unauthorized);
}
if (!BCrypt.Net.BCrypt.Verify(model.Password, user.Password))
{
return(HttpStatusCode.Unauthorized);
}
var jwtToken = new JwtToken
{
Expiry = DateTime.UtcNow.AddDays(9999),
UserId = user.Id
};
jwtToken.Claims.Add(user.Email == "*****@*****.**"
? new Claim(ClaimTypes.Role, "Administrator")
: new Claim(ClaimTypes.Role, "User"));
jwtToken.Claims.Add(new Claim(ClaimTypes.Email, user.Email));
jwtToken.Claims.Add(new Claim(ClaimTypes.Name, user.Email));
jwtToken.Claims.Add(new Claim(ClaimTypes.Sid, user.Id.ToString()));
var token = JsonWebToken.Encode(jwtToken, config.GetAppSetting("secret"), JwtHashAlgorithm.HS256);
return(Response.AsJson(token));
};
}
public NdmRequiredServices(IConfigProvider configProvider, IConfigManager configManager, INdmConfig ndmConfig,
string baseDbPath, IDbProvider rocksProvider, IMongoProvider mongoProvider, ILogManager logManager,
IBlockTree blockTree, ITxPool transactionPool, ISpecProvider specProvider, IReceiptStorage receiptStorage,
IFilterStore filterStore, IFilterManager filterManager, IWallet wallet, ITimestamper timestamper,
IEthereumEcdsa ecdsa, IKeyStore keyStore, IRpcModuleProvider rpcModuleProvider,
IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager ndmConsumerChannelManager, INdmDataPublisher ndmDataPublisher,
IGrpcServer grpcServer, IEthRequestService ethRequestService, INdmNotifier notifier,
bool enableUnsecuredDevWallet, IBlockProcessor blockProcessor, IJsonRpcClientProxy jsonRpcClientProxy,
IEthJsonRpcClientProxy ethJsonRpcClientProxy, IHttpClient httpClient, IMonitoringService monitoringService)
{
ConfigProvider = configProvider;
ConfigManager = configManager;
NdmConfig = ndmConfig;
BaseDbPath = baseDbPath;
RocksProvider = rocksProvider;
MongoProvider = mongoProvider;
LogManager = logManager;
BlockTree = blockTree;
TransactionPool = transactionPool;
SpecProvider = specProvider;
ReceiptStorage = receiptStorage;
FilterStore = filterStore;
FilterManager = filterManager;
Wallet = wallet;
Timestamper = timestamper;
Ecdsa = ecdsa;
KeyStore = keyStore;
RpcModuleProvider = rpcModuleProvider;
JsonSerializer = jsonSerializer;
CryptoRandom = cryptoRandom;
Enode = enode;
NdmConsumerChannelManager = ndmConsumerChannelManager;
NdmDataPublisher = ndmDataPublisher;
GrpcServer = grpcServer;
EthRequestService = ethRequestService;
Notifier = notifier;
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
BlockProcessor = blockProcessor;
JsonRpcClientProxy = jsonRpcClientProxy;
EthJsonRpcClientProxy = ethJsonRpcClientProxy;
HttpClient = httpClient;
MonitoringService = monitoringService;
}
public HiveRunner(
IBlockTree blockTree,
IConfigProvider configurationProvider,
ILogger logger,
IFileSystem fileSystem,
IBlockValidator blockValidator,
ITracer tracer)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_configurationProvider =
configurationProvider ?? throw new ArgumentNullException(nameof(configurationProvider));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
_blockValidator = blockValidator;
_tracer = tracer;
_resetEvent = new SemaphoreSlim(0);
}
public EthereumRunnerContextFactory(IConfigProvider configProvider, IJsonSerializer ethereumJsonSerializer, ILogManager logManager)
{
_configProvider = configProvider;
_logManager = logManager;
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
ILogger logger = _logManager.GetClassLogger();
if (logger.IsInfo)
{
logger.Info($"Loading chain spec from {initConfig.ChainSpecPath}");
}
IChainSpecLoader loader = new ChainSpecLoader(ethereumJsonSerializer);
ChainSpec chainSpec = loader.LoadFromFile(initConfig.ChainSpecPath);
Context = Create(chainSpec.SealEngineType);
Context.ChainSpec = chainSpec;
Context.SpecProvider = new ChainSpecBasedSpecProvider(Context.ChainSpec);
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public PluralsightMainViewModel(ILoginService loginService, ICourseService courseService, IConfigProvider configProvider)
{
_configProvider = configProvider;
CurrentUserAgent = _configProvider.UserAgent;
_courseService = courseService;
NumberOfSelectedCourses = 0;
AuthenticatedUser authenticatedUser = Newtonsoft.Json.JsonConvert.DeserializeObject <AuthenticatedUser>(loginService.LoginResultJson);
Title = $"{authenticatedUser.CurrentUser.FirstName} {authenticatedUser.CurrentUser.LastName} ({authenticatedUser.CurrentUser.Email})";
CourseTagSelectedCommand = new RelayCommand <string>(OnCourseTagSelected);
CancelDownloadsCommand = new RelayCommand(OnCancelDownloads, CanCancelDownload);
OpenDownloadsFolderCommand = new RelayCommand(OnOpenDownloadsFolder);
OpenSettingsWindowCommand = new RelayCommand(OnOpenSettingsWindow);
ProductCheckBoxToggledCommand = new RelayCommand <bool>(OnProductCheckBoxToggledCommand);
DownloadCourseCommand = new RelayCommand(OnDownloadCourseAsync, CanExecuteDownload);
NumberOfCoursesForTag = _courseService.CoursesByToolName.ToDictionary(kvp => kvp.Key, v => v.Value.Count);
AllCourses = _courseService.CoursesByToolName.Values.SelectMany(x => x).Distinct().ToList();
}
public ComplexHotkeyTracker(
[NotNull] IHotkeyConverter hotkeyConverter,
[NotNull] IConfigProvider <MicSwitchConfig> configProvider,
[NotNull] IFactory <IHotkeyTracker> hotkeyTrackerFactory)
{
this.hotkeyConverter = hotkeyConverter;
this.configProvider = configProvider;
this.hotkeyTrackerFactory = hotkeyTrackerFactory;
Log.Debug($"Scheduling HotkeyTracker initialization using background scheduler");
var bgThread = new Thread(x => Initialize())
{
IsBackground = true,
ApartmentState = ApartmentState.STA,
Name = "HotkeyTracker"
};
bgThread.Start();
}
public void Setup()
{
_ndmModule = Substitute.For <INdmModule>();
_ndmConsumersModule = Substitute.For <INdmConsumersModule>();
_configProvider = Substitute.For <IConfigProvider>();
_dbProvider = Substitute.For <IDbProvider>();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_txSender = Substitute.For <ITxSender>();
_specProvider = Substitute.For <ISpecProvider>();
_receiptFinder = Substitute.For <IReceiptFinder>();
_wallet = Substitute.For <IWallet>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_timestamper = Substitute.For <ITimestamper>();
_ecdsa = Substitute.For <IEthereumEcdsa>();
_rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
_keyStore = Substitute.For <IKeyStore>();
_jsonSerializer = Substitute.For <IJsonSerializer>();
_cryptoRandom = Substitute.For <ICryptoRandom>();
_enode = Substitute.For <IEnode>();
_consumerChannelManager = Substitute.For <INdmConsumerChannelManager>();
_dataPublisher = Substitute.For <INdmDataPublisher>();
_grpcServer = Substitute.For <IGrpcServer>();
_nodeStatsManager = Substitute.For <INodeStatsManager>();
_protocolsManager = Substitute.For <IProtocolsManager>();
_protocolValidator = Substitute.For <IProtocolValidator>();
_messageSerializationService = Substitute.For <IMessageSerializationService>();
_webSocketsManager = Substitute.For <IWebSocketsManager>();
_logManager = LimboLogs.Instance;
_blockProcessor = Substitute.For <IBlockProcessor>();
_jsonRpcClientProxy = Substitute.For <IJsonRpcClientProxy>();
_ethJsonRpcClientProxy = Substitute.For <IEthJsonRpcClientProxy>();
_httpClient = Substitute.For <IHttpClient>();
_monitoringService = Substitute.For <IMonitoringService>();
_enableUnsecuredDevWallet = false;
_ndmConfig = new NdmConfig {
Enabled = true, StoreConfigInDatabase = false
};
_configProvider.GetConfig <INdmConfig>().Returns(_ndmConfig);
_ndmInitializer = new NdmInitializer(_ndmModule, _ndmConsumersModule, _logManager);
_bloomStorage = Substitute.For <IBloomStorage>();
}
private StreamWriter OpenFile(IConfigProvider configProvider)
{
var parameters = configProvider.Get <LogFileParameters>();
var logFileName = Path.Combine(parameters.LogFolder, $"PerformanceTester_{DateTime.Now:yyyy-MM-dd_hhmmss}.log");
try
{
var fs = new FileStream(logFileName, FileMode.CreateNew);
var ts = new StreamWriter(fs, Encoding.UTF8);
_fileStream = fs;
Console.WriteLine($"Log file :\"{logFileName}\"");
return(ts);
}
catch (Exception e)
{
Console.WriteLine($"Could not open log file \"{logFileName}\" - {e.Message}");
throw;
}
}
protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
containerRegistry.RegisterForNavigation <NavigationPage>("Nav");
containerRegistry.RegisterForNavigation <LoginView, LoginViewModel>("Login");
containerRegistry.RegisterForNavigation <MainView, MainViewModel>("Main");
Simple.OData.Client.V4Adapter.Reference();
containerRegistry.GetBuilder().Register(c =>
{
ISecurityService securityService = c.Resolve <ISecurityService>();
ODataClient odataClient = new ODataClient(new ODataClientSettings(new Uri(c.Resolve <IConfigProvider>().HostUri, "odata/Test/"))
{
OnCreateMessageHandler = () => new TokenHandler(securityService, new HttpClientHandler())
});
return(odataClient);
});
containerRegistry.GetBuilder().Register(c =>
{
ISecurityService securityService = c.Resolve <ISecurityService>();
HttpClient httpClient = new HttpClient(new TokenHandler(securityService, new HttpClientHandler()))
{
BaseAddress = c.Resolve <IConfigProvider>().HostUri
};
return(httpClient);
}).SingleInstance();
containerRegistry.GetBuilder().Register(c =>
{
IConfigProvider configProvider = c.Resolve <IConfigProvider>();
return(new TokenClient(address: new Uri(configProvider.HostUri, "core/connect/token").ToString(), clientId: configProvider.OAuthResourceOwnerFlowClientId, clientSecret: configProvider.OAuthResourceOwnerFlowSecret));
}).SingleInstance();
containerRegistry.RegisterSingleton <BitOAuth2Authenticator>();
containerRegistry.RegisterSingleton <OAuthLoginPresenter>();
containerRegistry.RegisterSingleton <ISecurityService, DefaultSecurityService>();
containerRegistry.RegisterSingleton <IConfigProvider, TestConfigProvider>();
containerRegistry.RegisterSingleton <IDateTimeProvider, DefaultDateTimeProvider>();
containerRegistry.GetBuilder().Register(c => AccountStore.Create()).SingleInstance();
}
public void OnApplicationStart()
{
config = Conf.CreateConfig(ConfigType.YAML, BeatSaber.UserDataPath, "Particular");
try
{
HarmonyInstance harmony = HarmonyInstance.Create("com.jackbaron.beatsaber.particular");
harmony.PatchAll(Assembly.GetExecutingAssembly());
}
catch (Exception e)
{
log.Error(
"This plugin requires Harmony. Make sure you installed the plugin properly, " +
"as the Harmony DLL should have been installed with it."
);
log.Critical(e);
}
}
public AuthService(ICacheHandler cacheHandler, IAccountRepository accountRepository, IAccountAuthInfoRepository authInfoRepository, IAccountConfigRepository configRepository, IServiceProvider serviceProvider, ILoginInfo loginInfo, IConfigProvider configProvider, IVerifyCodeProvider verifyCodeProvider, IUserNameLoginHandler userNameLoginHandler, IEmailLoginHandler emailLoginHandler, IUserNameOrEmailLoginHandler userNameOrEmailLoginHandler, IPhoneLoginHandler phoneLoginHandler, IPhoneVerifyCodeProvider phoneVerifyCodeProvider, IAccountPermissionResolver permissionResolver, ICustomLoginHandler customLoginHandler, DateTimeHelper dateTimeHelper)
{
_cacheHandler = cacheHandler;
_accountRepository = accountRepository;
_authInfoRepository = authInfoRepository;
_configRepository = configRepository;
_serviceProvider = serviceProvider;
_loginInfo = loginInfo;
_configProvider = configProvider;
_verifyCodeProvider = verifyCodeProvider;
_userNameLoginHandler = userNameLoginHandler;
_emailLoginHandler = emailLoginHandler;
_userNameOrEmailLoginHandler = userNameOrEmailLoginHandler;
_phoneLoginHandler = phoneLoginHandler;
_phoneVerifyCodeProvider = phoneVerifyCodeProvider;
_permissionResolver = permissionResolver;
_customLoginHandler = customLoginHandler;
_dateTimeHelper = dateTimeHelper;
}
public void Init(IPALogger logger, [Config.Prefer("json")] IConfigProvider cfgProvider)
{
Logger.log = logger;
configProvider = cfgProvider;
config = cfgProvider.MakeLink <PluginConfig>((p, v) => {
if (v.Value == null || v.Value.RegenerateConfig)
{
p.Store(v.Value = new PluginConfig()
{
RegenerateConfig = false
});
}
config = v;
});
InitHarmony();
}
public static void SaveConfig(string path, IConfigProvider provider)
{
if (!CheckPath(ref path))
{
return;
}
var directory = FileManagerSecure.GetDirectoryName(path);
if (!FileManagerSecure.DirectoryExists(directory))
{
FileManagerSecure.CreateDirectory(directory);
}
var config = new JSONClass();
provider.StoreConfig(config);
Controller.SaveJSON(config, path, () => SuperController.LogMessage($"Saved config! \"{path}\""), null, null);
}
public void Setup()
{
repoPath = DefaultRepoPath;
workingPath = DefaultWorkingPath;
var options = Options.Create(new GitVersionOptions {
WorkingDirectory = repoPath
});
var sp = ConfigureServices(services =>
{
services.AddSingleton(options);
});
fileSystem = sp.GetService <IFileSystem>();
configurationProvider = sp.GetService <IConfigProvider>();
configFileLocator = sp.GetService <IConfigFileLocator>();
ShouldlyConfiguration.ShouldMatchApprovedDefaults.LocateTestMethodUsingAttribute <TestAttribute>();
}
/// <summary>
/// Uses CreateTypedConfig method to return strongly typed configuration object.
/// </summary>
/// <returns>A strongly typed configuration package</returns>
/// <remarks>
/// This method will always return the most recent configuration settings without the need to
/// restart the consuming application. For best results, call this method often rather than calling once at startup.
/// </remarks>
public virtual T GetConfiguration()
{
string callingAssemblyName = Assembly.GetCallingAssembly().GetName().Name;
IConfigProviderFactory configProviderFactory = _configProviderFactory ?? new ConfigProviderFactory(callingAssemblyName);
IConfigProvider applicationConfigProvider = configProviderFactory.Create(ApplicationComponentName, _applicationValidationMappings);
ConfigRoot applicationConfig = applicationConfigProvider.GetAndValidateConfiguration();
IConfigProvider environmentConfigProvider = configProviderFactory.Create(EnvironmentComponentName, _environmentValidationMappings);
ConfigRoot environmentConfig = environmentConfigProvider.GetAndValidateConfiguration();
// In order to keep the config names short and simple, we'll remove application/environment names as prefixes. The consuming application does not need this information.
var originalApplicationConfigDictionary = applicationConfig.Data.ToDictionary();
var originalEnvironmentConfigDictionary = environmentConfig.Data.ToDictionary();
var modifiedApplicationConfigDictionary = originalApplicationConfigDictionary.ToDictionary(originalKey => RemoveComponentPrefix(originalKey.Key, string.Format("{0}.", ApplicationComponentName)), y => y.Value);
var modifiedEnvironmentConfigDictionary = originalEnvironmentConfigDictionary.ToDictionary(originalKey => RemoveComponentPrefix(originalKey.Key, string.Format("{0}.", EnvironmentComponentName)), y => y.Value);
return(CreateTypedConfig(modifiedApplicationConfigDictionary, modifiedEnvironmentConfigDictionary));
}
public AuthService(ICacheHandler cacheHandler, IAccountRepository accountRepository, IAccountAuthInfoRepository authInfoRepository, IAccountConfigRepository configRepository, IServiceProvider serviceProvider, IMenuRepository menuRepository, IMapper mapper, ILoginInfo loginInfo, IVerifyCodeProvider verifyCodeProvider, UserNameLoginHandler userNameLoginHandler, EmailLoginHandler emailLoginHandler, UserNameOrEmailLoginHandler userNameOrEmailLoginHandler, PhoneLoginHandler phoneLoginHandler, IPhoneVerifyCodeProvider phoneVerifyCodeProvider, IConfigProvider configProvider, IAccountPermissionResolver permissionResolver)
{
_cacheHandler = cacheHandler;
_accountRepository = accountRepository;
_authInfoRepository = authInfoRepository;
_configRepository = configRepository;
_serviceProvider = serviceProvider;
_menuRepository = menuRepository;
_mapper = mapper;
_loginInfo = loginInfo;
_verifyCodeProvider = verifyCodeProvider;
_userNameLoginHandler = userNameLoginHandler;
_emailLoginHandler = emailLoginHandler;
_userNameOrEmailLoginHandler = userNameOrEmailLoginHandler;
_phoneLoginHandler = phoneLoginHandler;
_phoneVerifyCodeProvider = phoneVerifyCodeProvider;
_configProvider = configProvider;
_permissionResolver = permissionResolver;
}
public void Init(IPALogger logger, [Config.Prefer("json")] IConfigProvider cfgProvider)
{
Logger.log = logger;
Logger.log.Debug("Logger prepared");
configProvider = cfgProvider;
config = cfgProvider.MakeLink <PluginConfig>((p, v) =>
{
if (v.Value == null || v.Value.RegenerateConfig || v.Value == null && v.Value.RegenerateConfig)
{
p.Store(v.Value = new PluginConfig()
{
RegenerateConfig = false
});
}
config = v;
});
Logger.log.Debug("Configuration loaded");
}
protected async Task StartRunners(IConfigProvider configProvider)
{
var initParams = configProvider.GetConfig <IInitConfig>();
var logManager = new NLogManager(initParams.LogFileName, initParams.LogDirectory);
IRpcModuleProvider rpcModuleProvider = initParams.JsonRpcEnabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>())
: (IRpcModuleProvider)NullModuleProvider.Instance;
_ethereumRunner = new EthereumRunner(rpcModuleProvider, configProvider, logManager);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (initParams.JsonRpcEnabled)
{
var serializer = new UnforgivingJsonSerializer();
rpcModuleProvider.Register <IShhModule>(new ShhModule(configProvider, logManager, serializer));
rpcModuleProvider.Register <IWeb3Module>(new Web3Module(configProvider, logManager, serializer));
Bootstrap.Instance.JsonRpcService = new JsonRpcService(rpcModuleProvider, configProvider, logManager);
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = serializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
}
/// <summary>
/// All text and content files are copied to the destination using their relative path. Any exception ends the process.
/// </summary>
/// <param name="application">Represents text and content files of an application.</param>
/// <param name="configProvider">Provides tool configuration.Used to get output path.</param>
public void Generate(IGenerable application, IConfigProvider configProvider)
{
try
{
foreach (var file in application.Files)
{
try
{
var dirInfo = Directory.CreateDirectory(Path.Combine(application.OutputFolderPath,
file.GenerationInfo.RelativePathFolder));
File.WriteAllText(
Path.Combine(application.OutputFolderPath, file.GenerationInfo.RelativePathFolder,
file.GenerationInfo.FileName), file.GetFileText());
}
catch (Exception e)
{
throw new ArgumentException("Given application is not valid: " + file.GenerationInfo.FileName + " " + e.Message);
}
}
foreach (var content in application.Contents)
{
try
{
var path = Path.GetDirectoryName(Path.Combine(application.OutputFolderPath, content.OutputPath));
if (path != null)
{
Directory.CreateDirectory(path);
File.Copy(content.InputPath, Path.Combine(application.OutputFolderPath, content.OutputPath), true);
}
}
catch (Exception e)
{
throw new ArgumentException("Given resource is not valid: " + content.InputPath + " : " + e.Message);
}
}
}
catch (Exception e)
{
throw new ArgumentException(e.Message);
}
}
public void Get_trace()
{
GethTxTraceEntry entry = new GethTxTraceEntry();
entry.Storage = new Dictionary <string, string>
{
{ "1".PadLeft(64, '0'), "2".PadLeft(64, '0') },
{ "3".PadLeft(64, '0'), "4".PadLeft(64, '0') },
};
entry.Memory = new List <string>
{
"5".PadLeft(64, '0'),
"6".PadLeft(64, '0')
};
entry.Stack = new List <string>
{
"7".PadLeft(64, '0'),
"8".PadLeft(64, '0')
};
entry.Operation = "STOP";
entry.Gas = 22000;
entry.GasCost = 1;
entry.Depth = 1;
var trace = new GethLikeTxTrace();
trace.ReturnValue = Bytes.FromHexString("a2");
trace.Entries.Add(entry);
IDebugBridge debugBridge = Substitute.For <IDebugBridge>();
debugBridge.GetTransactionTrace(Arg.Any <Keccak>()).Returns(trace);
IConfigProvider configProvider = Substitute.For <IConfigProvider>();
DebugModule module = new DebugModule(configProvider, NullLogManager.Instance, debugBridge, new UnforgivingJsonSerializer());
string response = RpcTest.TestSerializedRequest <IDebugModule>(module, "debug_traceTransaction", TestObject.KeccakA.ToString(true));
Assert.AreEqual("{\"id\":67,\"jsonrpc\":\"2.0\",\"result\":{\"gas\":\"0x0\",\"failed\":false,\"returnValue\":\"0xa2\",\"structLogs\":[{\"pc\":0,\"op\":\"STOP\",\"gas\":22000,\"gasCost\":1,\"depth\":1,\"error\":null,\"stack\":[\"0000000000000000000000000000000000000000000000000000000000000007\",\"0000000000000000000000000000000000000000000000000000000000000008\"],\"memory\":[\"0000000000000000000000000000000000000000000000000000000000000005\",\"0000000000000000000000000000000000000000000000000000000000000006\"],\"storage\":{\"0000000000000000000000000000000000000000000000000000000000000001\":\"0000000000000000000000000000000000000000000000000000000000000002\",\"0000000000000000000000000000000000000000000000000000000000000003\":\"0000000000000000000000000000000000000000000000000000000000000004\"}}]}}", response);
}
public ProjectManager(string configFile, IConfigProvider configProvider, ILogger logger, IFileSystem fileSystem)
{
if (configFile == null) throw new ArgumentNullException("configFile");
if (configProvider == null) throw new ArgumentNullException("configProvider");
if (logger == null) throw new ArgumentNullException("logger");
if (fileSystem == null) throw new ArgumentNullException("fileSystem");
if (string.IsNullOrEmpty(configFile)) throw new ArgumentException("configFile must be defined");
_logger = logger;
_fileSystem = fileSystem;
_config = configProvider.Load<Config>(configFile);
_changedProjects = new List<string>();
_changedSolutions = new List<string>();
_processedReferences = new Dictionary<ReferenceConfig, bool>(_config.ReferencesConfig.Count);
foreach (var referenceConfig in ReferencesConfig)
{
_processedReferences.Add(referenceConfig, false);
}
}
public ComplexHotkeyTracker(
[NotNull] IHotkeyConverter hotkeyConverter,
[NotNull] IConfigProvider <MicSwitchHotkeyConfig> configProvider,
[NotNull] IFactory <IHotkeyTracker> hotkeyTrackerFactory)
{
this.hotkeyConverter = hotkeyConverter;
this.configProvider = configProvider;
this.hotkeyTracker = hotkeyTrackerFactory.Create();
Log.Debug($"Scheduling HotkeyTracker initialization using background scheduler");
this.RaiseWhenSourceValue(x => x.IsActive, hotkeyTracker, x => x.IsActive).AddTo(Anchors);
var bgThread = new Thread(x => Initialize())
{
IsBackground = true,
ApartmentState = ApartmentState.STA,
Name = "HotkeyTracker"
};
bgThread.Start();
}
public static ClientAdapter GetAdapterFromConfig(IConfigProvider iConfigProvider)
{
try
{
if (null == _clientProvider)
{
string configAdapterValue = iConfigProvider.GetValue("clientCotorraAdapter");
ClientConfiguration.ClientAdapter adapter;
Enum.TryParse(configAdapterValue, out adapter);
_clientProvider = adapter;
}
return((ClientAdapter)_clientProvider);
}
catch
{
//Retorna adapter default si falla lectura de archivo de configuración
return(ClientConfiguration.ClientAdapter.Proxy);
}
}
public PhotoViewModel(
IConfigProvider configProvider,
IDispatcherService dispatcherService,
IImageSourceLoader imageSourceLoader,
IViewerCommands viewerCommands,
int index,
string filePath)
{
_dispatcherService = dispatcherService;
_imageSourceLoader = imageSourceLoader;
_thumbnailSizeLimit = configProvider.ThumbnailSizeLimit;
_filePath = filePath;
DisplayName = Path.GetFileNameWithoutExtension(_filePath);
Index = index;
OpenPhotoCommand = viewerCommands.OpenPhotoCommand;
LoadThumbnailCommand = new DelegateCommand(StartLoadingThumbnail);
}
public EthereumRunner(IRpcModuleProvider rpcModuleProvider, IConfigProvider configurationProvider, ILogManager logManager,
IGrpcService grpcService, IGrpcClient grpcClient, INdmConsumerChannelManager ndmConsumerChannelManager,
INdmDataPublisher ndmDataPublisher, INdmInitializer ndmInitializer)
{
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_grpcService = grpcService;
_grpcClient = grpcClient;
_ndmConsumerChannelManager = ndmConsumerChannelManager;
_ndmDataPublisher = ndmDataPublisher;
_ndmInitializer = ndmInitializer;
_logger = _logManager.GetClassLogger();
InitRlp();
_configProvider = configurationProvider ?? throw new ArgumentNullException(nameof(configurationProvider));
_rpcModuleProvider = rpcModuleProvider ?? throw new ArgumentNullException(nameof(rpcModuleProvider));
_initConfig = configurationProvider.GetConfig <IInitConfig>();
_txPoolConfig = configurationProvider.GetConfig <ITxPoolConfig>();
_perfService = new PerfService(_logManager);
_networkHelper = new NetworkHelper(_logger);
}
public static void LoadConfig(string path, IConfigProvider provider)
{
if (!CheckPath(ref path))
{
return;
}
var directory = FileManagerSecure.GetDirectoryName(path);
if (!FileManagerSecure.DirectoryExists(directory))
{
return;
}
var config = Controller.LoadJSON(path);
provider.RestoreConfig(config);
SuperController.LogMessage($"Loaded config! \"{path}\"");
}
public EmployeeService(IMapper mapper, IEmployeeRepository repository, IAccountService accountService, IAccountRepository accountRepository, IEmployeeContactRepository contactRepository, AdminDbContext adminDbContext, PersonnelFilesDbContext dbContext, IEmployeeLeaveInfoRepository leaveInfoRepository, IEmployeePersonalRepository personalRepository, IEmployeeFamilyRepository familyRepository, IEmployeeEducationRepository educationRepository, IEmployeeWorkRepository workRepository, IEmployeeLatestSelectRepository latestSelectRepository, ICacheHandler cacheHandler, IDepartmentRepository departmentRepository, IAccountRoleRepository accountRoleRepository, IConfigProvider configProvider)
{
_mapper = mapper;
_repository = repository;
_accountService = accountService;
_accountRepository = accountRepository;
_contactRepository = contactRepository;
_adminDbContext = adminDbContext;
_dbContext = dbContext;
_leaveInfoRepository = leaveInfoRepository;
_personalRepository = personalRepository;
_familyRepository = familyRepository;
_educationRepository = educationRepository;
_workRepository = workRepository;
_latestSelectRepository = latestSelectRepository;
_cacheHandler = cacheHandler;
_departmentRepository = departmentRepository;
_accountRoleRepository = accountRoleRepository;
_configProvider = configProvider;
}
public NavigationService(
IEnumerable <KeyValuePair <Type, IStackAlgorithm> > stackAlgorithms,
IEnumerable <INavigationModule> navigationModules,
INavigationViewProvider navigationViewProvider,
IViewModelWrapperStorage viewModelWrapperStorage,
INavigationMapper navigationMapper,
INavigationPageFactory navigationPageFactory,
IConfigProvider <NavigationConfig> navigationConfigProvider,
IResolver resolver)
{
_stackAlgorithms = stackAlgorithms.ToDictionary(it => it.Key, it => it.Value);
_navigationViewProvider = navigationViewProvider;
_viewModelWrapperStorage = viewModelWrapperStorage;
_navigationMapper = navigationMapper;
_navigationPageFactory = navigationPageFactory;
_navigationConfigProvider = navigationConfigProvider;
_resolver = resolver;
navigationModules.ForEach(it => it.Map(navigationMapper));
}
public void Init(IPALogger logger, [Config.Prefer("json")] IConfigProvider cfgProvider)
{
Logger.log = logger;
configProvider = cfgProvider;
config = configProvider.MakeLink <PluginConfig>((p, v) => {
// Build new config file if it doesn't exist or RegenerateConfig is true
if (v.Value == null || v.Value.RegenerateConfig)
{
Logger.log.Debug("Regenerating PluginConfig");
p.Store(v.Value = new PluginConfig()
{
// Set your default settings here.
RegenerateConfig = false,
DisplayBeforeAuthor = false
});
}
config = v;
});
}
public virtual async Task <INdmCapabilityConnector> InitAsync(IConfigProvider configProvider,
IDbProvider dbProvider, string baseDbPath, IBlockProcessor blockProcessor, IBlockTree blockTree,
ITxPool txPool, ITxPoolInfoProvider txPoolInfoProvider, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, ITimestamp timestamp, IEthereumEcdsa ecdsa,
IRpcModuleProvider rpcModuleProvider, IKeyStore keyStore, IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom, IEnode enode, INdmConsumerChannelManager consumerChannelManager,
INdmDataPublisher dataPublisher, IGrpcService grpcService, INodeStatsManager nodeStatsManager,
IProtocolsManager protocolsManager, IProtocolValidator protocolValidator,
IMessageSerializationService messageSerializationService, bool enableUnsecuredDevWallet,
ILogManager logManager)
{
var(config, _, ethRequestService, faucet, consumerService, consumerAddress,
providerAddress) = await PreInitAsync(configProvider, dbProvider, baseDbPath, blockProcessor, blockTree,
txPool, txPoolInfoProvider, specProvider, receiptStorage, wallet, timestamp, ecdsa, rpcModuleProvider,
keyStore, jsonSerializer, cryptoRandom, enode, consumerChannelManager, dataPublisher, grpcService,
enableUnsecuredDevWallet, logManager);
if (!config.Enabled)
{
return(default);
public HarmonicKeyConverterFactory(
TraditionalTextHarmonicKeyConverter traditionalTextConverter,
TraditionalSymbolsHarmonicKeyConverter traditionalSymbolsConverter,
KeyCodeHarmonicKeyCoverter keyCodeConverter,
Id3v2TkeyHarmonicKeyConverter id3v2TkeyConverter,
OpenKeyNotationHarmonicKeyConverter openKeyNotationConverter,
BeatportHarmonicKeyConverter beatportHarmonicKeyConverter,
IConfigProvider configProvider)
{
if (traditionalTextConverter == null) throw new ArgumentNullException("traditionalTextConverter");
if (traditionalSymbolsConverter == null) throw new ArgumentNullException("traditionalSymbolsConverter");
if (keyCodeConverter == null) throw new ArgumentNullException("keyCodeConverter");
if (id3v2TkeyConverter == null) throw new ArgumentNullException("id3v2TkeyConverter");
if (openKeyNotationConverter == null) throw new ArgumentNullException("openKeyNotationConverter");
if (beatportHarmonicKeyConverter == null) throw new ArgumentNullException("beatportHarmonicKeyConverter");
if (configProvider == null) throw new ArgumentNullException("configProvider");
this.traditionalTextConverter = traditionalTextConverter;
this.traditionalSymbolsConverter = traditionalSymbolsConverter;
this.keyCodeConverter = keyCodeConverter;
id3V2TkeyConverter = id3v2TkeyConverter;
this.openKeyNotationConverter = openKeyNotationConverter;
this.configProvider = configProvider;
this.beatportHarmonicKeyConverter = beatportHarmonicKeyConverter;
}
public WitAdminProcessService(string argument, IConfigProvider configProvider)
{
var workingDirectory = configProvider.GetConfig("witAdminExecutableAddress");
var witAdminPath = string.Format("{0}\\{1}", workingDirectory, WitAdminExecFileName);
ProcessStartInfo startInfo = new ProcessStartInfo(witAdminPath)
{
Arguments = argument,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
Verb = "runas",
CreateNoWindow = true
};
Process process = new Process()
{
StartInfo = startInfo
};
process.OutputDataReceived += ((sender, e) =>
{
if (e.Data != null)
{
_output.AppendLine(e.Data);
_splitedOutput.Add(e.Data);
}
});
process.ErrorDataReceived += ((sender, e) =>
{
if (e.Data != null)
_error.AppendLine(e.Data);
});
_process = process;
}
public ConfigProcessor(IConfigProvider configProvider)
{
_configProvider = configProvider;
}
public ConfigSwitchingPlaybackSpeedAdjuster(
IConfigProvider configProvider)
{
if (configProvider == null) throw new ArgumentNullException("configProvider");
this.configProvider = configProvider;
}
public ConfigurationProvider(ApplicationConfiguration appConfig, IConfigProvider configProvider)
{
this.appConfig = appConfig;
this.configProvider = configProvider;
}
public void TestFixtureSetUp()
{
_provider = new FileSystemConfigProvider( _defaultClientConfig, ConnectionFactory.GetDefault());
}
