I am trying to do a p4 merge through command line but none of the arguments I see in the documentation actually seems to work to take the current CL I need to specify it manually with -c. Is there any way to merge from current CL (whatever that is) to child? I thought p4 merge without arguments would do it but it is not the caseas I get the Missing/wrong number of arguments. Error
The -c option specifies the pending changelist that the target files will be placed into, not the submitted changelist(s) that will be used as the source of the merge. If this option is not used, files are opened in the default changelist (which will become a numbered changelist when you run either p4 change or p4 submit).
The default behavior of most commands (including p4 merge) is to use the latest revisions/changelist. To merge to the current stream from its parent just do p4 merge. It is not necessary to specify the changelist. If you do need to specify a changelist, use an optional revision specifier, e.g. p4 merge #someChange. (Note: if you're using an old version of Perforce, specifying the child stream is necessary rather than having it inferred as being the one associated with the current workspace -- use -S currentStream.)
See p4 help merge for more information on what the different flags to p4 merge do, and p4 help revisions for information on revision specifiers in general.
P4 Server 2013.1/610569
I am trying to script the submission of default changelist with a Job. I understand that it is not possible to directly add a job to a pending changelist and submit it however I am open to doing things the indirect fashion. Basically the steps for me are
Move all files in the Pending changelist to a new numbered changelist
Add a given P4 Job name to this new numbered changelist
Set the textual description of the numbered changelist to be the same as the P4 Job name
Submit the given job
Can someone post me the p4 commands that need to be run for this? I tried doing this from the P4V and capture the commands at the bottom but it appears when you move files we have to list all files and I was looking for a straight-forward way of doing this.
Here's a starting place:
p4 change -o | sed 's/<enter.*>/Change to fix job000001/' >change.dat
echo 'Jobs: job000001' >> change.dat
p4 change -i < change.dat >changenumber.out
p4 submit -c `cut -f 2 -d ' ' < changenumber.out`
The first two lines construct the form data for the new changelist.
The third line creates the numbered changelist, and saves the output,
which is something like "Change 12345 saved".
The fourth line extracts that change number and gives it to 'p4 submit -c'.
Of course, I haven't done any error checking, reporting of the results to the user, etc.
As an alternative, consider this:
p4 submit -d "Change to fix job000001" | grep 'Change .* submitted' | cut -f 2 -d ' ' >change.out
p4 fix -c `cat change.out` job000001
That variant submits the change without the job attached, then associates the change with the job.
Either way, please consider using one of the Perforce scripting APIs (P4Perl, P4Ruby, P4Python, etc.) instead of this, as they are much, much easier.
I'm new to perforce, coming from a history of cvs->svn->git. I'm having a difficult time seeing a compact representation of the most recent changes impacting a set of file. For instance, if I go to a directory and type:
% p4 filelog .
It doesn't do anything useful. More interesting is
% p4 filelog *
However this shows me the change history of every file individually. I'd rather see a unified view of changes in a format showing: change number, submit message, changed files for the most recent N submits.
You can almost get this with:
p4 changes -lt [file[RevRange]...]
This will show you the changelists that affected the files in question. It doesn't show which files were affected by each change, however. You could write a script that took the output of p4 changes and used p4 describe -s to get the file listing for each changelist.
Note that p4 changes includes pending changes by default. Add -s submitted for only submitted changelists. There are other flags to narrow it down further, like -u username and -m max (to limit the number of changelists returned -- it returns newest first).
To list the files that have changed between your #start,#stop times,
p4 -c WORKSPACENAME files //Path/You/Care/About/...#2013/03/20:13:40,#2014/06/016:17:00
When submitting changelists in Perforce I need to allocate a job. The jobs which I am supposed to associate with my changelist are not allocated to me and does not show up in the list of available jobs when I invoke "p4 submit". I know the job number which I am going to use, but can't find a way to specify it. Basically, I want to do something like:
p4 submit -j
But there is no -j option...
You can create a numbered pending changelist, and attach jobs (p4 fix) to that.
I don't think there's a one shot way of submitting the default changelist with an arbitrary job.
In your change spec (when you do p4 submit or p4 change) simply add a Jobs: section with a newline separated list of jobs you wish to fix.
If you edit your user (p4 user) and add a jobview: section, the jobs section will appear automatically.
See http://kb.perforce.com/?article=052
A question that occasionally arises is what is the best way to determine the changelist that you last synced to in Perforce. This is often needed for things like injecting the changelist number into the revision info by the automatic build system.
I recommend the opposite for automatic build systems: you should first get the latest changelist from the server using:
p4 changes -s submitted -m1
then sync to that change and record it in the revision info. The reason is as follows. Although Perforce recommends the following to determine the changelist to which the workspace is synced:
p4 changes -m1 #clientname
they note a few gotchas:
This only works if you have not submitted anything from the workspace in question.
It is also possible that a client workspace is not synced to any specific changelist.
and there's an additional gotcha they don't mention:
If the highest changelist to which the sync occured strictly deleted files from the workspace, the next-highest changelist will be reported (unless it, too, strictly deleted files).
If you must sync first and record later, Perforce recommends running the following command to determine if you've been bit by the above gotchas; it should indicate nothing was synced or removed:
p4 sync -n #changelist_number
Note that this method doesn't work if a file is added in a changelist (n-1) and then deleted in the very next changelist (n). p4 changes -m1 #clientname and p4 changes ...#have both return n-3 and p4 sync -n #n-3 will say "file(s) up-to-date."
Just to answer this myself in keeping with Jeff's suggestion of using Stackoverflow as a place to keep technical snippets....
From the command line use:
p4 changes -m1 #<clientname>
And just replace with the name of your client spec. This will produce output of the form:
Change 12345 on 2008/08/21 by joebloggs#mainline-client '....top line of description...'
Which is easily parsed to extract the changelist number.
You may try finding the maximum change number in the output of the "p4 files" command. The working directory should not contain post-sync commits, though. This is just a tad better than
p4 changes -m1 "./...#have"
as the latter seems to run on the server and may fail on big source trees due to "MaxResults" limits.
$ p4 changes -m1 "./...#have"
Request too large (over 850000); see 'p4 help maxresults'.
$ p4 -G files "./...#have" | python c:/cygwin/usr/local/bin/p4lastchange.py
Files: 266948
2427657
where p4lastchange.py is based on the code from the Using P4G.py From the Command Line presentation by J.T.Goldstone, Kodak Information Network/Ofoto, April 15, 2005.
#! /usr/bin/env python
import sys, os, marshal
if os.name == "nt":
# Disable newline translation in Windows. Other operating systems do not
# translate file contents.
import msvcrt
msvcrt.setmode( sys.stdin.fileno(), os.O_BINARY )
lastcl = 0
num = 0
try:
while 1:
dict = marshal.load(sys.stdin)
num = num + 1
for key in dict.keys():
# print "%s: %s" % (key,dict[key])
if key == "change":
cl = int(dict[key])
if cl > lastcl:
lastcl = cl
except EOFError:
pass
print "Files: %s" % num
print lastcl
p4 changes -m1 #clientname which is the "recommended" way to do it for my client takes about 10 minutes
this is what I use:
p4 cstat ...#have | grep change | awk '$3 > x { x = $3 };END { print x }'
for the same client takes 2.1 seconds
If you are using P4V you can do this graphically:
In the Dashboard tab (View->Dashboard) choose a folder and you will see a list of changelists that the folder isn't yet updated with. Note the lowest number (in the highest row).
Make sure that in the Workspace Tree you have selected the same folder as previously in the Dashboard. Then go to the History tab (View->History) and scroll down to the number noted previously. The number just below that number is the number of your current changelist.
You could also use the cstat command:
p4 help cstat
cstat -- Dump change/sync status for current client
p4 cstat [files...]
Lists changes that are needed, had or partially synced in the current
client. The output is returned in tagged format, similar to the fstat
command.
The fields that cstat displays are:
change changelist number
status 'have', 'need' or 'partial'
For a serious build (one that is being prepared for testing), explicitly specify the desired label or changelist number, sync to label, and imbed it in build artifacts.
If a changelist (or label) is not given, use p4 counter change to get the current change number, and record it. But you still need to sync everything using that change number.
I don't think you can achieve exactly what you want, because in general, an entire workspace isn't synced to a particular changelist number. One can explicitly sync some files to older revisions, and then a single changelist number is meaningless. That's why a fresh sync is required to ensure that a single changelist number accurately represents the code version.
Regarding the comments: Yes, my answer is intended for use by configuration managers preparing a build to give to QA. Our developers don't normally sync as part of a build; they do a build prior to submitting—so that they can make sure their changes don't break the build or tests. In that context, we don't bother to embed a repository label.
With your approach, you are making the assumption that your whole workspace was synced to head at the time of your last changelist submission, and that changelist included all of your open files. It's too easy to be mistaken in those assumptions, hard to detect, and horribly expensive in terms of lost time. On the other hand, solving the problem is easy, with no drawbacks. And because a changelist number can be explicitly specified, it doesn't matter what revision you need or how quickly the codebase is changing.
For the whole depot (not just your workspace/client)
p4 counter change
does the job, just telling the last changelist.
The best I've found so far is to do your sync to whatever changelist you want to build and then use changes -m1 //...#have to get the current local changelist (revision).
p4 sync #CHANGELIST_NUM
p4 changes -m1 //...#have | awk '{print $2}'
Gives you the changelist number that you can the use wherever you want. I am currently looking for a simpler way than p4 changes -m1 //...#have.
I am not sure if you got the answer you needed but I had a similar problem. The goal was to write in our logger the specific version of the project. The problem was that while we are making our own makefile, the overall build system is controlled by our configuration management. This means that all the solutions which say "sync to something then do something" don't really work and I didn't want to manually change the version whenever we commit (a sure source for errors).
The solution (which is actually hinted in some of the answers above) is this:
in our makefile, I do p4 changes -m1 "./...#have"
The result for this is Change change_number on date by user#client 'msg'
I simply create the message into a string which is printed by the logger (the change number is the important element but the other is also useful to quickly decide if a certain version contains changes you know you made yourself without going to perforce to check).
Hope this helps.