コード例 #1
0
    public bool revertFileInChangelist(string filepath, P4PendingChangelist list)
    {
        string[]    args   = new string[] { "-c", list.Number.ToString(), filepath };
        P4RecordSet setRes = RunCmd("revert", args); // "-c", cl.Number.ToString(), "//depot/path/foo.cs", "//depot/path/bar.cs");

        return(true);
    }
コード例 #2
0
    public void parseFromRecordset(P4RecordSet rs)
    {
        if (rs.HasErrors())
        {
        }

        if (rs.HasWarnings())
        {
            for (int i = 0; i < rs.Warnings.Length; i++)
            {
                string warning = rs.Warnings[i];
                if (warning.Contains("no such file(s)"))
                {
                    mIsFileInPerforce = false;
                }
            }
        }


        if (rs.Records.Length != 0)
        {
            P4Record stat = rs.Records[0];

            //set the bools
            mIsFileInPerforce        = stat["headAction"] != "delete";
            mIsFileLatestRevision    = stat["headRev"] == stat["haveRev"];
            mIsFileCheckedOutByMe    = stat["action"] == "actionOwner";
            mIsFileCheckedOutByOther = stat["otherOpen0"] != null;
        }
    }
コード例 #3
0
        private ArrayList getUnpublishedFiles(String path)
        {
            this.Cursor = Cursors.WaitCursor;

            if (scan == false)
            {
                int trimIndex = path.IndexOf("art");
                path = path.Substring(trimIndex, path.Length - trimIndex);
                path = "//depot/phoenix/xbox/published/" + path.Replace("\\", "/");
            }

            p4 = new P4Connection();
            p4.Connect();
            p4I = new P4Interface();

            ArrayList unpublished = new ArrayList();

            String[]    args   = { "-n", "-d", "-i", "-t", "-v", "-b", "phx_published", path };
            P4RecordSet record = p4I.Run("integrate", args);

            foreach (P4Record entry in record)
            {
                unpublished.Add(entry.Fields["fromFile"]);
            }
            this.Cursor = Cursors.Default;
            return(unpublished);

            p4.Disconnect();
        }
コード例 #4
0
    public P4RecordSet SyncFiles(String[] path)
    {
        p4.Connect();
        P4RecordSet syncFiles = RunCmd("sync", path);

        p4.Disconnect();

        return(syncFiles);
    }
コード例 #5
0
    //---------------------------------
    public P4FileStatus getFileStatus(string filepath)
    {
        string[]     args   = new string[] { "-m1", filepath };
        P4RecordSet  setRes = RunCmd("fstat", args);
        P4FileStatus fs     = new P4FileStatus();

        fs.parseFromRecordset(setRes);
        return(fs);
    }
コード例 #6
0
        public bool isOpenForEdit(string _file)
        {
            if (m_connection == null)
            {
                return(false);
            }
            P4RecordSet p4rs = m_connection.Run("opened", _file);

            return(p4rs.Records.Length != 0);
        }
コード例 #7
0
        //=========================================================================================
        // file operation
        //

        private bool fileExists(string _file)
        {
            if (m_connection == null)
            {
                return(false);
            }
            P4RecordSet p4rs = m_connection.Run("files", _file);

            return(p4rs.Records.Length != 0);
        }
