Exemple #1
0
        protected override ITaskResult<Nothing> SafeExecute(TaskContext context)
        {
            if (Destination == null)
            {
                throw new Exception("Destination file is not set");
            }

            using (var zipStream = new ZipOutputStream(Destination.WriteStream))
            {
                foreach (var fileToCompress in _sourceFiles)
                {
                    var entry = new ZipEntry(fileToCompress.EntityPath)
                    {
                        Size = fileToCompress.File.Length
                    };

                    zipStream.PutNextEntry(entry);

                    using (var fileReadStream = fileToCompress.File.ReadStream)
                    {
                        fileReadStream.CopyTo(zipStream);
                    }

                    zipStream.CloseEntry();
                }

                zipStream.IsStreamOwner = true;
            }

            return Success;
        }
 public void BeforeTaskExecute(Identity id, ITask<object> task, TaskContext context)
 {
     try
     {
         foreach (ITaskInterceptor nestedInterceptor in _nestedInterceptors)
         {
             nestedInterceptor.BeforeTaskExecute(id, task, context);
         }
     }
     catch (Exception ex)
     {
         context.Log.Error(ex.Message);
     }
 }
Exemple #3
0
        protected virtual string GetProjectFile(TaskContext context)
        {
            if (ProjectFile != null)
            {
                return ProjectFile.AbsolutePath;
            }

            context.Log.Info(
            @"No project file defined. Start solution file lookup from directory
            {0}",
                context.WorkDirectory.AbsolutePath);

            var currentDirectory = context.WorkDirectory;
            while (currentDirectory != null)
            {
                var solutionFiles = currentDirectory.Files.IncludeByExtension("sln").ToArray();
                if (solutionFiles.Length > 0)
                {
                    if (solutionFiles.Length > 1)
                    {
                        context.Log.Info(
            @"Multiple solution files found in directory
            {0}
            The first file will be used.",
                             currentDirectory.AbsolutePath);
                    }

                    var solutionFile = solutionFiles.First().AbsolutePath;

                    context.Log.Info("Solution file found: {0}", solutionFile);

                    return solutionFile;
                }

                context.Log.Info(
            @"No solution files found in
            {0}
            Go to parent directory.",
                        currentDirectory.AbsolutePath);
                currentDirectory = currentDirectory.Parent;
            }

            context.Log.Warning("No solution file found. Default MSBuild lookup mechanism will be used.");

            return null;
        }
        protected override ITaskResult<Nothing> SafeExecute(TaskContext context)
        {
            if (_destination == null)
            {
                throw new Exception("Destination file could not be null");
            }

            _destination.EnsureExists();

            var model = new Model
            {
                Attributes = new List<AttributeInfo>(),
                Namespaces = new List<Namespace>()
            };

            foreach (var attributeExpression in Attributes)
            {
                var body = (NewExpression)attributeExpression.Body;
                var attributeInfo = new AttributeInfo();

                var namespaceName = body.Type.Namespace;

                if (model.Namespaces.All(n => n.Name != namespaceName))
                {
                    model.Namespaces.Add(new Namespace
                    {
                        Name = namespaceName
                    });
                }

                attributeInfo.Name = body.Type.Name;
                attributeInfo.Arguments = string.Join(", ", GetArgumetValues(body));

                model.Attributes.Add(attributeInfo);
            }

            var result = Render.StringToString(Template, model);

            _destination.EnsureExists();
            _destination.WriteStringToFile(result);

            return Success;
        }
 public void AfterTaskExecute(Identity id, ITask<object> task, TaskContext context, ITaskResult<object> result)
 {
     if (result.IsSuccess)
     {
         object data = result.Data;
         if (data == null || data is Nothing)
         {
             context.Log.Info("Completed");
         }
         else
         {
             context.Log.Info("Completed. Result is {0}", FormatData(data));
         }
     }
     else
     {
         context.Log.Error(result.Error == null ? "Unknown error occured" : result.Error.Message);
     }
 }
        private static ITaskResult<Nothing> ExecuteWorkflow(
            IWorkflow workflow,
            Identities tasks,
            ILogRenderer logRenderer,
            IDirectory workDirectory)
        {
            var executer = new SubflowTask<Nothing>(
                workflow,
                tasks);

            var context = new TaskContext(
                new ParallelExecutionStrategy(),
                logRenderer,
                workDirectory,
                new DefaultEnvironment(),
                new CompositeInterceptor(
                    new LoggingInterceptor()));

            return executer.Execute(context);
        }
        protected override IEnumerable<Assembly> GetAssemblies(LookupOptions options)
        {
            var buildWorkflow = new BuildWorkflowProjectWorkflow(options.RunningOptions);
            var executerTask = new SubflowTask<Nothing>(buildWorkflow, Identities.Empty);

            var taskContext = new TaskContext(
                new SequenceExecutionStrategy(),
                options.RunningOptions.LogRenderer,
                options.RunningOptions.WorkDirectory,
                new DefaultEnvironment(),
                interceptor: null);

            ITaskResult<Nothing> buildResult = executerTask.Execute(taskContext);

            if (buildResult.IsSuccess)
            {
                var projectName = options.RunningOptions.InputFile.NameWithoutExtension;
                IFile assemblyFile = options.RunningOptions.InputFile.Directory["bin"]["Debug"][projectName + ".dll"];

                yield return Assembly.LoadFile(assemblyFile.AbsolutePath);
            }
        }
 protected override IDirectory GetToolWorkDirectory(TaskContext context)
 {
     return SpecFile.Directory;
 }
 protected override string GetToolArguments(TaskContext context)
 {
     return string.Format("pack {0}", SpecFile.Name);
 }
        protected override ITaskResult<Nothing> SafeExecute(TaskContext context)
        {
            Destination.EnsureExists();
            using (var writer = new StreamWriter(Destination.WriteStream))
            {
                writer.WriteLine("<?xml version='1.0' encoding='utf-8'?>");
                writer.WriteLine("<package xmlns='http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd'>");
                writer.WriteLine("  <metadata>");
                foreach (var metadata in Metadata)
                {
                    writer.WriteLine("    <{0}>{1}</{0}>", metadata.Key, metadata.Value);
                }

                if (Dependencies.Count > 0)
                {
                    writer.WriteLine("    <dependencies>");

                    var targetFrameworks = Dependencies.Select(x => x.TargetFramework).Distinct();
                    foreach (var targetFramework in targetFrameworks)
                    {
                        var framework = targetFramework;
                        writer.Write("      <group");
                        WriteOptionalAttribute("targetFramework", targetFramework, writer);
                        writer.WriteLine(">");

                        foreach (var dependency in Dependencies.Where(d => d.TargetFramework == framework))
                        {
                            writer.Write("        <dependency id='{0}'", dependency.Id);
                            WriteOptionalAttribute("version", dependency.Version, writer);
                            writer.WriteLine(" />");
                        }

                        writer.WriteLine("      </group>");
                    }

                    writer.WriteLine("    </dependencies>");
                }

                if (References.Count > 0)
                {
                    writer.WriteLine("    <references>");
                    foreach (var reference in References)
                    {
                        writer.WriteLine("      <reference file='{0}' />", reference);
                    }

                    writer.WriteLine("    </references>");
                }

                if (FrameworkAssemblies.Count > 0)
                {
                    writer.WriteLine("    <frameworkAssemblies>");
                    foreach (var frameworkAssembly in FrameworkAssemblies)
                    {
                        writer.Write("      <frameworkAssembly assemblyName='{0}'", frameworkAssembly.AssemblyName);
                        WriteOptionalAttribute("targetFramework", frameworkAssembly.TargetFramework, writer);
                        writer.WriteLine(" />");
                    }

                    writer.WriteLine("    </frameworkAssemblies>");
                }

                writer.WriteLine("  </metadata>");

                if (Files.Count > 0)
                {
                    writer.WriteLine("  <files>");
                    foreach (var file in Files)
                    {
                        writer.Write("    <file src='{0}'", file.Src);
                        WriteOptionalAttribute("target", file.Target, writer);
                        WriteOptionalAttribute("exclude", file.Exclude, writer);
                        writer.WriteLine(" />");
                    }

                    writer.WriteLine("  </files>");
                }

                writer.WriteLine("</package>");
            }

            return Success;
        }
 public void BeforeTaskExecute(Identity id, ITask<object> task, TaskContext context)
 {
 }
