Donnerstag, 3. Juli 2014

Two workarounds to the PowerShell Workflow Problem

I got two workarounds to the problem in previous post.

Frank Peter Schultze ‏@fpschultze proposed to use inlinescript

 Workflow Strange
{
    param(
        [string]$folder
        )

    inlinescript
    {
    !(Test-Path -path $using:folder)
    }
}

and I found the following solution

Workflow Strange
{
    param(
        [string]$folder
        )
    $a = Test-Path -path $folder
    ! $a
}

Test-Path in PowerShell Workflow Problem

Hello PowerShell World.
I'm back an my current focus is PowerShell WorkFlows.

And I just found a strange example I can't explain.

Workflow Strange
{
    param(
        [string]$folder
        )


    if (Test-Path -path $folder)
    {
        "Folder $folder exists"
    }
    if (!(Test-Path -path $folder))
    {
        "Folder $folder seenms not exists"
        "But Get-Item shows it is there"
        Get-item -path $folder

    }

    $a = (Test-Path -path $folder)
    ! $a
}

Strange -folder 'C:\temp' -PSComputerName  MAGV-2012AKTDE
And here is its output

Folder C:\temp exists
Folder C:\temp seenms not exists
But Get-Item shows it is there


    Verzeichnis: C:\


Mode                LastWriteTime     Length Name                                                                          PSComputerName                                                             
----                -------------     ------ ----                                                                          --------------                                                             
d----        22.08.2013     10:53            temp                                                                          MAGV-2012AKTDE                                                             
True






All involved machines running PowerShell V3.0.

Sonntag, 19. August 2012

Screenshot of Windows 8 Pseudo Start Menu


Here is a screenshot of my Windows 8 RTM machine with the pseudo start menu. Click into the picture to see the complete desktop of my machine. And read my last post, to see how it was done.

How to build a Windows 8 Start Menu

Recently I read  How to Get the Classic Start Menu Back in Windows 8 from How-To-Geek.

Having my toolbar attached to the left it creates a menu near the left bottom corner. That is great.

The only problem is, that there are two start menu folder

%ProgramData%\Microsoft\Windows\Start Menu\Programs

and

%AppData%\Microsoft\Windows\Start Menu\Programs

To combine the two folders into one I create this little PowerShell function, which creates or updates a combined version at C:\Startmenu.

All to do to complete the trick is to use this path instead of the above pathes given by How-To-Geek to create the toolbar.

PS.: the new Windows 8 UI (formerly called Metro ) is just the backside of the desktop, it is nearly useless for Desktop Users.





Sonntag, 22. Juli 2012

Bookreview


Microsoft® SQL Server® 2012 T-SQL Fundamentals



By 
Publisher: Microsoft Press
Released: June 2012
Pages: 448



A succinct introduction for beginners and a profound reference for experienced users.

This is a fresh book about T-SQL. Its title references SQL-Server version 2012, but it is well suited to work with older versions, say back to SQL-Server 2005. Features not present in all versions are clearly tagged.

The book targets at beginners, but I can can assure you, that even after more than 10 years practise with  sql-scripts, it is an excellent reading.

Let us look at the contents, which is currently missing on O'Reilly's link below.

Chapter 1 Background to T-SQL Querying and Programming
Beside some theoretical background, here you learn what is new, like the ABC. These are acronyms standing for the flavors of SQL Server: Appliance, Box and Cloud. Box is the new name for what I knew as SQL Server from versions 6.0 to 2008. Now I know about A and C too.

Chapter 2 Single-Table Queries.
I didn't learn new features, but a better presentation of the order of the logical steps, which are done, when a query is executed. This helps later to understand some restrictions, which I though of a bit artificial until now.

Chapters 3 Joins
No new features since SQL Server 2005. But rather exhaustive, well suited for beginners.

Chapter 4 Subqueries
Here the section Dealing with Misbehaving Subqueries contains stuff I had learned the hard way, i.e. by doing.

Chapter 5 Table Expressions
I got the confirmation that some coding variants perform equally well and it is best to choose the most readable. For example Common Table Expressions (CTEs) often increase the readability and no measurable impact on the performance.

Chapter 6 Set Operators 
Here the understanding of the logical steps from chapter 2 bear fruits.