コード例 #8
0
        public override void P4Execute()
        {
            try
            {
                P4RecordSet rs = _p4.Run(_command, _args);

                _errors.AddRange(rs.Errors);
                _warnings.AddRange(rs.Warnings);
                _messages.AddRange(rs.Messages);

                foreach (string m in _errors)
                {
                    Log.LogError(m);
                }

                int i = 0;
                foreach (P4Record r in rs)
                {
                    string   itemspec = string.Format("P4Output-{0}-{1:D8}", _command, i);
                    TaskItem item     = new TaskItem(itemspec);
                    LogMessage(MessageImportance.High, "{0}", itemspec);
                    foreach (string key in r.Fields.Keys)
                    {
                        LogMessage(MessageImportance.Normal, "  {0,-10} : {1}", key, r[key]);
                        item.SetMetadata(key, r[key]);
                    }

                    //  array fields will be populated as:
                    //  key  : arr-<keyname>
                    //  value: ';' delimited list
                    foreach (string key in r.ArrayFields.Keys)
                    {
                        string newKey = string.Format("arr-{0}", key);
                        string newVal = string.Empty;
                        foreach (string val in r.ArrayFields[key])
                        {
                            if (newVal != string.Empty)
                            {
                                newVal += ";";
                            }
                            newVal += val;
                        }
                        LogMessage(MessageImportance.Normal, "  {0,-10} : {1}", newKey, newVal);
                        item.SetMetadata(newKey, newVal);
                    }
                    _parsedOutput.Add(item);
                    i++;
                }
            }
            catch (Exception e)
            {
                Log.LogError(e.Message);
            }
        }
コード例 #9
0
        public ArrayList GetUsers()
        {
            ArrayList userList = new ArrayList();

            P4RecordSet users = Run("users");

            foreach (P4Record user in users)
            {
                userList.Add(user.Fields["User"]);
            }
            return(userList);
        }
コード例 #10
0
        //-----------------------------------------------------------------------------------------
        public bool ClientIsValid()
        {
            P4RecordSet p4rs = m_connection.Run("clients");

            foreach (P4Record p4r in p4rs)
            {
                if (p4r["client"] == m_connection.Client && p4r["Host"] == m_connection.Host && p4r["Owner"] == m_connection.User)
                {
                    return(true);
                }
            }
            return(false);
        }
コード例 #11
0
 public P4RecordSet Run(String command, String[] args)
 {
     try
     {
         P4RecordSet results = p4.Run(command, args);
         return(results);
     }
     catch (System.Exception e)
     {
         MessageBox.Show(e.Message, "Perforce Error!");
         return(null);
     }
 }
コード例 #12
0
    //---------------------------------
    public P4RecordSet GetSyncFiles(String[] path)
    {
        String[] args = new String[path.Length + 1];
        args[0] = "-n";
        for (int i = 1; i < args.Length; i++)
        {
            args[i] = path[i - 1];
        }

        p4.Connect();
        P4RecordSet syncFiles = RunCmd("sync", args);

        p4.Disconnect();

        return(syncFiles);
    }
コード例 #13
0
        public bool addOrCheckout(string _file)
        {
            clearError();

            if (m_connection == null)
            {
                m_error = "Error: perforce not connected";
                return(false);
            }

            if (isOpenForEdit(_file))
            {
                return(true);
            }

            string      message = String.Empty;
            P4RecordSet p4rs    = null;

            try
            {
                if (fileExists(_file))
                {
                    p4rs = m_connection.Run("edit", _file);
                }
                else
                {
                    p4rs = m_connection.Run("add", _file);
                }
            }
            catch (Exception ex)
            {
                m_error = ex.Message;
                return(false);
            }

            if (p4rs.Messages.Length > 0)
            {
                m_warnings = "";
                foreach (string msg in p4rs.Messages)
                {
                    m_warnings += msg + "\n";
                }
            }

            return(true);
        }
