OSDN -- 開發和下載開源軟體
繁體中文翻譯狀態 translation status for zh-tw
  • R/O
  • SSH
  • HTTPS

okuyama: 提交


Commit MetaInfo

修訂1028 (tree)
時間2013-08-17 17:14:08
作者okuyamaoo

Log Message

MasterManagerHelper list struct method add

Change Summary

差異

--- trunk/src/okuyama/imdst/helper/KeyManagerHelper.java (revision 1027)
+++ trunk/src/okuyama/imdst/helper/KeyManagerHelper.java (revision 1028)
@@ -874,14 +874,23 @@
874874 case 51 :
875875
876876 // リスト構造を作成する
877+ boolean compulsiveFlg = false;
877878 String createListName = clientParameterList[1]; // List名
878879 transactionCode = clientParameterList[2]; // TransactionCode
880+ if (clientParameterList.length > 3 && clientParameterList[3].equals("1")) {
881+ compulsiveFlg = true; // 強制作成
882+ }
879883
880884 // メソッド呼び出し
881- retParams = this.createListStruct(createListName, transactionCode);
885+ retParams = this.createListStruct(createListName, compulsiveFlg, transactionCode);
882886 retParamBuf.append(retParams[0]);
883887 retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
884888 retParamBuf.append(retParams[1]);
889+ if (retParams.length > 2) {
890+ retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
891+ retParamBuf.append(retParams[2]);
892+ }
893+
885894 break;
886895 case 52 :
887896
@@ -901,7 +910,6 @@
901910 }
902911 break;
903912 case 53 :
904-
905913 // Listの後端に値を登録する
906914 String rPushListName = clientParameterList[1]; // List名
907915 String rPushValue = clientParameterList[2]; // 登録する値
@@ -916,7 +924,6 @@
916924 retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
917925 retParamBuf.append(retParams[2]);
918926 }
919-
920927 break;
921928 case 54 :
922929
@@ -935,6 +942,7 @@
935942 retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
936943 retParamBuf.append(retParams[2]);
937944 }
945+
938946 break;
939947 case 55 :
940948
@@ -970,6 +978,24 @@
970978 retParamBuf.append(retParams[2]);
971979 }
972980 break;
981+
982+ case 57 :
983+
984+ // Listサイズを取得する
985+ String lenListName = clientParameterList[1]; // List名
986+ transactionCode = clientParameterList[2]; // TransactionCode
987+
988+ // メソッド呼び出し
989+ retParams = this.listLen(lenListName, transactionCode);
990+ retParamBuf.append(retParams[0]);
991+ retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
992+ retParamBuf.append(retParams[1]);
993+
994+ if (retParams.length > 2) {
995+ retParamBuf.append(ImdstDefine.keyHelperClientParamSep);
996+ retParamBuf.append(retParams[2]);
997+ }
998+ break;
973999 case 60 :
9741000
9751001 // KeyMapManagerのデータサイズを返す
@@ -1186,6 +1212,7 @@
11861212 closeFlg = true;
11871213 reloopSameClient = false;
11881214 } catch (ArrayIndexOutOfBoundsException aie) {
1215+aie.printStackTrace();
11891216 logger.error("KeyManagerHelper No Method_1 =[" + clientParameterList[0] + "]");
11901217 reloopSameClient = false;
11911218 } catch (NumberFormatException nfe) {
@@ -2209,27 +2236,45 @@
22092236
22102237
22112238 // リスト構造体を作成する
2212- private String[] createListStruct(String listName, String transactionCode) {
2239+ private String[] createListStruct(String listName, boolean compulsiveFlg, String transactionCode) {
22132240 String[] retStrs = new String[3];
22142241
22152242 try {
2216- if(!this.keyMapManager.checkError()) {
2243+ if (listName.length() < ImdstDefine.saveKeyMaxSize) {
22172244
2218- this.keyMapManager.createListStruct(listName, transactionCode);
2219-
2220- retStrs[0] = "51";
2221- retStrs[1] = "true";
2222- retStrs[2] = "OK";
2245+ if(!this.keyMapManager.checkError()) {
2246+ int retSts = this.keyMapManager.createListStruct(listName, compulsiveFlg, transactionCode);
2247+
2248+ if (retSts == 0) {
2249+
2250+ retStrs[0] = "51";
2251+ retStrs[1] = "true";
2252+ retStrs[2] = "OK";
2253+ } else if (retSts == 2) {
2254+ // 既に存在する
2255+ retStrs[0] = "51";
2256+ retStrs[1] = "false";
2257+ retStrs[2] = "ListName=[" + listName + "] already exists";
2258+ } else if (retSts == 1) {
2259+ retStrs[0] = "51";
2260+ retStrs[1] = "false";
2261+ retStrs[2] = "ListName=[" + listName + "] create error";
2262+ }
2263+ } else {
2264+
2265+ retStrs[0] = "51";
2266+ retStrs[1] = "error";
2267+ retStrs[2] = "NG:KeyMapManager - createListStruct - CheckError - NG";
2268+ }
22232269 } else {
2224-
22252270 retStrs[0] = "51";
22262271 retStrs[1] = "false";
2227- retStrs[2] = "NG:KeyMapManager - createListStruct - CheckError - NG";
2272+ retStrs[2] = "List name max length error";
22282273 }
22292274 } catch (BatchException be) {
22302275 logger.debug("KeyManagerHelper - createListStruct - Error = [" + listName + "]", be);
22312276 retStrs[0] = "51";
2232- retStrs[1] = "false";
2277+ retStrs[1] = "error";
22332278 retStrs[2] = "NG:KeyManagerHelper - createListStruct - Exception - " + be.toString();
22342279 }
22352280
@@ -2260,13 +2305,13 @@
22602305 } else {
22612306
22622307 retStrs[0] = "52";
2263- retStrs[1] = "false";
2308+ retStrs[1] = "error";
22642309 retStrs[2] = "NG:KeyMapManager - listLPush - CheckError - NG";
22652310 }
22662311 } catch (BatchException be) {
22672312 logger.debug("KeyManagerHelper - listLPush - Error = [" + listName + "]", be);
22682313 retStrs[0] = "52";
2269- retStrs[1] = "false";
2314+ retStrs[1] = "error";
22702315 retStrs[2] = "NG:KeyManagerHelper - listLPush - Exception - " + be.toString();
22712316 }
22722317
@@ -2298,13 +2343,13 @@
22982343 } else {
22992344
23002345 retStrs[0] = "53";
2301- retStrs[1] = "false";
2346+ retStrs[1] = "error";
23022347 retStrs[2] = "NG:KeyMapManager - listRPush - CheckError - NG";
23032348 }
23042349 } catch (BatchException be) {
23052350 logger.debug("KeyManagerHelper - listRPush - Error = [" + listName + "]", be);
23062351 retStrs[0] = "53";
2307- retStrs[1] = "false";
2352+ retStrs[1] = "error";
23082353 retStrs[2] = "NG:KeyManagerHelper - listRPush - Exception - " + be.toString();
23092354 }
23102355
@@ -2342,13 +2387,13 @@
23422387 } else {
23432388
23442389 retStrs[0] = "54";
2345- retStrs[1] = "false";
2390+ retStrs[1] = "error";
23462391 retStrs[2] = "NG:KeyMapManager - listGetData - CheckError - NG";
23472392 }
23482393 } catch (BatchException be) {
23492394 logger.debug("KeyManagerHelper - listGetData - Error = [" + listName + "]", be);
23502395 retStrs[0] = "54";
2351- retStrs[1] = "false";
2396+ retStrs[1] = "error";
23522397 retStrs[2] = "NG:KeyManagerHelper - listGetData - Exception - " + be.toString();
23532398 }
23542399
@@ -2377,13 +2422,13 @@
23772422 } else {
23782423
23792424 retStrs[0] = "55";
2380- retStrs[1] = "false";
2425+ retStrs[1] = "error";
23812426 retStrs[2] = "NG:KeyMapManager - listLPop - CheckError - NG";
23822427 }
23832428 } catch (BatchException be) {
23842429 logger.debug("KeyManagerHelper - listLPop - Error = [" + listName + "]", be);
23852430 retStrs[0] = "55";
2386- retStrs[1] = "false";
2431+ retStrs[1] = "error";
23872432 retStrs[2] = "NG:KeyManagerHelper - listGetData - Exception - " + be.toString();
23882433 }
23892434
@@ -2411,13 +2456,13 @@
24112456 } else {
24122457
24132458 retStrs[0] = "56";
2414- retStrs[1] = "false";
2459+ retStrs[1] = "error";
24152460 retStrs[2] = "NG:KeyMapManager - listRPop - CheckError - NG";
24162461 }
24172462 } catch (BatchException be) {
24182463 logger.debug("KeyManagerHelper - listRPop - Error = [" + listName + "]", be);
24192464 retStrs[0] = "56";
2420- retStrs[1] = "false";
2465+ retStrs[1] = "error";
24212466 retStrs[2] = "NG:KeyManagerHelper - listRPop - Exception - " + be.toString();
24222467 }
24232468
@@ -2425,7 +2470,41 @@
24252470 }
24262471
24272472
2473+ // リスト構造体のサイズを取得する
2474+ private String[] listLen(String listName, String transactionCode) {
2475+ String[] retStrs = new String[3];
24282476
2477+ try {
2478+ if(!this.keyMapManager.checkError()) {
2479+
2480+ String ret = this.keyMapManager.listLen(listName, transactionCode);
2481+ if (ret != null) {
2482+
2483+ retStrs[0] = "57";
2484+ retStrs[1] = "true";
2485+ retStrs[2] = ret;
2486+ } else {
2487+ retStrs = new String[2];
2488+ retStrs[0] = "57";
2489+ retStrs[1] = "false";
2490+ }
2491+ } else {
2492+
2493+ retStrs[0] = "57";
2494+ retStrs[1] = "false";
2495+ retStrs[2] = "NG:KeyMapManager - listLen - CheckError - NG";
2496+ }
2497+ } catch (BatchException be) {
2498+ logger.debug("KeyManagerHelper - listLen - Error = [" + listName + "]", be);
2499+ retStrs[0] = "57";
2500+ retStrs[1] = "false";
2501+ retStrs[2] = "NG:KeyManagerHelper - listLen - Exception - " + be.toString();
2502+ }
2503+
2504+ return retStrs;
2505+ }
2506+
2507+
24292508 /**
24302509 * Clientとの接続を切断する.<br>
24312510 *
--- trunk/src/okuyama/imdst/helper/MasterManagerHelper.java (revision 1027)
+++ trunk/src/okuyama/imdst/helper/MasterManagerHelper.java (revision 1028)
@@ -860,6 +860,41 @@
860860 retParams[1] = "false";
861861 }
862862 break;
863+ case 51 :
864+
865+ // List構造体を作成する
866+ retParams = this.createListStruct(clientParameterList[1], clientParameterList[2]);
867+ break;
868+ case 52 :
869+
870+ // List構造の先頭に値を追加する
871+ retParams = this.listLPush(clientParameterList[1], clientParameterList[2], clientParameterList[3]);
872+ break;
873+ case 53 :
874+
875+ // List構造の末尾に値を追加する
876+ retParams = this.listRPush(clientParameterList[1], clientParameterList[2], clientParameterList[3]);
877+ break;
878+ case 54 :
879+
880+ // List構造からIndex指定で値を取得する
881+ retParams = this.listIndex(clientParameterList[1], clientParameterList[2], clientParameterList[3]);
882+ break;
883+ case 55 :
884+
885+ // List構造の先頭から値を取得する
886+ retParams = this.listLPop(clientParameterList[1], clientParameterList[2]);
887+ break;
888+ case 56 :
889+
890+ // List構造の末尾から値を取得する
891+ retParams = this.listRPop(clientParameterList[1], clientParameterList[2]);
892+ break;
893+ case 57 :
894+
895+ // List構造のサイズを取得する
896+ retParams = this.listLen(clientParameterList[1], clientParameterList[2]);
897+ break;
863898 case 61 :
864899
865900 if (StatusUtil.isMainMasterNode()) {
@@ -2035,8 +2070,734 @@
20352070 return retStrs;
20362071 }
20372072
2073+ /**
2074+ * List構造を作成する.<br>
2075+ * 既に作成済みの場合は失敗する.<br>
2076+ *
2077+ * @param listNameStr List名文字列
2078+ * @return String[] 結果
2079+ * @throws BatchException
2080+ */
2081+ private String[] createListStruct(String listNameStr, String transactionCode) throws BatchException {
2082+ //logger.debug("MasterManagerHelper - createListStruct - start");
2083+ String[] retStrs = new String[3];
20382084
2085+ // data部分はブランクの場合はブランク規定文字列で送られてくるのでそのまま保存する
2086+ String[] tagKeyPair = null;
2087+ String[] keyNodeSaveRet = null;
2088+
2089+
2090+ try {
2091+
2092+ if (DataDispatcher.hasOldRule()) {
2093+ // DataNode追加処理中は本メソッドはエラーとなる。
2094+ // これは完全性を維持することが出来ないためである。
2095+ retStrs[0] = "51";
2096+ retStrs[1] = "false";
2097+ retStrs[2] = "This method cannot use during \"DataNode\" addition processing.";
2098+ return retStrs;
2099+ }
2100+
2101+ // KeyをIsolation変換実行
2102+ listNameStr = this.encodeIsolationConvert(listNameStr);
2103+
2104+ // Key値チェック
2105+ if (!this.checkKeyLength(listNameStr)) {
2106+ // 保存失敗
2107+ retStrs[0] = "51";
2108+ retStrs[1] = "false";
2109+ retStrs[2] = "List name Length Error";
2110+ return retStrs;
2111+ }
2112+
2113+ // List名で作成をする
2114+ // 保存先問い合わせ
2115+ String[] keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2116+
2117+
2118+ // 保存実行
2119+ // スレーブKeyNodeが存在する場合で値を変更
2120+ if (keyNodeInfo.length == 3) {
2121+ keyNodeSaveRet = this.createListStruct(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], null, null, null, listNameStr, transactionCode);
2122+ } else if (keyNodeInfo.length == 6) {
2123+ keyNodeSaveRet = this.createListStruct(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, transactionCode);
2124+ } else if (keyNodeInfo.length == 9) {
2125+ keyNodeSaveRet = this.createListStruct(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, transactionCode);
2126+ }
2127+
2128+
2129+ // 保存結果確認
2130+ if (keyNodeSaveRet[1].equals("false")) {
2131+ // 保存失敗
2132+ retStrs[0] = "51";
2133+ retStrs[1] = "false";
2134+ retStrs[2] = keyNodeSaveRet[2];
2135+
2136+ return retStrs;
2137+ }
2138+
2139+
2140+ retStrs[0] = "51";
2141+ retStrs[1] = "true";
2142+ retStrs[2] = "OK";
2143+
2144+ } catch (BatchException be) {
2145+
2146+ logger.info("MasterManagerHelper - createListStruct - Error", be);
2147+ retStrs[0] = "51";
2148+ retStrs[1] = "error";
2149+ retStrs[2] = "NG:MasterNode - Exception";
2150+ } catch (Exception e) {
2151+ logger.info("MasterManagerHelper - createListStruct - Error", e);
2152+ retStrs[0] = "51";
2153+ retStrs[1] = "false";
2154+ retStrs[2] = "MasterNode - Exception";
2155+ }
2156+ //logger.debug("MasterManagerHelper - createListStruct - end");
2157+ return retStrs;
2158+ }
2159+
2160+
20392161 /**
2162+ * List構造の先頭に値を追加する.<br>
2163+ * 構造体を事前に作成していない場合は失敗する<br>
2164+ *
2165+ * @param listNameStr List名文字列
2166+ * @param listData Listへ追加するデータ
2167+ * @return String[] 結果
2168+ * @throws BatchException
2169+ */
2170+ private String[] listLPush(String listNameStr, String listData, String transactionCode) throws BatchException {
2171+ //logger.debug("MasterManagerHelper - listLPush - start");
2172+ String[] retStrs = new String[3];
2173+
2174+ // data部分はブランクの場合はブランク規定文字列で送られてくるのでそのまま保存する
2175+ String[] tagKeyPair = null;
2176+ String[] keyNodeSaveRet = null;
2177+
2178+
2179+ try {
2180+
2181+ if (DataDispatcher.hasOldRule()) {
2182+ // DataNode追加処理中は本メソッドはエラーとなる。
2183+ // これは完全性を維持することが出来ないためである。
2184+ retStrs[0] = "52";
2185+ retStrs[1] = "false";
2186+ retStrs[2] = "This method cannot use during \"DataNode\" addition processing.";
2187+ return retStrs;
2188+ }
2189+
2190+ // KeyをIsolation変換実行
2191+ listNameStr = this.encodeIsolationConvert(listNameStr);
2192+
2193+ // Key値チェック
2194+ if (!this.checkKeyLength(listNameStr)) {
2195+ // 保存失敗
2196+ retStrs[0] = "52";
2197+ retStrs[1] = "false";
2198+ retStrs[2] = "List name Length Error";
2199+ return retStrs;
2200+ }
2201+
2202+
2203+ // Data値チェック
2204+ if (!this.checkValueLength(listData)) {
2205+ // 保存失敗
2206+ retStrs[0] = "52";
2207+ retStrs[1] = "false";
2208+ retStrs[2] = "listData Length Error";
2209+ return retStrs;
2210+ }
2211+
2212+ // List名で作成をする
2213+ // 保存先問い合わせ
2214+ String[] keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2215+
2216+
2217+ // 保存実行
2218+ // スレーブKeyNodeが存在する場合で値を変更
2219+ if (keyNodeInfo.length == 3) {
2220+ keyNodeSaveRet = this.listLPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], null, null, null, listNameStr, listData, transactionCode);
2221+ } else if (keyNodeInfo.length == 6) {
2222+ keyNodeSaveRet = this.listLPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, listData, transactionCode);
2223+ } else if (keyNodeInfo.length == 9) {
2224+ keyNodeSaveRet = this.listLPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, listData, transactionCode);
2225+ }
2226+
2227+
2228+ // 保存結果確認
2229+ if (keyNodeSaveRet[1].equals("false") || keyNodeSaveRet[1].equals("false")) {
2230+ // 保存失敗
2231+ if (keyNodeSaveRet.length > 2) {
2232+
2233+ retStrs[0] = "52";
2234+ retStrs[1] = "false";
2235+ retStrs[2] = keyNodeSaveRet[2];
2236+ } else {
2237+ retStrs = new String[2];
2238+
2239+ retStrs[0] = "52";
2240+ retStrs[1] = keyNodeSaveRet[1];
2241+ }
2242+ return retStrs;
2243+ }
2244+
2245+ // 成功
2246+ retStrs[0] = "52";
2247+ retStrs[1] = "true";
2248+ retStrs[2] = "OK";
2249+
2250+ } catch (BatchException be) {
2251+
2252+ logger.info("MasterManagerHelper - listLPush - Error", be);
2253+ retStrs[0] = "52";
2254+ retStrs[1] = "error";
2255+ retStrs[2] = "NG:MasterNode - Exception";
2256+ } catch (Exception e) {
2257+ logger.info("MasterManagerHelper - listLPush - Error", e);
2258+ retStrs[0] = "52";
2259+ retStrs[1] = "false";
2260+ retStrs[2] = "MasterNode - Exception";
2261+ }
2262+ //logger.debug("MasterManagerHelper - listLPush - end");
2263+ return retStrs;
2264+ }
2265+
2266+
2267+ /**
2268+ * List構造の最後尾に値を追加する.<br>
2269+ * 構造体を事前に作成していない場合は失敗する<br>
2270+ *
2271+ * @param listNameStr List名文字列
2272+ * @param listData Listへ追加するデータ
2273+ * @return String[] 結果
2274+ * @throws BatchException
2275+ */
2276+ private String[] listRPush(String listNameStr, String listData, String transactionCode) throws BatchException {
2277+ //logger.debug("MasterManagerHelper - listRPush - start");
2278+ String[] retStrs = new String[3];
2279+
2280+ // data部分はブランクの場合はブランク規定文字列で送られてくるのでそのまま保存する
2281+ String[] tagKeyPair = null;
2282+ String[] keyNodeSaveRet = null;
2283+
2284+
2285+ try {
2286+
2287+ if (DataDispatcher.hasOldRule()) {
2288+ // DataNode追加処理中は本メソッドはエラーとなる。
2289+ // これは完全性を維持することが出来ないためである。
2290+ retStrs[0] = "53";
2291+ retStrs[1] = "false";
2292+ retStrs[2] = "This method cannot use during \"DataNode\" addition processing.";
2293+ return retStrs;
2294+ }
2295+
2296+ // KeyをIsolation変換実行
2297+ listNameStr = this.encodeIsolationConvert(listNameStr);
2298+
2299+ // Key値チェック
2300+ if (!this.checkKeyLength(listNameStr)) {
2301+ // 保存失敗
2302+ retStrs[0] = "53";
2303+ retStrs[1] = "false";
2304+ retStrs[2] = "List name Length Error";
2305+ return retStrs;
2306+ }
2307+
2308+
2309+ // Data値チェック
2310+ if (!this.checkValueLength(listData)) {
2311+ // 保存失敗
2312+ retStrs[0] = "53";
2313+ retStrs[1] = "false";
2314+ retStrs[2] = "listData Length Error";
2315+ return retStrs;
2316+ }
2317+
2318+ // List名で作成をする
2319+ // 保存先問い合わせ
2320+ String[] keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2321+
2322+
2323+ // 保存実行
2324+ // スレーブKeyNodeが存在する場合で値を変更
2325+ if (keyNodeInfo.length == 3) {
2326+ keyNodeSaveRet = this.listRPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], null, null, null, listNameStr, listData, transactionCode);
2327+ } else if (keyNodeInfo.length == 6) {
2328+ keyNodeSaveRet = this.listRPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, listData, transactionCode);
2329+ } else if (keyNodeInfo.length == 9) {
2330+ keyNodeSaveRet = this.listRPush(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, listData, transactionCode);
2331+ }
2332+
2333+
2334+ // 保存結果確認
2335+ if (keyNodeSaveRet[1].equals("false") || keyNodeSaveRet[1].equals("false")) {
2336+ // 保存失敗
2337+ if (keyNodeSaveRet.length > 2) {
2338+
2339+ retStrs[0] = "53";
2340+ retStrs[1] = "false";
2341+ retStrs[2] = keyNodeSaveRet[2];
2342+ } else {
2343+ retStrs = new String[2];
2344+
2345+ retStrs[0] = "53";
2346+ retStrs[1] = keyNodeSaveRet[1];
2347+ }
2348+ return retStrs;
2349+ }
2350+
2351+ // 成功
2352+ retStrs[0] = "53";
2353+ retStrs[1] = "true";
2354+ retStrs[2] = "OK";
2355+
2356+ } catch (BatchException be) {
2357+
2358+ logger.info("MasterManagerHelper - listRPush - Error", be);
2359+ retStrs[0] = "53";
2360+ retStrs[1] = "error";
2361+ retStrs[2] = "NG:MasterNode - Exception";
2362+ } catch (Exception e) {
2363+ logger.info("MasterManagerHelper - listRPush - Error", e);
2364+ retStrs[0] = "53";
2365+ retStrs[1] = "false";
2366+ retStrs[2] = "MasterNode - Exception";
2367+ }
2368+ //logger.debug("MasterManagerHelper - listRPush - end");
2369+ return retStrs;
2370+ }
2371+
2372+
2373+ /**
2374+ * List構造の指定Indexの値を取得する.<br>
2375+ * 構造体を事前に作成していない場合は失敗する<br>
2376+ * 指定位置が存在しない場合は結果はなしとなる<br>
2377+ *
2378+ * @param listNameStr List名文字列
2379+ * @param listData Listへ追加するデータ
2380+ * @return String[] 結果
2381+ * @throws BatchException
2382+ */
2383+ private String[] listIndex(String listNameStr, String index, String transactionCode) throws BatchException {
2384+ //logger.debug("MasterManagerHelper - listIndex - start");
2385+ String[] retStrs = new String[3];
2386+
2387+ // data部分はブランクの場合はブランク規定文字列で送られてくるのでそのまま保存する
2388+ String[] tagKeyPair = null;
2389+ String[] keyNodeListIndexRet = null;
2390+
2391+
2392+ try {
2393+
2394+ if (DataDispatcher.hasOldRule()) {
2395+ // DataNode追加処理中は本メソッドはエラーとなる。
2396+ // これは完全性を維持することが出来ないためである。
2397+ retStrs[0] = "54";
2398+ retStrs[1] = "false";
2399+ retStrs[2] = "This method cannot use during \"DataNode\" addition processing.";
2400+ return retStrs;
2401+ }
2402+
2403+ // KeyをIsolation変換実行
2404+ listNameStr = this.encodeIsolationConvert(listNameStr);
2405+
2406+ // Key値チェック
2407+ if (!this.checkKeyLength(listNameStr)) {
2408+ // List名が長すぎる
2409+ retStrs[0] = "54";
2410+ retStrs[1] = "false";
2411+ retStrs[2] = "List name Length Error";
2412+ return retStrs;
2413+ }
2414+
2415+ // Indexが数字であるかチェック
2416+ try {
2417+ Long indexChk = new Long(index);
2418+ } catch (NumberFormatException nfe) {
2419+ // 保存失敗
2420+ retStrs[0] = "54";
2421+ retStrs[1] = "false";
2422+ retStrs[2] = "Please specify \"index\" numerically.";
2423+ return retStrs;
2424+ }
2425+
2426+
2427+ // List名で作成をする
2428+ // 保存先問い合わせ
2429+ String[] keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2430+
2431+
2432+ // 保存実行
2433+ // スレーブKeyNodeが存在する場合で値を変更
2434+ if (keyNodeInfo.length == 3) {
2435+ keyNodeListIndexRet = this.listIndex(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], null, null, null, listNameStr, index, transactionCode);
2436+ } else if (keyNodeInfo.length == 6) {
2437+ keyNodeListIndexRet = this.listIndex(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, index, transactionCode);
2438+ } else if (keyNodeInfo.length == 9) {
2439+ keyNodeListIndexRet = this.listIndex(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, index, transactionCode);
2440+ }
2441+
2442+
2443+ // 保存結果確認
2444+ if (keyNodeListIndexRet[1].equals("false")) {
2445+ // 値なし
2446+ retStrs[0] = "54";
2447+ retStrs[1] = "false";
2448+ retStrs[2] = "";
2449+ return retStrs;
2450+ } else if (keyNodeListIndexRet[1].equals("true")) {
2451+ // 値あり
2452+ retStrs[0] = keyNodeListIndexRet[0];
2453+ retStrs[1] = "true";
2454+ retStrs[2] = keyNodeListIndexRet[2];
2455+ } else {
2456+ // Error
2457+ retStrs[0] = "54";
2458+ retStrs[1] = "error";
2459+ retStrs[2] = "NG:MasterNode - Exception";
2460+ }
2461+ } catch (BatchException be) {
2462+
2463+ logger.info("MasterManagerHelper - listIndex - Error", be);
2464+ retStrs[0] = "54";
2465+ retStrs[1] = "error";
2466+ retStrs[2] = "NG:MasterNode - Exception";
2467+ } catch (Exception e) {
2468+ logger.info("MasterManagerHelper - listIndex - Error", e);
2469+ retStrs[0] = "54";
2470+ retStrs[1] = "error";
2471+ retStrs[2] = "MasterNode - Exception";
2472+ }
2473+ //logger.debug("MasterManagerHelper - listIndex - end");
2474+ return retStrs;
2475+ }
2476+
2477+
2478+ /**
2479+ * 指定したList構造体の先頭から要素を取得する。取得された要素は削除されListは先頭から1つ詰められる.<br>
2480+ * 要素が存在しない場合はnullが返る。リストが存在しない場合はエラーとなる<br>
2481+ *
2482+ * @param listNameStr
2483+ * @param transactionCode
2484+ * @return String[] 結果
2485+ * @throws BatchException
2486+ */
2487+ private String[] listLPop(String listNameStr, String transactionCode) throws BatchException {
2488+ //logger.debug("MasterManagerHelper - listLPop - start");
2489+ String[] retStrs = new String[3];
2490+
2491+ String[] keyNodeRet = null;
2492+ String[] keyNodeInfo = null;
2493+
2494+ try {
2495+
2496+ // Isolation変換実行
2497+ listNameStr = this.encodeIsolationConvert(listNameStr);
2498+
2499+ if (!this.checkKeyLength(listNameStr)) {
2500+ // 保存失敗
2501+ retStrs[0] = "55";
2502+ retStrs[1] = "false";
2503+ retStrs[2] = "List name Length Error";
2504+ return retStrs;
2505+ }
2506+
2507+ // キー値を使用して取得先を決定
2508+ keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2509+
2510+ // 取得実行
2511+ // Main
2512+ try {
2513+ if (keyNodeInfo.length > 2) {
2514+ keyNodeRet = this.listLPop(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], listNameStr, transactionCode);
2515+ }
2516+ if (keyNodeRet == null) {
2517+ throw new Exception("");
2518+ }
2519+ } catch (Exception e1) {
2520+ keyNodeRet = new String[3];
2521+ keyNodeRet[0] = "55";
2522+ keyNodeRet[1] = "error";
2523+ keyNodeRet[2] = "MasterNode - Exception";
2524+ }
2525+
2526+ // Sub
2527+ try {
2528+ if (keyNodeInfo.length > 5) {
2529+ String[] retTmp = this.listLPop(keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, transactionCode);
2530+ if (keyNodeRet != null && keyNodeRet.length > 1 && keyNodeRet[1].equals("error")) {
2531+ keyNodeRet = retTmp;
2532+ }
2533+ }
2534+
2535+ if (keyNodeRet == null) {
2536+ throw new Exception("");
2537+ }
2538+ } catch (Exception e2) {
2539+ keyNodeRet = new String[3];
2540+ keyNodeRet[0] = "55";
2541+ keyNodeRet[1] = "error";
2542+ keyNodeRet[2] = "MasterNode - Exception";
2543+ }
2544+
2545+
2546+ // Third
2547+ try {
2548+ if (keyNodeInfo.length > 8) {
2549+ String[] retTmp = this.listLPop(keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, transactionCode);
2550+ if (keyNodeRet != null && keyNodeRet.length > 1 && keyNodeRet[1].equals("error")) {
2551+ keyNodeRet = retTmp;
2552+ }
2553+ }
2554+
2555+ if (keyNodeRet == null) {
2556+ throw new Exception("");
2557+ }
2558+ } catch (Exception e2) {
2559+ keyNodeRet = new String[3];
2560+ keyNodeRet[0] = "55";
2561+ keyNodeRet[1] = "error";
2562+ keyNodeRet[2] = "MasterNode - Exception";
2563+ }
2564+
2565+ // 取得結果確認
2566+ if (keyNodeRet[1].equals("false")) {
2567+
2568+ // 取得失敗(データなし)
2569+ retStrs[0] = "55";
2570+ retStrs[1] = "false";
2571+ retStrs[2] = "";
2572+ } else if (keyNodeRet != null && keyNodeRet.length > 2) {
2573+
2574+ // trueもしくはerrorの可能性あり
2575+ retStrs[0] = "55";
2576+ retStrs[1] = keyNodeRet[1];
2577+ retStrs[2] = keyNodeRet[2];
2578+ } else {
2579+ retStrs[0] = "55";
2580+ retStrs[1] = "error";
2581+ retStrs[2] = "DataNode - Exception";
2582+ }
2583+ } catch (Exception e) {
2584+ logger.error("MasterManagerHelper - listLPop - Error", e);
2585+ retStrs[0] = "55";
2586+ retStrs[1] = "error";
2587+ retStrs[2] = "MasterNode - Exception";
2588+ }
2589+ //logger.debug("MasterManagerHelper - listLPop - end");
2590+ return retStrs;
2591+ }
2592+
2593+
2594+
2595+ /**
2596+ * 指定したList構造体の末尾から要素を取得する。取得された要素は削除されListは末尾が1つ詰められる.<br>
2597+ * 要素が存在しない場合はnullが返る。リストが存在しない場合はエラーとなる<br>
2598+ *
2599+ * @param listNameStr
2600+ * @param transactionCode
2601+ * @return String[] 結果
2602+ * @throws BatchException
2603+ */
2604+ private String[] listRPop(String listNameStr, String transactionCode) throws BatchException {
2605+ //logger.debug("MasterManagerHelper - listLPop - start");
2606+ String[] retStrs = new String[3];
2607+
2608+ String[] keyNodeRet = null;
2609+ String[] keyNodeInfo = null;
2610+
2611+ try {
2612+
2613+ // Isolation変換実行
2614+ listNameStr = this.encodeIsolationConvert(listNameStr);
2615+
2616+ if (!this.checkKeyLength(listNameStr)) {
2617+ // 保存失敗
2618+ retStrs[0] = "55";
2619+ retStrs[1] = "false";
2620+ retStrs[2] = "List name Length Error";
2621+ return retStrs;
2622+ }
2623+
2624+ // キー値を使用して取得先を決定
2625+ keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2626+
2627+ // 取得実行
2628+ // Main
2629+ try {
2630+ if (keyNodeInfo.length > 2) {
2631+ keyNodeRet = this.listRPop(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], listNameStr, transactionCode);
2632+ }
2633+ if (keyNodeRet == null) {
2634+ throw new Exception("");
2635+ }
2636+ } catch (Exception e1) {
2637+ keyNodeRet = new String[3];
2638+ keyNodeRet[0] = "56";
2639+ keyNodeRet[1] = "error";
2640+ keyNodeRet[2] = "MasterNode - Exception";
2641+ }
2642+
2643+ // Sub
2644+ try {
2645+ if (keyNodeInfo.length > 5) {
2646+ String[] retTmp = this.listRPop(keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, transactionCode);
2647+ if (keyNodeRet != null && keyNodeRet.length > 1 && keyNodeRet[1].equals("error")) {
2648+ keyNodeRet = retTmp;
2649+ }
2650+ }
2651+
2652+ if (keyNodeRet == null) {
2653+ throw new Exception("");
2654+ }
2655+ } catch (Exception e2) {
2656+ keyNodeRet = new String[3];
2657+ keyNodeRet[0] = "56";
2658+ keyNodeRet[1] = "error";
2659+ keyNodeRet[2] = "MasterNode - Exception";
2660+ }
2661+
2662+
2663+ // Third
2664+ try {
2665+ if (keyNodeInfo.length > 8) {
2666+ String[] retTmp = this.listRPop(keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, transactionCode);
2667+ if (keyNodeRet != null && keyNodeRet.length > 1 && keyNodeRet[1].equals("error")) {
2668+ keyNodeRet = retTmp;
2669+ }
2670+ }
2671+
2672+ if (keyNodeRet == null) {
2673+ throw new Exception("");
2674+ }
2675+ } catch (Exception e2) {
2676+ keyNodeRet = new String[3];
2677+ keyNodeRet[0] = "56";
2678+ keyNodeRet[1] = "error";
2679+ keyNodeRet[2] = "MasterNode - Exception";
2680+ }
2681+
2682+ // 取得結果確認
2683+ if (keyNodeRet[1].equals("false")) {
2684+
2685+ // 取得失敗(データなし)
2686+ retStrs[0] = "56";
2687+ retStrs[1] = "false";
2688+ retStrs[2] = "";
2689+ } else if (keyNodeRet != null && keyNodeRet.length > 2) {
2690+
2691+ // trueもしくはerrorの可能性あり
2692+ retStrs[0] = "56";
2693+ retStrs[1] = keyNodeRet[1];
2694+ retStrs[2] = keyNodeRet[2];
2695+ } else {
2696+ retStrs[0] = "56";
2697+ retStrs[1] = "error";
2698+ retStrs[2] = "DataNode - Exception";
2699+ }
2700+ } catch (Exception e) {
2701+ logger.error("MasterManagerHelper - listRPop - Error", e);
2702+ retStrs[0] = "56";
2703+ retStrs[1] = "error";
2704+ retStrs[2] = "MasterNode - Exception";
2705+ }
2706+ //logger.debug("MasterManagerHelper - listRPop - end");
2707+ return retStrs;
2708+ }
2709+
2710+
2711+
2712+ /**
2713+ * List構造のサイズを取得する.<br>
2714+ * 構造体を事前に作成していない場合は失敗する<br>
2715+ *
2716+ * @param listNameStr List名文字列
2717+ * @param listData Listへ追加するデータ
2718+ * @return String[] 結果
2719+ * @throws BatchException
2720+ */
2721+ private String[] listLen(String listNameStr, String transactionCode) throws BatchException {
2722+ //logger.debug("MasterManagerHelper - listLen - start");
2723+ String[] retStrs = new String[3];
2724+
2725+ // data部分はブランクの場合はブランク規定文字列で送られてくるのでそのまま保存する
2726+ String[] tagKeyPair = null;
2727+ String[] keyNodeListLenRet = null;
2728+
2729+
2730+ try {
2731+
2732+ if (DataDispatcher.hasOldRule()) {
2733+ // DataNode追加処理中は本メソッドはエラーとなる。
2734+ // これは完全性を維持することが出来ないためである。
2735+ retStrs[0] = "57";
2736+ retStrs[1] = "false";
2737+ retStrs[2] = "This method cannot use during \"DataNode\" addition processing.";
2738+ return retStrs;
2739+ }
2740+
2741+ // KeyをIsolation変換実行
2742+ listNameStr = this.encodeIsolationConvert(listNameStr);
2743+
2744+ // Key値チェック
2745+ if (!this.checkKeyLength(listNameStr)) {
2746+ // List名が長すぎる
2747+ retStrs[0] = "57z";
2748+ retStrs[1] = "false";
2749+ retStrs[2] = "List name Length Error";
2750+ return retStrs;
2751+ }
2752+
2753+
2754+ // List名で作成をする
2755+ // 保存先問い合わせ
2756+ String[] keyNodeInfo = DataDispatcher.dispatchKeyNode(listNameStr, false);
2757+
2758+
2759+ // 保存実行
2760+ // スレーブKeyNodeが存在する場合で値を変更
2761+ if (keyNodeInfo.length == 3) {
2762+ keyNodeListLenRet = this.listLen(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], null, null, null, listNameStr, transactionCode);
2763+ } else if (keyNodeInfo.length == 6) {
2764+ keyNodeListLenRet = this.listLen(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], listNameStr, transactionCode);
2765+ } else if (keyNodeInfo.length == 9) {
2766+ keyNodeListLenRet = this.listLen(keyNodeInfo[0], keyNodeInfo[1], keyNodeInfo[2], keyNodeInfo[3], keyNodeInfo[4], keyNodeInfo[5], keyNodeInfo[6], keyNodeInfo[7], keyNodeInfo[8], listNameStr, transactionCode);
2767+ }
2768+
2769+
2770+ // 保存結果確認
2771+ if (keyNodeListLenRet[1].equals("false")) {
2772+ // 値なし
2773+ retStrs[0] = "57";
2774+ retStrs[1] = "false";
2775+ retStrs[2] = "";
2776+ return retStrs;
2777+ } else if (keyNodeListLenRet[1].equals("true")) {
2778+ // 値あり
2779+ retStrs[0] = keyNodeListLenRet[0];
2780+ retStrs[1] = "true";
2781+ retStrs[2] = keyNodeListLenRet[2];
2782+ }
2783+ } catch (BatchException be) {
2784+
2785+ logger.info("MasterManagerHelper - listLen - Error", be);
2786+ retStrs[0] = "57";
2787+ retStrs[1] = "error";
2788+ retStrs[2] = "NG:MasterNode - Exception";
2789+ } catch (Exception e) {
2790+ logger.info("MasterManagerHelper - listLen - Error", e);
2791+ retStrs[0] = "57";
2792+ retStrs[1] = "error";
2793+ retStrs[2] = "MasterNode - Exception";
2794+ }
2795+ //logger.debug("MasterManagerHelper - listLen - end");
2796+ return retStrs;
2797+ }
2798+
2799+
2800+ /**
20402801 * KeyでValueを取得する.<br>
20412802 * 処理フロー.<br>
20422803 * 1.DataDispatcherにKeyを使用してValueの保存先を問い合わせる<br>
@@ -5924,6 +6685,1687 @@
59246685
59256686
59266687 /**
6688+ * List構造体を作成する.<br>
6689+ * 既に登録されている場合は失敗する.<br>
6690+ *
6691+ * @param keyNodeName マスターデータノードの名前(IPなど)
6692+ * @param keyNodePort マスターデータノードのアクセスポート番号
6693+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
6694+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
6695+ * @param thirdKeyNodeName サードデータノードの名前(IPなど)
6696+ * @param thirdKeyNodePort サードデータノードのアクセスポート番号
6697+ *
6698+ * @param listName 作成するList名
6699+ * @return String[] 結果
6700+ * @throws BatchException
6701+ */
6702+ private String[] createListStruct(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String thirdKeyNodeName, String thirdKeyNodePort, String thirdKeyNodeFullName, String listName, String transactionCode) throws BatchException {
6703+ boolean exceptionFlg = false;
6704+ String[] ret = null;
6705+ String[] thirdRet = null;
6706+ BatchException retBe = null;
6707+
6708+ try {
6709+
6710+ ret = this.createListStruct(keyNodeName, keyNodePort, keyNodeFullName, subKeyNodeName, subKeyNodePort, subKeyNodeFullName, listName, transactionCode);
6711+ } catch (BatchException be) {
6712+
6713+ retBe = be;
6714+ exceptionFlg = true;
6715+ } catch (Exception e) {
6716+
6717+ retBe = new BatchException(e);
6718+ exceptionFlg = true;
6719+ } finally {
6720+
6721+ try {
6722+ if (exceptionFlg) {
6723+ thirdRet = this.createListStruct(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, transactionCode);
6724+ ret = thirdRet;
6725+ } else {
6726+ if (ret[1].equals("true")) {
6727+
6728+ // 保存成功
6729+ // まだ登録されていない
6730+ // 無条件で登録
6731+ thirdRet = this.createListStruct(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, transactionCode);
6732+ } else {
6733+ // サードノードの使用終了のみマーク
6734+ if (thirdKeyNodeFullName != null)
6735+ super.execNodeUseEnd(thirdKeyNodeFullName);
6736+ }
6737+ }
6738+ } catch (Exception e) {
6739+ if (exceptionFlg) throw retBe;
6740+ }
6741+ }
6742+
6743+ return ret;
6744+ }
6745+
6746+ /**
6747+ * List構造体を作成する.<br>
6748+ * 既に登録されている場合は失敗する.<br>
6749+ *
6750+ * @param keyNodeName マスターデータノードの名前(IPなど)
6751+ * @param keyNodePort マスターデータノードのアクセスポート番号
6752+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
6753+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
6754+ * @param listName 送信データ
6755+ * @return String[] 結果
6756+ * @throws BatchException
6757+ */
6758+ private String[] createListStruct(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String listName, String transactionCode) throws BatchException {
6759+
6760+ KeyNodeConnector keyNodeConnector = null;
6761+
6762+ String nodeName = keyNodeName;
6763+ String nodePort = keyNodePort;
6764+ String nodeFullName = keyNodeFullName;
6765+
6766+ String[] retParams = null;
6767+ String[] mainRetParams = null;
6768+ String[] subRetParams = null;
6769+
6770+ int counter = 0;
6771+
6772+ String tmpSaveHost = null;
6773+ String[] tmpSaveData = null;
6774+ String retParam = null;
6775+
6776+ boolean mainNodeSave = false;
6777+ boolean mainNodeNetworkError = false;
6778+ boolean subNodeSave = false;
6779+ boolean subNodeNetworkError = false;
6780+
6781+ try {
6782+
6783+ // TransactionModeの状態に合わせてLock状態を確かめる
6784+ if (transactionMode) {
6785+ while (true) {
6786+
6787+ // TransactionMode時
6788+ // TransactionManagerに処理を依頼
6789+ String[] keyNodeLockRet = hasLockKeyNode(transactionManagerInfo[0], transactionManagerInfo[1], listName);
6790+
6791+ // 取得結果確認
6792+ if (keyNodeLockRet[1].equals("true")) {
6793+
6794+ if (keyNodeLockRet[2].equals(transactionCode)) break;
6795+ } else {
6796+ break;
6797+ }
6798+ }
6799+ }
6800+
6801+
6802+ // まずメインデータノードへデータ登録
6803+ // KeyNodeとの接続を確立
6804+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, false);
6805+
6806+ if (keyNodeConnector != null) {
6807+ try {
6808+
6809+ // Key値でデータノード名を保存
6810+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
6811+ String sendStr = null;
6812+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
6813+ buf.append("51"); // Type
6814+ buf.append(ImdstDefine.keyHelperClientParamSep);
6815+ buf.append(this.stringCnv(listName)); // Key値
6816+ buf.append(ImdstDefine.keyHelperClientParamSep);
6817+ buf.append(transactionCode); // Transaction値
6818+ sendStr = buf.toString();
6819+
6820+ // 送信
6821+ keyNodeConnector.println(sendStr);
6822+ keyNodeConnector.flush();
6823+
6824+ // 返却値取得
6825+ retParam = keyNodeConnector.readLine(sendStr);
6826+
6827+ // 使用済みの接続を戻す
6828+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
6829+
6830+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
6831+ //retParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
6832+ if (retParam.indexOf(ImdstDefine.keyNodeListStructCreateSuccessStr) == 0) {
6833+
6834+ mainNodeSave = true;
6835+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
6836+ } else {
6837+
6838+ mainNodeSave = false;
6839+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
6840+ }
6841+ } catch (SocketException se) {
6842+ mainNodeNetworkError = true;
6843+ if (keyNodeConnector != null) {
6844+ keyNodeConnector.close();
6845+ keyNodeConnector = null;
6846+ }
6847+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 8, se);
6848+ logger.debug(se);
6849+ } catch (IOException ie) {
6850+ mainNodeNetworkError = true;
6851+ if (keyNodeConnector != null) {
6852+ keyNodeConnector.close();
6853+ keyNodeConnector = null;
6854+ }
6855+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 9, ie);
6856+ logger.debug(ie);
6857+ } catch (Exception ee) {
6858+ if (keyNodeConnector != null) {
6859+ keyNodeConnector.close();
6860+ keyNodeConnector = null;
6861+ }
6862+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 10, ee);
6863+ logger.debug(ee);
6864+ }
6865+
6866+ } else {
6867+ mainNodeNetworkError = true;
6868+ }
6869+
6870+
6871+ if (subKeyNodeName != null) {
6872+ // Subノードで実施
6873+ if (mainNodeSave == true || (mainNodeSave == false && mainNodeNetworkError == true)) {
6874+ String subNodeExecType = "";
6875+
6876+ // Mainノードが処理成功もしくは、ネットワークエラーの場合はSubノードの処理を行う。
6877+ // KeyNodeとの接続を確立
6878+ keyNodeConnector = this.createKeyNodeConnection(subKeyNodeName, subKeyNodePort, subKeyNodeFullName, false);
6879+
6880+ if (keyNodeConnector != null) {
6881+ try {
6882+
6883+ // Key値でデータノード名を保存
6884+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
6885+ String sendStr = null;
6886+
6887+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
6888+ buf.append("51"); // Type
6889+ buf.append(ImdstDefine.keyHelperClientParamSep);
6890+ buf.append(this.stringCnv(listName)); // Key値
6891+ buf.append(ImdstDefine.keyHelperClientParamSep);
6892+ buf.append(transactionCode); // Transaction値
6893+ buf.append(ImdstDefine.keyHelperClientParamSep);
6894+ buf.append("1"); // 強制登録を表す
6895+ sendStr = buf.toString();
6896+
6897+ // 送信
6898+ keyNodeConnector.println(sendStr);
6899+ keyNodeConnector.flush();
6900+
6901+ // 返却値取得
6902+ retParam = keyNodeConnector.readLine(sendStr);
6903+
6904+ // 使用済みの接続を戻す
6905+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
6906+
6907+
6908+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
6909+ if (retParam.indexOf(ImdstDefine.keyNodeListStructCreateSuccessStr) == 0) {
6910+
6911+ subNodeSave = true;
6912+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
6913+ } else {
6914+
6915+ subNodeSave = false;
6916+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
6917+ }
6918+ } catch (SocketException se) {
6919+ subNodeNetworkError = true;
6920+ if (keyNodeConnector != null) {
6921+ keyNodeConnector.close();
6922+ keyNodeConnector = null;
6923+ }
6924+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 11, se);
6925+ logger.debug(se);
6926+ } catch (IOException ie) {
6927+ subNodeNetworkError = true;
6928+ if (keyNodeConnector != null) {
6929+ keyNodeConnector.close();
6930+ keyNodeConnector = null;
6931+ }
6932+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 12, ie);
6933+ logger.debug(ie);
6934+ } catch (Exception ee) {
6935+ if (keyNodeConnector != null) {
6936+ keyNodeConnector.close();
6937+ keyNodeConnector = null;
6938+ }
6939+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 13, ee);
6940+ logger.debug(ee);
6941+ }
6942+
6943+ } else {
6944+ subNodeNetworkError = true;
6945+ }
6946+ }
6947+ }
6948+
6949+ // Main、Sub両方ともネットワークでのエラーがであるか確認
6950+ if (mainNodeNetworkError == true && subNodeNetworkError == true) {
6951+ // ネットワークエラー
6952+ throw new BatchException("Key Node IO Error: detail info for log file");
6953+ }
6954+
6955+ // ノードへの保存状況を確認
6956+ if (mainNodeSave == false) {
6957+
6958+ // MainNode保存失敗
6959+ if (mainNodeNetworkError == false) {
6960+
6961+ // 既に書き込み済みでの失敗
6962+ retParams = mainRetParams;
6963+ }
6964+ } else {
6965+
6966+ // MainNode保存成功
6967+ retParams = mainRetParams;
6968+ }
6969+
6970+
6971+ if (subKeyNodeName != null) {
6972+ // スレーブノードが存在する場合のみ
6973+ // MainNodeが既にデータ有りで失敗せずに、成功もしていない
6974+ if (retParams == null) {
6975+
6976+ if (subNodeSave == false) {
6977+
6978+ // SubNode保存失敗
6979+ if (subNodeNetworkError == false) {
6980+
6981+ // 既に書き込み済みでの失敗
6982+ retParams = subRetParams;
6983+ }
6984+ } else {
6985+
6986+ // SubNode保存成功
6987+ retParams = subRetParams;
6988+ }
6989+ }
6990+ }
6991+ } catch (BatchException be) {
6992+ if (keyNodeConnector != null) {
6993+ keyNodeConnector.close();
6994+ keyNodeConnector = null;
6995+ }
6996+ throw be;
6997+ } catch (Exception e) {
6998+ if (keyNodeConnector != null) {
6999+ keyNodeConnector.close();
7000+ keyNodeConnector = null;
7001+ }
7002+ throw new BatchException(e);
7003+ } finally {
7004+ // ノードの使用終了をマーク
7005+ super.execNodeUseEnd(keyNodeFullName);
7006+
7007+ if (subKeyNodeName != null)
7008+ super.execNodeUseEnd(subKeyNodeFullName);
7009+ }
7010+
7011+ return retParams;
7012+ }
7013+
7014+
7015+ /**
7016+ * List構造体の先頭に値を追加する.<br>
7017+ *
7018+ * @param keyNodeName マスターデータノードの名前(IPなど)
7019+ * @param keyNodePort マスターデータノードのアクセスポート番号
7020+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7021+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7022+ * @param thirdKeyNodeName サードデータノードの名前(IPなど)
7023+ * @param thirdKeyNodePort サードデータノードのアクセスポート番号
7024+ * @param listName 作成するList名
7025+ * @param listData 追加するData
7026+ * @return String[] 結果
7027+ * @throws BatchException
7028+ */
7029+ private String[] listLPush(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String thirdKeyNodeName, String thirdKeyNodePort, String thirdKeyNodeFullName, String listName, String listData, String transactionCode) throws BatchException {
7030+ boolean exceptionFlg = false;
7031+ String[] ret = null;
7032+ String[] thirdRet = null;
7033+ BatchException retBe = null;
7034+
7035+ try {
7036+
7037+ ret = this.listLPush(keyNodeName, keyNodePort, keyNodeFullName, subKeyNodeName, subKeyNodePort, subKeyNodeFullName, listName, listData, transactionCode);
7038+ } catch (BatchException be) {
7039+
7040+ retBe = be;
7041+ exceptionFlg = true;
7042+ } catch (Exception e) {
7043+
7044+ retBe = new BatchException(e);
7045+ exceptionFlg = true;
7046+ } finally {
7047+
7048+ try {
7049+ if (exceptionFlg) {
7050+ thirdRet = this.listLPush(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, listData, transactionCode);
7051+ ret = thirdRet;
7052+ } else {
7053+ if (ret[1].equals("true")) {
7054+
7055+ // 保存成功
7056+ // まだ登録されていない
7057+ // 無条件で登録
7058+ thirdRet = this.listLPush(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, listData, transactionCode);
7059+ } else {
7060+ // サードノードの使用終了のみマーク
7061+ if (thirdKeyNodeFullName != null)
7062+ super.execNodeUseEnd(thirdKeyNodeFullName);
7063+ }
7064+ }
7065+ } catch (Exception e) {
7066+ if (exceptionFlg) throw retBe;
7067+ }
7068+ }
7069+
7070+ return ret;
7071+ }
7072+
7073+ /**
7074+ * List構造体の先頭に値を追加する.<br>
7075+ *
7076+ * @param keyNodeName マスターデータノードの名前(IPなど)
7077+ * @param keyNodePort マスターデータノードのアクセスポート番号
7078+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7079+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7080+ * @param listName 送信データ
7081+ * @param listData 追加するData
7082+ * @return String[] 結果
7083+ * @throws BatchException
7084+ */
7085+ private String[] listLPush(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String listName, String listData, String transactionCode) throws BatchException {
7086+
7087+ KeyNodeConnector keyNodeConnector = null;
7088+
7089+ String nodeName = keyNodeName;
7090+ String nodePort = keyNodePort;
7091+ String nodeFullName = keyNodeFullName;
7092+
7093+ String[] retParams = null;
7094+ String[] mainRetParams = null;
7095+ String[] subRetParams = null;
7096+
7097+ int counter = 0;
7098+
7099+ String tmpSaveHost = null;
7100+ String[] tmpSaveData = null;
7101+ String retParam = null;
7102+
7103+ boolean mainNodeSave = false;
7104+ boolean mainNodeNetworkError = false;
7105+ boolean subNodeSave = false;
7106+ boolean subNodeNetworkError = false;
7107+
7108+ try {
7109+
7110+ // TransactionModeの状態に合わせてLock状態を確かめる
7111+ if (transactionMode) {
7112+ while (true) {
7113+
7114+ // TransactionMode時
7115+ // TransactionManagerに処理を依頼
7116+ String[] keyNodeLockRet = hasLockKeyNode(transactionManagerInfo[0], transactionManagerInfo[1], listName);
7117+
7118+ // 取得結果確認
7119+ if (keyNodeLockRet[1].equals("true")) {
7120+
7121+ if (keyNodeLockRet[2].equals(transactionCode)) break;
7122+ } else {
7123+ break;
7124+ }
7125+ }
7126+ }
7127+
7128+ // まずメインデータノードへデータ登録
7129+ // KeyNodeとの接続を確立
7130+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, false);
7131+
7132+ if (keyNodeConnector != null) {
7133+ try {
7134+
7135+ // Key値でデータノード名を保存
7136+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
7137+ String sendStr = null;
7138+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
7139+ buf.append("52"); // Type
7140+ buf.append(ImdstDefine.keyHelperClientParamSep);
7141+ buf.append(this.stringCnv(listName)); // List名
7142+ buf.append(ImdstDefine.keyHelperClientParamSep);
7143+ buf.append(this.stringCnv(listData)); // 追加Data値
7144+ buf.append(ImdstDefine.keyHelperClientParamSep);
7145+ buf.append(transactionCode); // Transaction値
7146+ sendStr = buf.toString();
7147+
7148+ // 送信
7149+ keyNodeConnector.println(sendStr);
7150+ keyNodeConnector.flush();
7151+
7152+ // 返却値取得
7153+ retParam = keyNodeConnector.readLine(sendStr);
7154+
7155+ // 使用済みの接続を戻す
7156+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7157+
7158+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
7159+ //retParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7160+ if (retParam.indexOf(ImdstDefine.keyNodeLPushSuccessStr) == 0) {
7161+
7162+ mainNodeSave = true;
7163+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7164+ } else {
7165+
7166+ mainNodeSave = false;
7167+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7168+ }
7169+ } catch (SocketException se) {
7170+ mainNodeNetworkError = true;
7171+ if (keyNodeConnector != null) {
7172+ keyNodeConnector.close();
7173+ keyNodeConnector = null;
7174+ }
7175+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 8, se);
7176+ logger.debug(se);
7177+ } catch (IOException ie) {
7178+ mainNodeNetworkError = true;
7179+ if (keyNodeConnector != null) {
7180+ keyNodeConnector.close();
7181+ keyNodeConnector = null;
7182+ }
7183+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 9, ie);
7184+ logger.debug(ie);
7185+ } catch (Exception ee) {
7186+ if (keyNodeConnector != null) {
7187+ keyNodeConnector.close();
7188+ keyNodeConnector = null;
7189+ }
7190+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 10, ee);
7191+ logger.debug(ee);
7192+ }
7193+
7194+ } else {
7195+ mainNodeNetworkError = true;
7196+ }
7197+
7198+
7199+ if (subKeyNodeName != null) {
7200+ // Subノードで実施
7201+ if (mainNodeSave == true || (mainNodeSave == false && mainNodeNetworkError == true)) {
7202+ String subNodeExecType = "";
7203+
7204+ // Mainノードが処理成功もしくは、ネットワークエラーの場合はSubノードの処理を行う。
7205+ // KeyNodeとの接続を確立
7206+ keyNodeConnector = this.createKeyNodeConnection(subKeyNodeName, subKeyNodePort, subKeyNodeFullName, false);
7207+
7208+ if (keyNodeConnector != null) {
7209+ try {
7210+
7211+ // Key値でデータノード名を保存
7212+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
7213+ String sendStr = null;
7214+
7215+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
7216+ buf.append("52"); // Type
7217+ buf.append(ImdstDefine.keyHelperClientParamSep);
7218+ buf.append(this.stringCnv(listName)); // List名
7219+ buf.append(ImdstDefine.keyHelperClientParamSep);
7220+ buf.append(this.stringCnv(listData)); // 追加Data値
7221+ buf.append(ImdstDefine.keyHelperClientParamSep);
7222+ buf.append(transactionCode); // Transaction値
7223+ buf.append(ImdstDefine.keyHelperClientParamSep);
7224+ buf.append("1"); // 強制登録を表す
7225+ sendStr = buf.toString();
7226+
7227+ // 送信
7228+ keyNodeConnector.println(sendStr);
7229+ keyNodeConnector.flush();
7230+
7231+ // 返却値取得
7232+ retParam = keyNodeConnector.readLine(sendStr);
7233+
7234+ // 使用済みの接続を戻す
7235+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7236+
7237+
7238+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
7239+ if (retParam.indexOf(ImdstDefine.keyNodeLPushSuccessStr) == 0) {
7240+
7241+ subNodeSave = true;
7242+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7243+ } else {
7244+
7245+ subNodeSave = false;
7246+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7247+ }
7248+ } catch (SocketException se) {
7249+ subNodeNetworkError = true;
7250+ if (keyNodeConnector != null) {
7251+ keyNodeConnector.close();
7252+ keyNodeConnector = null;
7253+ }
7254+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 11, se);
7255+ logger.debug(se);
7256+ } catch (IOException ie) {
7257+ subNodeNetworkError = true;
7258+ if (keyNodeConnector != null) {
7259+ keyNodeConnector.close();
7260+ keyNodeConnector = null;
7261+ }
7262+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 12, ie);
7263+ logger.debug(ie);
7264+ } catch (Exception ee) {
7265+ if (keyNodeConnector != null) {
7266+ keyNodeConnector.close();
7267+ keyNodeConnector = null;
7268+ }
7269+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 13, ee);
7270+ logger.debug(ee);
7271+ }
7272+
7273+ } else {
7274+ subNodeNetworkError = true;
7275+ }
7276+ }
7277+ }
7278+
7279+ // Main、Sub両方ともネットワークでのエラーがであるか確認
7280+ if (mainNodeNetworkError == true && subNodeNetworkError == true) {
7281+ // ネットワークエラー
7282+ throw new BatchException("Key Node IO Error: detail info for log file");
7283+ }
7284+
7285+ // ノードへの保存状況を確認
7286+ if (mainNodeSave == false) {
7287+
7288+ // MainNode保存失敗
7289+ if (mainNodeNetworkError == false) {
7290+
7291+ // 既に書き込み済みでの失敗
7292+ retParams = mainRetParams;
7293+ }
7294+ } else {
7295+
7296+ // MainNode保存成功
7297+ retParams = mainRetParams;
7298+ }
7299+
7300+
7301+ if (subKeyNodeName != null) {
7302+ // スレーブノードが存在する場合のみ
7303+ // MainNodeが既にデータ有りで失敗せずに、成功もしていない
7304+ if (retParams == null) {
7305+
7306+ if (subNodeSave == false) {
7307+
7308+ // SubNode保存失敗
7309+ if (subNodeNetworkError == false) {
7310+
7311+ // 既に書き込み済みでの失敗
7312+ retParams = subRetParams;
7313+ }
7314+ } else {
7315+
7316+ // SubNode保存成功
7317+ retParams = subRetParams;
7318+ }
7319+ }
7320+ }
7321+ } catch (BatchException be) {
7322+ if (keyNodeConnector != null) {
7323+ keyNodeConnector.close();
7324+ keyNodeConnector = null;
7325+ }
7326+ throw be;
7327+ } catch (Exception e) {
7328+ if (keyNodeConnector != null) {
7329+ keyNodeConnector.close();
7330+ keyNodeConnector = null;
7331+ }
7332+ throw new BatchException(e);
7333+ } finally {
7334+ // ノードの使用終了をマーク
7335+ super.execNodeUseEnd(keyNodeFullName);
7336+
7337+ if (subKeyNodeName != null)
7338+ super.execNodeUseEnd(subKeyNodeFullName);
7339+ }
7340+
7341+ return retParams;
7342+ }
7343+
7344+
7345+
7346+
7347+ /**
7348+ * List構造体の最後尾に値を追加する.<br>
7349+ *
7350+ * @param keyNodeName マスターデータノードの名前(IPなど)
7351+ * @param keyNodePort マスターデータノードのアクセスポート番号
7352+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7353+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7354+ * @param thirdKeyNodeName サードデータノードの名前(IPなど)
7355+ * @param thirdKeyNodePort サードデータノードのアクセスポート番号
7356+ * @param listName 作成するList名
7357+ * @param listData 追加するData
7358+ * @return String[] 結果
7359+ * @throws BatchException
7360+ */
7361+ private String[] listRPush(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String thirdKeyNodeName, String thirdKeyNodePort, String thirdKeyNodeFullName, String listName, String listData, String transactionCode) throws BatchException {
7362+ boolean exceptionFlg = false;
7363+ String[] ret = null;
7364+ String[] thirdRet = null;
7365+ BatchException retBe = null;
7366+
7367+ try {
7368+
7369+ ret = this.listRPush(keyNodeName, keyNodePort, keyNodeFullName, subKeyNodeName, subKeyNodePort, subKeyNodeFullName, listName, listData, transactionCode);
7370+ } catch (BatchException be) {
7371+
7372+ retBe = be;
7373+ exceptionFlg = true;
7374+ } catch (Exception e) {
7375+
7376+ retBe = new BatchException(e);
7377+ exceptionFlg = true;
7378+ } finally {
7379+
7380+ try {
7381+ if (exceptionFlg) {
7382+ thirdRet = this.listRPush(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, listData, transactionCode);
7383+ ret = thirdRet;
7384+ } else {
7385+ if (ret[1].equals("true")) {
7386+
7387+ // 保存成功
7388+ // まだ登録されていない
7389+ // 無条件で登録
7390+ thirdRet = this.listRPush(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listName, listData, transactionCode);
7391+ } else {
7392+ // サードノードの使用終了のみマーク
7393+ if (thirdKeyNodeFullName != null)
7394+ super.execNodeUseEnd(thirdKeyNodeFullName);
7395+ }
7396+ }
7397+ } catch (Exception e) {
7398+ if (exceptionFlg) throw retBe;
7399+ }
7400+ }
7401+
7402+ return ret;
7403+ }
7404+
7405+ /**
7406+ * List構造体の最後尾に値を追加する.<br>
7407+ *
7408+ * @param keyNodeName マスターデータノードの名前(IPなど)
7409+ * @param keyNodePort マスターデータノードのアクセスポート番号
7410+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7411+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7412+ * @param listName 送信データ
7413+ * @param listData 追加するData
7414+ * @return String[] 結果
7415+ * @throws BatchException
7416+ */
7417+ private String[] listRPush(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String listName, String listData, String transactionCode) throws BatchException {
7418+
7419+ KeyNodeConnector keyNodeConnector = null;
7420+
7421+ String nodeName = keyNodeName;
7422+ String nodePort = keyNodePort;
7423+ String nodeFullName = keyNodeFullName;
7424+
7425+ String[] retParams = null;
7426+ String[] mainRetParams = null;
7427+ String[] subRetParams = null;
7428+
7429+ int counter = 0;
7430+
7431+ String tmpSaveHost = null;
7432+ String[] tmpSaveData = null;
7433+ String retParam = null;
7434+
7435+ boolean mainNodeSave = false;
7436+ boolean mainNodeNetworkError = false;
7437+ boolean subNodeSave = false;
7438+ boolean subNodeNetworkError = false;
7439+
7440+ try {
7441+
7442+ // TransactionModeの状態に合わせてLock状態を確かめる
7443+ if (transactionMode) {
7444+ while (true) {
7445+
7446+ // TransactionMode時
7447+ // TransactionManagerに処理を依頼
7448+ String[] keyNodeLockRet = hasLockKeyNode(transactionManagerInfo[0], transactionManagerInfo[1], listName);
7449+
7450+ // 取得結果確認
7451+ if (keyNodeLockRet[1].equals("true")) {
7452+
7453+ if (keyNodeLockRet[2].equals(transactionCode)) break;
7454+ } else {
7455+ break;
7456+ }
7457+ }
7458+ }
7459+
7460+ // まずメインデータノードへデータ登録
7461+ // KeyNodeとの接続を確立
7462+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, false);
7463+
7464+ if (keyNodeConnector != null) {
7465+ try {
7466+
7467+ // Key値でデータノード名を保存
7468+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
7469+ String sendStr = null;
7470+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
7471+ buf.append("53"); // Type
7472+ buf.append(ImdstDefine.keyHelperClientParamSep);
7473+ buf.append(this.stringCnv(listName)); // List名
7474+ buf.append(ImdstDefine.keyHelperClientParamSep);
7475+ buf.append(this.stringCnv(listData)); // 追加Data値
7476+ buf.append(ImdstDefine.keyHelperClientParamSep);
7477+ buf.append(transactionCode); // Transaction値
7478+ sendStr = buf.toString();
7479+
7480+ // 送信
7481+ keyNodeConnector.println(sendStr);
7482+ keyNodeConnector.flush();
7483+
7484+ // 返却値取得
7485+ retParam = keyNodeConnector.readLine(sendStr);
7486+
7487+ // 使用済みの接続を戻す
7488+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7489+
7490+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
7491+ //retParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7492+ if (retParam.indexOf(ImdstDefine.keyNodeRPushSuccessStr) == 0) {
7493+
7494+ mainNodeSave = true;
7495+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7496+ } else {
7497+
7498+ mainNodeSave = false;
7499+ mainRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7500+ }
7501+ } catch (SocketException se) {
7502+ mainNodeNetworkError = true;
7503+ if (keyNodeConnector != null) {
7504+ keyNodeConnector.close();
7505+ keyNodeConnector = null;
7506+ }
7507+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 8, se);
7508+ logger.debug(se);
7509+ } catch (IOException ie) {
7510+ mainNodeNetworkError = true;
7511+ if (keyNodeConnector != null) {
7512+ keyNodeConnector.close();
7513+ keyNodeConnector = null;
7514+ }
7515+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 9, ie);
7516+ logger.debug(ie);
7517+ } catch (Exception ee) {
7518+ if (keyNodeConnector != null) {
7519+ keyNodeConnector.close();
7520+ keyNodeConnector = null;
7521+ }
7522+ super.setDeadNode(keyNodeName + ":" + keyNodePort, 10, ee);
7523+ logger.debug(ee);
7524+ }
7525+
7526+ } else {
7527+ mainNodeNetworkError = true;
7528+ }
7529+
7530+
7531+ if (subKeyNodeName != null) {
7532+ // Subノードで実施
7533+ if (mainNodeSave == true || (mainNodeSave == false && mainNodeNetworkError == true)) {
7534+ String subNodeExecType = "";
7535+
7536+ // Mainノードが処理成功もしくは、ネットワークエラーの場合はSubノードの処理を行う。
7537+ // KeyNodeとの接続を確立
7538+ keyNodeConnector = this.createKeyNodeConnection(subKeyNodeName, subKeyNodePort, subKeyNodeFullName, false);
7539+
7540+ if (keyNodeConnector != null) {
7541+ try {
7542+
7543+ // Key値でデータノード名を保存
7544+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
7545+ String sendStr = null;
7546+
7547+ // パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
7548+ buf.append("53"); // Type
7549+ buf.append(ImdstDefine.keyHelperClientParamSep);
7550+ buf.append(this.stringCnv(listName)); // List名
7551+ buf.append(ImdstDefine.keyHelperClientParamSep);
7552+ buf.append(this.stringCnv(listData)); // 追加Data値
7553+ buf.append(ImdstDefine.keyHelperClientParamSep);
7554+ buf.append(transactionCode); // Transaction値
7555+ buf.append(ImdstDefine.keyHelperClientParamSep);
7556+ buf.append("1"); // 強制登録を表す
7557+ sendStr = buf.toString();
7558+
7559+ // 送信
7560+ keyNodeConnector.println(sendStr);
7561+ keyNodeConnector.flush();
7562+
7563+ // 返却値取得
7564+ retParam = keyNodeConnector.readLine(sendStr);
7565+
7566+ // 使用済みの接続を戻す
7567+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7568+
7569+
7570+ // splitは遅いので特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
7571+ if (retParam.indexOf(ImdstDefine.keyNodeRPushSuccessStr) == 0) {
7572+
7573+ subNodeSave = true;
7574+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7575+ } else {
7576+
7577+ subNodeSave = false;
7578+ subRetParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
7579+ }
7580+ } catch (SocketException se) {
7581+ subNodeNetworkError = true;
7582+ if (keyNodeConnector != null) {
7583+ keyNodeConnector.close();
7584+ keyNodeConnector = null;
7585+ }
7586+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 11, se);
7587+ logger.debug(se);
7588+ } catch (IOException ie) {
7589+ subNodeNetworkError = true;
7590+ if (keyNodeConnector != null) {
7591+ keyNodeConnector.close();
7592+ keyNodeConnector = null;
7593+ }
7594+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 12, ie);
7595+ logger.debug(ie);
7596+ } catch (Exception ee) {
7597+ if (keyNodeConnector != null) {
7598+ keyNodeConnector.close();
7599+ keyNodeConnector = null;
7600+ }
7601+ super.setDeadNode(subKeyNodeName + ":" + subKeyNodePort, 13, ee);
7602+ logger.debug(ee);
7603+ }
7604+
7605+ } else {
7606+ subNodeNetworkError = true;
7607+ }
7608+ }
7609+ }
7610+
7611+ // Main、Sub両方ともネットワークでのエラーがであるか確認
7612+ if (mainNodeNetworkError == true && subNodeNetworkError == true) {
7613+ // ネットワークエラー
7614+ throw new BatchException("Key Node IO Error: detail info for log file");
7615+ }
7616+
7617+ // ノードへの保存状況を確認
7618+ if (mainNodeSave == false) {
7619+
7620+ // MainNode保存失敗
7621+ if (mainNodeNetworkError == false) {
7622+
7623+ // 既に書き込み済みでの失敗
7624+ retParams = mainRetParams;
7625+ }
7626+ } else {
7627+
7628+ // MainNode保存成功
7629+ retParams = mainRetParams;
7630+ }
7631+
7632+
7633+ if (subKeyNodeName != null) {
7634+ // スレーブノードが存在する場合のみ
7635+ // MainNodeが既にデータ有りで失敗せずに、成功もしていない
7636+ if (retParams == null) {
7637+
7638+ if (subNodeSave == false) {
7639+
7640+ // SubNode保存失敗
7641+ if (subNodeNetworkError == false) {
7642+
7643+ // 既に書き込み済みでの失敗
7644+ retParams = subRetParams;
7645+ }
7646+ } else {
7647+
7648+ // SubNode保存成功
7649+ retParams = subRetParams;
7650+ }
7651+ }
7652+ }
7653+ } catch (BatchException be) {
7654+ if (keyNodeConnector != null) {
7655+ keyNodeConnector.close();
7656+ keyNodeConnector = null;
7657+ }
7658+ throw be;
7659+ } catch (Exception e) {
7660+ if (keyNodeConnector != null) {
7661+ keyNodeConnector.close();
7662+ keyNodeConnector = null;
7663+ }
7664+ throw new BatchException(e);
7665+ } finally {
7666+ // ノードの使用終了をマーク
7667+ super.execNodeUseEnd(keyNodeFullName);
7668+
7669+ if (subKeyNodeName != null)
7670+ super.execNodeUseEnd(subKeyNodeFullName);
7671+ }
7672+
7673+ return retParams;
7674+ }
7675+
7676+
7677+ /**
7678+ * KeyNodeのList構造体から指定Indexの値を取得する.<br>
7679+ *
7680+ * @param keyNodeName マスターデータノードの名前(IPなど)
7681+ * @param keyNodePort マスターデータノードのアクセスポート番号
7682+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7683+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7684+ * @param listNameStr List名文字列
7685+ * @param listGetIndex 位置指定のIndex
7686+ * @return String[] 結果
7687+ * @throws BatchException
7688+ */
7689+ private String[] listIndex(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String thirdKeyNodeName, String thirdKeyNodePort, String thirdKeyNodeFullName, String listNameStr, String listGetIndex, String transactionCode) throws BatchException {
7690+ boolean exceptionFlg = false;
7691+ String[] ret = null;
7692+ String[] thirdRet = null;
7693+ BatchException retBe = null;
7694+
7695+ try {
7696+
7697+ ret = this.listIndex(keyNodeName, keyNodePort, keyNodeFullName, subKeyNodeName, subKeyNodePort, subKeyNodeFullName, listNameStr, listGetIndex, transactionCode);
7698+ } catch (BatchException be) {
7699+
7700+ retBe = be;
7701+ exceptionFlg = true;
7702+ } catch (Exception e) {
7703+
7704+ retBe = new BatchException(e);
7705+ exceptionFlg = true;
7706+ } finally {
7707+
7708+ try {
7709+ if (exceptionFlg) {
7710+ thirdRet = this.listIndex(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listNameStr, listGetIndex, transactionCode);
7711+ ret = thirdRet;
7712+ } else {
7713+ // サードノードの使用終了のみマーク
7714+ if (thirdKeyNodeFullName != null)
7715+ super.execNodeUseEnd(thirdKeyNodeFullName);
7716+ }
7717+ } catch (Exception e) {
7718+ if (exceptionFlg) throw retBe;
7719+ }
7720+ }
7721+
7722+ return ret;
7723+ }
7724+
7725+
7726+ /**
7727+ * KeyNodeからデータを取得する.<br>
7728+ *
7729+ * @param keyNodeName マスターデータノードの名前(IPなど)
7730+ * @param keyNodePort マスターデータノードのアクセスポート番号
7731+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
7732+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
7733+ * @param listNameStr List名文字列
7734+ * @param listGetIndex 位置指定のIndex
7735+ * @return String[] 結果
7736+ * @throws BatchException
7737+ */
7738+ private String[] listIndex(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String listNameStr, String listGetIndex, String transactionCode) throws BatchException {
7739+ KeyNodeConnector keyNodeConnector = null;
7740+
7741+ String[] retParams = null;
7742+ String[] cnvConsistencyRet = null;
7743+
7744+ boolean slaveUse = false;
7745+ boolean mainRetry = false;
7746+
7747+ String nowUseNodeInfo = null;
7748+
7749+
7750+ SocketException se = null;
7751+ IOException ie = null;
7752+ try {
7753+
7754+ // KeyNodeとの接続を確立
7755+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, false);
7756+
7757+ while (true) {
7758+
7759+ // 戻り値がnullの場合は何だかの理由で接続に失敗しているのでスレーブの設定がある場合は接続する
7760+ // スレーブの設定がない場合は、エラーとしてExceptionをthrowする
7761+ if (keyNodeConnector == null) {
7762+ if (subKeyNodeName != null) keyNodeConnector = this.createKeyNodeConnection(subKeyNodeName, subKeyNodePort, subKeyNodeFullName, false);
7763+
7764+ if (keyNodeConnector == null) throw new BatchException("Key Node IO Error: detail info for log file");
7765+ slaveUse = true;
7766+ }
7767+
7768+
7769+ try {
7770+ // Key値でValueを取得
7771+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
7772+ String sendStr = null;
7773+ // パラメータ作成
7774+ buf.append("54");
7775+ buf.append(ImdstDefine.keyHelperClientParamSep);
7776+ buf.append(this.stringCnv(listNameStr));
7777+ buf.append(ImdstDefine.keyHelperClientParamSep);
7778+ buf.append(listGetIndex);
7779+ buf.append(ImdstDefine.keyHelperClientParamSep);
7780+ buf.append(transactionCode);
7781+ sendStr = buf.toString();
7782+
7783+ // 送信
7784+ keyNodeConnector.println(buf.toString());
7785+ keyNodeConnector.flush();
7786+
7787+ // 返却値取得
7788+ String retParam = keyNodeConnector.readLine(sendStr);
7789+ // 返却値を分解
7790+ // value値にセパレータが入っていても無視する
7791+ retParams = retParam.split(ImdstDefine.keyHelperClientParamSep, 3);
7792+ // 使用済みの接続を戻す
7793+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7794+
7795+ if (retParams != null && retParams.length > 1 && retParams[1].equals("true")) {
7796+
7797+ // 一貫性データが付随した状態から通常データに変換する
7798+ // 弱一貫性の場合は時間は使用しない
7799+ cnvConsistencyRet = dataConvert4Consistency(retParams[2]);
7800+ retParams[2] = cnvConsistencyRet[0];
7801+ break;
7802+ } else if (retParams != null && retParams.length > 1 && retParams[1].equals("false")) {
7803+ // 結果なし 結果部分が返ってこない
7804+ if (retParams.length < 3) {
7805+ String[] tmpRetParams = new String[3];
7806+ tmpRetParams[0] = retParams[0];
7807+ tmpRetParams[1] = retParams[1];
7808+ tmpRetParams[2] = "";
7809+ retParams = tmpRetParams;
7810+ }
7811+ break;
7812+ } else if (retParams != null && retParams.length > 1 && retParams[1].equals("error")) {
7813+ break;
7814+ }
7815+ } catch(SocketException tSe) {
7816+ // ここでのエラーは通信中に発生しているので、スレーブノードを使用していない場合のみ再度スレーブへの接続を試みる
7817+ se = tSe;
7818+ if (keyNodeConnector != null) {
7819+ keyNodeConnector.close();
7820+ keyNodeConnector = null;
7821+ }
7822+ } catch(IOException tIe) {
7823+ // ここでのエラーは通信中に発生しているので、スレーブノードを使用していない場合のみ再度スレーブへの接続を試みる
7824+ ie = tIe;
7825+ if (keyNodeConnector != null) {
7826+ keyNodeConnector.close();
7827+ keyNodeConnector = null;
7828+ }
7829+ }
7830+
7831+ // 既にスレーブの接続を使用している場合は、もう一度だけメインノードに接続を試みる
7832+ // それで駄目な場合はエラーとする
7833+ if (slaveUse) {
7834+ if (mainRetry) {
7835+ if (se != null) throw se;
7836+ if (ie != null) throw ie;
7837+ throw new BatchException("Key Node IO Error: detail info for log file");
7838+ } else {
7839+
7840+ // メインKeyNodeとの接続を確立
7841+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, true);
7842+ if (keyNodeConnector == null) throw new BatchException("Key Node IO Error: detail info for log file");
7843+ mainRetry = true;
7844+ }
7845+ } else {
7846+ if (subKeyNodeName == null) {
7847+ if (se != null) throw se;
7848+ if (ie != null) throw ie;
7849+ } else{
7850+ keyNodeConnector = null;
7851+ }
7852+ }
7853+ }
7854+ } catch (Exception e) {
7855+ if (keyNodeConnector != null) {
7856+ keyNodeConnector.close();
7857+ keyNodeConnector = null;
7858+ }
7859+ throw new BatchException(e);
7860+ } finally {
7861+ // ノードの使用終了をマーク
7862+ super.execNodeUseEnd(keyNodeFullName);
7863+
7864+ if (subKeyNodeName != null)
7865+ super.execNodeUseEnd(subKeyNodeFullName);
7866+ }
7867+ return retParams;
7868+ }
7869+
7870+
7871+ /**
7872+ * KeyNodeにList構造体のLPOPを実行する.<br>
7873+ * 結果を返却する.<br>
7874+ *
7875+ * @param keyNodeName ノードフルネームの名前(IPなど)
7876+ * @param keyNodePort ノードフルネームのアクセスポート番号
7877+ * @param keyNodeFullName ノードフルネーム
7878+ * @param listNameStr List名
7879+ * @param transactionCode トランザクションコード
7880+ * @return String[] 結果
7881+ * @throws BatchException
7882+ */
7883+ private String[] listLPop(String keyNodeName, String keyNodePort, String keyNodeFullName, String listNameStr, String transactionCode) throws BatchException {
7884+ KeyNodeConnector keyNodeConnector = null;
7885+
7886+ String nodeName = keyNodeName;
7887+ String nodePort = keyNodePort;
7888+ String nodeFullName = keyNodeFullName;
7889+
7890+ String[] retParams = null;
7891+
7892+ int counter = 0;
7893+
7894+ String tmpSaveHost = null;
7895+ String[] tmpSaveData = null;
7896+ String retParam = null;
7897+
7898+ boolean mainNodeSave = false;
7899+
7900+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferSmallSize);
7901+ String sendStr = null;
7902+
7903+ try {
7904+
7905+ // TransactionModeの状態に合わせてLock状態を確かめる
7906+ if (transactionMode) {
7907+ while (true) {
7908+
7909+ // TransactionMode時
7910+ // TransactionManagerに処理を依頼
7911+ String[] keyNodeLockRet = hasLockKeyNode(transactionManagerInfo[0], transactionManagerInfo[1], listNameStr);
7912+
7913+ // 取得結果確認
7914+ if (keyNodeLockRet[1].equals("true")) {
7915+
7916+ if (keyNodeLockRet[2].equals(transactionCode)) break;
7917+ } else {
7918+ break;
7919+ }
7920+ }
7921+ }
7922+
7923+ // 送信パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
7924+ buf.append("55");
7925+ buf.append(ImdstDefine.keyHelperClientParamSep);
7926+ buf.append(this.stringCnv(listNameStr)); // List名
7927+ buf.append(ImdstDefine.keyHelperClientParamSep);
7928+ buf.append(transactionCode); // Transaction値
7929+
7930+ sendStr = buf.toString();
7931+
7932+ // KeyNodeとの接続を確立
7933+ keyNodeConnector = this.createKeyNodeConnection(nodeName, nodePort, nodeFullName, false);
7934+
7935+ // DataNodeに送信
7936+ if (keyNodeConnector != null) {
7937+ // 接続結果と、現在の保存先状況で処理を分岐
7938+ try {
7939+
7940+ // 送信
7941+ // LPOPはReadTimeoutになってもすぐに再送すると2回取り出してしまうので、
7942+ // ReadTimeout時間を長く設定する。
7943+ // 特にRecover時の挙動に合わせて長く設定している。
7944+ keyNodeConnector.setSoTimeout(ImdstDefine.nodeConnectionTimeout4RecoverMode);
7945+ keyNodeConnector.println(sendStr);
7946+ keyNodeConnector.flush();
7947+
7948+ // 返却値取得
7949+ retParam = keyNodeConnector.readLine(sendStr);
7950+ keyNodeConnector.setSoTimeout(ImdstDefine.nodeConnectionTimeout);
7951+
7952+ // Key値でValueを保存
7953+ // 特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
7954+ if (retParam != null && retParam.indexOf(ImdstDefine.keyNodeLPopSuccessStr) == 0) {
7955+
7956+ // 結果有りで成功
7957+ mainNodeSave = true;
7958+ } else if (retParam != null && retParam.indexOf(ImdstDefine.keyNodeLPopNullStr) == 0) {
7959+ // 結果なし
7960+ mainNodeSave = true;
7961+ } else {
7962+ // 論理的に登録失敗
7963+ logger.error("LPOP Error Node =[" + nodeName + ":" + nodePort + "] retParam=[" + retParam + "]" + " Connectoer=[" + keyNodeConnector.connectorDump() + "]");
7964+ }
7965+
7966+ // 使用済みの接続を戻す
7967+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
7968+
7969+ } catch (SocketException se) {
7970+
7971+ //se.printStackTrace();
7972+ if (keyNodeConnector != null) {
7973+ keyNodeConnector.close();
7974+ keyNodeConnector = null;
7975+ }
7976+ super.setDeadNode(nodeName + ":" + nodePort, 5, se);
7977+ logger.debug(se);
7978+ } catch (IOException ie) {
7979+
7980+ //ie.printStackTrace();
7981+ if (keyNodeConnector != null) {
7982+ keyNodeConnector.close();
7983+ keyNodeConnector = null;
7984+ }
7985+ super.setDeadNode(nodeName + ":" + nodePort, 6, ie);
7986+ logger.debug(ie);
7987+ } catch (Exception ee) {
7988+
7989+ //ee.printStackTrace();
7990+ if (keyNodeConnector != null) {
7991+ keyNodeConnector.close();
7992+ keyNodeConnector = null;
7993+ }
7994+ super.setDeadNode(nodeName + ":" + nodePort, 7, ee);
7995+ logger.debug(ee);
7996+ }
7997+
7998+ }
7999+
8000+ // ノードへの保存状況を確認
8001+ if (mainNodeSave == false) {
8002+ retParam = null;
8003+ }
8004+
8005+ } catch (Exception e) {
8006+
8007+ if (keyNodeConnector != null) {
8008+ keyNodeConnector.close();
8009+ keyNodeConnector = null;
8010+ }
8011+ retParam = null;
8012+ } finally {
8013+
8014+ // ノードの使用終了をマーク
8015+ super.execNodeUseEnd(keyNodeFullName);
8016+
8017+ // 返却地値をパースする
8018+ if (retParam != null) {
8019+ retParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
8020+ }
8021+ }
8022+
8023+ return retParams;
8024+ }
8025+
8026+
8027+ /**
8028+ * KeyNodeにList構造体のRPOPを実行する.<br>
8029+ * 結果を返却する.<br>
8030+ *
8031+ * @param keyNodeName ノードフルネームの名前(IPなど)
8032+ * @param keyNodePort ノードフルネームのアクセスポート番号
8033+ * @param keyNodeFullName ノードフルネーム
8034+ * @param listNameStr List名
8035+ * @param transactionCode トランザクションコード
8036+ * @return String[] 結果
8037+ * @throws BatchException
8038+ */
8039+ private String[] listRPop(String keyNodeName, String keyNodePort, String keyNodeFullName, String listNameStr, String transactionCode) throws BatchException {
8040+ KeyNodeConnector keyNodeConnector = null;
8041+
8042+ String nodeName = keyNodeName;
8043+ String nodePort = keyNodePort;
8044+ String nodeFullName = keyNodeFullName;
8045+
8046+ String[] retParams = null;
8047+
8048+ int counter = 0;
8049+
8050+ String tmpSaveHost = null;
8051+ String[] tmpSaveData = null;
8052+ String retParam = null;
8053+
8054+ boolean mainNodeSave = false;
8055+
8056+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferSmallSize);
8057+ String sendStr = null;
8058+
8059+ try {
8060+
8061+ // TransactionModeの状態に合わせてLock状態を確かめる
8062+ if (transactionMode) {
8063+ while (true) {
8064+
8065+ // TransactionMode時
8066+ // TransactionManagerに処理を依頼
8067+ String[] keyNodeLockRet = hasLockKeyNode(transactionManagerInfo[0], transactionManagerInfo[1], listNameStr);
8068+
8069+ // 取得結果確認
8070+ if (keyNodeLockRet[1].equals("true")) {
8071+
8072+ if (keyNodeLockRet[2].equals(transactionCode)) break;
8073+ } else {
8074+ break;
8075+ }
8076+ }
8077+ }
8078+
8079+ // 送信パラメータ作成 キー値のハッシュ値文字列[セパレータ]データノード名
8080+ buf.append("56");
8081+ buf.append(ImdstDefine.keyHelperClientParamSep);
8082+ buf.append(this.stringCnv(listNameStr)); // List名
8083+ buf.append(ImdstDefine.keyHelperClientParamSep);
8084+ buf.append(transactionCode); // Transaction値
8085+
8086+ sendStr = buf.toString();
8087+
8088+ // KeyNodeとの接続を確立
8089+ keyNodeConnector = this.createKeyNodeConnection(nodeName, nodePort, nodeFullName, false);
8090+
8091+ // DataNodeに送信
8092+ if (keyNodeConnector != null) {
8093+ // 接続結果と、現在の保存先状況で処理を分岐
8094+ try {
8095+
8096+ // 送信
8097+ // LPOPはReadTimeoutになってもすぐに再送すると2回取り出してしまうので、
8098+ // ReadTimeout時間を長く設定する。
8099+ // 特にRecover時の挙動に合わせて長く設定している。
8100+ keyNodeConnector.setSoTimeout(ImdstDefine.nodeConnectionTimeout4RecoverMode);
8101+ keyNodeConnector.println(sendStr);
8102+ keyNodeConnector.flush();
8103+
8104+ // 返却値取得
8105+ retParam = keyNodeConnector.readLine(sendStr);
8106+ keyNodeConnector.setSoTimeout(ImdstDefine.nodeConnectionTimeout);
8107+
8108+ // Key値でValueを保存
8109+ // 特定文字列で返却値が始まるかをチェックし始まる場合は登録成功
8110+ if (retParam != null && retParam.indexOf(ImdstDefine.keyNodeLPopSuccessStr) == 0) {
8111+
8112+ // 結果有りで成功
8113+ mainNodeSave = true;
8114+ } else if (retParam != null && retParam.indexOf(ImdstDefine.keyNodeLPopNullStr) == 0) {
8115+ // 結果なし
8116+ mainNodeSave = true;
8117+ } else {
8118+ // 論理的に登録失敗
8119+ logger.error("RPOP Error Node =[" + nodeName + ":" + nodePort + "] retParam=[" + retParam + "]" + " Connectoer=[" + keyNodeConnector.connectorDump() + "]");
8120+ }
8121+
8122+ // 使用済みの接続を戻す
8123+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
8124+
8125+ } catch (SocketException se) {
8126+
8127+ //se.printStackTrace();
8128+ if (keyNodeConnector != null) {
8129+ keyNodeConnector.close();
8130+ keyNodeConnector = null;
8131+ }
8132+ super.setDeadNode(nodeName + ":" + nodePort, 5, se);
8133+ logger.debug(se);
8134+ } catch (IOException ie) {
8135+
8136+ //ie.printStackTrace();
8137+ if (keyNodeConnector != null) {
8138+ keyNodeConnector.close();
8139+ keyNodeConnector = null;
8140+ }
8141+ super.setDeadNode(nodeName + ":" + nodePort, 6, ie);
8142+ logger.debug(ie);
8143+ } catch (Exception ee) {
8144+
8145+ //ee.printStackTrace();
8146+ if (keyNodeConnector != null) {
8147+ keyNodeConnector.close();
8148+ keyNodeConnector = null;
8149+ }
8150+ super.setDeadNode(nodeName + ":" + nodePort, 7, ee);
8151+ logger.debug(ee);
8152+ }
8153+
8154+ }
8155+
8156+ // ノードへの保存状況を確認
8157+ if (mainNodeSave == false) {
8158+ retParam = null;
8159+ }
8160+
8161+ } catch (Exception e) {
8162+
8163+ if (keyNodeConnector != null) {
8164+ keyNodeConnector.close();
8165+ keyNodeConnector = null;
8166+ }
8167+ retParam = null;
8168+ } finally {
8169+
8170+ // ノードの使用終了をマーク
8171+ super.execNodeUseEnd(keyNodeFullName);
8172+
8173+ // 返却地値をパースする
8174+ if (retParam != null) {
8175+ retParams = retParam.split(ImdstDefine.keyHelperClientParamSep);
8176+ }
8177+ }
8178+
8179+ return retParams;
8180+ }
8181+
8182+
8183+ /**
8184+ * KeyNodeのList構造体のサイズを取得する.<br>
8185+ *
8186+ * @param keyNodeName マスターデータノードの名前(IPなど)
8187+ * @param keyNodePort マスターデータノードのアクセスポート番号
8188+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
8189+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
8190+ * @param listNameStr List名文字列
8191+ * @return String[] 結果
8192+ * @throws BatchException
8193+ */
8194+ private String[] listLen(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String thirdKeyNodeName, String thirdKeyNodePort, String thirdKeyNodeFullName, String listNameStr, String transactionCode) throws BatchException {
8195+ boolean exceptionFlg = false;
8196+ String[] ret = null;
8197+ String[] thirdRet = null;
8198+ BatchException retBe = null;
8199+
8200+ try {
8201+
8202+ ret = this.listLen(keyNodeName, keyNodePort, keyNodeFullName, subKeyNodeName, subKeyNodePort, subKeyNodeFullName, listNameStr, transactionCode);
8203+ } catch (BatchException be) {
8204+
8205+ retBe = be;
8206+ exceptionFlg = true;
8207+ } catch (Exception e) {
8208+
8209+ retBe = new BatchException(e);
8210+ exceptionFlg = true;
8211+ } finally {
8212+
8213+ try {
8214+ if (exceptionFlg) {
8215+ thirdRet = this.listLen(thirdKeyNodeName, thirdKeyNodePort, thirdKeyNodeFullName, null, null, null, listNameStr, transactionCode);
8216+ ret = thirdRet;
8217+ } else {
8218+ // サードノードの使用終了のみマーク
8219+ if (thirdKeyNodeFullName != null)
8220+ super.execNodeUseEnd(thirdKeyNodeFullName);
8221+ }
8222+ } catch (Exception e) {
8223+ if (exceptionFlg) throw retBe;
8224+ }
8225+ }
8226+
8227+ return ret;
8228+ }
8229+
8230+
8231+ /**
8232+ * KeyNodeのList構造体のサイズを取得する.<br>
8233+ *
8234+ * @param keyNodeName マスターデータノードの名前(IPなど)
8235+ * @param keyNodePort マスターデータノードのアクセスポート番号
8236+ * @param subKeyNodeName スレーブデータノードの名前(IPなど)
8237+ * @param subKeyNodePort スレーブデータノードのアクセスポート番号
8238+ * @param listNameStr List名文字列
8239+ * @return String[] 結果
8240+ * @throws BatchException
8241+ */
8242+ private String[] listLen(String keyNodeName, String keyNodePort, String keyNodeFullName, String subKeyNodeName, String subKeyNodePort, String subKeyNodeFullName, String listNameStr, String transactionCode) throws BatchException {
8243+ KeyNodeConnector keyNodeConnector = null;
8244+
8245+ String[] retParams = null;
8246+ String[] cnvConsistencyRet = null;
8247+
8248+ boolean slaveUse = false;
8249+ boolean mainRetry = false;
8250+
8251+ String nowUseNodeInfo = null;
8252+
8253+
8254+ SocketException se = null;
8255+ IOException ie = null;
8256+ try {
8257+
8258+ // KeyNodeとの接続を確立
8259+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, false);
8260+
8261+ while (true) {
8262+
8263+ // 戻り値がnullの場合は何だかの理由で接続に失敗しているのでスレーブの設定がある場合は接続する
8264+ // スレーブの設定がない場合は、エラーとしてExceptionをthrowする
8265+ if (keyNodeConnector == null) {
8266+ if (subKeyNodeName != null) keyNodeConnector = this.createKeyNodeConnection(subKeyNodeName, subKeyNodePort, subKeyNodeFullName, false);
8267+
8268+ if (keyNodeConnector == null) throw new BatchException("Key Node IO Error: detail info for log file");
8269+ slaveUse = true;
8270+ }
8271+
8272+
8273+ try {
8274+ // Key値でValueを取得
8275+ StringBuilder buf = new StringBuilder(ImdstDefine.stringBufferMiddleSize);
8276+ String sendStr = null;
8277+ // パラメータ作成
8278+ buf.append("57");
8279+ buf.append(ImdstDefine.keyHelperClientParamSep);
8280+ buf.append(this.stringCnv(listNameStr));
8281+ buf.append(ImdstDefine.keyHelperClientParamSep);
8282+ buf.append(transactionCode);
8283+ sendStr = buf.toString();
8284+
8285+ // 送信
8286+ keyNodeConnector.println(buf.toString());
8287+ keyNodeConnector.flush();
8288+
8289+ // 返却値取得
8290+ String retParam = keyNodeConnector.readLine(sendStr);
8291+
8292+ // 返却値を分解
8293+ // value値にセパレータが入っていても無視する
8294+ retParams = retParam.split(ImdstDefine.keyHelperClientParamSep, 3);
8295+
8296+ // 使用済みの接続を戻す
8297+ super.addKeyNodeCacheConnectionPool(keyNodeConnector);
8298+
8299+ if (retParams != null && retParams.length > 1 && retParams[1].equals("true")) {
8300+
8301+ // 一貫性データが付随した状態から通常データに変換する
8302+ // 弱一貫性の場合は時間は使用しない
8303+ cnvConsistencyRet = dataConvert4Consistency(retParams[2]);
8304+ retParams[2] = cnvConsistencyRet[0];
8305+ break;
8306+ } else if (retParams != null && retParams.length > 1 && retParams[1].equals("false")) {
8307+ retParams[2] = "";
8308+ break;
8309+ } else if (retParams != null && retParams.length > 1 && retParams[1].equals("error")) {
8310+ break;
8311+ }
8312+ } catch(SocketException tSe) {
8313+ // ここでのエラーは通信中に発生しているので、スレーブノードを使用していない場合のみ再度スレーブへの接続を試みる
8314+ se = tSe;
8315+ if (keyNodeConnector != null) {
8316+ keyNodeConnector.close();
8317+ keyNodeConnector = null;
8318+ }
8319+ } catch(IOException tIe) {
8320+ // ここでのエラーは通信中に発生しているので、スレーブノードを使用していない場合のみ再度スレーブへの接続を試みる
8321+ ie = tIe;
8322+ if (keyNodeConnector != null) {
8323+ keyNodeConnector.close();
8324+ keyNodeConnector = null;
8325+ }
8326+ }
8327+
8328+ // 既にスレーブの接続を使用している場合は、もう一度だけメインノードに接続を試みる
8329+ // それで駄目な場合はエラーとする
8330+ if (slaveUse) {
8331+ if (mainRetry) {
8332+ if (se != null) throw se;
8333+ if (ie != null) throw ie;
8334+ throw new BatchException("Key Node IO Error: detail info for log file");
8335+ } else {
8336+
8337+ // メインKeyNodeとの接続を確立
8338+ keyNodeConnector = this.createKeyNodeConnection(keyNodeName, keyNodePort, keyNodeFullName, true);
8339+ if (keyNodeConnector == null) throw new BatchException("Key Node IO Error: detail info for log file");
8340+ mainRetry = true;
8341+ }
8342+ } else {
8343+ if (subKeyNodeName == null) {
8344+ if (se != null) throw se;
8345+ if (ie != null) throw ie;
8346+ } else{
8347+ keyNodeConnector = null;
8348+ }
8349+ }
8350+ }
8351+ } catch (Exception e) {
8352+ if (keyNodeConnector != null) {
8353+ keyNodeConnector.close();
8354+ keyNodeConnector = null;
8355+ }
8356+ throw new BatchException(e);
8357+ } finally {
8358+ // ノードの使用終了をマーク
8359+ super.execNodeUseEnd(keyNodeFullName);
8360+
8361+ if (subKeyNodeName != null)
8362+ super.execNodeUseEnd(subKeyNodeFullName);
8363+ }
8364+ return retParams;
8365+ }
8366+
8367+
8368+ /**
59278369 * KeyNodeに対してデータを保存する.<br>
59288370 * 同時に排他制御を行う(cas相当).<br>
59298371 *
--- trunk/src/okuyama/imdst/util/KeyMapManager.java (revision 1027)
+++ trunk/src/okuyama/imdst/util/KeyMapManager.java (revision 1028)
@@ -160,6 +160,9 @@
160160 // リスト構造体の現在の最大Pointerの表す値を取得する場合のList名に付加する値
161161 private static String listStructPointerPrefix = new String(BASE64EncoderStream.encode(ImdstDefine.imdstListStructPointerPrefixStr.getBytes()));
162162
163+ // リスト構造体の現在のサイズの表す値を取得する場合のList名に付加する値
164+ private static String listStructSizePrefix = new String(BASE64EncoderStream.encode(ImdstDefine.imdstListStructSizePrefixStr.getBytes()));
165+
163166 // リスト構造体のList内の値を格納するKeyのPrefix
164167 private static String listStructDataKeyPrefix = new String(BASE64EncoderStream.encode(ImdstDefine.imdstListDataPrefixStr.getBytes()));
165168
@@ -1090,12 +1093,13 @@
10901093 * 既に作成済みの場合は失敗となる<br>
10911094 *
10921095 * @param listName List名
1096+ * @param compulsiveFlg 強制作成フラグ
10931097 * @param transactionCode
1094- * @return 成否
1098+ * @return 処理ステータス 0=成功 1=失敗 2=既に存在する
10951099 * @throw BatchException
10961100 */
1097- public boolean createListStruct(String listName, String transactionCode) throws BatchException {
1098- boolean ret = false;
1101+ public int createListStruct(String listName, boolean compulsiveFlg, String transactionCode) throws BatchException {
1102+ int ret = 1;
10991103 if (!blocking) {
11001104 try {
11011105 // このsynchroの方法は正しくないきがするが。。。
@@ -1102,12 +1106,15 @@
11021106 synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
11031107
11041108 String pointerKey = listStructPointerPrefix + listName;
1109+ String sizeKey = listStructSizePrefix + listName;
11051110 String key = listStructStartPrefix + listName;
11061111 String[] keyList = new String[2];
11071112 keyList[0] = key;
11081113 keyList[1] = listStructEndPrefix + listName;;
11091114
1110- if(this.containsKeyPair(pointerKey)) {
1115+ if(compulsiveFlg == false && this.containsKeyPair(pointerKey)) {
1116+ // 既に作成済み
1117+ ret = 2;
11111118 return ret;
11121119 }
11131120
@@ -1121,6 +1128,9 @@
11211128
11221129 if (this.moveAdjustmentDataMap != null && this.moveAdjustmentDataMap.containsKey(pointerKey))
11231130 this.moveAdjustmentDataMap.remove(pointerKey);
1131+
1132+ if (this.moveAdjustmentDataMap != null && this.moveAdjustmentDataMap.containsKey(sizeKey))
1133+ this.moveAdjustmentDataMap.remove(sizeKey);
11241134 }
11251135 }
11261136
@@ -1154,7 +1164,7 @@
11541164 }
11551165 }
11561166
1157- // 最後に最終位置のポインター情報を格納
1167+ // 最終位置のポインター情報を格納
11581168 data = "0" + ImdstDefine.setTimeParamSep + "0";
11591169
11601170 keyMapObjPut(pointerKey, data);
@@ -1182,7 +1192,36 @@
11821192 }
11831193 }
11841194
1185- ret = true;
1195+
1196+ // リストサイズ情報を格納
1197+ data = "0" + ImdstDefine.setTimeParamSep + "0";
1198+
1199+ keyMapObjPut(sizeKey, data);
1200+
1201+ // データ操作履歴ファイルに追記
1202+ if (this.workFileMemory == false) {
1203+ synchronized(this.lockWorkFileSync) {
1204+ if (this.workFileFlushTiming) {
1205+
1206+ this.bw.write(new StringBuilder(ImdstDefine.stringBufferSmall_2Size).append("+").append(KeyMapManager.workFileSeq).append(sizeKey).append(KeyMapManager.workFileSeq).append(data).append(KeyMapManager.workFileSeq).append(JavaSystemApi.currentTimeMillis).append(KeyMapManager.workFileSeq).append(KeyMapManager.workFileEndPoint).append("\n").toString());
1207+ SystemUtil.diskAccessSync(this.bw);
1208+ this.checkTransactionLogWriterLimit(this.tLogWriteCount.incrementAndGet());
1209+ } else {
1210+
1211+ this.dataTransactionFileFlushDaemon.addDataTransaction(new StringBuilder(ImdstDefine.stringBufferSmall_2Size).append("+").append(KeyMapManager.workFileSeq).append(sizeKey).append(KeyMapManager.workFileSeq).append(data).append(KeyMapManager.workFileSeq).append(JavaSystemApi.currentTimeMillis).append(KeyMapManager.workFileSeq).append(KeyMapManager.workFileEndPoint).append("\n").toString());
1212+ }
1213+ }
1214+ }
1215+
1216+ if (this.diffDataPoolingFlg) {
1217+ synchronized (diffSync) {
1218+ if (this.diffDataPoolingFlg) {
1219+ this.diffDataPoolingListForFileBase.add("+" + KeyMapManager.workFileSeq + sizeKey + KeyMapManager.workFileSeq + data);
1220+ }
1221+ }
1222+ }
1223+
1224+ ret = 0;
11861225 }
11871226 // データの書き込みを指示
11881227 this.writeMapFileFlg = true;
@@ -1218,6 +1257,8 @@
12181257 // このsynchroの方法は正しくないきがするが。。。
12191258 synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
12201259 String pointerKey = listStructPointerPrefix + listName;
1260+ String sizeKey = listStructSizePrefix + listName;
1261+
12211262 String key = listStructStartPrefix + listName;
12221263 String[] keyList = new String[3];
12231264 boolean allDataDeleted = false;
@@ -1341,6 +1382,19 @@
13411382 saveDataList.add(saveDataTmp);
13421383 }
13431384
1385+ // Listサイズをインクリメント
1386+ String nowSizeRet = keyMapObjGet(sizeKey);
1387+ if (nowSizeRet == null) throw new BatchException("List size not found error");
1388+ String[] nowSizeRetSplit = nowSizeRet.split(ImdstDefine.setTimeParamSep);
1389+ long listSizeLong = new Long(nowSizeRetSplit[0]).longValue();
1390+ listSizeLong++;
1391+ String nextSize = listSizeLong + ImdstDefine.setTimeParamSep + "0";
1392+ keyMapObjPut(sizeKey, nextSize);
1393+ String[] saveSizeDataTmp = new String[]{sizeKey, nextSize};
1394+ saveDataList.add(saveSizeDataTmp);
1395+
1396+
1397+ // 以降操作記録ログへの書き込み処理
13441398 for (int idx = 0; idx < saveDataList.size(); idx++) {
13451399
13461400 String[] saveData = (String[])saveDataList.get(idx);
@@ -1412,6 +1466,7 @@
14121466 // このsynchroの方法は正しくないきがするが。。。
14131467 synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
14141468 String pointerKey = listStructPointerPrefix + listName;
1469+ String sizeKey = listStructSizePrefix + listName;
14151470 String key = listStructStartPrefix + listName;
14161471 String[] keyList = new String[3];
14171472 boolean allDataDeleted = false;
@@ -1533,6 +1588,20 @@
15331588 saveDataList.add(saveDataTmp);
15341589 }
15351590
1591+ // Listサイズをインクリメント
1592+ String nowSizeRet = keyMapObjGet(sizeKey);
1593+ if (nowSizeRet == null) throw new BatchException("List size not found error");
1594+ String[] nowSizeRetSplit = nowSizeRet.split(ImdstDefine.setTimeParamSep);
1595+ long listSizeLong = new Long(nowSizeRetSplit[0]).longValue();
1596+ listSizeLong++;
1597+ String nextSize = listSizeLong + ImdstDefine.setTimeParamSep + "0";
1598+
1599+ keyMapObjPut(sizeKey, nextSize);
1600+ String[] saveSizeDataTmp = new String[]{sizeKey, nextSize};
1601+ saveDataList.add(saveSizeDataTmp);
1602+
1603+
1604+ // 以降操作記録ログへの書き込み処理
15361605 for (int idx = 0; idx < saveDataList.size(); idx++) {
15371606
15381607 String[] saveData = (String[])saveDataList.get(idx);
@@ -1676,6 +1745,7 @@
16761745 // このsynchroの方法は正しくないきがするが。。。
16771746 synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
16781747 String pointerKey = listStructPointerPrefix + listName;
1748+ String sizeKey = listStructSizePrefix + listName;
16791749 String key = listStructStartPrefix + listName;
16801750 String[] keyList = new String[3];
16811751
@@ -1742,6 +1812,18 @@
17421812 saveDataList.add(saveDataTmp);
17431813 }
17441814
1815+ // Listサイズをデクリメント
1816+ String nowSizeRet = keyMapObjGet(sizeKey);
1817+ if (nowSizeRet == null) throw new BatchException("List size not found error");
1818+ String[] nowSizeRetSplit = nowSizeRet.split(ImdstDefine.setTimeParamSep);
1819+ long listSizeLong = new Long(nowSizeRetSplit[0]).longValue();
1820+ listSizeLong--;
1821+ String nextSize = listSizeLong + ImdstDefine.setTimeParamSep + "0";
1822+ keyMapObjPut(sizeKey, nextSize);
1823+ saveDataTmp = new String[]{sizeKey, nextSize};
1824+ saveDataList.add(saveDataTmp);
1825+
1826+
17451827 // ここまでの登録、削除を記録
17461828 for (int idx = 0; idx < saveDataList.size(); idx++) {
17471829
@@ -1814,6 +1896,7 @@
18141896 // このsynchroの方法は正しくないきがするが。。。
18151897 synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
18161898 String pointerKey = listStructPointerPrefix + listName;
1899+ String sizeKey = listStructSizePrefix + listName;
18171900 String[] keyList = new String[3];
18181901
18191902 String key = listStructStartPrefix + listName;
@@ -1883,6 +1966,17 @@
18831966 saveDataList.add(saveDataTmp);
18841967 }
18851968
1969+ // Listサイズをデクリメント
1970+ String nowSizeRet = keyMapObjGet(sizeKey);
1971+ if (nowSizeRet == null) throw new BatchException("List size not found error");
1972+ String[] nowSizeRetSplit = nowSizeRet.split(ImdstDefine.setTimeParamSep);
1973+ long listSizeLong = new Long(nowSizeRetSplit[0]).longValue();
1974+ listSizeLong--;
1975+ String nextSize = listSizeLong + ImdstDefine.setTimeParamSep + "0";
1976+ keyMapObjPut(sizeKey, nextSize);
1977+ saveDataTmp = new String[]{sizeKey, nextSize};
1978+ saveDataList.add(saveDataTmp);
1979+
18861980 // ここまでの登録、削除を記録
18871981 for (int idx = 0; idx < saveDataList.size(); idx++) {
18881982
@@ -1936,6 +2030,52 @@
19362030 }
19372031 return ret;
19382032 }
2033+
2034+
2035+ /**
2036+ * 現在のList構造体のサイズを返す.<br>
2037+ *
2038+ * @param listName リスト名
2039+ * @param transactionCode
2040+ * @return サイズ
2041+ * @throws BatchException Size構造体が存在しない場合
2042+ */
2043+ public String listLen(String listName, String transactionCode) throws BatchException {
2044+ String ret = null;
2045+
2046+ if (!blocking) {
2047+ try {
2048+ // このsynchroの方法は正しくないきがするが。。。
2049+ synchronized(this.parallelSyncObjs[((listName.hashCode() << 1) >>> 1) % KeyMapManager.parallelSize]) {
2050+ String pointerKey = listStructPointerPrefix + listName;
2051+ String sizeKey = listStructSizePrefix + listName;
2052+
2053+ // List構造体が存在しない場合はエラー
2054+ if(!this.containsKeyPair(pointerKey)) {
2055+ ret = null;
2056+ return ret;
2057+ }
2058+
2059+
2060+ // Listサイズをデクリメント
2061+ String nowSizeRet = keyMapObjGet(sizeKey);
2062+ if (nowSizeRet == null) throw new BatchException("List size not found error");
2063+ String[] nowSizeRetSplit = nowSizeRet.split(ImdstDefine.setTimeParamSep);
2064+ ret = nowSizeRetSplit[0];
2065+ }
2066+ } catch (BatchException be) {
2067+ throw be;
2068+ } catch (Exception e) {
2069+ e.printStackTrace();
2070+ logger.error("listLen - Error");
2071+ blocking = true;
2072+ StatusUtil.setStatusAndMessage(1, "listLen - Error [" + e.getMessage() + "]");
2073+ throw new BatchException(e);
2074+ }
2075+ }
2076+ return ret;
2077+ }
2078+
19392079 // Listの指定位置のデータを消す
19402080
19412081
@@ -3285,8 +3425,13 @@
32853425 if (obj == null) continue;
32863426 String key = null;
32873427 key = (String)obj.getKey();
3288- pw.println(key);
3289- pw.flush();
3428+ try {
3429+ String decodeKey = new String(BASE64DecoderStream.decode(key.getBytes()));
3430+ if (decodeKey.indexOf("{imdst_") != 0) {
3431+ pw.println(decodeKey);
3432+ pw.flush();
3433+ }
3434+ } catch(Exception ee){}
32903435 }
32913436
32923437 pw.println("-1");
--- trunk/src/okuyama/imdst/util/ImdstDefine.java (revision 1027)
+++ trunk/src/okuyama/imdst/util/ImdstDefine.java (revision 1028)
@@ -74,6 +74,9 @@
7474 // List構造体の現時点での最終ポインターデータを表すPrefix
7575 public static final String imdstListStructPointerPrefixStr = "{imdst_list_pointer#878685";
7676
77+ // List構造体の現時点でのリストサイズを表すPrefix
78+ public static final String imdstListStructSizePrefixStr = "{imdst_list_size#848382";
79+
7780 // List構造体の内部データを表すPrefix
7881 public static final String imdstListDataPrefixStr = "{imdst_list_data#567";
7982
@@ -96,6 +99,9 @@
9699 // データノードに対するKeyデータ登録時にバージョン値が変わっている場合のエラーメッセージ
97100 public static final String keyNodeKeyUpdatedErrMsg = "NG:Data has already been updated";
98101
102+ // 既にリスト構造体が存在する場合のエラーメッセージ
103+ public static final String keyNodeListCreateErrMsg = "NG:List already exists";
104+
99105 // データノードに対するKeyデータ削除時に成功した場合の返却文字列の先頭部分
100106 public static final String keyNodeKeyRemoveSuccessStr = "5,true";
101107
@@ -120,7 +126,21 @@
120126 // データノードに対するKeyに紐付くTagデータ削除時に失敗した場合の返却文字列の先頭部分
121127 public static final String keyNodeTgaInKeyRemoveNotFoundStr = "40,false";
122128
129+ // データノードに対するList構造体作成時に成功した場合の返却文字列の先頭部分
130+ public static final String keyNodeListStructCreateSuccessStr = "51,true";
123131
132+ // データノードに対するList構造体へにLPUSH時に成功した場合の返却文字列の先頭部分
133+ public static final String keyNodeLPushSuccessStr = "52,true";
134+
135+ // データノードに対するList構造体へにRPUSH時に成功した場合の返却文字列の先頭部分
136+ public static final String keyNodeRPushSuccessStr = "53,true";
137+
138+ // データノードに対するList構造体へにLPOP時に成功した場合の返却文字列の先頭部分
139+ public static final String keyNodeLPopSuccessStr = "55,true";
140+
141+ // データノードに対するList構造体へにLPOP時に成功した場合の返却文字列の先頭部分
142+ public static final String keyNodeLPopNullStr = "55,false";
143+
124144 // MasterNodeのgetMultiValueを呼び出した際のClientへの戻り値
125145 public static final String getMultiEndOfDataStr = "END";
126146
Show on old repository browser