Subversion Repositories openrisc_me

//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
//
// This program is part of the eCos host tools.
//
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free 
// Software Foundation; either version 2 of the License, or (at your option) 
// any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
// more details.
// 
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
//=================================================================
//
//        TestResource.cpp
//
//        Resource test class
//
//=================================================================
//=================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):     sdf
// Contributors:  sdf
// Date:          1999-04-01
// Description:   This class abstracts a test resource for use in the testing infrastructure
// Usage:
//
//####DESCRIPTIONEND####
#include "eCosStd.h"
#include "eCosTestUtils.h"
#include "eCosTrace.h"
#include "Subprocess.h"
 
#include "TestResource.h"
 
CTestResource *CTestResource::pFirstInstance=0;
unsigned int CTestResource::nCount=0;
 
String CTestResource::strResourceHostPort;
 
CTestResource::CTestResource(LPCTSTR pszHostPort, LPCTSTR target, LPCTSTR  pszDownloadPort, int nBaud, LPCTSTR pszResetString):
  m_strReset(pszResetString),
  m_bInUse(false),
  m_nBaud(nBaud),
  m_strPort(pszDownloadPort),
  m_bLocked(false),
  m_Target(target)
{
  CeCosSocket::ParseHostPort(pszHostPort,m_strHost,m_nPort);
  VTRACE(_T("@@@ Created resource %08x %s\n"),(unsigned int)this,(LPCTSTR)Image());
  Chain();
}
 
CTestResource::~CTestResource()
{
  ENTERCRITICAL;
  VTRACE(_T("@@@ Destroy resource %08x %s\n"),this,(LPCTSTR)Image());
  if(m_pPrevInstance || m_pNextInstance){
    nCount--;
  }
  if(pFirstInstance==this){
    pFirstInstance=m_pNextInstance;
  }
  if(m_pPrevInstance){
    m_pPrevInstance->m_pNextInstance=m_pNextInstance;
  }
  if(m_pNextInstance){
    m_pNextInstance->m_pPrevInstance=m_pPrevInstance;
  }
  LEAVECRITICAL;
}
 
// Find the resource matching the given host:port specification
// Returns 0 if no such host:port found
CTestResource * CTestResource::Lookup(LPCTSTR pszHostPort)
{
  CTestResource *pResource=NULL;
  ENTERCRITICAL;
  String strHost;
  int nPort;
  if(CeCosSocket::ParseHostPort(pszHostPort,strHost,nPort)){
    for(pResource=pFirstInstance;pResource;pResource=pResource->m_pNextInstance){
      if(nPort==pResource->TcpIPPort() && CeCosSocket::SameHost(strHost,pResource->Host())){
        break;
      }
    }
  }
  LEAVECRITICAL;
  return pResource;
}
 
unsigned int CTestResource::GetMatchCount (const CeCosTest::ExecutionParameters &e,bool bIgnoreLocking)
{
  unsigned int i=0;
  ENTERCRITICAL;
  for(const CTestResource *pResource=pFirstInstance;pResource;pResource=pResource->m_pNextInstance){
    if(pResource->Matches(e,bIgnoreLocking)){
      i++;
    }
  }
  LEAVECRITICAL;
  return i;
}
 
bool CTestResource::GetMatches (const CeCosTest::ExecutionParameters &e, StringArray &arstr, bool bIgnoreLocking)
{
  bool rc=false;
  arstr.clear();
  if(Load()){
    ENTERCRITICAL;
    for(CTestResource *pResource=pFirstInstance;pResource;pResource=pResource->m_pNextInstance){
		  if(pResource->Matches(e,bIgnoreLocking)){
        arstr.push_back(pResource->HostPort());
      }
    }
    LEAVECRITICAL;
    rc=true;
  }
  return rc;
}
 
void CTestResource::DeleteAllInstances()
{
  ENTERCRITICAL;
  while(pFirstInstance){
    delete pFirstInstance;
  }
  LEAVECRITICAL;
}
 