コード例 #14
0
ファイル: CohAssetMang.cs プロジェクト: LowerCode/coh-score
        private static string executeP4Cmd(string cmd, string [] args)
        {
            string results = "";

            try
            {
                P4Connection p4 = new P4Connection();
                p4.Connect();

                P4RecordSet recSet = p4.Run(cmd, args);

                foreach (object obj in recSet.Messages)
                {
                    results += String.Format("{0}\r\n", (string)obj);
                }

                foreach (P4Record rec in recSet)
                {
                    FieldDictionary fd = rec.Fields;
                    if (cmd.Equals("opened"))
                    {
                        results += fd["clientFile"];
                    }
                    else
                    {
                        foreach (string key in fd.Keys)
                        {
                            results += String.Format("{0}\t\t{1}\r\n", key, fd[key]);
                        }
                    }
                    results += "\r\n";
                }
                p4.Disconnect();
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
            return(results);
        }
コード例 #15
0
        /// <summary>
        /// Send the equivalent to a P4 command.
        /// Note that P4UnParsedRecordSet returns Empty from fstat.
        /// </summary>
        /// <param name="command">the p4 command, like "edit"</param>
        /// <param name="message">The first line of the P4 command result if no error, else the error message.</param>
        /// <param name="recordSet">The recordSet from P4</param>
        /// <param name="args">The args to add to the P4 command.</param>
        /// <returns>false if error (see message)</returns>
        private bool SendCommand(string command, out string message, out P4RecordSet recordSet, params string[] args)
        {
            string argsStr = Concatenate(args);

            try
            {
                //Log.Information(String.Format("P4Service.SendCommand() Starting: {0} {1}", command, argsStr));
                recordSet = _p4.Run(command, args);
            }
            catch (Exception ex)
            {
                Log.Error(String.Format("P4Service.SendCommand() Exception: {0}", ex.Message));
                message   = ex.Message;
                recordSet = null;
                return(false);
            }

            if (recordSet.HasErrors())
            {
                Log.Error(String.Format("P4Service.SendCommand() 1: {0}", recordSet.ErrorMessage));
                message = recordSet.ErrorMessage;
                return(false);
            }

            if (recordSet.HasWarnings())
            {
                message = Concatenate(recordSet.Warnings);
                Log.Warning(String.Format("P4Service.SendCommand() 2: {0}", message));
                return(true);
            }

            message = Concatenate(recordSet.Messages);
            if (!String.IsNullOrEmpty(message))
            {
                Log.Information(String.Format("P4Service.SendCommand() 3: {0}", message));
            }

            //Log.Information(String.Format("P4Service.SendCommand() Finished: {0} {1}", command, argsStr));
            return(true);
        }
コード例 #16
0
        private ArrayList getUnpublishedFiles()
        {
            this.Cursor = Cursors.WaitCursor;
            Scanning scan = new Scanning();

            scan.StartPosition = FormStartPosition.CenterParent;
            scan.Show();
            scan.Refresh();

            p4 = new P4Connection();
            p4.Connect();
            p4I = new P4Interface();

            ArrayList unpublished = new ArrayList();

            String[] args = { "-n", "-d", "-i", "-t", "-v", "-b", "phx_published", "//depot/phoenix/xbox/published/..." };

            // logging
            String tmp = "";

            foreach (String t in args)
            {
                tmp += t;
                tmp += " ";
            }
            LogLine(String.Concat("Running: Integrate ", tmp));

            P4RecordSet record = p4I.Run("integrate", args);

            LogLine(String.Concat("Total Records: ", record.Records.Length));
            foreach (P4Record entry in record)
            {
                if (checkBoxFilter.Checked)
                {
                    String file      = entry.Fields["depotFile"];
                    String delim     = "/";
                    int    trimIndex = -1;
                    if (file.Split(delim.ToCharArray())[6] == "art")
                    {
                        trimIndex = file.IndexOf("art");
                    }
                    else if (file.Split(delim.ToCharArray())[6] == "scenario")
                    {
                        trimIndex = file.IndexOf("scenario");
                    }

                    file = file.Substring(trimIndex, file.Length - trimIndex);
                    file = "//depot/phoenix/xbox/published/" + file.Replace("\\", "/");

                    String[]    args2   = { file.Replace("//depot/phoenix/xbox/published", localPath).Replace("\\", "/") };
                    P4RecordSet changes = p4I.Run("changes", args2);

                    if (changes.Records.Length > 0 && changes[0].Fields["user"] == comboBoxUsers.SelectedItem.ToString())
                    {
                        LogLine(String.Concat("Record: ", entry.Fields["depotFile"]));
                        unpublished.Add(entry.Fields["fromFile"]);
                    }
                }
                else
                {
                    unpublished.Add(entry.Fields["fromFile"]);
                }
            }
            scan.Close();
            this.Cursor = Cursors.Default;
            return(unpublished);

            p4.Disconnect();
        }
コード例 #17
0
ファイル: P4APIExceptions.cs プロジェクト: orecht/P4.net
 internal RunException(P4RecordSet rs)
 {
     _rs = rs;
 }
コード例 #18
0
        /// <summary>
        /// Add to states the state for each file, all at one time (Fast)
        /// If there's an exception, falls back to doing one at a time.
        /// </summary>
        /// <param name="filesUnderPerforceRoot">the VS fileNames for files already verified to be under the Perforce root</param>
        /// <param name="p4FileNames">parallel list of the P4 fileNames for files in filesUnderPerforceRoot</param>
        /// <param name="states">The dictionary we are loading. Key is vsFileName</param>
        private void AddStatesForAllFilesUnderPerforceRoot(List <string> filesUnderPerforceRoot, List <string> p4FileNames, IDictionary <string, FileState> states)
        {
            if (filesUnderPerforceRoot.Count == 0)
            {
                return;
            }
            P4RecordSet recordSet = null;
            string      message;
            bool        result = SendCommand("fstat", out message, out recordSet, p4FileNames.ToArray());

            if (!result)
            {
                //Some kind of error. Try to do each file individually so the error doesn't reflect on EVERY file
                AddStateForEachFile(filesUnderPerforceRoot, states);
                return;
            }

            if (recordSet.Records.Length <= 0)
            {
                foreach (var vsFileName in filesUnderPerforceRoot)
                {
                    states[vsFileName] = FileState.NotInPerforce;
                }
                return;
            }

            // Now decode each record. Missing records must be NotInPerforce
            // The key to filesWithState is p4FileName
            var filesWithState = new Dictionary <string, FileState>(filesUnderPerforceRoot.Count);

            foreach (P4Record record in recordSet)
            {
                string    p4FileName;
                FileState state = GetFileStateFromRecordSet(record, out p4FileName);
                filesWithState[p4FileName.ToLower()] = state;
            }

#if DEBUG
            var keysTmp   = new List <string>(filesWithState.Count);
            var statesTmp = new List <FileState>(filesWithState.Count);
            foreach (var kvp in filesWithState)
            {
                keysTmp.Add(kvp.Key);
                statesTmp.Add(kvp.Value);
            }
#endif


            // Now set each state we return.
            for (int i = 0; i < filesUnderPerforceRoot.Count; i++)
            {
                string    vsFileName = filesUnderPerforceRoot[i];
                var       p4FileName = GetP4FileName(vsFileName);
                FileState state;
                bool      hasState = filesWithState.TryGetValue(p4FileName.ToLower(), out state);
                if (hasState)
                {
                    states[vsFileName] = state;
                }
                else
                {
                    states[vsFileName] = FileState.NotInPerforce;
                }
            }
        }
コード例 #19
0
        private void BuildLabel(string JobName, P4Connection p4, EventLog log)
        {
            string LabelName = string.Format(_labelNameFormat, JobName);

            // delete the label... it may not exist, but finding that out is worse performance
            // than just deleting and assuming it doesn't exist.
            // The '-f' flag may cause problems if the p4 account running this command isn't a
            // super user.  You should be able to remove the flag... so long as no one
            // manually monkey's with the labels.
            P4UnParsedRecordSet labelDel = p4.RunUnParsed("label", "-f", "-d", LabelName);

            List <int> JobChanges = new List <int>();

            // Run a fixes to get all the changelists we need to add
            P4RecordSet fixes = p4.Run("fixes", "-j", JobName);

            // Spin the recordset to build a unique list of changelists
            foreach (P4Record fix in fixes)
            {
                JobChanges.Add(int.Parse(fix["Change"]));
            }

            // Sort them to be certain they are ascending
            JobChanges.Sort();

            // only build the label if there are indeed fixes
            if (JobChanges.Count > 0)
            {
                //re-create the label
                P4Form labelForm = p4.Fetch_Form("label", "-t", _labelTemplate, LabelName);

                // make sure the form is unlocked
                labelForm["Options"] = "unlocked";

                // make sure we're the owner
                labelForm["Owner"] = _p4user;
                p4.Save_Form(labelForm);

                int ChangesAdded = 0;

                //now need to labelsync to all latest changes
                foreach (int change in JobChanges)
                {
                    // using tag here so a valid client spec is not needed.
                    // for older servers, you could substitue for labelsync,
                    // but you'd need to pass in and set a valid client spec
                    P4UnParsedRecordSet ls = p4.RunUnParsed("tag", "-l", LabelName, string.Format("@={0}", change));

                    // this is why we set exception level to NoExceptionOnErrors
                    if (ls.HasErrors())
                    {
                        if (ls.ErrorMessage.StartsWith("Can't use a pending changelist number for this command."))
                        {
                            // Nothing to worry about.  p4 fixes returns fix records for pending changelists,
                            // but we don't know that going into this.  It's likely more performant to just
                            // assume it is a submitted changelist and ignore this error.
                        }
                        else
                        {
                            // Something's gone ary.  Should throw an Exception.
                            // But I'm lazy so we just log the error.
                            log.WriteEntry(ls.ErrorMessage);
                        }
                    }
                    else
                    {
                        ChangesAdded++;
                    }
                }

                // If ChangesAdded is still 0, then we should delete the label since
                // there are no files anyway
                if (ChangesAdded == 0)
                {
                    p4.RunUnParsed("label", "-f", "-d", LabelName);
                }
                else
                {
                    // now lock the label
                    labelForm["Options"] = "locked";
                    p4.Save_Form(labelForm);

                    // Note this trick.  You can re-save a form as many times as you need,
                    // no need to fetch before each save.  In fact you can use the form to save
                    // new objects... like:
                    //   labelForm["Label"] = "newLabelName";
                    //   p4.Save_Form(labelForm);
                    // and you created a new label named newLabelName.
                    // Cool, huh?  Well, I don't deserve the credit... it's the way the
                    // native C++ API works.
                }
            }
        }
コード例 #20
0
 internal RunException(P4RecordSet rs)
 {
     _rs = rs;
 }
コード例 #21
0
        //Guts of the logic.  This is where the app will dynamicaly build the job labels
        public void RunLabeler(EventLog log)
        {
            P4Connection p4 = null;

            try
            {
                p4      = new P4Connection();
                p4.Port = _p4port;
                p4.User = _p4user;
                if (!_useLogin)
                {
                    p4.Password = _p4password;
                }
                p4.Connect();
                if (_useLogin)
                {
                    p4.Login(_p4password);
                }

                // Don't throw an exception on a Perforce error.  We handle these manually.
                p4.ExceptionLevel = P4ExceptionLevels.NoExceptionOnErrors;

                //Use unparsed b/c older server versions do not support
                //parsed output for the counter command.  And, it's easy
                //to parse by hand.
                P4UnParsedRecordSet counter = p4.RunUnParsed("counter", _p4counter);

                int           counterValue       = int.Parse(counter[0]);
                int           LastSequenceNumber = 0;
                List <string> JobList            = new List <string>();

                //Run p4 logger to find all the changes and jobs since the last run
                P4RecordSet loggers = p4.Run("logger", "-c", counterValue.ToString());

                //spin the results, and get a unique list of jobs
                foreach (P4Record r in loggers)
                {
                    if (r.Fields["key"] == "job")
                    {
                        string JobName = r.Fields["attr"];
                        if (!JobList.Contains(JobName))
                        {
                            JobList.Add(JobName);
                        }
                    }
                    LastSequenceNumber = int.Parse(r.Fields["sequence"]);
                }

                // We're done with loggers, so lets remove the reference and
                // give the GC a chance to clean memory.  If it's been a long time
                // since the last run, it could be thousands of jobs to catch up.
                loggers = null;

                // Now spin all the jobs and build the label
                foreach (string JobName in JobList)
                {
                    BuildLabel(JobName, p4, log);
                }

                //Now we update the counter to the last sequence number from logger.
                p4.RunUnParsed("counter", _p4counter, LastSequenceNumber.ToString());
            }
            catch (Exception e)
            {
                // rethrow... b/c I'm lazy :-)
                throw e;
            }
            finally
            {
                // All done here... time to disconnect.
                p4.Disconnect();
            }
        }
コード例 #22
0
        public void ProcessRequest(HttpContext context)
        {
            // Don't allow this response to be cached by the browser.
            context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
            context.Response.Cache.SetNoStore();
            context.Response.Cache.SetExpires(DateTime.MinValue);

            // Create a new p4 connection, and set the appropriate properties
            P4Connection      p4          = new P4Connection();
            AppSettingsReader appSettings = new AppSettingsReader();

            p4.Port     = (string)appSettings.GetValue("P4PORT", typeof(string));
            p4.User     = (string)appSettings.GetValue("P4USER", typeof(string));
            p4.Client   = (string)appSettings.GetValue("P4CLIENT", typeof(string));
            p4.Password = (string)appSettings.GetValue("P4PASSWD", typeof(string));

            try
            {
                p4.Connect();

                //Figure out the clientPath for the file
                string clientPath = string.Format("//{0}/{1}", p4.Client, context.Request.AppRelativeCurrentExecutionFilePath.Substring(2));

                if (!clientPath.EndsWith("/"))
                {
                    // We have a path to a file

                    // find the MIME type and set it
                    string ext      = Path.GetExtension(clientPath);
                    string mimeType = getMimeType(ext);
                    context.Response.ContentType = mimeType;

                    //stream the results ... will throw an exception if the path isn't found
                    try
                    {
                        p4.PrintStream(context.Response.OutputStream, clientPath);
                        context.Response.OutputStream.Flush();
                    }
                    catch (P4API.Exceptions.FileNotFound)
                    {
                        context.Response.StatusCode = 404;
                    }
                }
                else
                {
                    // we have a directory... let's look for a default "index" file and redirect

                    // My Rule for a default page is:
                    // :: "index.htm" or "index.html" in the current directory (case insensitive)
                    //
                    // I don't rely on the Perforce server to be case insensitive, so I will run an fstat for
                    // all files in the directory and see if there are any "index.htm*" files
                    P4RecordSet rs = p4.Run("fstat", "-Op", clientPath + "*");
                    foreach (P4Record r in rs)
                    {
                        if (r["depotFile"].ToLower().EndsWith("index.html") || r["depotFile"].ToLower().EndsWith("index.htm"))
                        {
                            // the -Op switch means client file will be //<clientname>/<clientpath>
                            clientPath = r["clientFile"];
                            break;
                        }
                    }
                    if (clientPath.EndsWith("/"))
                    {
                        // clientPath not updated, means we can't find a default page

                        // For now, just 404... in the future we could allow directory browsing
                        // (which we be a lot bigger than a sample application ;-)
                        context.Response.StatusCode = 404;
                    }
                    else
                    {
                        // redirect to the index page
                        string redirect = "~" + clientPath.Substring(p4.Client.Length + 2);
                        context.Response.Redirect(redirect, false);
                    }
                }
            }
            catch (Exception e)
            {
                // unhandled exception... send a 500 to the browser
                System.Diagnostics.Trace.WriteLine(e.StackTrace);
                context.Response.StatusCode = 500;
            }
            finally
            {
                p4.Disconnect();
                context.Response.End();
            }
        }