Planet Linux Australia

January 28, 2012 · Celebrating Australians & Kiwis in the Linux and Free/Open-Source community...

pylint
E:  3,4:Foo.foo: An attribute affected in foo line 12 hide this method

class Foo:

    def foo(self):
        return True

    def foo_override(self):
        return False

    def __init__(self, override=False):
        if override:
            self.foo = self.foo_override

foo = Foo()
moo = Foo(override=True)

print "expect True  : %s" % foo.foo()
print "expect False : %s" % moo.foo()
print "expect True  : %s" % Foo.foo(foo)
print "expect False : %s" % Foo.foo(moo)

$ python ./foo.py 
expect True  : True
expect False : False
expect True  : True
expect False : True

moo.foo()
moo.__dict__["foo"](moo)
__dict__
moo
foo
>>> print moo.__dict__
{'foo': <bound method Foo.foo_override of <__main__.Foo instance at 0xb72838ac>>}

Foo.foo(moo)
Foo.__dict__["foo"](moo)
foo
moo
Foo.foo = Foo.foo_override
__dict__
libblah-extra-number
apt-get --ignore-hold install devede libavcodec-extra-53 libavdevice-extra-53 libavfilter-extra-2 libavutil-extra-51 libavformat-extra-53 libpostproc-extra-52 libswscale-extra-2

apt-get download libav-tools

apt-get download ffmpeg

apt-get download devede

dpkg -i --force-depends-version libav-tools_0.8-1ubuntu1_i386.deb

dpkg -i --force-depends-version ffmpeg_0.8-1ubuntu1_all.deb

dpkg -i --force-depends-version devede_3.21.0-0ubuntu2_all.deb
/*
LED segment mappings
Note that this is specific to the way I wired it
This will be different for you!

Top          = 0x01
Top left     = 0x02
Bottom left  = 0x04
Bottom       = 0x08
Top right    = 0x10
Middle       = 0x20
Bottom right = 0x40
Dot          = 0x80
*/

/* here we combine the above segments to produce a complete digit */
unsigned char digits[] = {
  0x5F, /* zero  */
  0x50, /* one   */
  0x3D, /* two   */
  0x79, /* three */
  0x72, /* four  */
  0x6B, /* five  */
  0x6F, /* six   */
  0x51, /* seven */
  0x7F, /* eight */
  0x7B  /* nine  */
};

void display_digit(unsigned char d)
{
  int i;

  /* examine each bit and determine if segment needs to be lit */
  for (i=0; i<8; i++) {
    digitalWrite(i, (d >> i & 0x01 == 0x01) ? HIGH : LOW); 
  }
}

void setup()
{
  int i;

  /* set pins 0-7 to output */
  for (i=0; i<8; i++) {
    pinMode(i, OUTPUT);
  }

  /* show all segments on bootup */
  display_digit(0xFF);
  delay(1000);
}

void loop()
{
  int i;

  /* display each digit one by one */
  for (i=0; i<10; i++) {
    display_digit(digits[i]);
    delay(500);
  }
}
Content-Length
  -- Note: This function produces garbage on invalid input. But serving an
  -- invalid content-length is a bad idea, mkay?
  readInt :: S.ByteString -> Integer
  readInt = S.foldl' (\x w -> x * 10 + fromIntegral w - 48) 0

Content-Length
readDec
Numeric
  import Data.ByteString (ByteString)
  import qualified Data.ByteString.Char8 as B
  import qualified Numeric as N

  readInt :: ByteString -> Integer
  readInt s =
      case N.readDec (B.unpack s) of
          [] -> 0
          (x, _):_ -> x

Content-Length
readDec
  import Data.ByteString (ByteString)
  import qualified Data.ByteString.Char8 as B
  import qualified Data.Char as C

  readIntTC :: Integral a => ByteString -> a
  readIntTC bs = fromIntegral
          $ B.foldl' (\i c -> i * 10 + C.digitToInt c) 0
          $ B.takeWhile C.isDigit bs