bool CTestResource::LoadFromDirectory (LPCTSTR psz)
{
  bool rc=true;
  ENTERCRITICAL;
  DeleteAllInstances();
  // Find all the files in directory "psz" and load from each of them
  TCHAR szOrigDir[256];
  _tgetcwd(szOrigDir,sizeof szOrigDir-1);
  if(0==_tchdir(psz)){
    String strFile;
    void *pHandle;
    for(bool b=CeCosTestUtils::StartSearch(pHandle,strFile);b;b=CeCosTestUtils::NextFile(pHandle,strFile)){
      if(CeCosTestUtils::IsFile(strFile)){
        CTestResource *pResource=new CTestResource(_T(""),_T(""));
        CTestResourceProperties prop(pResource);
        prop.LoadFromFile(strFile);
      }
    }
    CeCosTestUtils::EndSearch(pHandle);
  } else {
    TRACE(_T("Failed to change to %s from %s\n"),psz,szOrigDir);
  }
  _tchdir(szOrigDir);
  LEAVECRITICAL;
 
  return rc;
}
 
bool CTestResource::SaveToDirectory (LPCTSTR pszDir)
{
  bool rc=false;    
  ENTERCRITICAL;
  {
    // Delete all the files under directory "pszDir"
    void *pHandle;
    TCHAR szOrigDir[256];
    _tgetcwd(szOrigDir,sizeof szOrigDir-1);
    if(0==_tchdir(pszDir)){
      String strFile;
      for(bool b=CeCosTestUtils::StartSearch(pHandle,strFile);b;b=CeCosTestUtils::NextFile(pHandle,strFile)){
        if(CeCosTestUtils::IsFile(strFile)){
          _tunlink(strFile);
        }
      }
      CeCosTestUtils::EndSearch(pHandle);
      rc=true;
      for(CTestResource *pResource=pFirstInstance;pResource;pResource=pResource->m_pNextInstance){
        CTestResourceProperties prop(pResource);
        rc&=prop.SaveToFile(pResource->FileName());
      }
    } else {
      fprintf(stderr,"Failed to change to %s from %s\n",pszDir,szOrigDir);
    }
    _tchdir(szOrigDir);
  }
 
  LEAVECRITICAL;
 
  return rc;
}
 
#ifdef _WIN32
bool CTestResource::LoadFromRegistry(HKEY key,LPCTSTR psz)
{
  // Find all the keys under "psz" and load from each of them
  bool rc=false;    
  ENTERCRITICAL;
  HKEY hKey;
  if(ERROR_SUCCESS==RegOpenKeyEx ((HKEY)key, psz, 0L, KEY_ENUMERATE_SUB_KEYS, &hKey)){
		TCHAR szName[256];
    DWORD dwSizeName=sizeof szName;
    FILETIME ftLastWriteTime;
    for(DWORD dwIndex=0;ERROR_SUCCESS==RegEnumKeyEx(hKey, dwIndex, szName, &dwSizeName, NULL, NULL, NULL, &ftLastWriteTime); dwIndex++){
      CTestResource *pResource=new CTestResource(_T(""),_T(""));
      String strKey;
      strKey.Format(_T("%s\\%s"),psz,szName);
      CTestResourceProperties prop1(pResource);
      prop1.LoadFromRegistry(key,strKey);
      dwSizeName=sizeof szName;
    }
    RegCloseKey(hKey);
  }
  LEAVECRITICAL;
  return rc;
}
 
bool CTestResource::SaveToRegistry(HKEY key,LPCTSTR psz)
{
  bool rc=false;    
  ENTERCRITICAL;
  // Delete all the keys under "psz"
  HKEY hKey;
  if(ERROR_SUCCESS==RegOpenKeyEx ((HKEY)key, psz, 0L, KEY_ENUMERATE_SUB_KEYS, &hKey)){
    TCHAR szName[256];
    DWORD dwSizeName=sizeof szName;
    FILETIME ftLastWriteTime;
    DWORD dwIndex;
    if(ERROR_SUCCESS==RegQueryInfoKey(hKey,0,0,0,&dwIndex,0,0,0,0,0,0,0)){
      while((signed)--dwIndex>=0){
        if(ERROR_SUCCESS!=RegEnumKeyEx(hKey, dwIndex, szName, &dwSizeName, NULL, NULL, NULL, &ftLastWriteTime) ||
          ERROR_SUCCESS!=RegDeleteKey(hKey,szName)){
          rc=false;
        }
        dwSizeName=sizeof szName;
      }
    }
    RegCloseKey(hKey);
  }
  rc=true;
  for(CTestResource *pResource=pFirstInstance;pResource;pResource=pResource->m_pNextInstance){
    CTestResourceProperties prop1(pResource);
    rc&=prop1.SaveToRegistry(key,pResource->FileName());
  }
 
  LEAVECRITICAL;
  return rc;
}
 
#endif
 
