diff options
Diffstat (limited to 'lib/snmp/src/agent/snmpa_general_db.erl')
| -rw-r--r-- | lib/snmp/src/agent/snmpa_general_db.erl | 578 |
1 files changed, 578 insertions, 0 deletions
diff --git a/lib/snmp/src/agent/snmpa_general_db.erl b/lib/snmp/src/agent/snmpa_general_db.erl new file mode 100644 index 0000000000..795c353a9e --- /dev/null +++ b/lib/snmp/src/agent/snmpa_general_db.erl @@ -0,0 +1,578 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2000-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +-module(snmpa_general_db). + + +%%%----------------------------------------------------------------- +%%% This module implements a very simple "generic" MIB database +%%% interface. It contains the most common functions performed. +%%% It is generic in the sense that it implements both an interface +%%% to mnesia and ets. +%%% +%%% Note that this module has nothing to do with the snmp_generic +%%% and snmp_generic_mnesia modules. +%%%----------------------------------------------------------------- + +-export([open/5, close/1, read/2, write/2, delete/1, delete/2]). +-export([sync/1, backup/2]). +-export([match_object/2, match_delete/2]). +-export([tab2list/1, info/1, info/2]). + + +-define(VMODULE,"GDB"). +-include("snmp_verbosity.hrl"). + + +%% --------------------------------------------------------------- +%% open(Info,Name,RecName,Attr,Type) -> term() +%% Info -> ets | {ets, Dir} | +%% {dets, Dir} | {dets, Dir, Action} | +%% {mnesia, Nodes} | {mnesia, Nodes, Action} +%% Name -> atom() +%% RecName -> Name of the record to store +%% Attr -> Attributes of the record stored in the table +%% Type -> set | bag +%% Dir -> string() +%% Nodes -> [node()] +%% Action -> keep | clear +%% +%% Open or create a database table. In the mnesia/dets case, +%% where the table is stored on disc, it could be of interest +%% to clear the table. This is controlled by the Action parameter. +%% An empty node list ([]), is traslated into a list containing +%% only the own node. +%% --------------------------------------------------------------- +open({mnesia,Nodes,clear}, Name, RecName, Attr, Type) when is_list(Nodes) -> + ?vtrace("[mnesia] open ~p database ~p for ~p on ~p; clear", + [Type, Name, RecName, Nodes]), + mnesia_open(mnesia_table_check(Name), Nodes, RecName, Attr, Type, clear); +open({mnesia,Nodes,_}, Name, RecName, Attr, Type) -> + ?vtrace("[mnesia] open ~p database ~p for ~p on ~p; keep", + [Type, Name, RecName, Nodes]), + open({mnesia,Nodes}, Name, RecName, Attr, Type); +open({mnesia,Nodes}, Name, RecName, Attr, Type) when is_list(Nodes) -> + ?vtrace("[mnesia] open ~p database ~p for ~p on ~p", + [Type, Name, RecName, Nodes]), + mnesia_open(mnesia_table_check(Name), Nodes, RecName, Attr, Type, keep); + +open({dets, Dir, Action}, Name, _RecName, _Attr, Type) -> + dets_open(Name, dets_filename(Name, Dir), Type, Action); +open({dets, Dir}, Name, _RecName, _Attr, Type) -> + dets_open(Name, dets_filename(Name, Dir), Type, keep); + +%% This function creates the ets table +open(ets, Name, _RecName, _Attr, Type) -> + ?vtrace("[ets] open ~p database ~p", [Type, Name]), + Ets = ets:new(Name, [Type, protected, {keypos, 2}]), + {ets, Ets, undefined}; +open({ets, Dir}, Name, _RecName, _Attr, Type) -> + ets_open(Name, Dir, keep, Type); +open({ets, Dir, Action}, Name, _RecName, _Attr, Type) -> + ets_open(Name, Dir, Action, Type). + +ets_open(Name, Dir, keep, Type) -> + ?vtrace("[ets] open ~p database ~p", [Type, Name]), + File = filename:join(Dir, atom_to_list(Name) ++ ".db"), + case file:read_file_info(File) of + {ok, _} -> + case ets:file2tab(File) of + {ok, Tab} -> + {ets, Tab, File}; + {error, Reason} -> + user_err("failed converting file to (ets-) tab: " + "File: ~p" + "~n~p", [File, Reason]), + Ets = ets:new(Name, [Type, protected, {keypos, 2}]), + {ets, Ets, File} + end; + {error, _} -> + Ets = ets:new(Name, [Type, protected, {keypos, 2}]), + {ets, Ets, File} + end; +ets_open(Name, Dir, clear, Type) -> + File = filename:join(Dir, atom_to_list(Name) ++ ".db"), + Ets = ets:new(Name, [Type, protected, {keypos, 2}]), + {ets, Ets, File}. + + + +mnesia_open({table_exist,Name},_Nodes,_RecName,_Attr,_Type,clear) -> + ?vtrace("[mnesia] database ~p already exists; clear content",[Name]), + Pattern = '_', + F = fun() -> + Recs = mnesia:match_object(Name,Pattern,read), + lists:foreach(fun(Rec) -> + mnesia:delete_object(Name,Rec,write) + end, Recs), + Recs + end, + case mnesia:transaction(F) of + {aborted,Reason} -> + exit({aborted,Reason}); + {atomic,_} -> + {mnesia,Name} + end; +mnesia_open({table_exist,Name},_Nodes,_RecName,_Attr,_Type,keep) -> + ?vtrace("[mnesia] database ~p already exists; keep content",[Name]), + {mnesia,Name}; +mnesia_open({no_table,Name},[],Type,RecName,Attr,Action) -> + mnesia_open({no_table,Name},[node()],Type,RecName,Attr,Action); +mnesia_open({no_table,Name},Nodes,RecName,Attr,Type,_) -> + ?vtrace("[mnesia] no database ~p: create for ~p of type ~p", + [Name,RecName,Type]), + %% Ok, we assume that this means that the table does not exist + Args = [{record_name,RecName}, {attributes,Attr}, + {type,Type}, {disc_copies,Nodes}], + case mnesia:create_table(Name,Args) of + {atomic,ok} -> + {mnesia,Name}; + {aborted,Reason} -> + %% ?vinfo("[mnesia] aborted: ~p", [Reason]), + exit({failed_create_mnesia_table,Reason}) + end. + + +mnesia_table_check(Name) -> + ?vtrace("[mnesia] check existens of database ~p",[Name]), + case (catch mnesia:table_info(Name,type)) of + {'EXIT', _Reason} -> + {no_table, Name}; + _ -> + {table_exist, Name} + end. + + +dets_open(Name, File, Type, Action) -> + ?vtrace("[dets] open database ~p (~p)", [Name, Action]), + N = dets_open1(Name, File, Type), + dets_open2(N, Action). + +dets_open1(Name, File, Type) -> + ?vtrace("[dets] open database ~p of type ~p",[Name, Type]), + {ok, N} = dets:open_file(Name, [{file, File}, {type, Type}, {keypos, 2}]), + N. + +dets_open2(N, clear) -> + dets:match_delete(N,'_'), + {dets, N}; +dets_open2(N, _) -> + {dets, N}. + +%% dets_table_check(Name, Dir) -> +%% Filename = dets_filename(Name, Dir), +%% ?vtrace("[dets] check existens of database: " +%% "~n ~p -> ~s" +%% "~n ~p" +%% "~n ~p" +%% , +%% [Name, Filename, file:list_dir(Dir), file:read_file_info(Filename)]), +%% case (catch dets:info(Filename, size)) of +%% {'EXIT', Reason} -> +%% {no_table, Name, Filename}; +%% undefined -> %% Introduced in R8 +%% {no_table, Name, Filename}; +%% _ -> +%% {table_exist, Name, Filename} +%% end. + + +dets_filename(Name, Dir) -> + Dir1 = dets_filename1(Dir), + Dir2 = string:strip(Dir1, right, $/), + io_lib:format("~s/~p.dat", [Dir2, Name]). + +dets_filename1([]) -> "."; +dets_filename1(Dir) -> Dir. + + +%% --------------------------------------------------------------- +%% close(DbRef) -> +%% DbRef -> term() +%% +%% Close the database. This does nothing in the mnesia case, but +%% deletes the table in the ets case. +%% --------------------------------------------------------------- +close({mnesia,_}) -> + ?vtrace("[mnesia] close database: NO ACTION",[]), + ok; +close({dets, Name}) -> + ?vtrace("[dets] close database ~p",[Name]), + dets:close(Name); +close({ets, Name, undefined}) -> + ?vtrace("[ets] close (delete) table ~p",[Name]), + ets:delete(Name); +close({ets, Name, File}) -> + ?vtrace("[ets] close (delete) table ~p",[Name]), + write_ets_file(Name, File), + ets:delete(Name). + + +%% --------------------------------------------------------------- +%% read(DbRef,Key) -> false | {value,Rec} +%% DbRef -> term() +%% Rec -> tuple() +%% +%% Retrieve a record from the database. +%% --------------------------------------------------------------- +read({mnesia, Name}, Key) -> + ?vtrace("[mnesia] read (dirty) from database ~p: ~p",[Name,Key]), + case (catch mnesia:dirty_read(Name,Key)) of + [Rec|_] -> {value,Rec}; + _ -> false + end; +read({dets, Name}, Key) -> + ?vtrace("[dets] read from table ~p: ~p",[Name,Key]), + case dets:lookup(Name, Key) of + [Rec|_] -> {value, Rec}; + _ -> false + end; +read({ets, Name, _}, Key) -> + ?vtrace("[ets] read from table ~p: ~p",[Name,Key]), + case ets:lookup(Name, Key) of + [Rec|_] -> {value, Rec}; + _ -> false + end. + + +%% --------------------------------------------------------------- +%% write(DbRef,Rec) -> ok +%% DbRef -> term() +%% Rec -> tuple() +%% +%% Write a record to the database. +%% --------------------------------------------------------------- +write({mnesia, Name}, Rec) -> + ?vtrace("[mnesia] write to database ~p",[Name]), + F = fun() -> mnesia:write(Name, Rec, write) end, + case mnesia:transaction(F) of + {aborted, Reason} -> + exit({aborted, Reason}); + {atomic,_} -> + ok + end; +write({dets, Name}, Rec) -> + ?vtrace("[dets] write to table ~p",[Name]), + dets:insert(Name, Rec); +write({ets, Name, _}, Rec) -> + ?vtrace("[ets] write to table ~p",[Name]), + ets:insert(Name, Rec). + + +%% --------------------------------------------------------------- +%% delete(DbRef) -> +%% DbRef -> term() +%% +%% Delete the database. +%% --------------------------------------------------------------- +delete({mnesia, Name}) -> + ?vtrace("[mnesia] delete database: ~p",[Name]), + mnesia:delete_table(Name); +delete({dets, Name}) -> + ?vtrace("[dets] delete database ~p",[Name]), + File = dets:info(Name, filename), + case dets:close(Name) of + ok -> + file:delete(File); + Error -> + Error + end; +delete({ets, Name, undefined}) -> + ?vtrace("[dets] delete table ~p",[Name]), + ets:delete(Name); +delete({ets, Name, File}) -> + ?vtrace("[dets] delete table ~p",[Name]), + file:delete(File), + ets:delete(Name). + + +%% --------------------------------------------------------------- +%% delete(DbRef, Key) -> ok +%% DbRef -> term() +%% Key -> term() +%% +%% Delete a record from the database. +%% --------------------------------------------------------------- +delete({mnesia, Name}, Key) -> + ?vtrace("[mnesia] delete from database ~p: ~p", [Name, Key]), + F = fun() -> mnesia:delete(Name, Key, write) end, + case mnesia:transaction(F) of + {aborted,Reason} -> + exit({aborted,Reason}); + {atomic,_} -> + ok + end; +delete({dets, Name}, Key) -> + ?vtrace("[dets] delete from table ~p: ~p", [Name, Key]), + dets:delete(Name, Key); +delete({ets, Name, _}, Key) -> + ?vtrace("[ets] delete from table ~p: ~p", [Name, Key]), + ets:delete(Name, Key). + + +%% --------------------------------------------------------------- +%% match_object(DbRef,Pattern) -> [tuple()] +%% DbRef -> term() +%% Pattern -> tuple() +%% +%% Search the database for records witch matches the pattern. +%% --------------------------------------------------------------- +match_object({mnesia, Name}, Pattern) -> + ?vtrace("[mnesia] match_object in ~p of ~p",[Name, Pattern]), + F = fun() -> mnesia:match_object(Name, Pattern, read) end, + case mnesia:transaction(F) of + {aborted, Reason} -> + exit({aborted, Reason}); + {atomic, Recs} -> + Recs + end; +match_object({dets, Name}, Pattern) -> + ?vtrace("[dets] match_object in ~p of ~p",[Name, Pattern]), + dets:match_object(Name, Pattern); +match_object({ets, Name, _}, Pattern) -> + ?vtrace("[ets] match_object in ~p of ~p",[Name, Pattern]), + ets:match_object(Name, Pattern). + + +%% --------------------------------------------------------------- +%% match_delete(DbRef,Pattern) -> +%% DbRef -> term() +%% Pattern -> tuple() +%% +%% Search the database for records witch matches the pattern and +%% deletes them from the database. +%% --------------------------------------------------------------- +match_delete({mnesia, Name}, Pattern) -> + ?vtrace("[mnesia] match_delete in ~p with pattern ~p",[Name,Pattern]), + F = fun() -> + Recs = mnesia:match_object(Name, Pattern, read), + lists:foreach(fun(Rec) -> + mnesia:delete_object(Name, Rec, write) + end, Recs), + Recs + end, + case mnesia:transaction(F) of + {aborted, Reason} -> + exit({aborted, Reason}); + {atomic,R} -> + R + end; +match_delete({dets, Name}, Pattern) -> + ?vtrace("[dets] match_delete in ~p with pattern ~p",[Name,Pattern]), + Recs = dets:match_object(Name, Pattern), + dets:match_delete(Name, Pattern), + Recs; +match_delete({ets, Name, _}, Pattern) -> + ?vtrace("[ets] match_delete in ~p with pattern ~p",[Name,Pattern]), + Recs = ets:match_object(Name, Pattern), + ets:match_delete(Name, Pattern), + Recs. + + +%% --------------------------------------------------------------- +%% tab2list(DbRef) -> [tuple()] +%% DbRef -> term() +%% +%% Return all records in the table in the form of a list. +%% --------------------------------------------------------------- +tab2list({mnesia, Name}) -> + ?vtrace("[mnesia] tab2list -> list of ~p", [Name]), + match_object({mnesia, Name}, mnesia:table_info(Name, wild_pattern)); +tab2list({dets, Name}) -> + ?vtrace("[dets] tab2list -> list of ~p", [Name]), + match_object({dets, Name}, '_'); +tab2list({ets, Name, _}) -> + ?vtrace("[ets] tab2list -> list of ~p", [Name]), + ets:tab2list(Name). + + + +%% --------------------------------------------------------------- +%% info(Db) -> taglist() +%% info(Db, Item) -> Info +%% Db -> term() +%% Item -> atom() +%% tablist() -> [{key(),value()}] +%% key() -> atom() +%% value() -> term() +%% +%% Retrieve table information. +%% --------------------------------------------------------------- +info({mnesia, Name}) -> + case (catch mnesia:table_info(Name, all)) of + Info when is_list(Info) -> + Info; + {'EXIT', {aborted, Reason}} -> + {error, Reason}; + Else -> + {error, Else} + end; +info({dets, Name}) -> + dets:info(Name); +info({ets, Name, _}) -> + case ets:info(Name) of + undefined -> + []; + L -> + L + end. + + +info({mnesia, Name}, Item) -> + case (catch mnesia:table_info(Name, Item)) of + {'EXIT', {aborted, Reason}} -> + {error, Reason}; + Info -> + Info + end; +info({dets, Name}, memory) -> + dets:info(Name, file_size); +info({dets, Name}, Item) -> + dets:info(Name, Item); +info({ets, Name, _}, Item) -> + ets:info(Name, Item). + + +%% --------------------------------------------------------------- +%% sync(Db) -> ok | {error, Reason} +%% Db -> term() +%% Reason -> term() +%% +%% Dump table to disc (if possible) +%% --------------------------------------------------------------- + +sync({mnesia, _}) -> + ok; +sync({dets, Name}) -> + dets:sync(Name); +sync({ets, _Name, undefined}) -> + ok; +sync({ets, Name, File}) -> + write_ets_file(Name, File). + + +%% --------------------------------------------------------------- +%% backup(Db, BackupDir) -> ok | {error, Reason} +%% Db -> term() +%% Reason -> term() +%% +%% Make a backup copy of the DB (only valid for det and ets) +%% --------------------------------------------------------------- + +backup({mnesia, _}, _) -> + ok; +backup({dets, Name}, BackupDir) -> + case dets:info(Name, filename) of + undefined -> + {error, no_file}; + Filename -> + case filename:dirname(Filename) of + BackupDir -> + {error, db_dir}; + _ -> + Type = dets:info(Name, type), + KP = dets:info(Name, keypos), + dets_backup(Name, + filename:basename(Filename), + BackupDir, Type, KP) + end + end; +backup({ets, _Name, undefined}, _BackupDir) -> + ok; +backup({ets, Name, File}, BackupDir) -> + Filename = filename:basename(File), + case filename:join(BackupDir, Filename) of + File -> + %% Oups: backup-dir and db-dir the same + {error, db_dir}; + BackupFile -> + write_ets_file(Name, BackupFile) + end. + + +dets_backup(Name, Filename, BackupDir, Type, KP) -> + ?vtrace("dets_backup -> entry with" + "~n Name: ~p" + "~n Filename: ~p" + "~n BackupDir: ~p" + "~n Type: ~p" + "~n KP: ~p", [Name, Filename, BackupDir, Type, KP]), + BackupFile = filename:join(BackupDir, Filename), + ?vtrace("dets_backup -> " + "~n BackupFile: ~p", [BackupFile]), + Backup = list_to_atom(atom_to_list(Name) ++ "_backup"), + Opts = [{file, BackupFile}, {type, Type}, {keypos, KP}], + case dets:open_file(Backup, Opts) of + {ok, B} -> + ?vtrace("dets_backup -> create fun", []), + F = fun(Arg) -> + dets_backup(Arg, start, Name, B) + end, + dets:safe_fixtable(Name, true), + Res = dets:init_table(Backup, F, [{format, bchunk}]), + dets:safe_fixtable(Name, false), + ?vtrace("dets_backup -> Res: ~p", [Res]), + Res; + Error -> + ?vinfo("dets_backup -> open_file failed: " + "~n ~p", [Error]), + Error + end. + + +dets_backup(close, _Cont, _Name, B) -> + dets:close(B), + ok; +dets_backup(read, Cont1, Name, B) -> + case dets:bchunk(Name, Cont1) of + {Cont2, Data} -> + F = fun(Arg) -> + dets_backup(Arg, Cont2, Name, B) + end, + {Data, F}; + '$end_of_table' -> + dets:close(B), + end_of_input; + Error -> + Error + end. + + +%%---------------------------------------------------------------------- + +write_ets_file(Name, File) -> + TmpFile = File ++ ".tmp", + case ets:tab2file(Name, TmpFile) of + ok -> + case file:rename(TmpFile, File) of + ok -> + ok; + Else -> + user_err("Warning: could not move file ~p" + " (~p)", [File, Else]) + end; + {error, Reason} -> + user_err("Warning: could not save file ~p (~p)", + [File, Reason]) + end. + + +%%---------------------------------------------------------------------- + +user_err(F, A) -> + snmpa_error:user_err(F, A). |