Integral
ByteString
Integral
Int
Int64
Integral
  prop_read_show_idempotent :: Integral a => (ByteString -> a) -> a -> Bool
  prop_read_show_idempotent freader x =
      let posx = abs x
      in posx == freader (B.pack $ show posx)

freader
Content-Length
  ghc -Wall -O3 --make readInt.hs -o readInt && ./readInt

  Quickcheck tests.
  +++ OK, passed 100 tests.
  +++ OK, passed 100 tests.
  +++ OK, passed 100 tests.
  Criterion tests.
  warming up
  estimating clock resolution...
  mean is 3.109095 us (320001 iterations)
  found 27331 outliers among 319999 samples (8.5%)
    4477 (1.4%) low severe
    22854 (7.1%) high severe
  estimating cost of a clock call...
  mean is 719.4627 ns (22 iterations)

  benchmarking readIntOrig
  mean: 4.653041 us, lb 4.645949 us, ub 4.663823 us, ci 0.950
  std dev: 43.94805 ns, lb 31.52653 ns, ub 73.82125 ns, ci 0.950

  benchmarking readDec
  mean: 13.12692 us, lb 13.10881 us, ub 13.14411 us, ci 0.950
  std dev: 90.63362 ns, lb 77.52619 ns, ub 112.4304 ns, ci 0.950

  benchmarking readRaw
  mean: 591.8697 ns, lb 590.9466 ns, ub 594.1634 ns, ci 0.950
  std dev: 6.995869 ns, lb 3.557109 ns, ub 14.54708 ns, ci 0.950

  benchmarking readInt
  mean: 388.3835 ns, lb 387.9500 ns, ub 388.8342 ns, ci 0.950
  std dev: 2.261711 ns, lb 2.003214 ns, ub 2.585137 ns, ci 0.950

  benchmarking readInt64
  mean: 389.4380 ns, lb 388.9864 ns, ub 389.9312 ns, ci 0.950
  std dev: 2.399116 ns, lb 2.090363 ns, ub 2.865227 ns, ci 0.950

  benchmarking readInteger
  mean: 389.3450 ns, lb 388.8463 ns, ub 389.8626 ns, ci 0.950
  std dev: 2.599062 ns, lb 2.302428 ns, ub 2.963600 ns, ci 0.950

readIntTC
Numeric.readDec
readInt
module Redcarpet
  module Render
    class HTMLWithoutBlockElements < HTML
      include SmartyPants

      def initialize(opts = {})
        opts[:tables] = false
        super(opts)
      end

      # Regular markdown, just ignore all the block-level elements

      def block_code(code, language)
        code
      end

      def block_quote(quote)
        quote
      end

      def block_html(raw_html)
        raw_html
      end

      def header(text, header_level)
        "#{text} "
      end

      def hrule
        " "
      end

      def list(contents, list_type)
        " #{contents}"
      end

      def list_item(text, list_type)
        "* #{text}"
      end

      def paragraph(text)
        text
      end

      # Span-level calls

      def linebreak
        " "
      end

      # Postprocessing: strip the newlines

      def postprocess(document)
        document.gsub("\n", ' ').strip
      end
    end
  end
end

module ApplicationHelper
  def markdown(text)
    renderer = Redcarpet::Render::HTML.new({
      :filter_html => true,
      :hard_wrap => true
    })
    markdown = Redcarpet::Markdown.new(renderer, {
      :autolink => true,
      :no_intra_emphasis => true
    })

    markdown.render(text).html_safe
  end

  def markdown_line(text)
    renderer = Redcarpet::Render::HTMLWithoutBlockElements.new({
      :filter_html => true,
      :hard_wrap => true
    })
    markdown = Redcarpet::Markdown.new(renderer, {
      :autolink => true,
      :no_intra_emphasis => true
    })

    markdown.render(text).html_safe
  end
end