CTestResource::CTestResourceProperties::CTestResourceProperties(CTestResource *pResource)
{
  Add(_T("Baud"),       pResource->m_nBaud);
  Add(_T("BoardId"),    pResource->m_strBoardID);
  Add(_T("Date"),       pResource->m_strDate);
  Add(_T("Email"),      pResource->m_strEmail);
  Add(_T("Host"),       pResource->m_strHost);
  Add(_T("Port"),       pResource->m_nPort);
  Add(_T("Locked"),     pResource->m_bLocked);
  Add(_T("Originator"), pResource->m_strUser);
  Add(_T("Reason"),     pResource->m_strReason);
  Add(_T("Reset"),      pResource->m_strReset);
  Add(_T("Serial"),     pResource->m_strPort);
  Add(_T("Target"),     pResource->m_Target);
  Add(_T("User"),       pResource->m_strUser);
}
 
bool CTestResource::Lock()
{
  if(!m_bLocked){
    m_bLocked=true;
    return true;
  } else {
    return false;
  }
}
 
bool CTestResource::Unlock()
{
  if(m_bLocked){
    m_bLocked=false;
    return true;
  } else {
    return false;
  }
}
 
bool CTestResource::LoadSocket(LPCTSTR pszResourceHostPort,Duration dTimeout/*=10*1000*/)
{
  bool rc=false;
  ENTERCRITICAL;
  CTestResource *pResource;
  // If the resource is in use, we don't dare delete it!
  for(pResource=CTestResource::First();pResource;pResource=pResource->Next()){
    pResource->m_bFlag=false;
  }
  CeCosSocket sock;
  if(sock.Connect(pszResourceHostPort,dTimeout)){
    // Write the message to the socket
    int nRequest=0; // read
    if(!sock.sendInteger(nRequest)){
      ERROR(_T("Failed to write to socket\n"));
    } else {
      int nResources;
      if(sock.recvInteger(nResources,_T(""),dTimeout)){
        rc=true;
        while(nResources--){
          String strImage;
          if(sock.recvString(strImage,_T(""),dTimeout)){
            VTRACE(_T("Recv \"%s\"\n"),(LPCTSTR)strImage);
            CTestResource tmp;
            tmp.FromStr(strImage);
            CTestResource *pResource=Lookup(tmp.HostPort());
            if(0==pResource){
              pResource=new CTestResource(_T(""),_T(""));
            }
            pResource->FromStr(strImage);
            pResource->m_bFlag=true;
          } else {
            rc=false;
            break;
          }
        }
      }
    }
  }
  // If the resource is in use, we don't dare delete it!
  CTestResource *pNext;
  for(pResource=CTestResource::First();pResource;pResource=pNext){
    pNext=pResource->Next();
    if(!pResource->m_bFlag && !pResource->m_bInUse){
      delete pResource;
    }
  }
 
  LEAVECRITICAL;
  return rc;
}
 
bool CTestResource::SaveSocket(LPCTSTR pszResourceHostPort,Duration dTimeout)
{
  bool rc=true;
  ENTERCRITICAL;
  CeCosSocket sock(pszResourceHostPort, dTimeout);
  if(sock.Ok()){
    // Write the message to the socket
    int nRequest=1; //write
    if(!sock.sendInteger(nRequest, _T(""),dTimeout)){
      ERROR(_T("Failed to write to socket\n"));
      rc=false;
    } else {
      int nResources=0;
      CTestResource *pResource;
      for(pResource=CTestResource::First();pResource;pResource=pResource->Next()){
        nResources++;
      }
      if(sock.sendInteger(nResources,_T("resource count"),dTimeout)){
        for(pResource=CTestResource::First();pResource;pResource=pResource->Next()){
          String strImage;
          CTestResourceProperties prop(pResource);
          strImage=prop.MakeCommandString();
          TRACE(_T("Send \"%s\"\n"),(LPCTSTR)strImage);
          if(!sock.sendString (strImage, _T("reply"),dTimeout)){
            rc=false;
            break;
          }
        }
      } else {
        rc=false;
      }
    }
  } else {
    rc=false;
  }
  LEAVECRITICAL;
  return rc;
}
 
/*
void CTestResource::Image(String &str)
{
  CTestResourceProperties prop(this);
  str=prop.MakeCommandString();
  VTRACE(_T("Make command string %s\n"),(LPCTSTR)str);
}
*/
 
