dscl . append /Groups/wheel GroupMembership 'username'
sudo chmod g+rw /dev/bpf*; open /Applications/Wireshark.app
alias wireshark='sudo chmod g+rw /dev/bpf*; open /Applications/Wireshark.app'
on open {filename}
set p to POSIX path of filename
set myArray to my theSplit(p, "/")
set numItems to (count myArray) - 1
set AppNameFull to getArrayValue(myArray, numItems)
set myArray to my theSplit(AppNameFull, ".")
set numItems to (count myArray) - 1
set AppName to getArrayValue(myArray, 1)
do shell script p & "/Contents/MacOS/" & AppName with administrator privileges
end open
on theSplit(theString, theDelimiter)
-- save delimiters to restore old settings
set oldDelimiters to AppleScript's text item delimiters
-- set delimiters to delimiter to be used
set AppleScript's text item delimiters to theDelimiter
-- create the array
set theArray to every text item of theString
-- restore the old setting
set AppleScript's text item delimiters to oldDelimiters
-- return the result
return theArray
end theSplit
on getArrayValue(array, location)
-- very important -- The list index starts at 1 not 0
return item location in array
end getArrayValue
#!/usr/bin/bash
test=$1
echo $test
args=("$@")
file="$1"
echo ${file}
temp_file=$1.tmp
echo $temp_file
cp $file $temp_file
file=`echo "$1" | sed s/.escript/.erl/g`
sed -n '1!p' $temp_file > $file
/usr/bin/env erlc $file
cp $temp_file $file
rm $temp_file
#!/usr/bin/env escript
%%! -smp disable
#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp disable
%% Author: Drew Gulino
-module(runavg).
-export([main/1]).
main(CmdLine) ->
OptSpecList = option_spec_list(),
case getopt:parse(OptSpecList, CmdLine) of
{ok, {Options, NonOptArgs}} ->
true;
{error, {Reason, Data}} ->
Options = [],
NonOptArgs = [],
io:format("Error: ~s ~p~n~n", [Reason, Data]),
version(),
getopt:usage(OptSpecList, "runavg")
end,
SampleSize = get_opt_value(size,Options),
OutputInterval = get_opt_value(interval,Options),
case NonOptArgs of
[] ->
F = standard_io;
_ ->
{ok, F} = file:open(NonOptArgs, read)
end,
%io:format("~p,~p,~p~n",[F, SampleSize, OutputInterval]),
proc_file(F, SampleSize, OutputInterval ).
proc_file(F, SampleSize, OutputInterval) ->
%io:format("1"),
proc_file(F, SampleSize, OutputInterval, [], 0, 0).
proc_file(F, SampleSize, OutputInterval, SampleAcc, SampleCount, IntervalCount) when IntervalCount >= OutputInterval ->
io:format("~.2f~n",[lists:sum(SampleAcc)/erlang:length(SampleAcc)]),
proc_file(F, SampleSize, OutputInterval, SampleAcc, SampleCount, 0);
proc_file(F, SampleSize, OutputInterval, [_|T] , SampleCount, IntervalCount) when SampleCount >= SampleSize ->
%io:format("T: ~p~n",[T]),
proc_file(F, SampleSize, OutputInterval, T, SampleCount - 1, IntervalCount);
proc_file(F, SampleSize, OutputInterval, SampleAcc, SampleCount, IntervalCount) ->
%io:format("SampleAcc: ~p~n", [SampleAcc]),
L = io:get_line(F, ''),
case L of
eof ->
ok;
"\n" ->
false;
Line ->
Stripped = strip_newlines(Line),
Num = cast_to_integer(Stripped),
proc_file(F, SampleSize, OutputInterval, [Num] ++ SampleAcc, SampleCount + 1, IntervalCount + 1)
end.
version() ->
io:format("Version: 1.0\n").
get_opt_value(Key, Options) ->
case lists:keyfind(Key,1,Options) of
{Key, Value} ->
Value
end,
Value.
option_spec_list() ->
[
%% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
{help, $h, "help", undefined, "Show the program options"},
{version, $v, "version", undefined, "Version"},
{size, $s, "size", {integer, 5}, "Size of average sample, Default=5"},
{interval, $i, "interval", {integer, 5}, "How many input entries before average is displayed, Default=5"}
].
strip_newlines(String) ->
string:strip(re:replace(String,"(.*)[\n\r]","\\1", [global,{return,list}])).
cast_to_integer([]) ->
[];
cast_to_integer(Input) when is_integer(Input) ->
Input;
cast_to_integer(Input) when is_float(Input) ->
erlang:round(Input);
cast_to_integer(Input) when is_list(Input)->
case lists:member($., Input) of
true ->
erlang:round(erlang:list_to_float(Input));
false ->
erlang:list_to_integer(Input)
end.
#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp disable
%% Author: Drew Gulino
-module(randstream).
-export([main/1]).
main(_) ->
{A1,A2,A3} = now(),
random:seed(A1, A2, A3),
rand().
rand() ->
Num = random:uniform(100),
io:format("~B~n",[Num]),
rand().
chmod u+x tgraph.escript$ cat test.txt | ./tgraph.escript -t 40 -c 40./tgraph.escript test.txt -t 40 -c 401
50
20
3
45
34.0
12
0
1000
0
100
34
****************************************1
****************************************50
****************20
**3
************************************45
***************************34
**********12
0
****************************************1000
0
****100
*34
#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp disable
%% Author: Drew Gulino
-module(tgraph).
-export([main/1]).
main(CmdLine) ->
OptSpecList = option_spec_list(),
case getopt:parse(OptSpecList, CmdLine) of
{ok, {Options, NonOptArgs}} ->
true;
{error, {Reason, Data}} ->
Options = [],
NonOptArgs = [],
io:format("Error: ~s ~p~n~n", [Reason, Data]),
version(),
getopt:usage(OptSpecList, "tgraph")
end,
Symbol = get_opt_value(symbol,Options),
Columns = get_opt_value(columns,Options),
Display_number = get_opt_value(display_number,Options),
Threshold = get_opt_value(threshold,Options),
Maximum = get_opt_value(maximum,Options),
Bold = strip_newlines(os:cmd("tput bold")),
Init = strip_newlines(os:cmd("tput init")),
Dim = strip_newlines(os:cmd("tput sgr0")),
Red = strip_newlines(os:cmd("tput setaf 1")),
%Green = strip_newlines(os:cmd("tput setaf 2")),
%Yellow = strip_newlines(os:cmd("tput setaf 3")),
%Blue = strip_newlines(os:cmd("tput setaf 4")),
%Magenta = strip_newlines(os:cmd("tput setaf 5")),
case NonOptArgs of
[] ->
F = standard_io;
_ ->
{ok, F} = file:open(NonOptArgs, read)
end,
proc_file(F, {Symbol, Columns, Display_number, Threshold, Maximum} , {Bold, Init, Dim, Red}).
version() ->
io:format("Version: 1.1\n").
get_opt_value(Key, Options) ->
case lists:keyfind(Key,1,Options) of
{Key, Value} ->
Value
end,
Value.
option_spec_list() ->
%CurrentUser = os:getenv("USER"),
[
%% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
{help, $h, "help", undefined, "Show the program options"},
{version, $v, "version", undefined, "Version"},
{display_number, $n, "display_number", {boolean, true}, "Display number w/graph"},
{columns, $c, "columns", {integer, 72}, "Display columns (default = 72)"},
{symbol, $s, "symbol", {string, "*"}, "Symbol to display (default = '*')"},
{threshold, $t, "threshold", {integer, 0}, "Will color lines over this value"},
{maximum, $m, "maximum", {integer, 0}, "Presets the scale for this maximum value (default = 0)"}
].
proc_file(F, Options, Tput) ->
{Symbol, Columns, Display_number, Threshold, Maximum} = Options,
{Bold, Init, Dim, Red} = Tput,
%Columns = erlang:list_to_integer(os:cmd("tput cols")) - 8},
L = io:get_line(F, ''),
case L of
eof ->
ok;
"\n" ->
false;
Line ->
Stripped = strip_newlines(Line),
Num = cast_to_integer(Stripped),
io:put_chars(Init),
case Num > 0 of
true ->
case Num >= Maximum of
true ->
NewMax = Num,
io:put_chars(Bold);
false ->
NewMax = Maximum,
io:put_chars(Dim)
end,
Scale = Columns / NewMax,
Graph = lists:map(fun(_) -> io_lib:format(Symbol,[]) end , lists:seq(1,erlang:round(Num * Scale))),
case Threshold of
0 ->
false;
_ ->
case Num >= Threshold of
true ->
io:put_chars(Red);
false ->
%io:put_chars(Init)
false
end
end,
case Display_number of
true ->
io:format("~s~p~n",[Graph,Num]);
false ->
io:format("~p~n",[Graph])
end,
NewOptions = {Symbol, Columns, Display_number, Threshold, NewMax},
proc_file(F,NewOptions, Tput);
false ->
io:put_chars(Dim),
io:put_chars(Init),
io:format("~p~n",[Num]),
proc_file(F,Options, Tput)
end
end.
strip_newlines(String) ->
string:strip(re:replace(String,"(.*)[\n\r]","\\1", [global,{return,list}])).
cast_to_integer([]) ->
[];
cast_to_integer(Input) when is_integer(Input) ->
Input;
cast_to_integer(Input) when is_float(Input) ->
erlang:round(Input);
cast_to_integer(Input) when is_list(Input)->
case lists:member($., Input) of
true ->
erlang:round(erlang:list_to_float(Input));
false ->
erlang:list_to_integer(Input)
end.
-module(container).
-export([start/1, rpc/2, swap_code/1]).
-include("callback.hrl").
start(Mod) ->
register(?SERVERNAME, spawn(fun() -> loop(?SERVERNAME, Mod, Mod:init()) end)).
swap_code(Mod) -> rpc(?SERVERNAME, {swap_code, Mod}).
%
% Standard code for abstracting the "RPC-call" layer
%
rpc(Name, Request) ->
Name ! {self(), Request},
receive
{Name, Response} -> Response
end.
%
% Standard code for looping and waiting for messages from clients
%
loop(Name, Mod, OldState) ->
receive
{From, {swap_code, NewCallbackMod}} ->
From ! {Name, ack},
loop(Name, NewCallbackMod, OldState);
{From, Request} ->
{Response, NewState} = Mod:handle(Request,OldState),
From ! {Name, Response},
loop(Name, Mod, NewState)
end.
The registered server name is stored in an .hrl file included in the container and callback code:-define(SERVERNAME, moneyserver).callback.erl:
-module(callback).
-export([dollarToYen/1, yenToEuro/1]).
-include("callback.hrl").
-import(container, [rpc/2]).
%% client routines
dollarToYen(Dollars) -> rpc(?SERVERNAME, {convertToYen, Dollars}).
yenToEuro(Yen) -> rpc(?SERVERNAME, {convertToEuro, Yen}).
callback_impl.erl:-module(callback_impl).
-export([init/0, handle/2]).
-import(container, [rpc/2]).
%% client routines
-import(callback, [dollarToYen/1,yenToEuro/1]).
%% callback routines
init() -> dict:new().
handle({convertToYen, Dollars}, Dict) -> { Dollars * 126, Dict};
handle({convertToEuro, Yen}, Dict) -> {Yen * 0.0077, Dict}.
-module(callback_impl2).
-export([init/0, handle/2]).
-import(container, [rpc/2]).
%% client routines
-import(callback, [dollarToYen/1,yenToEuro/1]).
%% callback routines
init() -> dict:new().
handle({convertToYen, Dollars}, Dict) -> { Dollars * 126 * 126, Dict};
handle({convertToEuro, Yen}, Dict) -> {Yen * 0.0077 * 0.0077, Dict}.
> c(container).
> c(callback).
> c(callback_impl).
> c(callback_impl2).
% our first implementation:
> container:start(callback_impl).
> callback:dollarToYen(1).
126
> callback:yenToEuro(1).
0.0077
> container:swap_code(callback_impl2).
ack
> callback:yenToEuro(1).
5.929e-5
> callback:dollarToYen(1).
15876
%% Author: Drew Gulino: drew dot gulino at gmail dot com
%% Created: Mar 30, 2011
%% Description: Process to auto reload compiled code in shell
-module(reload).
%%
%% Exported Functions
%%
-export([start/0, start/1, stop/0, reloadAll/0]).
%% API Functions
start() ->
start(1000).
start(Milliseconds) ->
register(reload, spawn_link(fun() -> loop(Milliseconds) end)).
stop() ->
throw(reload_stopped).
%% Local Functions
loop(Milliseconds) ->
reloadAll(),
timer:sleep(1000),
loop(Milliseconds).
reload(M) ->
code:purge(M),
code:soft_purge(M),
{module, M} = code:load_file(M),
{ok, M}.
reloadAll() ->
Modules = [M || {M, P} <- code:all_loaded(), is_list(P)
andalso M =/= reload
andalso string:str(P, "/home/drew/workspace/erlang/") > 0],
[reload(M) || M <- Modules].