<div class="item">
  <h3 class="name"><%= markdown_line(item.name) %></h3>
  <div class="description">
    <%= markdown(item.description) %>
  </div>
</div>

browser_monitoring:
  auto_instrument: false

192.168.1.1
iptables -A INPUT -s 192.168.1.1 -p udp --dport 514 -j ACCEPT
/var/log/syslog
/etc/rsyslog.d/10-gargoyle-router.conf
$ModLoad imudp

$UDPServerRun 514

:fromhost-ip, isequal, "192.168.1.1" /var/log/gargoyle-router.log

& ~
/var/log/syslog
192.168.1.2
uci set system.@system[0].log_ip=192.168.1.2

uci set system.@system[0].conloglevel=7

uci commit
tail -f /var/log/gargoyle-router.log
  import Control.Concurrent (forkIO, killThread)
  import Control.Monad.IO.Class (MonadIO, liftIO)
  import Control.Monad.Trans.Resource
  import Data.Conduit
  import Data.Conduit.Binary
  import Network (connectTo, PortID (..))
  import System.Environment (getArgs, getProgName)
  import System.IO

  main :: IO ()
  main = do
      args <- getArgs
      case args of
          [host, port] -> telnet host (read port :: Int)
          _ -> usageExit
    where
      usageExit = do
          name <- getProgName
          putStrLn $ "Usage : " ++ name ++ " host port"

  telnet :: String -> Int -> IO ()
  telnet host port = runResourceT $ do
      (releaseSock, hsock) <- with (connectTo host $ PortNumber $ fromIntegral port) hClose
      liftIO $ mapM_ (`hSetBuffering` LineBuffering) [ stdin, stdout, hsock ]
      (releaseThread, _) <- with (
                            forkIO $ runResourceT $ sourceHandle stdin $$ sinkHandle hsock
                            ) killThread
      sourceHandle hsock $$ sinkHandle stdout
      release releaseThread
      release releaseSock

main
telnet
telnet
runResourceT
telnet
connectTo
connectTo
with
with
  with :: Resource m
       => Base m a             -- Base monad for the current monad stack
       -> (a -> Base m ())     -- Resource de-allocation function
       -> ResourceT m (ReleaseKey, a)

with
ReleaseKey
with
forkIO
killThread
sourceHandle
sinkHandle
stdin
hsock
stdout
release

January 28, 2012

January 27, 2012

January 26, 2012

Monday 16 January 2012

Thursday 19 January 2012

Friday 20 January 2012

What next?

Advertising

January 25, 2012

Policy

Kernel

Audit

Libraries

Play Machine

January 24, 2012

January 23, 2012

Flickr photos for LCA2012 now online

January 22, 2012

January 21, 2012

January 20, 2012

Codec 2 – David Rowe

UEFI and Linux – Matthew Garrett

Bloat: How and Why UNIX Grew Up (and Out) – Matt Evans and Rusty Russell

Open vSwitch – Simon Horman

January 19, 2012

Challenges for the Linux plumbing community – Jonathan Corbet

What is in a tiny Linux installation? by Malcolm Tredinnick

Cheap Tabloid tricks – Angus Kidman

January 18, 2012

January 17, 2012

A Tour of btrfs – Avi Miller

The Web as an application development platform – Shane Stephens and Mike Lawther

Mistakes were made by Selena Deckelmann

Smashing a square peg into a round hole – David Basden and Chris Collins

Extracting metrics from logs for realtime trending and alerting by Jamie Wilkinson

January 16, 2012

January 15, 2012

January 14, 2012

Server Configuration

Router Configuration

January 13, 2012

January 12, 2012

January 11, 2012

January 10, 2012

See the presenters you want to see

Learn about the tools that you want to use

Heard enough?

January 09, 2012

January 08, 2012

The Value of Cruises

How Cruise Companies Make Money

How to have a Cheap Cruise

Entertainment

Things to do Before Booking a Cruise