src/lwes_esf_validator.erl

   1 -module(lwes_esf_validator).
   2
   3 -behaviour(gen_server).
   4
   5 %% API
   6 -export([start_link/0,
   7          add_esf/2,
   8          validate/2,
   9          stats/0]).
  10
  11 %% gen_server callbacks
  12 -export([init/1,
  13          handle_call/3,
  14          handle_cast/2,
  15          handle_info/2,
  16          terminate/2,
  17          code_change/3]).
  18
  19 -include_lib ("lwes.hrl").
  20
  21 -define (SPEC_TAB, lwes_esf_specs).
  22
  23 -define(LEXER, lwes_esf_lexer).
  24 -define(PARSER, lwes_esf_parser).
  25
  26 -define(META_EVENT, "MetaEventInfo").
  27 -define(STATS_KEY, stats).
  28
  29 %%====================================================================
  30 %% API
  31 %%====================================================================
  32 start_link () ->
  33   gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
  34
  35 add_esf (ESFName, ESFFile) ->
  36   Events = parse (file, ESFFile),
  37   add_esf_events(ESFName, Events).
  38
  39 add_esf_events(ESFName, Events) ->
  40   % if 'MetaEventInfo' is defined we need to merge the attribute
  41   %specification from the 'Meta Event' to the specification of
  42   % all other 'real' events
  43   Events1 = case lists:keyfind (?META_EVENT, 2, Events) of
  44      false -> Events;
  45      MetaEvent ->
  46        RealEvents = lists:delete (MetaEvent, Events),
  47        {event, _, MetaAttrs} = MetaEvent,
  48        [{event, Name, Attrs ++ MetaAttrs } || {event, Name, Attrs} <- RealEvents]
  49   end,
  50   lists:foreach (fun (E) -> add_event (ESFName, E) end, Events1).
  51
  52 validate (ESFName, #lwes_event {name = EventName, attrs = Attrs} = _Event) ->
  53   ets:update_counter (?SPEC_TAB, ?STATS_KEY, {2,1}),
  54
  55   EventName1 = lwes_util:any_to_list (EventName),
  56   Key = { ESFName, EventName1 },
  57
  58   case ets:lookup (?SPEC_TAB, Key) of
  59     [{_, EventSpec}] ->
  60         validate_event (EventName1, EventSpec, Attrs);
  61     _ -> {error, {event_undefined, EventName}}
  62   end.
  63
  64 stats () ->
  65   [Stats] = ets:lookup (?SPEC_TAB, ?STATS_KEY),
  66   Stats.
  67
  68 %%====================================================================
  69 %% gen_server callbacks
  70 %%====================================================================
  71
  72 init ([]) ->
  73   % make sure terminate is called
  74   process_flag (trap_exit, true),
  75
  76   ets:new (?SPEC_TAB, [set, public, named_table, {keypos, 1}]),
  77   ets:insert (?SPEC_TAB,{?STATS_KEY, 0, 0}),
  78   { ok, {} }.
  79
  80 handle_call ({state}, _From, State) ->
  81   {reply, State, State }.
  82
  83 handle_cast (_Msg, State) ->
  84   { noreply, State }.
  85
  86 handle_info (_Info, State) ->
  87   { noreply, State }.
  88
  89 terminate (_Reason, _State) ->
  90   ets:delete (?SPEC_TAB),
  91   ok.
  92
  93 code_change (_OldVsn, State, _Extra) ->
  94   { ok, State }.
  95
  96 %%--------------------------------------------------------------------
  97 %%% Internal functions
  98 %%--------------------------------------------------------------------
  99
 100 add_event (ESFName, Event) ->
 101   { event, EventName, Attributes } = Event,
 102   Attributes1 = [ A || {attribute, A} <- Attributes ],
 103   { RequiredAttrs, OptionalAttrs } =
 104     lists:partition(
 105        fun ({_, _, _, Qualifier}) -> Qualifier == required end,
 106        Attributes1),
 107   ets:insert (?SPEC_TAB,
 108              {{ ESFName, EventName }, { RequiredAttrs, OptionalAttrs }}).
 109
 110 validate_event (EventName, { RequiredSpec, OptionalSpec }, EventAttrs) ->
 111   case validate_unique (EventName, EventAttrs, []) of
 112     ok ->
 113       case validate_required (EventName, RequiredSpec, EventAttrs) of
 114         {ok, OptionalAttrs} ->
 115                case validate_optional (EventName, OptionalSpec, OptionalAttrs) of
 116                  ok -> ets:update_counter (?SPEC_TAB, ?STATS_KEY, {3,1}),
 117                          ok;
 118                  ErrorOpt -> ErrorOpt
 119                end;
 120         ErrorReq -> ErrorReq
 121       end;
 122     ErrorUnique -> ErrorUnique
 123   end.
 124
 125
 126 validate_unique (_, [], _) -> ok;
 127 validate_unique (EventName, [{_, AttrName, _} | T], AttrsFound) ->
 128   case lists:keyfind (AttrName, 1, AttrsFound) of
 129     false -> validate_unique(EventName, T, [{AttrName} | AttrsFound]);
 130     _ ->
 131        {error, {field_duplicate, AttrName, EventName}}
 132   end.
 133
 134 validate_required (_, [], EventAttrs) -> {ok, EventAttrs};
 135
 136 validate_required (EventName, [{_Type_S,
 137                    AttributeName_S, _, _} = H| T], EventAttrs) ->
 138   case lists:keyfind (AttributeName_S, 2, EventAttrs) of
 139      false ->
 140        {error, {field_missing, AttributeName_S, EventName}};
 141      Attr ->
 142        case validate_attribute (EventName, H, Attr) of
 143          ok ->
 144            EventAttrs1 = lists:delete (Attr, EventAttrs),
 145            validate_required (EventName, T, EventAttrs1);
 146          Error -> Error
 147         end
 148   end.
 149
 150 validate_optional (_, _OptionalSpec, []) -> ok;
 151
 152 validate_optional (EventName, OptionalSpec, [{_Type, AttrName, _} = H | T]) ->
 153     case lists:keyfind (AttrName, 2, OptionalSpec) of
 154        false ->
 155          {error, {field_undefined, AttrName, EventName}};
 156        Spec ->
 157          case validate_attribute (EventName, Spec, H) of
 158            ok -> validate_optional (EventName, OptionalSpec, T);
 159            Error -> Error
 160           end
 161     end.
 162
 163 validate_attribute (EventName, {Type_S, AttrName_S, _, _}, {Type, AttrName, _}) ->
 164     case AttrName_S == AttrName andalso Type_S == Type of
 165         false ->
 166            {error, {field_type_mismatch, AttrName, EventName, Type, Type_S}};
 167         _ -> ok
 168     end.
 169
 170 parse (file, FileName) ->
 171     { ok, InFile } = file:open(FileName, [read]),
 172     Acc = loop (InFile, []),
 173     file:close (InFile),
 174     {ok, ParseTree} = ?PARSER:parse (Acc),
 175     ParseTree.
 176
 177 loop (InFile, Acc) ->
 178     case io:request(InFile, { get_until, prompt, ?LEXER, token, [1] } ) of
 179         { ok, Toks, _EndLine } ->
 180             loop (InFile,Acc ++ [Toks]);
 181         { error, token } ->
 182             error_logger:error_msg ("failed to read ESF file"),
 183             Acc;
 184         { eof, _ } ->
 185             Acc
 186     end.
 187
 188 %%--------------------------------------------------------------------
 189 %%% Test functions
 190 %%--------------------------------------------------------------------
 191
 192 -ifdef(TEST).
 193 -include_lib("eunit/include/eunit.hrl").
 194
 195
 196 parse_string (String) ->
 197     {ok, Tokens, _EndLine} = ?LEXER:string (String),
 198     {ok, ParseTree} = ?PARSER:parse ( Tokens ),
 199     ParseTree.
 200
 201 validate_test_() ->
 202   EventDefs = parse_string(
 203      "TestEvent {
 204         required int32 i = 1;
 205         required boolean j;
 206         int32 k = 1;
 207         string l;
 208       }"
 209   ),
 210   Validate = fun (Attrs) ->
 211     try
 212       ets:delete (?SPEC_TAB)
 213     catch _:_ -> 0 end,
 214     ets:new (?SPEC_TAB, [set, public, named_table, {keypos, 1}]),
 215     ets:insert (?SPEC_TAB,{?STATS_KEY, 0, 0}),
 216     add_esf_events(test_esf, EventDefs),
 217     Valid = validate(test_esf, #lwes_event {name = <<"TestEvent">>, attrs = Attrs}),
 218     ets:delete (?SPEC_TAB),
 219     Valid
 220   end,
 221   [
 222     ?_assertEqual(ok, % all fields
 223       Validate([{int32,<<"i">>,314159},
 224        {boolean,<<"j">>,false},
 225        {int32,<<"k">>,654321},
 226        {string,<<"l">>,<<"foo">>}])
 227     ),
 228     % NOTE: Default values aren't patched in anywhere currently.
 229     %   So, let this fail validation for now.
 230     %?assertEqual(true, % missing required field with default
 231     %  Validate([ {boolean,<<"j">>,false},
 232     %   {int32,<<"k">>,654321},
 233     %   {string,<<"l">>,<<"foo">>}])
 234     %),
 235     ?_assertEqual({error, {field_missing, <<"j">>, "TestEvent"}},
 236       % missing required field (no default)
 237       Validate([{int32,<<"i">>,314159},
 238        {int32,<<"k">>,654321},
 239        {string,<<"l">>,<<"foo">>}])
 240     ),
 241     ?_assertEqual({error, {field_duplicate, <<"j">>, "TestEvent"}},
 242       % duplicate field
 243       Validate([{int32,<<"i">>,314159},
 244        {boolean,<<"j">>,false},
 245        {boolean,<<"j">>,false},
 246        {int32,<<"k">>,654321},
 247        {string,<<"l">>,<<"foo">>}])
 248     ),
 249     ?_assertEqual({error, {field_type_mismatch, <<"i">>, "TestEvent", boolean, int32}},
 250       % type error, required field
 251       Validate([{boolean,<<"i">>,true},
 252        {boolean,<<"j">>,false},
 253        {int32,<<"k">>,654321},
 254        {string,<<"l">>,<<"foo">>}])
 255     ),
 256     ?_assertEqual({error, {field_type_mismatch, <<"k">>, "TestEvent", string, int32}},
 257       % type error, optional field
 258       Validate([{int32,<<"i">>,314159},
 259        {boolean,<<"j">>,false},
 260        {string,<<"k">>,<<"blah">>},
 261        {string,<<"l">>,<<"foo">>}])
 262     ),
 263     ?_assertEqual({error, {field_undefined, <<"extra">>, "TestEvent"}},
 264       % extra undefined field
 265       Validate([{int32,<<"i">>,314159},
 266        {boolean,<<"j">>,false},
 267        {int32,<<"k">>,654321},
 268        {int32,<<"extra">>,12345},
 269        {string,<<"l">>,<<"foo">>}])
 270     )
 271   ].
 272
 273 parse_test_() ->
 274   TestCases = [
 275                 {
 276                  [{event,"A",
 277                     [{attribute, {int32, <<"i">>, undefined, undefined}}]}],
 278                  "A
 279                   {
 280                     int32 i;
 281                   }
 282                  "
 283                 },
 284                 {
 285                  [{event,"A",
 286                     [{attribute, {int32, <<"i">>, undefined, undefined}},
 287                      {attribute, {uint32, <<"j">>, undefined, undefined}}]}],
 288                  "A
 289                   {
 290                     int32 i;
 291                     uint32 j;
 292                   }
 293                  "
 294                 },
 295                 {
 296                  [{event,"A",
 297                     [{attribute, {int32, <<"i">>, undefined, undefined}},
 298                      {attribute, {uint32, <<"j">>, undefined, undefined}}]}],
 299                  "A
 300                   {
 301                     int32 i; # comments should be ignored
 302                     uint32 j; # comments should be ignored
 303                   }
 304                  "
 305                 },
 306                 {
 307                  [{event,"A",
 308                     [{attribute, {int32, <<"i">>, undefined, undefined}},
 309                      {attribute, {uint32, <<"j">>, undefined, undefined}}]}],
 310                  "
 311                   # comments should be ignored
 312                   # like this one
 313                   A
 314                   {
 315                     int32 i;
 316                     uint32 j;
 317                   }
 318                  "
 319                 },
 320                 {
 321                  [{event,"A",
 322                     [{attribute, {int32, <<"i">>, "1", undefined}},
 323                      {attribute, {uint32, <<"j">>, undefined, undefined}}]}],
 324                  "
 325                   # comments should be ignored
 326                   # like this one
 327                   A
 328                   {
 329                     int32 i = 1; # we can set defaults
 330                     uint32 j;
 331                   }
 332                  "
 333                 },
 334                 {
 335                  [{event,"A",
 336                     [{attribute, {int32, <<"i">>, "-1", undefined}},
 337                      {attribute, {uint32, <<"j">>, undefined, undefined}}]}],
 338                  "
 339                   A
 340                   {
 341                     int32 i = -1; # we can set negative defaults
 342                     uint32 j;
 343                   }
 344                  "
 345                 },
 346                 {
 347                  [{event,"A",
 348                     [{attribute, {float, <<"i">>, "-0.1234", undefined}},
 349                      {attribute, {float, <<"j">>, "12.8999", undefined}}]}],
 350                  "
 351                   A
 352                   {
 353                     float i = -0.1234; # we can set negative defaults for float
 354                     float j = 12.8999;
 355                   }
 356                  "
 357                 },
 358                 {
 359                  [{event,"A",
 360                     [{attribute, {double, <<"i">>, "-0.1234", undefined}},
 361                      {attribute, {double, <<"j">>, "12.8999", undefined}}]}],
 362                  "
 363                   A
 364                   {
 365                     double i = -0.1234; # we can set negative defaults for double
 366                     double j = 12.8999;
 367                   }
 368                  "
 369                 },
 370                 {
 371                  [{event,"A",
 372                     [{attribute, {boolean, <<"i">>, "true", undefined}},
 373                      {attribute, {boolean, <<"j">>, "false", undefined}}]}],
 374                  "
 375                   A
 376                   {
 377                     boolean i = true; # we can set defaults for boolean
 378                     boolean j = false;
 379                   }
 380                  "
 381                 },
 382                 {
 383                  [{event,"A",
 384                     [{attribute, {string, <<"i">>, "\"hello\"", undefined}},
 385                      {attribute, {string, <<"j">>, "\"hello\nworld\"", undefined}}]}],
 386                  "
 387                   A
 388                   {
 389                     string i = \"hello\"; # we can set defaults for string
 390                     string j = \"hello\nworld\";
 391                   }
 392                  "
 393                 },
 394                 {
 395                  [{event,"A",
 396                     [{attribute, {uint32, <<"i">>, "1", optional}},
 397                      {attribute, {int32, <<"j">>, "-1", nullable}},
 398                      {attribute, {uint32, <<"k">>, "2", required}}]}],
 399                  "
 400                   A
 401                   {
 402                     optional uint32 i = 1; # make this optional
 403                     nullable int32 j = -1; # nullable
 404                     required uint32 k = 2; # required
 405                   }
 406                  "
 407                 },
 408                 {
 409                  [{event,"A",
 410                     [{attribute, {byte, <<"i">>, "1",undefined}}]}],
 411                  "
 412                   A
 413                   {
 414                     byte i = 1; # define 'byte' attribute
 415                   }
 416                  "
 417                 },
 418                 {
 419                  [{event,"A",
 420                     [{attribute, {nullable_int32_array, <<"i">>, undefined, nullable}}]}],
 421                  "
 422                   A
 423                   {
 424                     nullable int32 i[16]; # define array attribute
 425                   }
 426                  "
 427                 },
 428                 {
 429                  [{event,"A",
 430                     [{attribute, {int32_array, <<"i">>, undefined, undefined}}]}],
 431                  "
 432                   A
 433                   {
 434                     int32 i[16]; # define array attribute
 435                   }
 436                  "
 437                 },
 438                 {
 439                  [{event,"A",
 440                     [{attribute, {int32_array, <<"i">>, undefined, required}}]}],
 441                  "
 442                   A
 443                   {
 444                     required int32 i[16]; # define array attribute
 445                   }
 446                  "
 447                 }
 448               ],
 449   [ ?_assertEqual (E, parse_string(TC)) || {E, TC} <- TestCases ].
 450
 451 -endif.