Chapter 7 Beyond the Fundamentals of Querying
This starts with Window Functions. Obviously a new name, for something I knew as Analytical functions. And there are a few new functions here to learn with SQL Server 2012. You also find Pivoting, Unpivoting and Grouping Sets here.

Chapter 8 Data Modification
Besides INSERT, UPDATE and DELETE, you find truncate, bulk insert and merge here too.

Chapter 9 Transactions and Concurrency. 
I have to reread this later again. Just found out, that I have some gaps here.

Chapter 10 Programmable Objects 
This is about batches, functions and store procedures.

And there is an appendix showing how to do an install, to try all the things out.

Let me resume in 10 chapters, you have all the basic stuff to write correct T-SQL scripts. Even some hints concerning performance are included.

If T-SQL is new to you, you find lots of exercises and solutions in the book. 
I only threw a short look on them.

To me this is a valuable reference book and a resource to fill some gaps.

I got my team leader to order a copy of the book for my two younger co-workers. I think it is good to have things in place in one book we all have read, than having to collect each bit from the web when need arises.


More info about the book you find here:
I review for the O'Reilly Blogger Review Program

Sonntag, 20. Mai 2012

Small Framework to load sql scripts simultaniously to several Servers

I use the following framework to run scripts calling sqlcmd simultaneously as PowerShell jobs during some MsBuild Task. My Buildagents are running Server 2003 and there are some linitations cf. StackOverflow.
But just calling sqlcmd works fine. In fact I'm dropping and recreating my test databases and running a lot of sql scripts completly within such background jobs. I didn't try it with the Oracle part using sqlplus which I run in the main script and after whose termination I wait for jobs to terminate in time or terminate them. 

$workdir = Split-Path $MyInvocation.MyCommand.Path            
$logdir = 'C:\temp\log'            
$server1 = 'my_sql2008'            
$server2 = 'my_sql2005'            
$datbase = 'PowerShellTest'            
            