Exemple #12
0
        protected override IEnumerable<IFile> GetToolPathLookup(TaskContext context)
        {
            try
            {
                string[] registryKeys = ToolVersion == null ?
                    /*
                     * If no specific version provided we look up for
                     * the mosk fresh version of MsBuild
                     */
                    LookUpMsBuildRegistryKeys()
                    : new [] { ToolVersion.Value };

                if (registryKeys.Length == 0)
                {
                    context.Log.Warning("No MsBuild registry entries have been found. MsBuild probably hav not been installed.");
                }

                return registryKeys
                    .Select(key =>
                    {
                        string registryKey = string.Format(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\{0}", key);
                        string toolDirectory = (string) Registry.GetValue(registryKey, "MSBuildToolsPath", null);

                        return new DefaultFile(Path.Combine(toolDirectory, "MsBuild.exe"));
                    });
            }
            catch (Exception ex)
            {
                context.Log.Warning("Error occured while reading registry: {0}", ex.Message);
            }

            return new IFile[0];
        }
Exemple #13
0
        protected override string GetToolPath(TaskContext context)
        {
            if (context.Environment.IsMono)
            {
                return "xbuild";
            }

            return base.GetToolPath(context);
        }
Exemple #14
0
        protected override string GetToolArguments(TaskContext context)
        {
            string projectFile = GetProjectFile(context);
            string switches = string.Join(" ", Switches.Select(s => s.CommandLinePart));

            return string.Format("{0} {1}", switches, projectFile);
        }
Exemple #15
0
 //        protected override string GetToolPath(TaskContext context)
 //        {
 //            return "nuget";
 //        }
 protected override string GetToolArguments(TaskContext context)
 {
     return string.Format(
         "push \"{1}\" {0} {2} -NonInteractive",
         ApiKey,
         PackageFile.AbsolutePath,
         string.Join(" ", Options.Select(option => option.CommandLinePart)));
 }