bool CTestResource::FromStr(LPCTSTR pszImage)
{
  CTestResourceProperties prop(this);
  prop.LoadFromCommandString(pszImage);
  VTRACE(_T("From command string %s\n"),pszImage);
  return true;
}
 
void CTestResource::Chain()
{
  ENTERCRITICAL;
  nCount++;
  m_pNextInstance=pFirstInstance;
  if(m_pNextInstance){
    m_pNextInstance->m_pPrevInstance=this;
  }
  m_pPrevInstance=0;
  pFirstInstance=this;
  LEAVECRITICAL;
}
 
bool CTestResource::Matches  (const CeCosTest::ExecutionParameters &e,bool bIgnoreLocking) const
{
  return (bIgnoreLocking||(!m_bLocked)) && (0==_tcsicmp(e.PlatformName(),m_Target)); 
};
 
CeCosTest::ServerStatus CTestResource::Query() 
{
  CeCosTest::ExecutionParameters e(CeCosTest::ExecutionParameters::QUERY,m_Target);
  CeCosSocket *pSock=0;
  CeCosTest::ServerStatus s=CeCosTest::Connect(HostPort(),pSock,e,m_strInfo);
  delete pSock;
  return s;
}
 
int CTestResource::Count(const CeCosTest::ExecutionParameters &e)
{
  int nCount=0;
  for(const CTestResource *p=pFirstInstance;p;p=p->m_pNextInstance){
    if(p->Matches(e)){
      nCount++;
    }
  }
  return nCount;
}
 
bool CTestResource::Use()
{
  bool rc;
  ENTERCRITICAL;
  if(m_bInUse){
    rc=false;
  } else {
    m_bInUse=true;
    rc=true;
  }
  LEAVECRITICAL;
  return rc;
}
 
CTestResource *CTestResource::GetResource (const CeCosTest::ExecutionParameters &e)
{
  CTestResource *p=0;
  if(0==Count(e)){
    ERROR(_T("GetResource: no candidates available\n"));
  } else {
    ENTERCRITICAL;
    for(p=pFirstInstance;p;p=p->m_pNextInstance){
      if(p->Matches(e) && !p->m_bInUse){
        TRACE(_T("Acquired %s\n"),p->Serial());
				    p->Use();
            break;
      }
    }
    LEAVECRITICAL;
  }
  return p;
}
 
const String CTestResource::Image() const
{
  String str;
  str.Format(_T("%10s %20s %8s"),(LPCTSTR)HostPort(),(LPCTSTR)Target(),(LPCTSTR)Serial());
  if(IsLocked()){
    str+=_T(" [RL]");
  }
  return str;
}
 
bool CTestResource::Matches(LPCTSTR pszHostPort, const CeCosTest::ExecutionParameters &e)
{
  bool rc=false;
  ENTERCRITICAL;
  if(Load()){
    CTestResource *pResource=Lookup(pszHostPort);
    if(pResource){
      rc=pResource->Matches(e);
    }
  }
  LEAVECRITICAL;
  return rc;
}
 
CResetAttributes::ResetResult CTestResource::Reset(LogFunc *pfnLog, void *pfnLogparam)
{
  String strReset;
  strReset.Format(_T("port(%s,%d) %s"),Serial(),Baud(),ResetString());
  return CResetAttributes(strReset).Reset(pfnLog,pfnLogparam);
}
 
CResetAttributes::ResetResult CTestResource::Reset(String &str)
{
  return Reset(StringLogFunc,&str);
}
 
void CALLBACK CTestResource::StringLogFunc (void *pParam,LPCTSTR psz)
{
  *((String *)pParam)+=psz;
}
 
 
CResetAttributes::ResetResult CTestResource::RemoteReset(LogFunc *pfnLog, void *pfnLogparam)
{
  String strHost;
  int nPort;
  CeCosSocket::ParseHostPort(HostPort(),strHost,nPort);
  String strCmd;
  strCmd.Format(_T("rsh %s x10reset %s\n"),(LPCTSTR)strHost,ResetString());
  pfnLog(pfnLogparam,strCmd);
 
  CSubprocess sp;
  sp.Run(pfnLog,pfnLogparam,strCmd);
  return CResetAttributes::RESET_OK; // FIXME
}
 
String CTestResource::FileName() const
{
  String strHost;
  int nPort;
  CeCosSocket::ParseHostPort(HostPort(),strHost,nPort);
  return String::SFormat(_T("%s-%d"),(LPCTSTR)strHost,nPort);
}