public InfoRefsService(ITracer tracer, IGitServer gitServer, IEnvironment environment, RepositoryConfiguration configuration)
 {
     _gitServer = gitServer;
     _tracer = tracer;
     _deploymentTargetPath = environment.DeploymentTargetPath;
     _configuration = configuration;
 }

 public string ExecuteMSBuild(ITracer tracer, string arguments, params object[] args)
 {
     using (var writer = new ProgressWriter())
     {
         writer.Start();
         return _msbuildExe.Execute(tracer, arguments, args).Item1;
     }
 }

        public PropertiesView(ITracer tracer)
        {
            Contract.Requires(tracer != null);
            _tracer = tracer;

            InitializeComponent();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Settings"/> class.
 /// </summary>
 /// <param name="manager">The settings manager that will read and save data for this instance.</param>
 public Settings(ISettingsManager manager)
 {
     this.tracer = Tracer.Get(this.GetType());
     this.manager = manager;
     this.manager.Read(this);
     this.IsInitialized = false;
 }

 /// <summary>
 /// Gets the path to the guidance document from the current element.
 /// </summary>
 /// <remarks>
 /// Returns the first artifact link with a *.doc extension of the current element.
 /// </remarks>
 public static string GetDocumentPath(ITracer tracer, IProductElement element, IUriReferenceService uriService)
 {
     // Return path of first reference
     var references = SolutionArtifactLinkReference.GetResolvedReferences(element, uriService);
     if (!references.Any())
     {
         tracer.Warn(String.Format(CultureInfo.CurrentCulture,
             Resources.GuidanceDocumentPathProvider_NoLinksFound, element.InstanceName));
         return string.Empty;
     }
     else
     {
         var reference = references.FirstOrDefault(r => r.PhysicalPath.EndsWith(GuidanceDocumentExtension));
         if (reference == null)
         {
             tracer.Warn(String.Format(CultureInfo.CurrentCulture,
                 Resources.GuidanceDocumentPathProvider_NoDocumentLinkFound, element.InstanceName));
             return string.Empty;
         }
         else
         {
             tracer.Info(String.Format(CultureInfo.CurrentCulture,
                 Resources.GuidanceDocumentPathProvider_LinkFound, element.InstanceName, reference.PhysicalPath));
             return reference.PhysicalPath;
         }
     }
 }

 public virtual async Task Fetch(IRepository repository, DeploymentInfo deploymentInfo, string targetBranch, ILogger logger, ITracer tracer)
 {
     // (A)sync with dropbox
     var dropboxInfo = (DropboxInfo)deploymentInfo;
     _dropBoxHelper.Logger = logger;
     deploymentInfo.TargetChangeset = await _dropBoxHelper.Sync(dropboxInfo, targetBranch, repository, tracer);
 }

 public SSHKeyController(ITracer tracer, ISSHKeyManager sshKeyManager, IFileSystem fileSystem, IOperationLock sshKeyLock)
 {
     _tracer = tracer;
     _sshKeyManager = sshKeyManager;
     _fileSystem = fileSystem;
     _sshKeyLock = sshKeyLock;
 }

        public SiteExtensionLogManager(ITracer tracer, string directoryPath)
        {
            _tracer = tracer;
            _directoryPath = directoryPath;

            UpdateCurrentPath();
        }

 public UploadPackHandler(ITracer tracer,
                           IGitServer gitServer,
                           IOperationLock deploymentLock,
                           IDeploymentManager deploymentManager)
     : base(tracer, gitServer, deploymentLock, deploymentManager)
 {
 }

        public DietCalculator(Diet diet, IIngredientQuantityRepository ingredientQuantityRepository, ITracer tracer)
        {
            _diet = diet;
            _ingredientQuantityRepository = ingredientQuantityRepository;
            _tracer = tracer;
            tracer.WriteTrace("Henter ut ingredienser og måltid");
            var ingredients = _diet.DietIngredients.ToList();
            var meals = _diet.DietMeals.ToList();
            foreach (var di in ingredients)
            {
                var quantityConversion = di.Quantity / QuantityConverter.ConvertTo100Grams(di.QuantityTypeId, _ingredientQuantityRepository.GetConvertFactor(di.IngredientId, di.QuantityTypeId)) * di.Day.ToIntArray().Count();
                _totalIngredientCarbsGrams += di.Ingredient.Carb * quantityConversion;
                _totalIngredientFatGrams += di.Ingredient.Fat * quantityConversion;
                _totalIngredientProteinGrams += di.Ingredient.Protein * quantityConversion;
                _totalIngredientKcals += di.Ingredient.Kcal * quantityConversion;
            }

            foreach (var dm in meals)
            {
                var mealDays = dm.Day.ToIntArray().Count();
                var mealCalulator = new MealCalculator(dm.Meal, _ingredientQuantityRepository);
                _totalMealCarbGrams += mealCalulator.CalculateTotalCarb() * mealDays;
                _totalMealFatGrams += mealCalulator.CalculateTotalFat() * mealDays;
                _totalMealProteinGrams += mealCalulator.CalculateTotalProtein() * mealDays;
                _totalMealKcals += mealCalulator.CalculateTotalKcal() * mealDays;
            }

            _totalGrams = _totalIngredientCarbsGrams + _totalIngredientFatGrams + _totalIngredientProteinGrams +
                          _totalMealCarbGrams + _totalMealFatGrams + _totalMealProteinGrams;
            _tracer.WriteTrace("Ferdig med constructor");
        }

        public DataEngine(ITracer tracer, string instanceName, int maxConcurrency, IStorageDriver storageDriver, DataContainerDescriptor containerDescriptor)
        {
            if (tracer == null)
            {
                throw new ArgumentNullException("tracer");
            }

            if (maxConcurrency <= 0 || maxConcurrency > 10000)
            {
                throw new ArgumentOutOfRangeException("maxConcurrency");
            }

            if (storageDriver == null)
            {
                throw new ArgumentNullException("storageDriver");
            }

            if (containerDescriptor == null)
            {
                throw new ArgumentNullException("containerDescriptor");
            }

            m_tracer = tracer;
            m_containerDescriptor = containerDescriptor;
            m_maxConcurrency = maxConcurrency;
            m_parsedRequestCache = new ParsedRequestCache(instanceName);
            m_storageDriver = storageDriver;
            m_parser = new QueryParser(containerDescriptor, maxConcurrency);
            m_activeProcessors = new ConcurrentDictionary<RequestExecutionContext, Task>(m_maxConcurrency, m_maxConcurrency);
            m_utcLastUsedAt = DateTime.UtcNow;
        }

 public void ValidateCommandSettings(ITracer tracer)
 {
     this.tracer = tracer;
     this.ValidateAssociatedArtifactConfiguration();
     this.ValidateAuthoringUriIsValidAndTemplateIsConfiguredCorrectly(false);
     this.ValidateTemplateUriIsNotEmpty();
 }

        public Solution(ITracer tracer, IVsServiceProvider serviceProvider)
        {
            Contract.Requires(tracer != null);
            Contract.Requires(serviceProvider != null);

            _deferredUpdateThrottle = new DispatcherThrottle(DispatcherPriority.ContextIdle, Update);

            _tracer = tracer;
            _serviceProvider = serviceProvider;

            _specificProjectConfigurations = Projects.ObservableSelectMany(prj => prj.SpecificProjectConfigurations);
            _solutionContexts = SolutionConfigurations.ObservableSelectMany(cfg => cfg.Contexts);
            _defaultProjectConfigurations = Projects.ObservableSelect(prj => prj.DefaultProjectConfiguration);
            _projectConfigurations = new ObservableCompositeCollection<ProjectConfiguration>(_defaultProjectConfigurations, _specificProjectConfigurations);

            _solutionEvents = Dte?.Events?.SolutionEvents;
            if (_solutionEvents != null)
            {
                _solutionEvents.Opened += Solution_Changed;
                _solutionEvents.AfterClosing += Solution_Changed;
                _solutionEvents.ProjectAdded += _ => Solution_Changed();
                _solutionEvents.ProjectRemoved += _ => Solution_Changed();
                _solutionEvents.ProjectRenamed += (_, __) => Solution_Changed();
            }

            Update();
        }

 public DropboxHandler(ITracer tracer,
                       IDeploymentStatusManager status,
                       IDeploymentSettingsManager settings,
                       IEnvironment environment)
 {
     _dropBoxHelper = new DropboxHelper(tracer, status, settings, environment);
 }

        /// <summary>
        /// Ctr.
        /// </summary>
        /// <param name="process">Parent process, receives crash notifications</param>
        /// <param name="tracer">Tracer object</param>
        public RequestExecutionContext(IPqlEngineHostProcess process, ITracer tracer)
        {
            if (process == null)
            {
                throw new ArgumentNullException("process");
            }

            if (tracer == null)
            {
                throw new ArgumentNullException("tracer");
            }

            m_tracer = tracer;

            m_process = process;

            ParsedRequest = new ParsedRequest(false);
            Request = new DataRequest();
            RequestBulk = new DataRequestBulk();
            RequestParameters = new DataRequestParams();

            m_buffersRingItems = new []
                {
                    new RequestExecutionBuffer(),
                    new RequestExecutionBuffer(),
                    new RequestExecutionBuffer()
                };
        }

        public JArray GetTriggerInputs(ITracer tracer)
        {
            JArray inputs = new JArray();
            foreach (var functionJson in EnumerateFunctionFiles())
            {
                try
                {
                    var json = JObject.Parse(FileSystemHelpers.ReadAllText(functionJson));
                    var binding = json.Value<JObject>("bindings");
                    foreach (JObject input in binding.Value<JArray>("input"))
                    {
                        var type = input.Value<string>("type");
                        if (type.EndsWith("Trigger", StringComparison.OrdinalIgnoreCase))
                        {
                            tracer.Trace(String.Format("Sync {0} of {1}", type, functionJson));
                            inputs.Add(input);
                        }
                        else
                        {
                            tracer.Trace(String.Format("Skip {0} of {1}", type, functionJson));
                        }
                    }
                }
                catch (Exception ex)
                {
                    tracer.Trace(String.Format("{0} is invalid. {1}", functionJson, ex.Message));
                }
            }

            return inputs;
        }

        public string ExecuteMSBuild(ITracer tracer, string arguments, params object[] args)
        {
            using (var writer = new ProgressWriter())
            {
                writer.Start();

                // The line with the MSB3644 warnings since it's not important
                return _msbuildExe.Execute(tracer,
                                           output =>
                                           {
                                               if (output.Contains("MSB3644:") || output.Contains("MSB3270:"))
                                               {
                                                   return false;
                                               }

                                               writer.WriteOutLine(output);
                                               return true;
                                           },
                                           error =>
                                           {
                                               writer.WriteErrorLine(error);
                                               return true;
                                           },
                                           Console.OutputEncoding,
                                           arguments,
                                           args).Item1;
            }
        }

        public FetchHandler(ITracer tracer,
                            IDeploymentManager deploymentManager,
                            IDeploymentSettingsManager settings,
                            IDeploymentStatusManager status,
                            IOperationLock deploymentLock,
                            IEnvironment environment,
                            IEnumerable<IServiceHookHandler> serviceHookHandlers,
                            IRepositoryFactory repositoryFactory,
                            IAutoSwapHandler autoSwapHandler)
        {
            _tracer = tracer;
            _deploymentLock = deploymentLock;
            _environment = environment;
            _deploymentManager = deploymentManager;
            _settings = settings;
            _status = status;
            _serviceHookHandlers = serviceHookHandlers;
            _repositoryFactory = repositoryFactory;
            _autoSwapHandler = autoSwapHandler;
            _markerFilePath = Path.Combine(environment.DeploymentsPath, "pending");

            // Prefer marker creation in ctor to delay create when needed.
            // This is to keep the code simple and avoid creation synchronization.
            if (!FileSystemHelpers.FileExists(_markerFilePath))
            {
                try
                {
                    FileSystemHelpers.WriteAllText(_markerFilePath, String.Empty);
                }
                catch (Exception ex)
                {
                    tracer.TraceError(ex);
                }
            }
        }

            public TraceActivity(ITracer tracer, string format, params object[] args)
            {
                this.displayName = format;
                if (args != null && args.Length > 0)
                    this.args = args;

                this.tracer = tracer;
                this.newId = Guid.NewGuid();
                this.oldId = Trace.CorrelationManager.ActivityId;

                if (this.oldId != Guid.Empty)
                    tracer.Trace(TraceEventType.Transfer, this.newId);

                Trace.CorrelationManager.ActivityId = newId;

                if (this.args == null)
                {
                    this.tracer.Trace(TraceEventType.Start, this.displayName);
                    //Trace.CorrelationManager.StartLogicalOperation(this.displayName);
                }
                else
                {
                    this.tracer.Trace(TraceEventType.Start, this.displayName, args);
                    //Trace.CorrelationManager.StartLogicalOperation(string.Format(displayName, args));
                }
            }

        public DataContainer(ITracer tracer, DataContainerDescriptor dataContainerDescriptor, string storageRoot)
        {
            if (tracer == null)
            {
                throw new ArgumentNullException("tracer");
            }

            if (dataContainerDescriptor == null)
            {
                throw new ArgumentNullException("dataContainerDescriptor");
            }

            // intentionally allowed to be null - in case if we don't want to use any persistence
            m_storageRoot = storageRoot;
            m_tracer = tracer;
            m_memoryPool = new DynamicMemoryPool();

            m_dataContainerDescriptor = dataContainerDescriptor;
            m_documentDataContainers = new Dictionary<int, DocumentDataContainer>(50);
            m_documentDataContainerLocks = new Dictionary<int, object>(50);

            foreach (var item in dataContainerDescriptor.EnumerateDocumentTypes())
            {
                m_documentDataContainerLocks.Add(item.DocumentType, new object());
            }
        }