SQLiteEstateData.cs 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Data;
  30. using System.Reflection;
  31. using log4net;
  32. #if CSharpSqlite
  33. using Community.CsharpSqlite.Sqlite;
  34. #else
  35. using Mono.Data.Sqlite;
  36. #endif
  37. using OpenMetaverse;
  38. using OpenSim.Framework;
  39. using OpenSim.Region.Framework.Interfaces;
  40. namespace OpenSim.Data.SQLite
  41. {
  42. public class SQLiteEstateStore : IEstateDataStore
  43. {
  44. private static readonly ILog m_log =
  45. LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  46. private SqliteConnection m_connection;
  47. private string m_connectionString;
  48. private FieldInfo[] m_Fields;
  49. private Dictionary<string, FieldInfo> m_FieldMap =
  50. new Dictionary<string, FieldInfo>();
  51. protected virtual Assembly Assembly
  52. {
  53. get { return GetType().Assembly; }
  54. }
  55. public SQLiteEstateStore()
  56. {
  57. }
  58. public SQLiteEstateStore(string connectionString)
  59. {
  60. Initialise(connectionString);
  61. }
  62. public void Initialise(string connectionString)
  63. {
  64. m_connectionString = connectionString;
  65. m_log.Info("[ESTATE DB]: Sqlite - connecting: "+m_connectionString);
  66. m_connection = new SqliteConnection(m_connectionString);
  67. m_connection.Open();
  68. Migration m = new Migration(m_connection, Assembly, "EstateStore");
  69. m.Update();
  70. //m_connection.Close();
  71. // m_connection.Open();
  72. Type t = typeof(EstateSettings);
  73. m_Fields = t.GetFields(BindingFlags.NonPublic |
  74. BindingFlags.Instance |
  75. BindingFlags.DeclaredOnly);
  76. foreach (FieldInfo f in m_Fields)
  77. if (f.Name.Substring(0, 2) == "m_")
  78. m_FieldMap[f.Name.Substring(2)] = f;
  79. }
  80. private string[] FieldList
  81. {
  82. get { return new List<string>(m_FieldMap.Keys).ToArray(); }
  83. }
  84. public EstateSettings LoadEstateSettings(UUID regionID, bool create)
  85. {
  86. string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_map left join estate_settings on estate_map.EstateID = estate_settings.EstateID where estate_settings.EstateID is not null and RegionID = :RegionID";
  87. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  88. cmd.CommandText = sql;
  89. cmd.Parameters.AddWithValue(":RegionID", regionID.ToString());
  90. return DoLoad(cmd, regionID, create);
  91. }
  92. private EstateSettings DoLoad(SqliteCommand cmd, UUID regionID, bool create)
  93. {
  94. EstateSettings es = new EstateSettings();
  95. es.OnSave += StoreEstateSettings;
  96. IDataReader r = null;
  97. try
  98. {
  99. r = cmd.ExecuteReader();
  100. }
  101. catch (SqliteException)
  102. {
  103. m_log.Error("[SQLITE]: There was an issue loading the estate settings. This can happen the first time running OpenSimulator with CSharpSqlite the first time. OpenSimulator will probably crash, restart it and it should be good to go.");
  104. }
  105. if (r != null && r.Read())
  106. {
  107. foreach (string name in FieldList)
  108. {
  109. if (m_FieldMap[name].GetValue(es) is bool)
  110. {
  111. int v = Convert.ToInt32(r[name]);
  112. if (v != 0)
  113. m_FieldMap[name].SetValue(es, true);
  114. else
  115. m_FieldMap[name].SetValue(es, false);
  116. }
  117. else if (m_FieldMap[name].GetValue(es) is UUID)
  118. {
  119. UUID uuid = UUID.Zero;
  120. UUID.TryParse(r[name].ToString(), out uuid);
  121. m_FieldMap[name].SetValue(es, uuid);
  122. }
  123. else
  124. {
  125. m_FieldMap[name].SetValue(es, Convert.ChangeType(r[name], m_FieldMap[name].FieldType));
  126. }
  127. }
  128. r.Close();
  129. }
  130. else if (create)
  131. {
  132. r.Close();
  133. List<string> names = new List<string>(FieldList);
  134. names.Remove("EstateID");
  135. string sql = "insert into estate_settings ("+String.Join(",", names.ToArray())+") values ( :"+String.Join(", :", names.ToArray())+")";
  136. cmd.CommandText = sql;
  137. cmd.Parameters.Clear();
  138. foreach (string name in FieldList)
  139. {
  140. if (m_FieldMap[name].GetValue(es) is bool)
  141. {
  142. if ((bool)m_FieldMap[name].GetValue(es))
  143. cmd.Parameters.AddWithValue(":"+name, "1");
  144. else
  145. cmd.Parameters.AddWithValue(":"+name, "0");
  146. }
  147. else
  148. {
  149. cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
  150. }
  151. }
  152. cmd.ExecuteNonQuery();
  153. cmd.CommandText = "select LAST_INSERT_ROWID() as id";
  154. cmd.Parameters.Clear();
  155. r = cmd.ExecuteReader();
  156. r.Read();
  157. es.EstateID = Convert.ToUInt32(r["id"]);
  158. r.Close();
  159. cmd.CommandText = "insert into estate_map values (:RegionID, :EstateID)";
  160. cmd.Parameters.AddWithValue(":RegionID", regionID.ToString());
  161. cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
  162. // This will throw on dupe key
  163. try
  164. {
  165. cmd.ExecuteNonQuery();
  166. }
  167. catch (Exception)
  168. {
  169. }
  170. es.Save();
  171. }
  172. LoadBanList(es);
  173. es.EstateManagers = LoadUUIDList(es.EstateID, "estate_managers");
  174. es.EstateAccess = LoadUUIDList(es.EstateID, "estate_users");
  175. es.EstateGroups = LoadUUIDList(es.EstateID, "estate_groups");
  176. return es;
  177. }
  178. public void StoreEstateSettings(EstateSettings es)
  179. {
  180. List<string> fields = new List<string>(FieldList);
  181. fields.Remove("EstateID");
  182. List<string> terms = new List<string>();
  183. foreach (string f in fields)
  184. terms.Add(f+" = :"+f);
  185. string sql = "update estate_settings set "+String.Join(", ", terms.ToArray())+" where EstateID = :EstateID";
  186. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  187. cmd.CommandText = sql;
  188. foreach (string name in FieldList)
  189. {
  190. if (m_FieldMap[name].GetValue(es) is bool)
  191. {
  192. if ((bool)m_FieldMap[name].GetValue(es))
  193. cmd.Parameters.AddWithValue(":"+name, "1");
  194. else
  195. cmd.Parameters.AddWithValue(":"+name, "0");
  196. }
  197. else
  198. {
  199. cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
  200. }
  201. }
  202. cmd.ExecuteNonQuery();
  203. SaveBanList(es);
  204. SaveUUIDList(es.EstateID, "estate_managers", es.EstateManagers);
  205. SaveUUIDList(es.EstateID, "estate_users", es.EstateAccess);
  206. SaveUUIDList(es.EstateID, "estate_groups", es.EstateGroups);
  207. }
  208. private void LoadBanList(EstateSettings es)
  209. {
  210. es.ClearBans();
  211. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  212. cmd.CommandText = "select bannedUUID from estateban where EstateID = :EstateID";
  213. cmd.Parameters.AddWithValue(":EstateID", es.EstateID);
  214. IDataReader r = cmd.ExecuteReader();
  215. while (r.Read())
  216. {
  217. EstateBan eb = new EstateBan();
  218. UUID uuid = new UUID();
  219. UUID.TryParse(r["bannedUUID"].ToString(), out uuid);
  220. eb.BannedUserID = uuid;
  221. eb.BannedHostAddress = "0.0.0.0";
  222. eb.BannedHostIPMask = "0.0.0.0";
  223. es.AddBan(eb);
  224. }
  225. r.Close();
  226. }
  227. private void SaveBanList(EstateSettings es)
  228. {
  229. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  230. cmd.CommandText = "delete from estateban where EstateID = :EstateID";
  231. cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
  232. cmd.ExecuteNonQuery();
  233. cmd.Parameters.Clear();
  234. cmd.CommandText = "insert into estateban (EstateID, bannedUUID, bannedIp, bannedIpHostMask, bannedNameMask) values ( :EstateID, :bannedUUID, '', '', '' )";
  235. foreach (EstateBan b in es.EstateBans)
  236. {
  237. cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
  238. cmd.Parameters.AddWithValue(":bannedUUID", b.BannedUserID.ToString());
  239. cmd.ExecuteNonQuery();
  240. cmd.Parameters.Clear();
  241. }
  242. }
  243. void SaveUUIDList(uint EstateID, string table, UUID[] data)
  244. {
  245. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  246. cmd.CommandText = "delete from "+table+" where EstateID = :EstateID";
  247. cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString());
  248. cmd.ExecuteNonQuery();
  249. cmd.Parameters.Clear();
  250. cmd.CommandText = "insert into "+table+" (EstateID, uuid) values ( :EstateID, :uuid )";
  251. foreach (UUID uuid in data)
  252. {
  253. cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString());
  254. cmd.Parameters.AddWithValue(":uuid", uuid.ToString());
  255. cmd.ExecuteNonQuery();
  256. cmd.Parameters.Clear();
  257. }
  258. }
  259. UUID[] LoadUUIDList(uint EstateID, string table)
  260. {
  261. List<UUID> uuids = new List<UUID>();
  262. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  263. cmd.CommandText = "select uuid from "+table+" where EstateID = :EstateID";
  264. cmd.Parameters.AddWithValue(":EstateID", EstateID);
  265. IDataReader r = cmd.ExecuteReader();
  266. while (r.Read())
  267. {
  268. // EstateBan eb = new EstateBan();
  269. UUID uuid = new UUID();
  270. UUID.TryParse(r["uuid"].ToString(), out uuid);
  271. uuids.Add(uuid);
  272. }
  273. r.Close();
  274. return uuids.ToArray();
  275. }
  276. public EstateSettings LoadEstateSettings(int estateID)
  277. {
  278. string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_settings where estate_settings.EstateID = :EstateID";
  279. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  280. cmd.CommandText = sql;
  281. cmd.Parameters.AddWithValue(":EstateID", estateID.ToString());
  282. return DoLoad(cmd, UUID.Zero, false);
  283. }
  284. public List<EstateSettings> LoadEstateSettingsAll()
  285. {
  286. List<EstateSettings> estateSettings = new List<EstateSettings>();
  287. List<int> estateIds = GetEstatesAll();
  288. foreach (int estateId in estateIds)
  289. estateSettings.Add(LoadEstateSettings(estateId));
  290. return estateSettings;
  291. }
  292. public List<int> GetEstates(string search)
  293. {
  294. List<int> result = new List<int>();
  295. string sql = "select EstateID from estate_settings where estate_settings.EstateName = :EstateName";
  296. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  297. cmd.CommandText = sql;
  298. cmd.Parameters.AddWithValue(":EstateName", search);
  299. IDataReader r = cmd.ExecuteReader();
  300. while (r.Read())
  301. {
  302. result.Add(Convert.ToInt32(r["EstateID"]));
  303. }
  304. r.Close();
  305. return result;
  306. }
  307. public List<int> GetEstatesAll()
  308. {
  309. List<int> result = new List<int>();
  310. string sql = "select EstateID from estate_settings";
  311. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  312. cmd.CommandText = sql;
  313. IDataReader r = cmd.ExecuteReader();
  314. while (r.Read())
  315. {
  316. result.Add(Convert.ToInt32(r["EstateID"]));
  317. }
  318. r.Close();
  319. return result;
  320. }
  321. public List<int> GetEstatesByOwner(UUID ownerID)
  322. {
  323. List<int> result = new List<int>();
  324. string sql = "select EstateID from estate_settings where estate_settings.EstateOwner = :EstateOwner";
  325. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  326. cmd.CommandText = sql;
  327. cmd.Parameters.AddWithValue(":EstateOwner", ownerID);
  328. IDataReader r = cmd.ExecuteReader();
  329. while (r.Read())
  330. {
  331. result.Add(Convert.ToInt32(r["EstateID"]));
  332. }
  333. r.Close();
  334. return result;
  335. }
  336. public bool LinkRegion(UUID regionID, int estateID)
  337. {
  338. SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
  339. cmd.CommandText = "insert into estate_map values (:RegionID, :EstateID)";
  340. cmd.Parameters.AddWithValue(":RegionID", regionID.ToString());
  341. cmd.Parameters.AddWithValue(":EstateID", estateID.ToString());
  342. if (cmd.ExecuteNonQuery() == 0)
  343. return false;
  344. return true;
  345. }
  346. public List<UUID> GetRegions(int estateID)
  347. {
  348. return new List<UUID>();
  349. }
  350. public bool DeleteEstate(int estateID)
  351. {
  352. return false;
  353. }
  354. }
  355. }