protected AbstractTestCaseResolver(IActivityLogger log, TestRunImportSettings settings, IEnumerable<TestRunImportResultInfo> resultInfos,
IEnumerable<TestCaseTestPlanDTO> testCaseTestPlans)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
_log = log;
if (settings == null)
{
_log.Error("Ctor member TestRunImportSettings settings is null");
throw new ArgumentNullException("settings");
}
if (testCaseTestPlans == null)
{
_log.Error("Ctor member IEnumerable<TestCaseTestPlanDTO> testCaseTestPlans is null");
throw new ArgumentNullException("testCaseTestPlans");
}
TestCaseTestPlans = testCaseTestPlans;
if (resultInfos == null)
{
_log.Error("Ctor member IEnumerable<TestRunImportResultInfo> resultInfos is null");
throw new ArgumentNullException("resultInfos");
}
ResultInfos = resultInfos;
}
public Handler(DataContext context, IUploadAccessor uploadAccessor, IHttpContextAccessor httpContextAccessor, IActivityLogger logger)
{
_httpContextAccessor = httpContextAccessor;
_logger = logger;
_uploadAccessor = uploadAccessor;
_context = context;
}
void IMuxActivityLoggerClient.OnGroupClosed(IActivityLogger sender, IActivityLogGroup group, IReadOnlyList <ActivityLogGroupConclusion> conclusions)
{
foreach (var l in RegisteredMuxClients)
{
l.OnGroupClosed(sender, group, conclusions);
}
}
void IMuxActivityLoggerClient.OnOpenGroup(IActivityLogger sender, IActivityLogGroup group)
{
foreach (var l in RegisteredMuxClients)
{
l.OnOpenGroup(sender, group);
}
}
void IMuxActivityLoggerClient.OnUnfilteredLog(IActivityLogger sender, LogLevel level, string text)
{
foreach (var l in RegisteredMuxClients)
{
l.OnUnfilteredLog(sender, level, text);
}
}
void IMuxActivityLoggerClient.OnFilterChanged(IActivityLogger sender, LogLevelFilter current, LogLevelFilter newValue)
{
foreach (var l in RegisteredMuxClients)
{
l.OnFilterChanged(sender, current, newValue);
}
}
public override IDictionary <string, string> Execute(GeoCodeContext context, IActivityLogger logger)
{
string connectionString = context.ConnectionString;
logger.Write("Folder Path: {0}, FileName: {1}", context.FolderPath, context.FileName);
string output = string.Empty; // for use later.
CloudStorageAccount inputStorageAccount = CloudStorageAccount.Parse(context.ConnectionString);
CloudBlobClient inputClient = inputStorageAccount.CreateCloudBlobClient();
CloudBlobContainer inputContainer = inputClient.GetContainerReference(context.FolderPath);
CloudBlockBlob blob = inputContainer.GetBlockBlobReference(context.FileName);
logger.Write("Entering Calculate for blob {0}", blob.Uri.ToString());
output = Calculate(blob, logger, context);
logger.Write("Calculate complete");
string datepart = DateTime.UtcNow.ToString().Substring(0, 10);
string[] dateparts = datepart.Split('/');
CloudBlobContainer outputContainer = inputClient.GetContainerReference(context.OutputFolder);
CloudBlockBlob outputBlob = outputContainer.GetBlockBlobReference(dateparts[2] + "/" + dateparts[0] + "/" + dateparts[1] + "/" + context.FileName);
logger.Write("Writing to the output blob: {0}", outputBlob.Uri);
outputBlob.UploadText(output);
logger.Write("Blob uploaded");
return(new Dictionary <string, string>());
}
public Handler(DataContext context, UserManager <User> userManager, IJwtGenerator jwtGenerator, IActivityLogger logger)
{
_logger = logger;
_jwtGenerator = jwtGenerator;
_userManager = userManager;
_context = context;
}
/// <summary>
/// Initializes a new <see cref="ActivityLoggerOutput"/> bound to a <see cref="IActivityLogger"/>.
/// </summary>
/// <param name="logger"></param>
public ActivityLoggerOutput( IActivityLogger logger )
{
Logger = logger;
_clients = new List<IActivityLoggerClient>();
_clientsEx = new ReadOnlyListOnIList<IActivityLoggerClient>( _clients );
_nonRemoveableClients = new List<IActivityLoggerClientBase>();
}
private static void LogBlobDataSetInfo(AzureBlobDataset blobDataset, IActivityLogger logger)
{
logger.Write("\n******** Blob Storage info ********");
logger.Write("\nBlob folder: " + blobDataset.FolderPath);
logger.Write("\nBlob format: " + blobDataset.Format);
var partitions = blobDataset.PartitionedBy?.Count ?? 0;
logger.Write($"\nPartitions ({partitions}):");
for (int i = 0; i < partitions; i++)
{
logger.Write(
$"\n\t{blobDataset.PartitionedBy?[i].Name ?? "null"}: {blobDataset.PartitionedBy?[i]?.Value}");
}
logger.Write("\nBlob file: " + blobDataset.FileName);
if (blobDataset.FolderPath.IndexOf("/", StringComparison.InvariantCulture) <= 0)
{
throw new Exception($"Can't find container name for dataset '{blobDataset.FolderPath}'");
}
logger.Write("\nContainer Name: {0}", GetContainerName(blobDataset.FolderPath));
logger.Write("\nDirectory Name: {0}", GetDirectoryName(blobDataset.FolderPath));
}
public SeleniumResultsCommand(IStorageRepository storageRepository, ILocalBus localBus, ITestRunImportResultsReaderFactory resultsReaderFactory, IActivityLogger log)
{
_storageRepository = storageRepository;
_localBus = localBus;
_resultsReaderFactory = resultsReaderFactory;
_log = log;
}
public SettingService(ICacheManager cache, SmartDbContext db, IActivityLogger activityLogger)
{
_cache = cache;
_db = db;
_setSettings = _db.Settings;
_activityLogger = activityLogger;
}
public AzureParallelInfrastructureCoordinatorFactory(
Uri serviceName,
IConfigStore configStore,
string configSectionName,
Guid partitionId,
long replicaId,
IInfrastructureAgentWrapper agent)
{
this.serviceName = serviceName.Validate("serviceName");
configStore.Validate("configStore");
configSectionName.Validate("configSectionName");
this.agent = agent.Validate("agent");
this.configSection = new ConfigSection(TraceType, configStore, configSectionName);
this.partitionId = partitionId;
this.replicaId = replicaId;
try
{
this.tenantId = AzureHelper.GetTenantId(configSection);
}
catch (Exception ex)
{
// this happens on the Linux environment (since there is no registry)
this.tenantId = PartitionIdPrefix + partitionId;
TraceType.WriteWarning("Unable to get tenant Id from configuration. Using partition Id '{0}' text instead. Exception: {1}", this.tenantId, ex);
}
// TODO use tenant ID or config section name suffix as base trace ID?
this.env = new CoordinatorEnvironment(this.serviceName.AbsoluteUri, this.configSection, tenantId, this.agent);
this.activityLogger = new ActivityLoggerFactory().Create(env.CreateTraceType("Event"));
this.policyAgentServiceWrapper = new PolicyAgentServiceWrapper(env, activityLogger);
}
public SetEnableForTp2(IPluginContext pluginContext, IActivityLogger log, IProfileCollection profileCollection, ITpBus bus)
{
_pluginContext = pluginContext;
_log = log;
_profileCollection = profileCollection;
_bus = bus;
}
public Handler(DataContext context, IUserAccessor userAccessor, UserManager <User> userManager, IActivityLogger logger)
{
_userManager = userManager;
_logger = logger;
_userAccessor = userAccessor;
_context = context;
}
public OrderProcessingService(
SmartDbContext db,
IWorkContext workContext,
IWebHelper webHelper,
ILocalizationService localizationService,
ICurrencyService currencyService,
IPaymentService paymentService,
IProductService productService,
IProductAttributeMaterializer productAttributeMaterializer,
IProductAttributeFormatter productAttributeFormatter,
IOrderCalculationService orderCalculationService,
ITaxService taxService,
IShoppingCartService shoppingCartService,
IShoppingCartValidator shoppingCartValidator,
IShippingService shippingService,
IGiftCardService giftCardService,
INewsletterSubscriptionService newsletterSubscriptionService,
ICheckoutAttributeFormatter checkoutAttributeFormatter,
IEncryptor encryptor,
IMessageFactory messageFactory,
IEventPublisher eventPublisher,
IActivityLogger activityLogger,
RewardPointsSettings rewardPointsSettings,
CatalogSettings catalogSettings,
OrderSettings orderSettings,
ShoppingCartSettings shoppingCartSettings,
LocalizationSettings localizationSettings,
TaxSettings taxSettings)
{
_db = db;
_workContext = workContext;
_webHelper = webHelper;
_localizationService = localizationService;
_currencyService = currencyService;
_paymentService = paymentService;
_productService = productService;
_productAttributeMaterializer = productAttributeMaterializer;
_productAttributeFormatter = productAttributeFormatter;
_orderCalculationService = orderCalculationService;
_taxService = taxService;
_shoppingCartService = shoppingCartService;
_shoppingCartValidator = shoppingCartValidator;
_shippingService = shippingService;
_giftCardService = giftCardService;
_newsletterSubscriptionService = newsletterSubscriptionService;
_checkoutAttributeFormatter = checkoutAttributeFormatter;
_encryptor = encryptor;
_messageFactory = messageFactory;
_eventPublisher = eventPublisher;
_activityLogger = activityLogger;
_rewardPointsSettings = rewardPointsSettings;
_catalogSettings = catalogSettings;
_orderSettings = orderSettings;
_shoppingCartSettings = shoppingCartSettings;
_localizationSettings = localizationSettings;
_taxSettings = taxSettings;
_primaryCurrency = currencyService.PrimaryCurrency;
_workingCurrency = workContext.WorkingCurrency;
}
public IDictionary<string, string> Execute(IEnumerable<LinkedService> linkedServices, IEnumerable<Dataset> datasets, Activity activity, IActivityLogger logger)
{
var adl_helper = new DataLakeHelper();
var sf_helper = new SalesForceHelper();
var extendedProperties = ((DotNetActivity)activity.TypeProperties).ExtendedProperties;
logger.Write("######ExtendedProperties Begin######");
foreach (KeyValuePair<string, string> entry in extendedProperties)
{
logger.Write($"<key:{entry.Key}> <value:{entry.Value}>");
}
logger.Write("######ExtendedProperties End######");
//Extended Properties
var slice_start = DateTime.Parse(extendedProperties["SliceStart"]);
var root_folder = extendedProperties["RootFolder"];
var name = extendedProperties["FileName"];
var file_name = $"{name}.csv";
var current_dir = $"/{root_folder}/{slice_start.Year}/{slice_start.Month:D2}/{slice_start.Day:D2}/";
try
{
var rows = new List<string>();
var count = 0;
var is_file_created = false;
foreach (var row in sf_helper.GetLeads())
{
rows.Add(row.ToString());
count++;
if (count != 2000) continue;
adl_helper.StoreData(current_dir + file_name, rows, is_file_created);
if (!is_file_created) is_file_created = true;
count = 0;
rows = new List<string>();
}
if (count <= 0) return new Dictionary<string, string>();
adl_helper.StoreData(current_dir + file_name, rows, is_file_created);
}
catch (Exception e)
{
logger.Write(e.Message);
logger.Write(e.InnerException.Message);
throw;
}
return new Dictionary<string, string>();
}
internal virtual void ProcessTabularModel(Model tabularModel, IActivityLogger logger)
{
// We request a refresh for all tables
foreach (var table in tabularModel.Tables)
{
// For partition tables, we process each partition.
if (table.Partitions.Any())
{
logger.Write("Table {0} will be processed partition by partition", table.Name);
foreach (var partition in table.Partitions)
{
partition.RequestRefresh(RefreshType.Full);
}
}
else
{
logger.Write("Table {0} will be processed in full mode", table.Name);
table.RequestRefresh(RefreshType.Full);
}
}
logger.Write("Azure AS processing started");
tabularModel.SaveChanges();
logger.Write("Azure AS was successfully processed");
}
/// <summary>
/// Initializes a new <see cref="ActivityLoggerOutput"/> bound to a <see cref="IActivityLogger"/>.
/// </summary>
/// <param name="logger"></param>
public ActivityLoggerOutput(IActivityLogger logger)
{
Logger = logger;
_clients = new List <IActivityLoggerClient>();
_clientsEx = new ReadOnlyListOnIList <IActivityLoggerClient>(_clients);
_nonRemoveableClients = new List <IActivityLoggerClientBase>();
}
public NewRevisionRangeDetectedMessageHandler(IVersionControlSystem versionControlSystem, ILocalBus bus, IActivityLogger logger)
{
_versionControlSystem = versionControlSystem;
_bus = bus;
_logger = logger;
_parser = new CommentParser();
}
public SetEnableForTp2(IPluginContext pluginContext, IActivityLogger log, IProfileCollection profileCollection, ITpBus bus)
{
_pluginContext = pluginContext;
_log = log;
_profileCollection = profileCollection;
_bus = bus;
}
public static void OptimizeDocumentIndexesIfRunning(this IDocumentIndexProvider documentIndexProvider, IPluginContext context, IActivityLogger logger)
{
foreach (IDocumentIndex documentIndex in GetDocumentIndexes(documentIndexProvider, context, runningOnly:true).Where(d => !d.IsOptimized))
{
documentIndex.Optimize(DocumentIndexOptimizeSetup.ImmediateOptimize);
}
}
public CustomActivityBase()
{
if (Debugger.IsAttached)
{
var attributes = this.GetType().GetMethod("RunActivity").CustomAttributes;
var customActivityAttribute = attributes.FirstOrDefault(x => x.AttributeType.Name == "CustomActivityAttribute");
string activityName = customActivityAttribute?.NamedArguments?.FirstOrDefault(x => x.MemberName == "ActivityName").TypedValue.Value?.ToString();
string pipelineLocation = customActivityAttribute?.NamedArguments?.FirstOrDefault(x => x.MemberName == "PipelineLocation").TypedValue.Value?.ToString();
string deployConfig = customActivityAttribute?.NamedArguments?.FirstOrDefault(x => x.MemberName == "DeployConfig").TypedValue.Value?.ToString();
if (!string.IsNullOrEmpty(activityName) || !string.IsNullOrEmpty(pipelineLocation))
{
string dataFactoryProjLocation =
Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "..\\..", Path.GetDirectoryName(pipelineLocation)));
DotNetActivityContext context = Runner.DeserializeActivity(Path.GetFileName(pipelineLocation), activityName, deployConfig, dataFactoryProjLocation);
LinkedServices = context.LinkedServices;
Datasets = context.Datasets;
Activity = context.Activity;
Logger = context.Logger;
typeProperties = Activity.TypeProperties as DotNetActivity;
}
else
{
throw new Exception($"The CustomActivity attribute needs to have the following properties populated: {nameof(CustomActivityAttribute.PipelineLocation)} and {nameof(CustomActivityAttribute.ActivityName)}");
}
}
}
public TestStepsIndexing(IEntityIndexer entityIndexer, Func <ITestStepIndexingSagaData> data,
IEntityTypeProvider entityTypesProvider, Action <ITestStepIndexingSagaData> onComplete,
Action <TestStepQuery> sendQuery, IActivityLogger logger, Action <TestStepDTO, IEntityIndexer> indexMethod)
: base(entityIndexer, data, entityTypesProvider, onComplete, sendQuery, logger, "testStep")
{
_indexMethod = indexMethod;
}
protected VersionControlSystem(ISourceControlConnectionSettingsSource settings,
ICheckConnectionErrorResolver errorResolver, IActivityLogger logger)
{
_settings = settings;
_errorResolver = errorResolver;
_logger = logger;
}
protected internal SimpleTestCaseResolver(IActivityLogger log,
TestRunImportSettings settings,
IEnumerable <TestRunImportResultInfo> resultInfos,
IEnumerable <TestCaseTestPlanDTO> testCaseTestPlans)
: base(log, settings, resultInfos, testCaseTestPlans)
{
}
private static IContainer RegisterServiceBusContainer(out IActivityLogger logger, QueueLoggerSettings queueSettings)
{
var queueName = "mytestqueue";
///
/// Service bus connection string looks like this:
/// Endpoint=sb://myservicebusmodule.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=m0nmPm2T4JFIAOs8G2vpJrnz9QKUp1HvZq6baRMIrVs=
///
var connectionstring = "<enter service bus connection here>";
if (connectionstring == "<enter service bus connection here>")
{
throw new ArgumentException("need to provide a service bus connection string");
}
//delete as part of the test
NamespaceManager namespaceManager =
NamespaceManager.CreateFromConnectionString(connectionstring);
namespaceManager.DeleteQueue(queueName);
var builder = new ContainerBuilder();
builder.RegisterModule(new QueueActivityModule(connectionstring, queueName, queueSettings));
var container = builder.Build();
logger = container.Resolve <IActivityLogger>();
return(container);
}
public SearchCommand(QueryRunner queryRunner, IProfile profile, DocumentIndexRebuilder documentIndexRebuilder, IActivityLogger logger)
{
_queryRunner = queryRunner;
_profile = profile;
_documentIndexRebuilder = documentIndexRebuilder;
_logger = logger;
}
public PolicyAgentServiceWrapper(CoordinatorEnvironment environment, IActivityLogger activityLogger, Uri zeroSdkUri = null, bool silentErrors = false)
{
this.traceType = environment.Validate("environment").CreateTraceType("ZeroSdkClient");
this.activityLogger = activityLogger.Validate("activityLogger");
this.traceWriteConditionalWarning = silentErrors ? new WriteTraceDelegate(traceType.WriteInfo) : new WriteTraceDelegate(traceType.WriteWarning);
this.zeroSdkUri = zeroSdkUri ?? GetMRZeroSdkUri(environment.Config);
}
public Handler(DataContext context, IMapper mapper, ISlugGenerator slugGenerator, IActivityLogger logger)
{
_logger = logger;
_slugGenerator = slugGenerator;
_mapper = mapper;
_context = context;
}
public SearchCommand(QueryRunner queryRunner, IProfile profile, DocumentIndexRebuilder documentIndexRebuilder, IActivityLogger logger)
{
_queryRunner = queryRunner;
_profile = profile;
_documentIndexRebuilder = documentIndexRebuilder;
_logger = logger;
}
private static List <TextSample> ReadDataFromBlobs(
Dataset inputDataset,
AzureStorageLinkedService inputLinkedService,
IActivityLogger logger
)
{
var result = new List <TextSample>();
var folderPath = GetFolderPath(inputDataset);
var inputConnectionString = inputLinkedService.ConnectionString;
var inputStorageAccount = CloudStorageAccount.Parse(inputConnectionString);
var inputClient = inputStorageAccount.CreateCloudBlobClient();
BlobContinuationToken continuationToken = null;
do
{
var blobList = inputClient.ListBlobsSegmented(folderPath,
true,
BlobListingDetails.Metadata,
null,
continuationToken,
null,
null);
result.AddRange(DownloadBlobs(blobList, logger, folderPath, ref continuationToken));
} while (continuationToken != null);
return(result);
}
public AutomaticSearcherListener(IPluginContext pluginContext, IProfileReadonly profile, IDocumentIndexProvider documentIndexProvider, IActivityLogger logger)
{
_pluginContext = pluginContext;
_profile = profile;
_documentIndexProvider = documentIndexProvider;
_logger = logger;
}
protected internal SimpleTestCaseResolver(IActivityLogger log,
TestRunImportSettings settings,
IEnumerable<TestRunImportResultInfo> resultInfos,
IEnumerable<TestCaseTestPlanDTO> testCaseTestPlans)
: base(log, settings, resultInfos, testCaseTestPlans)
{
}
public AzureParallelDisabledCoordinator(
CoordinatorEnvironment environment,
string tenantId,
Func <Task <IPolicyAgentClient> > policyAgentClientAsyncFactory,
IRepairManager repairManager,
IHealthClient healthClient,
IActivityLogger activityLogger,
Guid partitionId,
long replicaId)
{
this.environment = environment.Validate("environment");
this.tenantId = tenantId.Validate("tenantId");
this.partitionId = partitionId;
this.policyAgentClientAsyncFactory = policyAgentClientAsyncFactory.Validate("policyAgentClientAsyncFactory");
this.traceType = environment.CreateTraceType("DisabledCoordinator");
this.repairManager = repairManager.Validate("repairManager");
this.healthClient = healthClient.Validate("healthClient");
this.configSection = environment.Config;
this.activityLogger = activityLogger.Validate("activityLogger");
var assembly = this.GetType().GetTypeInfo().Assembly;
assemblyFileVersion = FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion;
}
public SeleniumResultsCommand(IStorageRepository storageRepository, ILocalBus localBus, ITestRunImportResultsReaderFactory resultsReaderFactory, IActivityLogger log)
{
_storageRepository = storageRepository;
_localBus = localBus;
_resultsReaderFactory = resultsReaderFactory;
_log = log;
}
public ImportBugsChunkHandler(ILocalBus bus, IStorageRepository storageRepository, IActivityLogger logger, IBugzillaService bugzillaService)
{
_bus = bus;
_storageRepository = storageRepository;
_logger = logger;
_bugzillaService = bugzillaService;
}
public Handler(DataContext context, IMapper mapper, IOptionAccessor optionAccessor, IActivityLogger logger)
{
_logger = logger;
_optionAccessor = optionAccessor;
_mapper = mapper;
_context = context;
}
public IDictionary <string, string> Execute(
IEnumerable <LinkedService> linkedServices,
IEnumerable <Dataset> datasets,
Activity activity,
IActivityLogger logger)
{
var datasetsByName = datasets.ToDictionary(dataset => dataset.Name);
var linkedServicesByName = linkedServices.ToDictionary(linkedService => linkedService.Name);
var inputDataset = datasetsByName[InputTableReddit];
var inputLinkedService = linkedServicesByName[inputDataset.Properties.LinkedServiceName];
var inputLinkedServiceStorage = (AzureStorageLinkedService)inputLinkedService.Properties.TypeProperties;
var jsonDatas = ReadDataFromBlobs(inputDataset, inputLinkedServiceStorage, logger);
var outputDataset = datasetsByName[OutputTable];
var outputLinkedService = linkedServicesByName[outputDataset.Properties.LinkedServiceName];
var outputLinkedServiceStorage = (AzureStorageLinkedService)outputLinkedService.Properties.TypeProperties;
var outputCsv = DataMap(jsonDatas);
WriteDataToBlob(outputDataset, outputLinkedServiceStorage, logger, outputCsv);
// The dictionary can be used to chain custom activities together in the future.
// This feature is not implemented yet, so just return an empty dictionary.
return(new Dictionary <string, string>());
}
public RunAtStartStopInitializer()
{
_documentIndexProvider = ObjectFactory.GetInstance<IDocumentIndexProvider>();
_log = ObjectFactory.GetInstance <IActivityLogger>();
_isOnSite = ObjectFactory.GetInstance<IMsmqTransport>().RoutableTransportMode == RoutableTransportMode.OnSite;
_documentIndexRebuilder = ObjectFactory.GetInstance<DocumentIndexRebuilder>();
_pluginContext = ObjectFactory.GetInstance<IPluginContext>();
}
public GitVersionControlSystem(ISourceControlConnectionSettingsSource settings,
ICheckConnectionErrorResolver errorResolver, IActivityLogger logger,
IDiffProcessor diffProcessor, IStorageRepository profile)
: base(settings, errorResolver, logger)
{
_diffProcessor = diffProcessor;
_git = new GitClient(settings, profile.Get<GitRepositoryFolder>());
}
public static void ShutdownDocumentIndexes(this IDocumentIndexProvider documentIndexProvider, IPluginContext context, DocumentIndexShutdownSetup setup, IActivityLogger logger)
{
foreach (IDocumentIndex documentIndex in GetDocumentIndexes(documentIndexProvider, context, runningOnly:false))
{
var success = documentIndex.Shutdown(setup);
logger.DebugFormat("{0} was {1} shutted down", documentIndex.Type.TypeToken, success ? string.Empty : "not");
}
}
protected VersionControlSystemProcessorBase(IRevisionIdComparer revisionComparer, IStorageRepository storage, ISourceControlConnectionSettingsSource settingsSource, IVersionControlSystem versionControlSystem, ILocalBus bus, IActivityLogger logger)
{
RevisionComparer = revisionComparer;
Storage = storage;
VersionControlSystem = versionControlSystem;
Bus = bus;
Logger = logger;
StartRevision = revisionComparer.ConvertToRevisionId(settingsSource.StartRevision);
}
public static void ShutdownDocumentIndexesIfRunning(this IDocumentIndexProvider documentIndexProvider, IPluginContext context, DocumentIndexShutdownSetup setup, IActivityLogger logger)
{
foreach (IDocumentIndex documentIndex in GetDocumentIndexes(documentIndexProvider, context, runningOnly:true))
{
if (documentIndex.Shutdown(setup))
{
logger.DebugFormat("{0} was shutted down", documentIndex.Type.TypeToken);
}
}
}
public RunAtStartStopInitializer()
{
_documentIndexProvider = ObjectFactory.GetInstance<IDocumentIndexProvider>();
_log = ObjectFactory.GetInstance <IActivityLogger>();
_profileCollection = ObjectFactory.GetInstance<IProfileCollection>();
_isOnSite = ObjectFactory.GetInstance<IMsmqTransport>().RoutableTransportMode == RoutableTransportMode.OnSite;
_bus = ObjectFactory.GetInstance<ITpBus>();
_pluginContext = ObjectFactory.GetInstance<IPluginContext>();
_pluginMetadata = ObjectFactory.GetInstance<IPluginMetadata>();
}
public MercurialVersionControlSystem(
ISourceControlConnectionSettingsSource settings,
ICheckConnectionErrorResolver errorResolver,
IActivityLogger logger,
IDiffProcessor diffProcessor)
: base(settings, errorResolver, logger)
{
_diffProcessor = diffProcessor;
_mercurial = new MercurialClient(settings);
}
public PluginIcon(IPluginMetadata pluginMetadata, IActivityLogger log)
{
_log = log;
var iconFileRelativePath = pluginMetadata.PluginData.IconFilePath;
if (!string.IsNullOrEmpty(iconFileRelativePath))
{
_iconFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
pluginMetadata.PluginData.IconFilePath);
}
}
private void Process(
IEnumerable<CloudBlockBlob> inputFilesBlobs, CloudBlobContainer archiveBlobContainer,
string customersSqlConnectionString, IActivityLogger logger = null)
{
using (var sqlconn = new SqlConnection(customersSqlConnectionString))
{
sqlconn.Open();
if (logger != null)
logger.Write("Traversing through the inputFilesBlobs...");
foreach (var blob in inputFilesBlobs)
{
if (logger != null)
logger.Write("Blob Name: {0}", blob.Name);
var folderName = string.Empty;
var fileName = string.Empty;
StorageHelper.GetBlobFileInfo(blob.Name, ref folderName, ref fileName);
if (logger != null)
logger.Write("(Folder, FileName) : {0}, {1}", folderName, fileName);
var json = blob.DownloadText();
var customers = Customer.FromJson(json);
foreach (var customer in customers)
{
customer.Identifier = Customer.GenerateIdentifier(folderName, fileName, Properties.Settings.Default.FileNamePrefix.Length);
var sqlcmd = new SqlCommand() { Connection = sqlconn };
sqlcmd.CommandText = string.Format(
"INSERT INTO Customers(Identifier, Name, Surname, TimeStamp) VALUES('{0}','{1}','{2}','{3}')",
customer.Identifier, customer.Name, customer.Surname, customer.TimeStamp);
if (logger != null)
logger.Write(sqlcmd.CommandText);
sqlcmd.ExecuteNonQuery();
}
if (logger != null)
logger.Write("Archiving...");
var archiveBlob = archiveBlobContainer.GetBlockBlobReference(blob.Name);
archiveBlob.UploadText(json);
if (logger != null)
logger.Write("Removing Blob from Source...");
blob.Delete();
}
}
}
public void Execute(IActionVisitor visitor, Action<ITargetProcessCommand> executor, IActivityLogger logger)
{
Visit(visitor);
if (CanBeExecuted)
{
Log(logger);
executor(CreateCommand());
}
}
public DocumentIndexRebuilder(IDocumentIndexProvider documentIndexProvider, DocumentIndexSetup documentIndexSetup, ITpBus bus, IPluginContext pluginContext, IPluginMetadata pluginMetadata, IProfileCollection profileCollection, IProfile profile, IActivityLogger logger)
{
_documentIndexProvider = documentIndexProvider;
_documentIndexSetup = documentIndexSetup;
_bus = bus;
_pluginContext = pluginContext;
_pluginMetadata = pluginMetadata;
_profileCollection = profileCollection;
_profile = profile;
_logger = logger;
}
protected internal RegExpTestCaseResolver(IActivityLogger log,
TestRunImportSettings settings,
IEnumerable<TestRunImportResultInfo> resultInfos,
IEnumerable<TestCaseTestPlanDTO> testCaseTestPlans
)
: base(log, settings, resultInfos, testCaseTestPlans)
{
if (settings.RegExp != null)
{
_rx = new Regex(settings.RegExp, RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
}
protected AbstractTestRunImportResultsReader(IActivityLogger log, TextReader reader)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
_log = log;
if (reader == null)
{
_log.Error("Ctor member reader is null");
throw new ArgumentNullException("reader");
}
Reader = reader;
}
public void Process(
string inputFileStorageConnectionString, string inputFilesStorageFolderPath,
string archiveStorageConnectionString, string archiveStorageFolderPath,
string customersSqlConnectionString,
IActivityLogger logger = null
)
{
var inputFilesStorageAccount = CloudStorageAccount.Parse(inputFileStorageConnectionString);
var inputFilesClient = inputFilesStorageAccount.CreateCloudBlobClient();
var inputFilesBlobContainer = inputFilesClient.GetContainerReference(inputFilesStorageFolderPath);
var inputFilesBlobs = inputFilesBlobContainer.ListBlobs(useFlatBlobListing: true).OfType<CloudBlockBlob>().Cast<CloudBlockBlob>();
var archiveStorageAccount = CloudStorageAccount.Parse(archiveStorageConnectionString);
var archiveClient = archiveStorageAccount.CreateCloudBlobClient();
var archiveBlobContainer = archiveClient.GetContainerReference(archiveStorageFolderPath);
Process(inputFilesBlobs, archiveBlobContainer, customersSqlConnectionString, logger);
}
public IDictionary<string, string> Execute(
IEnumerable<ResolvedTable> inputTables,
IEnumerable<ResolvedTable> outputTables,
IDictionary<string, string> extendedProperties,
IActivityLogger logger)
{
var directoryName = new FileInfo(typeof(DataGenerator).Assembly.Location).DirectoryName;
if (directoryName != null)
{
string sampleFilePath = Path.Combine(directoryName, @"SampleDataFiles");
logger.Write(TraceEventType.Information, "SampleFilePath is the following: {0}", sampleFilePath);
logger.Write(TraceEventType.Information, "Printing dictionary entities if any...");
foreach (KeyValuePair<string, string> entry in extendedProperties)
{
logger.Write(TraceEventType.Information, "<key:{0}> <value:{1}>", entry.Key, entry.Value);
}
foreach (ResolvedTable outputTable in outputTables)
{
string storageConnectionString = GetConnectionString(outputTable.LinkedService);
string folderPath = GetFolderPath(outputTable.Table);
if (String.IsNullOrEmpty(storageConnectionString))
{
logger.Write(TraceEventType.Error, "Null or Empty Connection string for output table: {0}", outputTable);
throw new Exception(string.Format("Null or Empty Connection string for output table: {0}", outputTable));
}
if (String.IsNullOrEmpty(folderPath))
{
logger.Write(TraceEventType.Error, "Null or Empty folderpath for output table: {0}", outputTable);
throw new Exception(string.Format("Null or Empty folder path for output table: {0}", outputTable));
}
logger.Write(TraceEventType.Information, "Writing blob to: {0}", folderPath);
CloudStorageAccount outputStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
ProcessFiles(sampleFilePath, outputStorageAccount, folderPath, outputTable.Table.Name, logger);
}
}
return new Dictionary<string, string>();
}
//public IDictionary<string, string> Execute(
// IEnumerable<ResolvedTable> inputTables,
// IEnumerable<ResolvedTable> outputTables,
// IDictionary<string, string> inputs,
// IActivityLogger activityLogger)
public IDictionary<string, string> Execute(
IEnumerable<LinkedService> linkedServices,
IEnumerable<Dataset> datasets,
Activity activity,
IActivityLogger logger)
{
// to get extended properties (for example: SliceStart)
DotNetActivity dotNetActivity = (DotNetActivity)activity.TypeProperties;
_dataStorageAccountName = dotNetActivity.ExtendedProperties["dataStorageAccountName"];
_dataStorageAccountKey = dotNetActivity.ExtendedProperties["dataStorageAccountKey"];
_dataStorageContainer = dotNetActivity.ExtendedProperties["dataStorageContainer"];
string sliceStartTime = dotNetActivity.ExtendedProperties["sliceStart"];
string urlFormat = dotNetActivity.ExtendedProperties["urlFormat"];
_logger = logger;
GatherDataForOneHour(sliceStartTime, urlFormat);
_logger.Write("Exit");
return new Dictionary<string, string>();
}
public IDictionary<string, string> Execute(
IEnumerable<ResolvedTable> inputTables,
IEnumerable<ResolvedTable> outputTables,
IDictionary<string, string> inputs,
IActivityLogger activityLogger)
{
_dataStorageAccountName = inputs["dataStorageAccountName"];
_dataStorageAccountKey = inputs["dataStorageAccountKey"];
_dataStorageContainer = inputs["dataStorageContainer"];
string sliceStartTime = inputs["sliceStart"];
string urlFormat = inputs["urlFormat"];
_logger = activityLogger;
_logger.Write(TraceEventType.Information, "Data Storage Account Name is : {0}", _dataStorageAccountName);
_logger.Write(TraceEventType.Information, "Data Storage Account Name is : {0}", _dataStorageAccountKey);
_logger.Write(TraceEventType.Information, "URL Format is : {0}", urlFormat);
_logger.Write(TraceEventType.Information, "Slice start time is : {0}", sliceStartTime);
GatherDataForOneHour(sliceStartTime, urlFormat);
_logger.Write(TraceEventType.Information, "Exit");
return new Dictionary<string, string>();
}
public IDictionary<string, string> Execute(IEnumerable<LinkedService> linkedServices, IEnumerable<Dataset> datasets, Activity activity, IActivityLogger logger)
{
IDictionary<string, string> extendedProperties = ((DotNetActivity)activity.TypeProperties).ExtendedProperties;
logger.Write("Initializing Input Files DataSet...");
var inputFilesDataSet = datasets.First(ds => ds.Name == Properties.Settings.Default.InputFilesDataSetName);
var inputFilesLinkedService = linkedServices.First(linkedService => linkedService.Name == inputFilesDataSet.Properties.LinkedServiceName).Properties.TypeProperties as AzureStorageLinkedService;
logger.Write("Initializing Archive DataSet...");
var archiveDataSet = datasets.First(ds => ds.Name == Properties.Settings.Default.ArchiveDataSetName);
var archiveLinkedService = linkedServices.First(linkedService => linkedService.Name == archiveDataSet.Properties.LinkedServiceName).Properties.TypeProperties as AzureStorageLinkedService;
logger.Write("Initializing Customers DataSet...");
var customersDataSet = datasets.First(ds => ds.Name == Properties.Settings.Default.CustomersDataSetName);
var customersLinkedService = linkedServices.First(linkedService => linkedService.Name == customersDataSet.Properties.LinkedServiceName).Properties.TypeProperties as AzureSqlDatabaseLinkedService;
logger.Write("Processing...");
var inputFileStorageConnectionString = StorageHelper.GetStorageConnectionString(inputFilesLinkedService);
var inputFilesStorageFolderPath = StorageHelper.GetStorageFolderPath(inputFilesDataSet);
var archiveStorageConnectionString = StorageHelper.GetStorageConnectionString(archiveLinkedService);
var archiveStorageFolderPath = StorageHelper.GetStorageFolderPath(archiveDataSet);
var customersSqlConnectionString = customersLinkedService.ConnectionString;
logger.Write("...inputFileStorageConnectionString = {0}", inputFileStorageConnectionString);
logger.Write("...inputFilesStorageFolderPath = {0}", inputFilesStorageFolderPath);
logger.Write("...archiveStorageConnectionString = {0}", archiveStorageConnectionString);
logger.Write("...archiveStorageFolderPath = {0}", archiveStorageFolderPath);
logger.Write("...customersSqlConnectionString = {0}", customersSqlConnectionString);
Process(inputFileStorageConnectionString, inputFilesStorageFolderPath,
archiveStorageConnectionString, archiveStorageFolderPath,
customersSqlConnectionString,
logger);
logger.Write("Custom Activity Completed.");
return new Dictionary<string, string>();
}
public static void Setup(string connectionString, string assembliesPath, IActivityLogger logger)
{
using (var context = new SqlSetupContext(connectionString, logger))
{
//if( !context.DefaultSqlDatabase.IsOpen() ) context.DefaultSqlDatabase.Open( context.DefaultSqlDatabase.Server );
using (context.Logger.OpenGroup(LogLevel.Trace, "Begin setup " + DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)))
{
SqlSetupCenter c = new SqlSetupCenter(context);
c.DiscoverFilePackages(assembliesPath);
var assemblies = new[]
{
"Neva.Basic.Model",
"Neva.Messaging.Sql",
"Neva.Resource.Model",
"MultiRando.Model"
};
context.AssemblyRegistererConfiguration.DiscoverAssemblyNames.AddRange(assemblies);
c.Run();
}
}
}
public void Execute(IActionVisitor visitor, Action<ITargetProcessCommand> executor, IActivityLogger logger)
{
visitor.Accept(this);
executor(CreateCommand());
}
public UserMapper(IStorageRepository storageRepository, IActivityLogger logger)
{
_storageRepository = storageRepository;
_logger = logger;
}
