_library.lua
上传用户:cccombo
上传日期:2021-01-31
资源大小:16445k
文件大小:11k
源码类别:

MySQL数据库

开发平台:

SQL

  1. -- ----------------------------------------------------------------------------------------
  2. -- Copyright (C) 2004 MySQL AB
  3. --
  4. -- This program is free software; you can redistribute it and/or modify
  5. -- it under the terms of the GNU General Public License as published by
  6. -- the Free Software Foundation; either version 2 of the License, or
  7. -- (at your option) any later version.
  8. --
  9. -- This program is distributed in the hope that it will be useful,
  10. -- but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. -- GNU General Public License for more details.
  13. --
  14. -- You should have received a copy of the GNU General Public License
  15. -- along with this program; if not, write to the Free Software
  16. -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17. -- ----------------------------------------------------------------------------------------
  18. -- ----------------------------------------------------------------------------------------
  19. -- @file _library.lua
  20. -- @brief A collection of common auxiliary functions that is loaded when the Lua loader 
  21. -- gets initialized
  22. -- ----------------------------------------------------------------------------------------
  23. grt= {GrtLuaLibraryVersion= "1.0"}
  24. -- ----------------------------------------------------------------------------------------
  25. -- @brief dummy implemenation for _()
  26. --
  27. --   This is a placeholder till a real _() function is implemented
  28. --
  29. -- Example:
  30. --   print(_("test"))
  31. --
  32. -- @param txt the text that has to be translated
  33. --
  34. -- @return the original text
  35. -- ----------------------------------------------------------------------------------------
  36. function _(txt)
  37.   return txt
  38. end
  39. -- ----------------------------------------------------------------------------------------
  40. -- @brief Prepares a return value
  41. --
  42. --   Every function that is exposed to the Grt needs to return its value in a dict that
  43. -- has a "value" entry. Use this function to prepare the result values. The function can
  44. -- also be called without a parameter. In that case 1 will be returned to the Grt.
  45. --
  46. -- Example:
  47. --   function calcDouble(args)
  48. --     return _success(args[1] * 2)
  49. --   end
  50. --
  51. -- @param result  the result value that should be returned to the Grt.
  52. --
  53. -- @return the result value prepared to be returned to the Grt
  54. -- ----------------------------------------------------------------------------------------
  55. function grt.success(result)
  56.   return result and {value= result} or {value= 1}
  57. end
  58. -- ----------------------------------------------------------------------------------------
  59. -- @brief Returns an error to the Grt
  60. --
  61. --   Use this function to pass an error message back to the Grt.
  62. --
  63. -- Example:
  64. --   function calcDouble(args)
  65. --     return args[1] and 
  66. --       grt.success(args[1] * 2) or 
  67. --       grt.error("You need to pass a number as argument")
  68. --   end
  69. --
  70. -- @param errorText  the error message
  71. -- @param errorDetails  detailed information about the error
  72. --
  73. -- @return the error prepared to be returned to the Grt
  74. -- ----------------------------------------------------------------------------------------
  75. function grt.error(errorText, errorDetails)
  76.   return {error= errorText, detail= errorDetails}
  77. end
  78. -- ----------------------------------------------------------------------------------------
  79. -- @brief Prints the error message if a GRT module function call failed
  80. --
  81. --   Checks if the grtError and prints the error if it is set. Passes the result back
  82. --
  83. -- @param result  the result from a GRT module function call
  84. --
  85. -- @return the result
  86. -- ----------------------------------------------------------------------------------------
  87. function grt.getRes(result)
  88.   if (grtError ~= nil) then
  89.     print(grtError.error)
  90.     if (grtError.detail ~= nil) then
  91.       print(grtError.detail)
  92.     end
  93.   end
  94.   return result
  95. end
  96. -- ----------------------------------------------------------------------------------------
  97. -- @brief Extracts the return value of a Grt function as a Lua value
  98. --
  99. --   A Grt function returns its result as a dict in the "value" entry. This function
  100. -- extracts the value and converts it to a Lua value
  101. --
  102. -- @return the result converted to a Lua object
  103. -- ----------------------------------------------------------------------------------------
  104. function grt.getResLua(result)
  105.   return grtV.toLua(grt.getRes(result))
  106. end
  107. -- ----------------------------------------------------------------------------------------
  108. -- @brief Checks if an GRT error has occured and if so, prints the error adn exits
  109. --
  110. --   Checks if the grtError and prints the error if it is set. Exists with error code 1
  111. --
  112. -- @param errorString  the error string that will be printed before the error message
  113. -- ----------------------------------------------------------------------------------------
  114. function grt.exitOnError(errorString)
  115.   if (grtError ~= nil) then
  116.     print("ERROR: " .. errorString)
  117.     
  118.     print(grtError.error)
  119.     if (grtError.detail ~= nil) then
  120.       print(grtError.detail)
  121.     end
  122.     
  123.     exit(1)
  124.   end
  125. end
  126. -- ----------------------------------------------------------------------------------------
  127. -- @brief Returns a new generated GUID
  128. --
  129. --   Calls the Grt function getGuid() from the module Base to retrieve a GUID. The Grt
  130. -- function result is then converted to a Lua string
  131. --
  132. -- @return a new generated GUID as lua string
  133. -- ----------------------------------------------------------------------------------------
  134. function grt.newGuid()
  135.   return grt.getResLua(Base:getGuid())
  136. end
  137. -- ----------------------------------------------------------------------------------------
  138. -- @brief Checks if a files exists
  139. --
  140. --   Tries to open the file. If the file exists it will close the file again and 
  141. -- return true. If it does not exists it will return false (as Lua will return false 
  142. -- when nothing is returned explicitly
  143. --
  144. -- @param filename the file to check
  145. --
  146. -- @return true if the files exists, false if not
  147. -- ----------------------------------------------------------------------------------------
  148. function grt.fileExists(filename)
  149.   local f = io.open(filename, "r")
  150.   if f then
  151.     f:close()
  152.     return true
  153.   end
  154.   
  155.   return false
  156. end
  157. -- ----------------------------------------------------------------------------------------
  158. -- @brief Splits a Lua string into a list of Lua strings.
  159. --
  160. --   Splits the given string based on the separator and puts the tokens into a list
  161. --
  162. -- @param str the string to split
  163. -- @param sep the separator character
  164. --
  165. -- @return returns the list of tokens
  166. -- ----------------------------------------------------------------------------------------
  167. function grt.split(str, sep)
  168.   local t= {}
  169.   local function helper(token) table.insert(t, token) end
  170.   helper((string.gsub(str, "(.-)(" .. sep .. ")", helper)))
  171.   return t
  172. end
  173. -- ----------------------------------------------------------------------------------------
  174. -- @brief Aligns the given string to the left and adds blanks.
  175. --
  176. --   Splits the given string based on the separator and puts the tokens into a list
  177. --
  178. -- @param str the string to align left
  179. -- @param width the length of the new string
  180. --
  181. -- @return returns the aligned string
  182. -- ----------------------------------------------------------------------------------------
  183. function grt.alignLeft(str, width)
  184.   local s
  185.   
  186.   if str == nil then
  187.     s= string.rep(" ", width)
  188.   else
  189.     local l= string.len(str)
  190.     
  191.     if l < width then
  192.       s= str .. string.rep(" ", width - l)
  193.     elseif l > width then
  194.       s= string.sub(str, 1, width)
  195.     else
  196.       s= str
  197.     end
  198.   end
  199.   
  200.   return s
  201. end
  202. -- ----------------------------------------------------------------------------------------
  203. -- @brief Invoke a remote agent function and wait it to finish.
  204. --
  205. --   Invokes a remote function, polling the agent until it is finished.
  206. -- Once finished, it will return the exit status and result value.
  207. -- 
  208. -- The first parameter has to be a table {hostname= "192.168.1.100", port= 12345}
  209. --
  210. -- Example:
  211. --   agent= {hostname= "192.168.1.100", port= 12345}
  212. --   res= grt.callRemoteFunction(agent, "BaseJava", "engineVersion", nil, false)
  213. --
  214. -- @param agent a table with connection information, e.g. {hostname= "192.168.1.100", port= 12345}
  215. -- @param module name of the module to call
  216. -- @param funcname name of the module function to call
  217. -- @param argument the arguments to pass to the module function (have to be in a list)
  218. -- @param syncGlobals if true the global object trees are synced on both sides
  219. --
  220. -- @return {error : error_status, result : result_value }
  221. -- ----------------------------------------------------------------------------------------
  222. function grt.callRemoteFunction(agent, module, funcname, argument, syncGlobals)
  223.   local session= grtA.connect(agent.hostname, agent.port)
  224.   local result= nil
  225.   
  226.   if session then
  227.     if syncGlobals then
  228.       grtA.setGlobal(session)
  229.     end
  230.   
  231.     if grtA.invoke(session, module, funcname, argument) == 0 then
  232.       while 1 do
  233.         print("checking")
  234.         st= grtA.check(session)
  235.         if st == 0 then     -- nothing executing!?
  236.           grtA.close(session)
  237.           print("Unexpected state in remote agent.")
  238.           break
  239.         elseif st == 2 then   -- executing
  240.           sleep(50)
  241.           grtA.messages(session)
  242.         elseif st == 3 then   -- finished
  243.   result= grtA.finish(session)
  244.           break
  245.         else                -- anything else
  246.           grtA.close(session)
  247.           print("Error waiting remote function to finish.")
  248.   return nil
  249.         end
  250.       end
  251.     else
  252.       print("Error invoking remote method.")
  253.       grtA.close(session)
  254.       return nil
  255.     end
  256.     
  257.     print("sync globals")
  258.     if syncGlobals then
  259.       grtA.getglobal(session)
  260.     end
  261.     grtA.close(session)
  262.   end
  263.   return result
  264. end
  265. -- ----------------------------------------------------------------------------------------
  266. -- @brief Checks if a module exists
  267. --
  268. --   Goes through the list of modules to see if the module with the given name exists
  269. --
  270. -- @param moduleName the name of the module
  271. --
  272. -- @return returns true if the module exists
  273. -- ----------------------------------------------------------------------------------------
  274. function grt.moduleExists(moduleName)
  275.   local moduleList= grtM.get()
  276.   local i
  277.   
  278.   for i= 1, table.getn(moduleList) do
  279.     if moduleList[i] == moduleName then
  280.       return true
  281.     end 
  282.   end
  283.   return false
  284. end