$cmd1 = [scriptblock]::Create(". $workdir\script_containing_function_for_background_job.ps1
Some_function -server $server1 -database $datbase $logdir -asJob" )            
            
                
$cmd1 = [scriptblock]::Create(". $workdir\script_containing_function_for_background_job.ps1
Some_function -server $server2 -database $datbase $logdir -asJob" )            
            
            
"...Starting the background jobs"            
$SQLJobStartTime = Get-date            
$jnr1 = (Start-Job -ScriptBlock $cmd1).Id            
$jnr2 = (Start-Job -ScriptBlock $cmd2).Id            
# *****************************************            
            
' Doing something slow here (it happens to be with an Oracle Server'            
<#
....
#>            
            
function Get-WaitTime             
{            
    param(            
        [DateTime]$start,            
        $dauer            
    )            
    $rest = $dauer - ((Get-Date) - $start).Totalseconds             
    if ($rest -lt 0) {$rest = 0}            
    $rest            
}            
            
'...Waiting for job on  SQL Server 2008'            
Wait-job -id $jnr1 -timeout ( Get-WaitTime $SQLJobStartTime 960 )   # max 16 min            
if ((Get-job -id $jnr1).state -eq 'Running')            
{            
    Stop-job -id $jnr1            
}             
Receive-Job -id $jnr1            
$state1 = (Get-job -id $jnr1).State            
$dauer1 = ((get-date) - $SQLJobStartTime).Totalseconds            
            
"$(Get-date -f d)  $(Get-date -f t) Release $release($build) Einspielen auf SQl-Server 2008 $state1 $dauer1 secs"            
            
'...Waiting for job  SQL Server 2005'            
Wait-job -id $jnr2 -timeout ( Get-WaitTime $SQLJobStartTime 960 )   # max 16 min            
if ((Get-job -id $jnr2).state -eq 'Running')            
{            
    Stop-job -id $jnr2            
}             
Receive-Job -id $jnr2            
$state2 = (Get-job -id $jnr2).State            
$dauer2 = ((get-date) - $SQLJobStartTime).Totalseconds            
            
"$(Get-date -f d)  $(Get-date -f t) Release $release($build) Einspielen auf SQl-Server 2005 $state2 $dauer2 secs"            

Displaying the builds of a given build-definition since the latest succesfull one

When it comes to fixing broken builds, the first step is to determine when the last successful build run and which builds failed afterwards.
In practice I'm looking for the state of 20 build definitions each morning, but here I reduce the script to a single one.

# adapt the following 4 lines to your environment            
Add-Type -Path "C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.TeamFoundation.Build.Client.dll"            
            
$tfsuri = 'your tfs server'            
$project = "your prpject"            
$buildDefinition = 'Main'            
            
function Get-BuildInfo            
{            
    param(            
        $buildDefinition,             
        $MaxBuildsPerDefinition = 5,            
        [switch]$DontBreakOnSuccess,            
        [switch]$Starttime            
        )            
            
    #Write-Host "Using MaxBuildsPerDefinition $MaxBuildsPerDefinition"            
    $tfs = [Microsoft.TeamFoundation.Client.TeamFoundationServerFactory]::GetServer($tfsuri)            
    $buildServerType = [Microsoft.TeamFoundation.Build.Client.IBuildServer]            
    $buildServer = $tfs.GetService($buildServerType);            
            
    $buildDetailSpec = $buildServer.CreateBuildDetailSpec($project, $buildDefinition);            
    if ($Starttime)            
    {            
        $buildDetailSpec.QueryOrder = [Microsoft.TeamFoundation.Build.Client.BuildQueryOrder]::StartTimeDescending            
    } else {            
        $buildDetailSpec.QueryOrder = [Microsoft.TeamFoundation.Build.Client.BuildQueryOrder]::FinishTimeDescending            
    }            
    $buildDetailSpec.MaxBuildsPerDefinition = $MaxBuildsPerDefinition            
            
            
    try            
    {            
     $buildQueryResult = $buildServer.QueryBuilds($buildDetailSpec)            
            
        foreach ($build in $buildQueryResult.builds)            
        {                
            # [Microsoft.TeamFoundation.Build.Client.IBuildDetail]$buildDetail = $buildQueryResult.builds[0]             
            $tfsBuildNumber = $build.BuildNumber            
            $shortBuildNumber = $tfsBuildNumber.Substring($tfsBuildNumber.LastIndexOf('_')+1)            
            
    #         #$shortBuildNumber            
    #         $buildQueryResult.failures.length            
    #         $buildQueryResult.builds.length            
    #         $buildQueryResult.builds[0].BuildNumber            
    #         #$buildQueryResult.builds[0].Status            
    #         #$buildQueryResult.builds[0].BuildDefinitionUri.AbsolutePath            
    #         $buildQueryResult.builds[0].StartTime            
    #         $buildQueryResult.builds[0].FinishTime            
              
              $buildAgent = '??'            
              $build.Information | % {            
                $_.nodes | % {            
                    try             
                    {            
                    $buildAgent = $_.children.nodes[2].fields['ReservedAgentName']            
                    }            
                    catch            
                    {            
                    }            
                }             
            }            
                
            New-Object PSObject -Property @{             
                Buildnumber = $build.BuildNumber;             
                Status = $build.Status;            
                CompilationStatus = $build.CompilationStatus;            
                Start = $build.StartTime;            
                End = $build.FinishTime;            
                DropLocation = $build.DropLocation;            
                SourceGetVersion = $build.SourceGetVersion;            
                BuildAgent = $buildAgent            
                }            
            if ($build.Status -eq 'Succeeded' -and ! $DontBreakOnSuccess) { break  }                
                            
        }            
    }            
    catch [Exception]            
    {            
     throw "TFS nicht erreichbar."            
    }            
            
}            
            
            
$a = @(Get-BuildInfo $buildDefinition)            
$a | % {            
    if ($_.Status -eq 'InProgress') { $end = Get-Date } else { $end = $_.End }            
    "{0,-32} {1,18}  {2:ddd} {3} - {4:T} {5,5:0} {6} {7,6} {8}" -f $_.Buildnumber, $_.Status, $_.Start, $_.Start, $End, ($End -$_.Start).Totalminutes, $_.SourceGetVersion, $_.buildAgent, $Droplocation            
}

The result tells me start time, end time, duration, included change set  and drop location.
In the case of failed builds I some further checks on the log files not included here to dispatch the problem as quick as possible to the developer  who caused the problem.